jamespath 0.5.0

data/test/compliance/multiselect.json

@@ -0,0 +1,214 @@
+[{
+    "given": {
+      "foo": {
+        "bar": "bar",
+        "baz": "baz",
+        "qux": "qux",
+        "nested": {
+          "one": {
+            "a": "first",
+            "b": "second",
+            "c": "third"
+          },
+          "two": {
+            "a": "first",
+            "b": "second",
+            "c": "third"
+          },
+          "three": {
+            "a": "first",
+            "b": "second",
+            "c": {"inner": "third"}
+          }
+        }
+      },
+      "bar": 1,
+      "baz": 2,
+      "qux\"": 3
+    },
+     "cases": [
+         {
+            "expression": "foo.{bar: bar}",
+            "result": {"bar": "bar"}
+         },
+         {
+            "expression": "foo.{\"bar\": bar}",
+            "result": {"bar": "bar"}
+         },
+         {
+            "expression": "foo.{\"foo.bar\": bar}",
+            "result": {"foo.bar": "bar"}
+         },
+         {
+            "expression": "foo.{bar: bar, baz: baz}",
+            "result": {"bar": "bar", "baz": "baz"}
+         },
+         {
+            "expression": "foo.{\"bar\": bar, \"baz\": baz}",
+            "result": {"bar": "bar", "baz": "baz"}
+         },
+         {
+            "expression": "{\"baz\": baz, \"qux\\\"\": \"qux\\\"\"}",
+            "result": {"baz": 2, "qux\"": 3}
+         },
+         {
+            "expression": "foo.{bar:bar,baz:baz}",
+            "result": {"bar": "bar", "baz": "baz"}
+         },
+         {
+            "expression": "foo.{bar: bar,qux: qux}",
+            "result": {"bar": "bar", "qux": "qux"}
+         },
+         {
+            "expression": "foo.{bar: bar, noexist: noexist}",
+            "result": {"bar": "bar", "noexist": null}
+         },
+         {
+            "expression": "foo.{noexist: noexist, alsonoexist: alsonoexist}",
+            "result": {"noexist": null, "alsonoexist": null}
+         },
+         {
+            "expression": "foo.badkey.{nokey: nokey, alsonokey: alsonokey}",
+            "result": null
+         },
+         {
+            "expression": "foo.nested.*.{a: a,b: b}",
+            "result": [{"a": "first", "b": "second"},
+                       {"a": "first", "b": "second"},
+                       {"a": "first", "b": "second"}]
+         },
+         {
+            "expression": "foo.nested.three.{a: a, cinner: c.inner}",
+            "result": {"a": "first", "cinner": "third"}
+         },
+         {
+            "expression": "foo.nested.three.{a: a, c: c.inner.bad.key}",
+            "result": {"a": "first", "c": null}
+         },
+         {
+            "expression": "foo.{a: nested.one.a, b: nested.two.b}",
+            "result": {"a": "first", "b": "second"}
+         },
+         {
+            "expression": "{bar: bar, baz: baz}",
+            "result": {"bar": 1, "baz": 2}
+         },
+         {
+            "expression": "{bar: bar}",
+            "result": {"bar": 1}
+         },
+         {
+            "expression": "{otherkey: bar}",
+            "result": {"otherkey": 1}
+         },
+         {
+            "expression": "{no: no, exist: exist}",
+            "result": {"no": null, "exist": null}
+         },
+         {
+            "expression": "foo.[bar]",
+            "result": ["bar"]
+         },
+         {
+            "expression": "foo.[bar,baz]",
+            "result": ["bar", "baz"]
+         },
+         {
+            "expression": "foo.[bar,qux]",
+            "result": ["bar", "qux"]
+         },
+         {
+            "expression": "foo.[bar,noexist]",
+            "result": ["bar", null]
+         },
+         {
+            "expression": "foo.[noexist,alsonoexist]",
+            "result": [null, null]
+         }
+     ]
+}, {
+    "given": {
+      "foo": {"bar": 1, "baz": [2, 3, 4]}
+    },
+    "cases": [
+         {
+            "expression": "foo.{bar:bar,baz:baz}",
+            "result": {"bar": 1, "baz": [2, 3, 4]}
+         },
+         {
+            "expression": "foo.[bar,baz[0]]",
+            "result": [1, 2]
+         },
+         {
+            "expression": "foo.[bar,baz[1]]",
+            "result": [1, 3]
+         },
+         {
+            "expression": "foo.[bar,baz[2]]",
+            "result": [1, 4]
+         },
+         {
+            "expression": "foo.[bar,baz[3]]",
+            "result": [1, null]
+         },
+         {
+            "expression": "foo.[bar[0],baz[3]]",
+            "result": [null, null]
+         }
+    ]
+}, {
+    "given": {
+      "foo": {"bar": 1, "baz": 2}
+    },
+    "cases": [
+         {
+            "expression": "foo.{bar: bar, baz: baz}",
+            "result": {"bar": 1, "baz": 2}
+         },
+         {
+            "expression": "foo.[bar,baz]",
+            "result": [1, 2]
+         }
+    ]
+}, {
+    "given": {
+      "foo": {
+          "bar": {"baz": [{"one": 1}, {"two": 2}]},
+          "ignoreme": 1,
+          "includeme": true
+      }
+    },
+    "cases": [
+         {
+            "expression": "foo.{bar: bar.baz[1],includeme: includeme}",
+            "result": {"bar": {"two": 2}, "includeme": true}
+         },
+         {
+            "expression": "foo.{\"bar.baz.two\": bar.baz[1].two, includeme: includeme}",
+            "result": {"bar.baz.two": 2, "includeme": true}
+         }
+    ]
+}, {
+    "given": {
+      "reservations": [{
+          "instances": [
+              {"id": "id1",
+               "name": "first"},
+              {"id": "id2",
+               "name": "second"}
+          ]}, {
+          "instances": [
+              {"id": "id3",
+               "name": "third"},
+              {"id": "id4",
+               "name": "fourth"}
+          ]}
+      ]},
+    "cases": [
+         {
+            "expression": "reservations[*].instances[*].{id: id, name: name}",
+            "result": [[{"id": "id1", "name": "first"}, {"id": "id2", "name": "second"}],
+                       [{"id": "id3", "name": "third"}, {"id": "id4", "name": "fourth"}]]
+         }
+    ]
+}]

data/test/compliance/ormatch.json

@@ -0,0 +1,46 @@
+[{
+    "given":
+        {"outer": {"foo": "foo", "bar": "bar", "baz": "baz"}},
+     "cases": [
+         {
+            "expression": "outer.foo || outer.bar",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.foo||outer.bar",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.bar || outer.baz",
+            "result": "bar"
+         },
+         {
+            "expression": "outer.bar||outer.baz",
+            "result": "bar"
+         },
+         {
+            "expression": "outer.bad || outer.foo",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.bad||outer.foo",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.foo || outer.bad",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.foo||outer.bad",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.bad || outer.alsobad",
+            "result": null
+         },
+         {
+            "expression": "outer.bad||outer.alsobad",
+            "result": null
+         }
+     ]
+}]

data/test/compliance/wildcard.json

@@ -0,0 +1,100 @@
+[{
+    "given": {
+        "foo": {
+            "bar": {
+                "baz": "one"
+            },
+            "other": {
+                "baz": "two"
+            },
+            "other2": {
+                "baz": "three"
+            },
+            "other3": {
+                "notbaz": ["a", "b", "c"]
+            },
+            "other4": {
+                "notbaz": ["d", "e", "f"]
+            }
+        }
+    },
+    "cases": [
+         {
+            "expression": "foo.*.baz",
+            "result": ["one", "two", "three"]
+         },
+         {
+            "expression": "foo.bar.*",
+            "result": ["one"]
+         },
+         {
+            "expression": "foo.*.notbaz",
+            "result": [["a", "b", "c"], ["d", "e", "f"]]
+         },
+         {
+            "expression": "foo.*.notbaz[0]",
+            "result": ["a", "d"]
+         },
+         {
+            "expression": "foo.*.notbaz[-1]",
+            "result": ["c", "f"]
+         },
+         {
+            "expression": "foo.*",
+            "result": [{"baz": "one"}, {"baz": "two"}, {"baz": "three"}, {"notbaz": ["a", "b", "c"]}, {"notbaz": ["d", "e", "f"]}]
+         },
+         {
+            "expression": "foo.*.*",
+            "result": null
+         },
+         {
+            "expression": "foo.*.*.*",
+            "result": null
+         },
+         {
+            "expression": "foo.*.*.*.*",
+            "result": null
+         }
+    ]
+}, {
+    "given": {
+        "foo": {
+            "bar": "one"
+        },
+        "other": {
+            "bar": "two"
+        },
+        "nomatch": {
+            "notbar": "three"
+        }
+    },
+    "cases": [
+         {
+            "expression": "*.bar",
+            "result": ["one", "two"]
+         }
+    ]
+}, {
+    "given": {
+        "top1": {
+            "sub1": {"foo": "one"}
+        },
+        "top2": {
+            "sub1": {"foo": "two"}
+        },
+        "top3": {
+            "sub3": {"notfoo": "notfoo"}
+        }
+    },
+    "cases": [
+         {
+            "expression": "*.*.foo",
+            "result": null
+         },
+         {
+            "expression": "*.sub1.foo",
+            "result": ["one", "two"]
+         }
+    ]
+}
+]

data/test/compliance_test.rb

@@ -0,0 +1,29 @@
+require 'minitest/autorun'
+require 'json'
+require_relative '../lib/jamespath'
+
+def compliance_test(file)
+  json = File.read(File.dirname(__FILE__) + '/compliance/' + file + '.json')
+  test_datas = JSON.parse(json)
+  describe "Compliance for #{file}.json" do
+    test_datas.each.with_index do |test_data, i|
+      describe "Given case #{i+1}" do
+        object = test_data['given']
+        test_data['cases'].each do |test_case|
+          expr, result = test_case['expression'], test_case['result']
+          it "handles '#{expr}'" do
+            Jamespath.search(expr, object).must_equal(result)
+          end
+        end
+      end
+    end
+  end
+end
+
+describe "Compliance testing" do
+  compliance_test 'basic'
+  compliance_test 'escape'
+  compliance_test 'ormatch'
+  compliance_test 'wildcard'
+  compliance_test 'indices'
+end

data/test/struct_test.rb

@@ -0,0 +1,23 @@
+require 'minitest/autorun'
+require_relative '../lib/jamespath'
+
+describe "Struct" do
+
+  it "treats struct objects like hashes" do
+    struct_class = Struct.new(:foo, :bar)
+    data = struct_class.new(struct_class.new(nil, 'yuck'), nil)
+    Jamespath.search('foo.bar', data).must_equal('yuck')
+  end
+
+  it "selects all values from a struct" do
+    struct_class = Struct.new(:foo, :bar)
+    data = struct_class.new(nil, struct_class.new('f', 'b'))
+    Jamespath.search('bar.*', data).must_equal(['f', 'b'])
+  end
+
+  it "supports wildcard indexing on structs" do
+    struct_class = Struct.new(:foo, :bar)
+    data = struct_class.new('foo_value', 'bar_value')
+    Jamespath.search('[*]', data).must_equal(['foo', 'bar'])
+  end
+end

data/test/tokenizer_test.rb

@@ -0,0 +1,15 @@
+require 'minitest/autorun'
+require_relative '../lib/jamespath'
+
+describe Jamespath::Tokenizer do
+
+  it "handles tokenization errors" do
+    err = nil
+    begin
+      Jamespath::Tokenizer.new.tokenize('foo.$%^&')
+    rescue SyntaxError => e
+      err = e
+    end
+    err.message.must_equal 'unexpected token at pos=4: $'
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: jamespath
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Loren Segal
+- Trevor Rowe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: rdiscount
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.7
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.7
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Like XPath, but for JSON and other structured objects.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- jamespath.gemspec
+- lib/jamespath.rb
+- lib/jamespath/parser.rb
+- lib/jamespath/tokenizer.rb
+- lib/jamespath/version.rb
+- lib/jamespath/vm.rb
+- test/compliance/basic.json
+- test/compliance/escape.json
+- test/compliance/indices.json
+- test/compliance/multiselect.json
+- test/compliance/ormatch.json
+- test/compliance/wildcard.json
+- test/compliance_test.rb
+- test/struct_test.rb
+- test/tokenizer_test.rb
+homepage: http://github.com/lsegal/jamespath
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Implements JMESpath declarative object searching.
+test_files:
+- test/compliance/basic.json
+- test/compliance/escape.json
+- test/compliance/indices.json
+- test/compliance/multiselect.json
+- test/compliance/ormatch.json
+- test/compliance/wildcard.json
+- test/compliance_test.rb
+- test/struct_test.rb
+- test/tokenizer_test.rb
+has_rdoc: