Merge pull request #7 from pkgodara/fix-decode-num-keys

Fix pointer lookups for numeric keys

Author: lpgauth

.github/workflows/ci.yml

@@ -37,6 +37,8 @@ jobs:
     strategy:
       matrix:
         include:
+          - otp: "28"
+            elixir: "1.18"
           - otp: "27"
             elixir: "1.18"
           - otp: "26"

native/torque_nif/src/decoder.rs

@@ -35,7 +35,7 @@ fn pointer_lookup<'v>(value: &'v sonic_rs::Value, path: &str) -> Option<&'v soni
     let mut current = value;
     for segment in path[1..].split('/') {
         let seg_bytes = segment.as_bytes();
-        if !seg_bytes.is_empty() && seg_bytes[0].is_ascii_digit() {
+        if current.is_array() && !seg_bytes.is_empty() && seg_bytes[0].is_ascii_digit() {
             if let Ok(index) = segment.parse::<usize>() {
                 current = current.get(index)?;
                 continue;

test/property_test.exs

@@ -6,16 +6,9 @@ defmodule Torque.PropertyTest do
 
   # ---- Generators ----
 
-  # Non-empty alphanumeric key, guaranteed to not be purely numeric.
-  # Purely numeric keys (e.g. "2") are mis-routed through array-index lookup in
-  # pointer_lookup, so they can't be reached via JSON Pointer on objects.
+  # Non-empty alphanumeric key.
   defp json_key do
-    filter(string(:alphanumeric, min_length: 1, max_length: 15), fn s ->
-      case Integer.parse(s) do
-        {_, ""} -> false
-        _ -> true
-      end
-    end)
+    string(:alphanumeric, min_length: 1, max_length: 15)
   end
 
   # Scalars that roundtrip exactly through Jason → Torque (no float precision issues)
@@ -286,6 +279,17 @@ defmodule Torque.PropertyTest do
         assert {:error, :no_such_field} == Torque.get(doc, "/#{missing_key}")
       end
     end
+
+    property "get works for numeric top-level object keys" do
+      check all(
+              k <- integer(0..99_999_999) |> map(&Integer.to_string/1),
+              v <- json_scalar_exact()
+            ) do
+        json = Jason.encode!(%{k => v})
+        {:ok, doc} = Torque.parse(json)
+        assert {:ok, v} == Torque.get(doc, "/#{k}")
+      end
+    end
   end
 
   describe "get_many consistency" do
@@ -609,15 +613,6 @@ defmodule Torque.PropertyTest do
       {:ok, doc2} = Torque.parse(~s({"a":[1,2,3]}))
       assert {:error, :no_such_field} = Torque.get(doc2, "/a/0/x")
     end
-
-    property "numeric string keys on objects always return no_such_field" do
-      check all(n <- integer(0..100)) do
-        json = ~s({"#{n}": "val"})
-        {:ok, doc} = Torque.parse(json)
-        # A purely numeric segment on an object (not an array) never matches
-        assert {:error, :no_such_field} = Torque.get(doc, "/#{n}")
-      end
-    end
   end
 
   # ---- get/3 raises on nesting_too_deep ----

test/torque_test.exs

@@ -132,6 +132,28 @@ defmodule Torque.PointerTest do
       assert geo["country"] == "US"
       assert geo["zip"] == "10001"
     end
+
+    test "numeric string object key is reachable via JSON Pointer" do
+      {:ok, doc} = Torque.parse(~s({"2":"two","10":"ten"}))
+      assert {:ok, "two"} = Torque.get(doc, "/2")
+      assert {:ok, "ten"} = Torque.get(doc, "/10")
+    end
+
+    test "nested numeric string object key is reachable via JSON Pointer" do
+      {:ok, doc} = Torque.parse(~s({"k1":"v1","k2":{"10":"ten","n1":"nv1"}}))
+      assert {:ok, "v1"} = Torque.get(doc, "/k1")
+      assert {:ok, %{"10" => "ten", "n1" => "nv1"}} = Torque.get(doc, "/k2")
+      assert {:ok, "ten"} = Torque.get(doc, "/k2/10")
+      assert {:ok, "nv1"} = Torque.get(doc, "/k2/n1")
+    end
+
+    test "numeric segment dispatches on node type" do
+      {:ok, obj_doc} = Torque.parse(~s({"0":"from-object"}))
+      {:ok, arr_doc} = Torque.parse(~s(["from-array"]))
+
+      assert {:ok, "from-object"} = Torque.get(obj_doc, "/0")
+      assert {:ok, "from-array"} = Torque.get(arr_doc, "/0")
+    end
   end
 
   describe "get_many/2" do
@@ -150,6 +172,11 @@ defmodule Torque.PointerTest do
       assert [] = Torque.get_many(doc, [])
     end
 
+    test "numeric string object keys" do
+      {:ok, doc} = Torque.parse(~s({"1":"one","2":"two"}))
+      assert [{:ok, "one"}, {:ok, "two"}] = Torque.get_many(doc, ["/1", "/2"])
+    end
+
     test "all fields", %{doc: doc} do
       paths = [
         "/id",