riffraff_jsonpath 0.8.2

data/lib/jsonpath/parser.treetop

@@ -0,0 +1,106 @@
+grammar JSONPathGrammar
+
+  rule path
+    root selectors:child+ <JSONPath::Nodes::RootNode>
+  end
+
+  rule root
+    '$'
+  end
+  
+  rule number
+    '-'? [0-9]+
+  end
+  
+  rule wildcard
+    '*' / '\'' '*' '\''
+  end
+  
+  rule lower
+    descendant / '.'
+  end
+  
+  rule descendant
+    '..'
+  end
+  
+  rule word_list
+    quoted_word ',' ' '*  word_list
+    /
+    quoted_word
+  end
+  
+  rule quoted_word
+    '\'' key:(!'\'' . )+ '\''
+  end
+  
+  rule child
+    # .foo or ..foo
+    lower key:bareword <JSONPath::Nodes::KeyNode>
+    /
+    # .* or ..*
+    lower wildcard <JSONPath::Nodes::WildcardNode>
+    /
+    # '?(@ % 2 == 0)'
+    lower '\'?(' template_code:(!')\'' . )+ ')\'' <JSONPath::Nodes::FilterNode>
+    /
+    # .'foo'
+    lower '\'' key:(!'\'' . )+ '\'' <JSONPath::Nodes::KeyNode>
+    /
+    # [*] and ['*']
+    '[' wildcard ']' <JSONPath::Nodes::WildcardNode>
+    /
+    # [0]
+    '[' index:number ']' <JSONPath::Nodes::IndexNode>
+    /
+    # .[0] and ..[0]
+    lower '[' index:number ']' <JSONPath::Nodes::IndexNode>
+    /
+    # [1:2]
+    '[' start:number ':' stop:number ']' <JSONPath::Nodes::SliceNode>
+    /
+    # .[1:2] and ..[1:2]
+    lower '[' start:number ':' stop:number ']' <JSONPath::Nodes::SliceNode>  
+    /
+    # [1:]
+    '[' start:number ':]' <JSONPath::Nodes::SliceNode>
+    /
+    # .[1:] and ..[1:]
+    lower '[' start:number ':]' <JSONPath::Nodes::SliceNode>
+    /
+    # [1:4:2]
+    '[' start:number ':' stop:number ':' step:number ']' <JSONPath::Nodes::SliceNode>
+    /
+    # .[1:4:2] and ..[1:4:2]
+    lower '[' start:number ':' stop:number ':' step:number ']' <JSONPath::Nodes::SliceNode>
+    /
+    # [1::2]
+    '[' start:number '::' step:number ']' <JSONPath::Nodes::SliceNode>
+    /
+    # .[1::2] and ..[1::2]
+    lower '[' start:number '::' step:number ']' <JSONPath::Nodes::SliceNode>
+    /    
+    # [(@.length - 1)]
+    '[(' template_code:(!')]' . )+ ')]' <JSONPath::Nodes::ExprNode>
+    /
+    # .[(@.length - 1)] and ..[(@.length - 1)]
+    lower '[(' template_code:(!')]' . )+ ')]' <JSONPath::Nodes::ExprNode>
+    /
+    # [?(@ % 2 == 0)]
+    '[?(' template_code:(!')]' . )+ ')]' <JSONPath::Nodes::FilterNode>
+    /
+    # .[?(@ % 2 == 0)] and ..[?(@ % 2 == 0)]
+    lower '[?(' template_code:(!')]' . )+ ')]' <JSONPath::Nodes::FilterNode>
+    /    
+    # ['foo']
+    '[' word_list ']' <JSONPath::Nodes::KeyNode>
+    /    
+    # .['foo'] and ..['foo]
+    lower '[' word_list ']' <JSONPath::Nodes::KeyNode>
+  end
+  
+  rule bareword
+    [_a-zA-Z0-9]+
+  end
+
+end

data/test/parser_test.rb

@@ -0,0 +1,199 @@
+require File.dirname(__FILE__) << "/test_helper"
+
+# The content below was taken from the tests for the JS and PHP
+# reference implementations at http://code.google.com/p/jsonpath/ 
+class ParserTest < Test::Unit::TestCase
+
+  context 'Traversing' do
+    context "hash" do
+      should "handle underscore in field names" do
+        path = '$.a_b'
+        assert_resolves({"a_b" => 1}, path, [1])
+      end
+      should "parse bareword child with single terminal" do
+        path = '$.a'
+        assert_resolves({"a" => 1}, path, [1])
+      end
+      should "parse subscripted quoted child with single terminal" do
+        path = "$['a b']"
+        assert_resolves({"a b" => 1}, path, [1])
+      end
+      should "parse subscripted quoted child and chained bareword" do
+        path = "$['a b'].c"
+        assert_resolves({"a b" => {"c" => 1}}, path, [1])
+      end
+      should "parses bare wildcard" do
+        path = "$.*"
+        assert_resolves({"a" => 1, "b" => 2}, path, [1, 2])
+      end
+      should "parse quoted wildcard on hash" do
+        path = "$['*']"
+        assert_resolves({"a" => 1, "b" => 2}, path, [1, 2])
+      end
+      should "parse quoted key outside of brackets" do
+        path = "$.'a b'"
+        assert_resolves({"a b" => 1}, path, [1])
+      end
+    end
+    context "array" do
+      should "parse bare wildcard" do
+        path = "$.*"
+        assert_resolves([1, 2, 3], path, [1, 2, 3])
+      end
+      should "parses subscripted quoted wildcard" do
+        path = "$['*']"
+        assert_resolves([1, 2, 3], path, [1, 2, 3])
+      end
+      should "parses through bare wildcard" do
+        path = "$.*.name"
+        assert_resolves([{"name" => 1}, {"name" => 2}, {"name" => 3}], path, [1, 2, 3])
+      end
+      should "parse index to single terminal" do
+        path = "$[1]"
+        assert_resolves(%w(foo bar baz), path, %w(bar))
+      end
+      should "parse index to multiple terminals" do
+        path = "$.*[1].name"
+        assert_resolves({
+          "a" => [1, {"name" => 2}, 3],
+          "b" => [4, {"name" => 5}, 6],
+          "c" => [7, {"name" => 8}, 9],
+        }, path, [2, 5, 8])
+      end
+      should "find all descendants in a array selection" do
+        path = "$.[0]..name"
+        assert_resolves([[
+            {'name'=>'joe'},
+            {'name'=>'jean'},
+            {'name'=>'jane'}]],
+            path, ['joe', 'jean', 'jane'])
+        path = "$.ary[0]..name"
+        assert_resolves({
+          "ary"=>[[
+            {'name'=>'joe'},
+            {'name'=>'jean'},
+            {'name'=>'jane'}]]},
+            path, ['joe', 'jean', 'jane'])
+      end
+    end
+    context "combination wildcards" do
+      should "parses through bare wildcard on array with additional wildcard" do
+        path = "$.*.names.*"
+        assert_resolves([
+          {"names" => %w(foo bar)},
+          {"names" => %w(baz quux)},
+          {"names" => %w(spam eggs)}
+        ], path, %w(foo bar baz quux spam eggs))
+      end
+    end
+    context "using slices" do
+      setup {
+        @deep = [
+          {"a" => {"name" => "a1"}, "b" => {"name" => "b1"}},
+          {"c" => {"name" => "c1"}, "d" => {"name" => "d1"}},
+          {"e" => {"name" => "e1"}, "f" => {"name" => "f1"}},
+          {"g" => {"name" => "g1"}, "h" => {"name" => "h1"}},
+          {"i" => {"name" => "i1"}, "j" => {"name" => "j1"}},
+          {"k" => {"name" => "k1"}, "l" => {"name" => "l1"}},
+          {"m" => {"name" => "m1"}, "n" => {"name" => "n1"}},          
+        ]
+        @shallow = [1, 2, 3, 4, 5, 6]
+      }
+      context "with explicit start and stop" do
+        context "with implicit step" do
+          should "parse to single terminal" do
+            path = '$[2:4]'
+            assert_resolves(@shallow, path, [3, 4, 5])
+          end
+          should "parse to multiple terminals" do
+            path = '$[2:4].*.name'
+            assert_resolves(@deep, path, %w(e1 f1 g1 h1 i1 j1))
+          end
+        end
+        context "with explicit step" do
+          should "parse to single terminal" do
+            path = '$[2:4:2]'
+            assert_resolves(@shallow, path, [3, 5])
+          end
+          should "parse to multiple terminals" do
+            path = '$[2:4:2].*.name'
+            assert_resolves(@deep, path, %w(e1 f1 i1 j1))
+          end
+        end
+      end
+      context "with explicit start and implict stop" do
+        context "with implicit step" do
+          should "parse to single terminal" do
+            path = '$[2:]'
+            assert_resolves(@shallow, path, [3, 4, 5, 6])
+          end
+          should "parse to multiple terminals" do
+            path = '$[2:].*.name'
+            assert_resolves(@deep, path, %w(e1 f1 g1 h1 i1 j1 k1 l1 m1 n1))
+          end
+        end
+        context "with explicit step" do
+           should "parse to single terminal" do
+             path = '$[2::2]'
+             assert_resolves(@shallow, path, [3, 5])
+           end
+           should "parse to multiple terminals" do
+             path = '$[2::2].*.name'
+             assert_resolves(@deep, path, %w(e1 f1 i1 j1 m1 n1))
+           end
+         end
+      end
+    end
+    context "supporting filters in Ruby" do
+      setup do
+        @numbers = [1, 2, 3, 4, 5, 6, 7, 8]
+        @hashes = [
+          {"name" => 'Bruce', "age" => 29},
+          {"name" => "Braedyn", "age" => 3},
+          {"name" => "Jamis", "age" => 2},
+        ]
+      end
+      context "when using self-contained single statements" do
+        should "support simple object operations" do
+          path = '$[?(@ % 2 == 0)]'
+          assert_resolves(@numbers, path, [2, 4, 6, 8])
+        end
+        should "support manual object pathing" do
+          path = %($[?(@['age'] % 2 == 0)].name)
+          assert_resolves(@hashes, path, ["Jamis"])
+        end
+      end
+      
+    end
+    context "descendants" do
+      setup do
+        @object = {
+          "a" => [1, 2, [3, 4]],
+          "b" => {
+            "c" => 5,
+            "e" => [6, 7]
+          }
+        }
+      end
+      should "be found with wildcard" do
+        path = '$..*'
+        assert_resolves(@object, path, [[1, 2, [3, 4]], 1, 2, [3, 4], 3, 4, {"c" => 5, "e" => [6, 7]}, 5, [6, 7], 6, 7, @object])
+      end
+      should "be found with deeper key" do
+        path = '$..e'
+        assert_resolves(@object, path, [[6, 7]])
+      end
+      should "be found with deeper index" do
+        path = '$..[0]'
+        assert_resolves(@object, path, [1, 3, 6])
+      end
+      should "resolve deeper chained selectors" do
+        path = '$..e[?(@ % 2 == 0)]'
+        assert_resolves(@object, path, [6])
+      end
+      
+    end
+    
+  end
+    
+end

data/test/reference_test.rb

@@ -0,0 +1,136 @@
+require File.dirname(__FILE__) << "/test_helper"
+require 'json'
+
+# The content below was taken from the tests for the JS and PHP
+# reference implementations at http://code.google.com/p/jsonpath/ 
+class ReferenceTest < Test::Unit::TestCase
+
+  context 'Sample 1' do
+    setup { @json = %({"a":"a","b":"b","c d":"e"}) }
+    should 'resolve a simple path' do
+      assert_resolves(object, "$.a", ["a"])
+    end
+    should 'resolve a path with quotes in brackets' do
+      assert_resolves(object, "$['a']", ["a"])
+    end
+    should 'resolve a path with a space' do
+      assert_resolves(object, "$.'c d'", ["e"])
+    end
+    should 'resolve a star' do
+      assert_resolves(object, "$.*", ["a", "b", "e"])
+    end
+    should 'resolve a star with quotes in brackets' do
+      assert_resolves(object, "$['*']", ["a", "b", "e"])
+    end
+    should 'resolve a star with quotes' do
+      assert_resolves(object, "$[*]", ["a", "b", "e"])
+    end
+  end
+  context 'Sample 2' do
+    setup { @json = %([1, "2", 3.14, true, null]) }
+    should 'resolve with a number in brackets' do
+      assert_resolves(object, "$[0]", [1])
+    end
+    should 'resolve another number in brackets' do
+      assert_resolves(object, "$[4]", [nil])
+    end
+    should 'resolve a star in brackets' do
+      assert_resolves(object, "$[*]", [1, "2", 3.14, true, nil])
+    end
+    should 'resolve an end slice' do
+      assert_resolves(object, "$[-1:]", [nil])
+    end
+  end
+  context 'Sample 3' do
+    setup { @json = %({"points":[{"id": "i1", "x": 4, "y": -5}, {"id": "i2", "x": -2, "y": 2, "z": 1}, {"id": "i3", "x": 8, "y": 3}, {"id": "i4", "x": -6, "y": -1}, {"id": "i5", "x": 0, "y": 2, "z": 1}, {"id": "i6", "x": 1, "y": 4}]}) }
+    should 'resolve correctly' do
+      assert_resolves(object, "$.points[1]", [{"id" => "i2", "x" => -2, "y" => 2, "z" => 1}])
+    end
+    should 'resolve a chained path' do
+      assert_resolves(object, "$.points[4].x", [0])
+    end
+    should 'resolve by attribute match' do
+      assert_resolves(object, "$.points[?(@['id']=='i4')].x", [-6])
+    end
+    should 'resolve a chained path with a star in brackets' do
+      assert_resolves(object, "$.points[*].x", [4, -2, 8, -6, 0, 1])
+    end
+    should 'resolve by attribute operation' do
+      assert_resolves(object, "$['points'][?(@['x']*@['x']+@['y']*@['y'] > 50)].id", ["i3"])
+    end
+    should 'resolve by attribute existence' do
+      assert_resolves(object, "$.points[?(@['z'])].id", ["i2", "i5"])
+    end
+    should 'resolve by length property operation' do
+      assert_resolves(object, "$.points[(@.length-1)].id", ["i6"])
+    end
+  end
+  context 'Sample 4' do
+    setup { @json = %({"menu":{"header":"SVG Viewer","items":[{"id": "Open"}, {"id": "OpenNew", "label": "Open New"}, null, {"id": "ZoomIn", "label": "Zoom In"}, {"id": "ZoomOut", "label": "Zoom Out"}, {"id": "OriginalView", "label": "Original View"}, null, {"id": "Quality"}, {"id": "Pause"}, {"id": "Mute"}, null, {"id": "Find", "label": "Find..."}, {"id": "FindAgain", "label": "Find Again"}, {"id": "Copy"}, {"id": "CopyAgain", "label": "Copy Again"}, {"id": "CopySVG", "label": "Copy SVG"}, {"id": "ViewSVG", "label": "View SVG"}, {"id": "ViewSource", "label": "View Source"}, {"id": "SaveAs", "label": "Save As"}, null, {"id": "Help"}, {"id": "About", "label": "About Adobe CVG Viewer..."}]}}) }
+    should 'resolve testing on attribute' do
+      assert_resolves(object, "$.menu.items[?(@ && @['id'] && !@['label'])].id", ["Open", "Quality", "Pause", "Mute", "Copy", "Help"])
+    end
+    should 'resolve testing on attribute with regular expression' do
+      assert_resolves(object, "$.menu.items[?(@ && @['label'] && @['label'] =~ /SVG/)].id", ["CopySVG", "ViewSVG"])
+    end
+    should 'resolve on negative' do
+      # !nil == true in Ruby
+      assert_resolves(object, "$.menu.items[?(!@)]", [nil, nil, nil, nil])
+    end
+    should 'resolve descendant with number in brackets' do
+      assert_resolves(object, "$..[0]", [{"id" => "Open"}])
+    end
+  end
+  context 'Sample 5' do
+    setup { @json = %({"a":[1, 2, 3, 4],"b":[5, 6, 7, 8]}) }
+    should 'resolve descendant with number in brackets' do
+      assert_resolves(object, "$..[0]", [1, 5])
+    end
+    should 'resolve descendant last items' do
+      assert_resolves(object, "$..[-1:]", [4, 8])
+    end
+    should 'resolve by descendant value' do
+      assert_resolves(object, "$..[?(@.is_a?(Numeric) && @ % 2 == 0)]", [2, 4, 6, 8])
+    end
+  end
+  context 'Sample 6' do
+    setup { @json = %({"lin":{"color":"red","x":2,"y":3},"cir":{"color":"blue","x":5,"y":2,"r":1},"arc":{"color":"green","x":2,"y":4,"r":2,"phi0":30,"dphi":120},"pnt":{"x":0,"y":7}}) }
+    should 'resolve by operation in quotes' do
+      assert_resolves(object, "$.'?(@['color'])'.x", [2, 5, 2])
+    end
+    should 'resolve by multiple quoted values in brackets' do
+      assert_resolves(object, "$['lin','cir'].color", ["red", "blue"])
+    end
+  end
+  context 'Sample 7' do
+    setup { @json = %({"text":["hello", "world2.0"]}) }
+    should 'resolve correctly filter 1' do
+      assert_resolves(object, "$.text[?(@.length > 5)]", ["world2.0"])
+    end
+    should 'resolve correctly filter 2' do
+      assert_resolves(object, "$.text[?(@[0, 1] == 'h')]", ["hello"])
+    end
+  end
+  context 'Sample 8' do
+    setup { @json = %({"a":{"a":2,"b":3},"b":{"a":4,"b":5},"c":{"a":{"a":6,"b":7},"c":8}}) }
+    should 'resolve descendant' do
+      assert_resolves(object, "$..a", [{"a" => 2, "b" => 3}, 2, 4, {"a" => 6, "b" => 7}, 6])
+    end
+  end
+  context 'Sample 10' do
+    setup { @json = %({"a":[{"a": 5, "@": 2, "$": 3}, {"a": 6, "@": 3, "$": 4}, {"a": 7, "@": 4, "$": 5}]}) }
+    should 'resolve with quoted operation and escaped special character' do
+      assert_resolves(object, "$.a[?(@['\\@']==3)]", [{"a" => 6, "@" => 3, "$" => 4}])
+    end
+    should 'resolve with quotes and brackets in operation' do
+      assert_resolves(object, "$.a[?(@['$']==5)]", [{"a" => 7, "@" => 4, "$" => 5}])
+    end
+  end
+    
+  private
+  
+  def object
+    JSON.parse(@json)
+  end
+    
+end

data/test/test_helper.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'jsonpath'
+
+class Test::Unit::TestCase
+  
+  private
+  
+  def parser
+    @parser ||= JSONPath::Parser.new
+  end
+  
+  def parse(path)
+    parser.parse(path)
+  end
+  
+  def assert_parses(path)
+    result = parse(path)
+    assert result, parser.failure_reason
+  end
+  
+  def assert_resolves(obj, path, result)
+    assert_parses path
+    assert_equal safe_sort(result), safe_sort(parse(path).walk(obj))
+  end
+  
+  def safe_sort(objs)
+    objs.sort_by do |obj|
+      obj ? obj.to_s : 0.to_s
+    end
+  end
+  
+end