jsonpath 0.9.9 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: '090827e0ad9fbdb81bf8a03fbd783b3ec6791fe75f272f34a867d4230941acbc'
-  data.tar.gz: 1590a5a7c869b86f6c8f9cd2f6fc356fffb7d1456012adbdcd1c39a2cad08ca3
+SHA1:
+  metadata.gz: 86c7a2524bbfbf973b55437a09068d62ae594a05
+  data.tar.gz: 8653a33163faa160f9eef04155e3906ff6419343
 SHA512:
-  metadata.gz: 46e38791ff5794763c762360b7721944f283c32f317e10e046171c6a57b40afb62b0f9cc5db924f52a95b2135b248a8e055a7da08341b95641dc38fec3e8b26f
-  data.tar.gz: 52e95058cf0373fc98c3773585542960bd3a1cac2f13e3b038820cc6c91311f165441a2aa80644c20ad60be1c9c04cb17b5dfd79c8307e7a70627969aabe7c90
+  metadata.gz: ca8350260d52a9c24fc1782393975e74a14639c6152a6d4e450efde8e980882aefd0009ed1c6063cd24be2d36e5f64c16e81e361a42c075b35494c613b1c57d2
+  data.tar.gz: aa60fa92da9e3ba857f3914ebb902a473bada3f53a4486997d04a7d37530c942fbe93b13e3ac4cd4e39253ae2b57cdc8191afd4875ab1d9a34e678afb41ae2dc

data/lib/jsonpath/parser.rb

@@ -8,22 +8,46 @@ class JsonPath
   class Parser
     def initialize(node)
       @_current_node = node
+      @_expr_map = {}
     end
 
+    # parse will parse an expression in the following way.
+    # Split the expression up into an array of legs for && and || operators.
+    # Parse this array into a map for which the keys are the parsed legs
+    # of the split. This map is then used to replace the expression with their
+    # corresponding boolean or numeric value. This might look something like this:
+    # ((false || false) && (false || true))
+    # Once this string is assembled... we proceed to evaluate from left to right.
+    # The above string is broken down like this:
+    # (false && (false || true))
+    # (false && true)
+    # false
     def parse(exp)
       exps = exp.split(/(&&)|(\|\|)/)
-      ret = parse_exp(exps.shift)
+      construct_expression_map(exps)
+      @_expr_map.each {|k, v| exp.sub!(k, "#{v}")}
+      raise ArgumentError, "unmatched parenthesis in expression: #{exp}" unless check_parenthesis_count(exp)
+      while (exp.include?("("))
+        exp = parse_parentheses(exp)
+      end
+      bool_or_exp(exp)
+    end
+
+    # Construct a map for which the keys are the expressions
+    # and the values are the corresponding parsed results.
+    # Exp.:
+    # {"(@['author'] =~ /herman|lukyanenko/i)"=>0}
+    # {"@['isTrue']"=>true}
+    def construct_expression_map(exps)
       exps.each_with_index do |item, index|
-        case item
-        when '&&'
-          ret &&= parse_exp(exps[index + 1])
-        when '||'
-          ret ||= parse_exp(exps[index + 1])
-        end
+        next if item == '&&' || item == '||'
+        item = item.strip.gsub(/\)*$/, '').gsub(/^\(*/, '')
+        @_expr_map[item] = parse_exp(item)
       end
-      ret
     end
 
+    # using a scanner break down the individual expressions and determine if
+    # there is a match in the JSON for it or not.
     def parse_exp(exp)
       exp = exp.sub(/@/, '').gsub(/^\(/, '').gsub(/\)$/, '').tr('"', '\'').strip
       scanner = StringScanner.new(exp)
@@ -79,5 +103,86 @@ class JsonPath
       prev = keys.shift
       dig(keys, hash.fetch(prev))
     end
+
+    # This will break down a parenthesis from the left to the right
+    # and replace the given expression with it's returned value.
+    # It does this in order to make it easy to eliminate groups
+    # one-by-one.
+    def parse_parentheses(str)
+      opening_index = 0
+      closing_index = 0
+
+      (0..str.length-1).step(1) do |i|
+        if str[i] == '('
+          opening_index = i
+        end
+        if str[i] == ')'
+          closing_index = i
+          break
+        end
+      end
+
+      to_parse = str[opening_index+1..closing_index-1]
+
+      # handle cases like (true && true || false && true) in
+      # one giant parenthesis.
+      top = to_parse.split(/(&&)|(\|\|)/)
+      top = top.map{|t| t.strip}
+      res = bool_or_exp(top.shift)
+      top.each_with_index do |item, index|
+        case item
+        when '&&'
+          res &&= top[index + 1]
+        when '||'
+          res ||= top[index + 1]
+        end
+      end
+
+      # if we are at the last item, the opening index will be 0
+      # and the closing index will be the last index. To avoid
+      # off-by-one errors we simply return the result at that point.
+      if closing_index+1 >= str.length && opening_index == 0
+        return "#{res}"
+      else
+        return "#{str[0..opening_index-1]}#{res}#{str[closing_index+1..str.length]}"
+      end
+    end
+
+    # This is convoluted and I should probably refactor it somehow.
+    # The map that is created will contain strings since essentially I'm
+    # constructing a string like `true || true && false`.
+    # With eval the need for this would disappear but never the less, here
+    # it is. The fact is that the results can be either boolean, or a number
+    # in case there is only indexing happening like give me the 3rd item... or
+    # it also can be nil in case of regexes or things that aren't found.
+    # Hence, I have to be clever here to see what kind of variable I need to
+    # provide back.
+    def bool_or_exp(b)
+      if "#{b}" == 'true'
+        return true
+      elsif "#{b}" == 'false'
+        return false
+      elsif "#{b}" == ""
+        return nil
+      end
+      b = Float(b) rescue b
+      b
+    end
+
+    # this simply makes sure that we aren't getting into the whole
+    # parenthesis parsing business without knowing that every parenthesis
+    # has its pair.
+    def check_parenthesis_count(exp)
+      return true unless exp.include?("(")
+      depth = 0
+      exp.chars.each do |c|
+        if c == '('
+          depth += 1
+        elsif c == ')'
+          depth -= 1
+        end
+      end
+      depth == 0
+    end
   end
 end

data/lib/jsonpath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class JsonPath
-  VERSION = '0.9.9'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/test/test_jsonpath.rb

@@ -717,6 +717,17 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal [true], JsonPath.on(json, broken_path)
   end
 
+  def test_complex_nested_grouping
+    path = "$..book[?((@['author'] == 'Evelyn Waugh' || @['author'] == 'Herman Melville') && (@['price'] == 33 || @['price'] == 9))]"
+    assert_equal [@object['store']['book'][2]], JsonPath.new(path).on(@object)
+  end
+
+  def test_complex_nested_grouping_unmatched_parent
+    path = "$..book[?((@['author'] == 'Evelyn Waugh' || @['author'] == 'Herman Melville' && (@['price'] == 33 || @['price'] == 9))]"
+    err = assert_raises(ArgumentError, "should have raised an exception") { JsonPath.new(path).on(@object)}
+    assert_match(/unmatched parenthesis in expression: \(\(false \|\| false && \(false \|\| true\)\)/, err.message)
+  end
+
   def test_delete_more_items
     a = { 'itemList' =>
       [{ 'alfa' => 'beta1' },

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonpath
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 1.0.0
 platform: ruby
 authors:
 - Joshua Hull
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-07 00:00:00.000000000 Z
+date: 2019-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -158,7 +158,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubyforge_project: jsonpath
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of http://goessner.net/articles/JsonPath/