jpt 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11f0008d935a2ce891b13af68fe35da1984c733c6d36cc03a3490749ac5deaa6
-  data.tar.gz: fbe7f467057066b07c70fb6f37628f0b105b08e8da560af4f99f3a94aa3336d8
+  metadata.gz: b5cd5e1be60d226440d14670f9fc40383d68ce388e9e7cef676912959024a58d
+  data.tar.gz: 774cd3d70e96d9bc57cf1b55549a71cba3f3cebd084e90c8ccc28cb89562e620
 SHA512:
-  metadata.gz: ecc6e9084048e7d9253fd14c175acc83e932caad33817790579d1f53000bca8efc89cf350fead4255b27fa9b72ec1fd67a6b67c9f0ccfbee4b1c9a23ee40b11e
-  data.tar.gz: 4a7a95f87230e35d9c5437aba5da7593f9a08bdbedabc09d56d4143dd72254e1c224c06f9fbc725d64a75a68c286db44ae601bb358af4926c8ac1c56c8708e23
+  metadata.gz: 0a304a2b0562e0ccb5553fc28d3dea48714bed50c5c6bdaae37ebf2577d5eae9b5c55937b91fba3dc9571146e7371aba7850f97ae00727b9ff5d9e1db77f0eb1
+  data.tar.gz: 718acc8d15e8a56fb23f3147adf8c68ab6ef40710df1bda90e29c4ed323d29d810a8cebfa20f1197078d56e04351f49194e3614e42139cd16b646517544aa758

data/jpt.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "jpt"
-  s.version = "0.1.0"
+  s.version = "0.1.2"
   s.summary = "JSONPath tools"
   s.description = %q{jpt implements converters and miscellaneous tools for JSONPath}
   s.author = "Carsten Bormann"

data/lib/jpt.rb

@@ -15,6 +15,13 @@ module JPTType
     FUNCTABLE[name] = sig.chars.map {FUNCSIG_CHARS[_1]}
   end
 
+  def query_singular?(ast)
+    case ast
+    in [("@" | "$"), *segments]
+      ! segments.any? {|segment| Array === segment}
+    end
+  end
+
   def declared_type(ast)
     case ast
     in Numeric | String | false | true | nil
@@ -39,7 +46,9 @@ module JPTType
     case [dt, rt]
     in a, b if a == b
       true
-    in [:nodes, :value] | [:nodes, :logical]
+    in [:nodes, :value]
+      query_singular?(ast)
+    in [:nodes, :logical]
       true
     else
       warn "*** Cannot use #{ast} with declared_type #{dt||:undefined} for required type #{rt}#{s}"
@@ -216,7 +225,7 @@ class JPT
 
   def filt_to_logical(val)
     case val
-    in [:nodes, v]
+    in [(:nodes|:onenode), v]
       v != []
     in [:logical, v]
       v
@@ -225,10 +234,11 @@ class JPT
 
   def filt_to_value(val)
     case val
-    in [:nodes, v]
-      if v.length == 1
+    in [:onenode, v]
+      case v.length
+      in 1
         v[0]
-      else
+      in 0
         :nothing
       end
     in [:value, v]
@@ -242,9 +252,11 @@ class JPT
     # warn "***B #{logexp.inspect} #{root_node.inspect} #{curr_node.inspect}"
     case logexp
     in ["@", *]
-      [:nodes, select_query(logexp, curr_node, root_node, curr_node)]
+      rt = query_singular?(logexp) ? :onenode : :nodes
+      [rt, select_query(logexp, curr_node, root_node, curr_node)]
     in ["$", *]
-      [:nodes, select_query(logexp, root_node, root_node, curr_node)]
+      rt = query_singular?(logexp) ? :onenode : :nodes
+      [rt, select_query(logexp, root_node, root_node, curr_node)]
     in [("==" | "!=" | "<" | ">" | "<=" | ">="), a, b]
       lhs = filt_to_value(filt_apply(a, root_node, curr_node)) rescue :nothing
       rhs = filt_to_value(filt_apply(b, root_node, curr_node)) rescue :nothing
@@ -299,7 +311,7 @@ class JPT
     in ["func", "count", nodes]
       ty, nodes = filt_apply(nodes, root_node, curr_node)
       [:value,
-       if ty != :nodes
+       if ty != :nodes && ty != :onenode
          warn "*** func count ty #{ty.inspect}"
          0
        else

data/lib/parser/jptgrammar.rb

@@ -10,7 +10,7 @@ module JPTGRAMMAR
   end
 
   module Jptgrammar0
-    def json_path
+    def jsonpath_query
       elements[0]
     end
 
@@ -21,7 +21,7 @@ module JPTGRAMMAR
 
   module Jptgrammar1
     def ast
-      json_path.ast
+      jsonpath_query.ast
     end
   end
 
@@ -37,7 +37,7 @@ module JPTGRAMMAR
     end
 
     i0, s0 = index, []
-    r1 = _nt_json_path
+    r1 = _nt_jsonpath_query
     s0 << r1
     if r1
       r2 = _nt_S
@@ -57,7 +57,7 @@ module JPTGRAMMAR
     r0
   end
 
-  module JsonPath0
+  module JsonpathQuery0
     def root_identifier
       elements[0]
     end
@@ -67,18 +67,18 @@ module JPTGRAMMAR
     end
   end
 
-  module JsonPath1
+  module JsonpathQuery1
     def ast
       ["$", *segments.ast]
     end
   end
 
-  def _nt_json_path
+  def _nt_jsonpath_query
     start_index = index
-    if node_cache[:json_path].has_key?(index)
-      cached = node_cache[:json_path][index]
+    if node_cache[:jsonpath_query].has_key?(index)
+      cached = node_cache[:jsonpath_query][index]
       if cached
-        node_cache[:json_path][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:jsonpath_query][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -93,14 +93,14 @@ module JPTGRAMMAR
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(JsonPath0)
-      r0.extend(JsonPath1)
+      r0.extend(JsonpathQuery0)
+      r0.extend(JsonpathQuery1)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:json_path][start_index] = r0
+    node_cache[:jsonpath_query][start_index] = r0
 
     r0
   end
@@ -163,6 +163,101 @@ module JPTGRAMMAR
     r0
   end
 
+  def _nt_B
+    start_index = index
+    if node_cache[:B].has_key?(index)
+      cached = node_cache[:B][index]
+      if cached
+        node_cache[:B][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if (match_len = has_terminal?(" ", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('" "')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("\t", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"\\t"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        if (match_len = has_terminal?("\n", false, index))
+          r3 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"\\n"')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          if (match_len = has_terminal?("\r", false, index))
+            r4 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"\\r"')
+            r4 = nil
+          end
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+    end
+
+    node_cache[:B][start_index] = r0
+
+    r0
+  end
+
+  def _nt_S
+    start_index = index
+    if node_cache[:S].has_key?(index)
+      cached = node_cache[:S][index]
+      if cached
+        node_cache[:S][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_B
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+    node_cache[:S][start_index] = r0
+
+    r0
+  end
+
   def _nt_root_identifier
     start_index = index
     if node_cache[:root_identifier].has_key?(index)
@@ -692,11 +787,11 @@ module JPTGRAMMAR
           r0.extend(Unescaped0)
           r0.extend(Unescaped0)
         else
-          if has_terminal?(@regexps[gr = '\A[\\]-􏿿]'] ||= Regexp.new(gr), :regexp, index)
+          if has_terminal?(@regexps[gr = '\A[\\]-퟿]'] ||= Regexp.new(gr), :regexp, index)
             r4 = true
             @index += 1
           else
-            terminal_parse_failure('[\\]-􏿿]')
+            terminal_parse_failure('[\\]-퟿]')
             r4 = nil
           end
           if r4
@@ -705,8 +800,22 @@ module JPTGRAMMAR
             r0.extend(Unescaped0)
             r0.extend(Unescaped0)
           else
-            @index = i0
-            r0 = nil
+            if has_terminal?(@regexps[gr = '\A[-􏿿]'] ||= Regexp.new(gr), :regexp, index)
+              r5 = true
+              @index += 1
+            else
+              terminal_parse_failure('[-􏿿]')
+              r5 = nil
+            end
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+              r0.extend(Unescaped0)
+              r0.extend(Unescaped0)
+            else
+              @index = i0
+              r0 = nil
+            end
           end
         end
       end
@@ -1887,114 +1996,19 @@ module JPTGRAMMAR
     r0
   end
 
-  def _nt_B
-    start_index = index
-    if node_cache[:B].has_key?(index)
-      cached = node_cache[:B][index]
-      if cached
-        node_cache[:B][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0 = index
-    if (match_len = has_terminal?(" ", false, index))
-      r1 = true
-      @index += match_len
-    else
-      terminal_parse_failure('" "')
-      r1 = nil
-    end
-    if r1
-      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
-      r0 = r1
-    else
-      if (match_len = has_terminal?("\t", false, index))
-        r2 = true
-        @index += match_len
-      else
-        terminal_parse_failure('"\\t"')
-        r2 = nil
-      end
-      if r2
-        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
-        r0 = r2
-      else
-        if (match_len = has_terminal?("\n", false, index))
-          r3 = true
-          @index += match_len
-        else
-          terminal_parse_failure('"\\n"')
-          r3 = nil
-        end
-        if r3
-          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
-          r0 = r3
-        else
-          if (match_len = has_terminal?("\r", false, index))
-            r4 = true
-            @index += match_len
-          else
-            terminal_parse_failure('"\\r"')
-            r4 = nil
-          end
-          if r4
-            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
-            r0 = r4
-          else
-            @index = i0
-            r0 = nil
-          end
-        end
-      end
-    end
-
-    node_cache[:B][start_index] = r0
-
-    r0
-  end
-
-  def _nt_S
-    start_index = index
-    if node_cache[:S].has_key?(index)
-      cached = node_cache[:S][index]
-      if cached
-        node_cache[:S][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    s0, i0 = [], index
-    loop do
-      r1 = _nt_B
-      if r1
-        s0 << r1
-      else
-        break
-      end
-    end
-    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-
-    node_cache[:S][start_index] = r0
-
-    r0
-  end
-
   module FilterSelector0
     def S
       elements[1]
     end
 
-    def boolean_expr
+    def logical_expr
       elements[2]
     end
   end
 
   module FilterSelector1
     def ast
-      ["filt", boolean_expr.ast]
+      ["filt", logical_expr.ast]
     end
   end
 
@@ -2022,7 +2036,7 @@ module JPTGRAMMAR
       r2 = _nt_S
       s0 << r2
       if r2
-        r3 = _nt_boolean_expr
+        r3 = _nt_logical_expr
         s0 << r3
       end
     end
@@ -2040,12 +2054,12 @@ module JPTGRAMMAR
     r0
   end
 
-  def _nt_boolean_expr
+  def _nt_logical_expr
     start_index = index
-    if node_cache[:boolean_expr].has_key?(index)
-      cached = node_cache[:boolean_expr][index]
+    if node_cache[:logical_expr].has_key?(index)
+      cached = node_cache[:logical_expr][index]
       if cached
-        node_cache[:boolean_expr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:logical_expr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -2053,7 +2067,7 @@ module JPTGRAMMAR
 
     r0 = _nt_logical_or_expr
 
-    node_cache[:boolean_expr][start_index] = r0
+    node_cache[:logical_expr][start_index] = r0
 
     r0
   end
@@ -2294,6 +2308,143 @@ module JPTGRAMMAR
     r0
   end
 
+  module ParenExpr0
+    def logical_not_op
+      elements[0]
+    end
+
+    def S
+      elements[1]
+    end
+  end
+
+  module ParenExpr1
+    def S1
+      elements[2]
+    end
+
+    def logical_expr
+      elements[3]
+    end
+
+    def S2
+      elements[4]
+    end
+
+  end
+
+  module ParenExpr2
+    def ast
+      if elements[0].text_value == ''
+        elements[3].ast
+      else
+        ["not", elements[3].ast]
+      end
+    end
+  end
+
+  def _nt_paren_expr
+    start_index = index
+    if node_cache[:paren_expr].has_key?(index)
+      cached = node_cache[:paren_expr][index]
+      if cached
+        node_cache[:paren_expr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    i2, s2 = index, []
+    r3 = _nt_logical_not_op
+    s2 << r3
+    if r3
+      r4 = _nt_S
+      s2 << r4
+    end
+    if s2.last
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      r2.extend(ParenExpr0)
+    else
+      @index = i2
+      r2 = nil
+    end
+    if r2
+      r1 = r2
+    else
+      r1 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?("(", false, index))
+        r5 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"("')
+        r5 = nil
+      end
+      s0 << r5
+      if r5
+        r6 = _nt_S
+        s0 << r6
+        if r6
+          r7 = _nt_logical_expr
+          s0 << r7
+          if r7
+            r8 = _nt_S
+            s0 << r8
+            if r8
+              if (match_len = has_terminal?(")", false, index))
+                r9 = true
+                @index += match_len
+              else
+                terminal_parse_failure('")"')
+                r9 = nil
+              end
+              s0 << r9
+            end
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(ParenExpr1)
+      r0.extend(ParenExpr2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:paren_expr][start_index] = r0
+
+    r0
+  end
+
+  def _nt_logical_not_op
+    start_index = index
+    if node_cache[:logical_not_op].has_key?(index)
+      cached = node_cache[:logical_not_op][index]
+      if cached
+        node_cache[:logical_not_op][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if (match_len = has_terminal?("!", false, index))
+      r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"!"')
+      r0 = nil
+    end
+
+    node_cache[:logical_not_op][start_index] = r0
+
+    r0
+  end
+
   module TestExpr0
     def logical_not_op
       elements[0]
@@ -2355,7 +2506,7 @@ module JPTGRAMMAR
     s0 << r1
     if r1
       i5 = index
-      r6 = _nt_filter_path
+      r6 = _nt_filter_query
       if r6
         r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
         r5 = r6
@@ -2385,24 +2536,24 @@ module JPTGRAMMAR
     r0
   end
 
-  def _nt_filter_path
+  def _nt_filter_query
     start_index = index
-    if node_cache[:filter_path].has_key?(index)
-      cached = node_cache[:filter_path][index]
+    if node_cache[:filter_query].has_key?(index)
+      cached = node_cache[:filter_query][index]
       if cached
-        node_cache[:filter_path][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:filter_query][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
     i0 = index
-    r1 = _nt_rel_path
+    r1 = _nt_rel_query
     if r1
       r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
       r0 = r1
     else
-      r2 = _nt_json_path
+      r2 = _nt_jsonpath_query
       if r2
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
@@ -2412,12 +2563,12 @@ module JPTGRAMMAR
       end
     end
 
-    node_cache[:filter_path][start_index] = r0
+    node_cache[:filter_query][start_index] = r0
 
     r0
   end
 
-  module RelPath0
+  module RelQuery0
     def current_node_identifier
       elements[0]
     end
@@ -2427,18 +2578,18 @@ module JPTGRAMMAR
     end
   end
 
-  module RelPath1
+  module RelQuery1
     def ast
       ["@", *segments.ast]
     end
   end
 
-  def _nt_rel_path
+  def _nt_rel_query
     start_index = index
-    if node_cache[:rel_path].has_key?(index)
-      cached = node_cache[:rel_path][index]
+    if node_cache[:rel_query].has_key?(index)
+      cached = node_cache[:rel_query][index]
       if cached
-        node_cache[:rel_path][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:rel_query][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -2453,14 +2604,14 @@ module JPTGRAMMAR
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(RelPath0)
-      r0.extend(RelPath1)
+      r0.extend(RelQuery0)
+      r0.extend(RelQuery1)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:rel_path][start_index] = r0
+    node_cache[:rel_query][start_index] = r0
 
     r0
   end
@@ -2489,143 +2640,6 @@ module JPTGRAMMAR
     r0
   end
 
-  module ParenExpr0
-    def logical_not_op
-      elements[0]
-    end
-
-    def S
-      elements[1]
-    end
-  end
-
-  module ParenExpr1
-    def S1
-      elements[2]
-    end
-
-    def boolean_expr
-      elements[3]
-    end
-
-    def S2
-      elements[4]
-    end
-
-  end
-
-  module ParenExpr2
-    def ast
-      if elements[0].text_value == ''
-        elements[3].ast
-      else
-        ["not", elements[3].ast]
-      end
-    end
-  end
-
-  def _nt_paren_expr
-    start_index = index
-    if node_cache[:paren_expr].has_key?(index)
-      cached = node_cache[:paren_expr][index]
-      if cached
-        node_cache[:paren_expr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0, s0 = index, []
-    i2, s2 = index, []
-    r3 = _nt_logical_not_op
-    s2 << r3
-    if r3
-      r4 = _nt_S
-      s2 << r4
-    end
-    if s2.last
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      r2.extend(ParenExpr0)
-    else
-      @index = i2
-      r2 = nil
-    end
-    if r2
-      r1 = r2
-    else
-      r1 = instantiate_node(SyntaxNode,input, index...index)
-    end
-    s0 << r1
-    if r1
-      if (match_len = has_terminal?("(", false, index))
-        r5 = true
-        @index += match_len
-      else
-        terminal_parse_failure('"("')
-        r5 = nil
-      end
-      s0 << r5
-      if r5
-        r6 = _nt_S
-        s0 << r6
-        if r6
-          r7 = _nt_boolean_expr
-          s0 << r7
-          if r7
-            r8 = _nt_S
-            s0 << r8
-            if r8
-              if (match_len = has_terminal?(")", false, index))
-                r9 = true
-                @index += match_len
-              else
-                terminal_parse_failure('")"')
-                r9 = nil
-              end
-              s0 << r9
-            end
-          end
-        end
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(ParenExpr1)
-      r0.extend(ParenExpr2)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:paren_expr][start_index] = r0
-
-    r0
-  end
-
-  def _nt_logical_not_op
-    start_index = index
-    if node_cache[:logical_not_op].has_key?(index)
-      cached = node_cache[:logical_not_op][index]
-      if cached
-        node_cache[:logical_not_op][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    if (match_len = has_terminal?("!", false, index))
-      r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-      @index += match_len
-    else
-      terminal_parse_failure('"!"')
-      r0 = nil
-    end
-
-    node_cache[:logical_not_op][start_index] = r0
-
-    r0
-  end
-
   module ComparisonExpr0
     def comparable1
       elements[0]
@@ -2769,7 +2783,7 @@ module JPTGRAMMAR
       r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
       r0 = r1
     else
-      r2 = _nt_singular_path
+      r2 = _nt_singular_query
       if r2
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
@@ -2882,24 +2896,24 @@ module JPTGRAMMAR
     r0
   end
 
-  def _nt_singular_path
+  def _nt_singular_query
     start_index = index
-    if node_cache[:singular_path].has_key?(index)
-      cached = node_cache[:singular_path][index]
+    if node_cache[:singular_query].has_key?(index)
+      cached = node_cache[:singular_query][index]
       if cached
-        node_cache[:singular_path][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:singular_query][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
     i0 = index
-    r1 = _nt_rel_singular_path
+    r1 = _nt_rel_singular_query
     if r1
       r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
       r0 = r1
     else
-      r2 = _nt_abs_singular_path
+      r2 = _nt_abs_singular_query
       if r2
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
@@ -2909,33 +2923,33 @@ module JPTGRAMMAR
       end
     end
 
-    node_cache[:singular_path][start_index] = r0
+    node_cache[:singular_query][start_index] = r0
 
     r0
   end
 
-  module RelSingularPath0
+  module RelSingularQuery0
     def current_node_identifier
       elements[0]
     end
 
-    def singular_path_segments
+    def singular_query_segments
       elements[1]
     end
   end
 
-  module RelSingularPath1
+  module RelSingularQuery1
     def ast
-      ["@", *singular_path_segments.ast]
+      ["@", *singular_query_segments.ast]
     end
   end
 
-  def _nt_rel_singular_path
+  def _nt_rel_singular_query
     start_index = index
-    if node_cache[:rel_singular_path].has_key?(index)
-      cached = node_cache[:rel_singular_path][index]
+    if node_cache[:rel_singular_query].has_key?(index)
+      cached = node_cache[:rel_singular_query][index]
       if cached
-        node_cache[:rel_singular_path][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:rel_singular_query][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -2945,45 +2959,45 @@ module JPTGRAMMAR
     r1 = _nt_current_node_identifier
     s0 << r1
     if r1
-      r2 = _nt_singular_path_segments
+      r2 = _nt_singular_query_segments
       s0 << r2
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(RelSingularPath0)
-      r0.extend(RelSingularPath1)
+      r0.extend(RelSingularQuery0)
+      r0.extend(RelSingularQuery1)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:rel_singular_path][start_index] = r0
+    node_cache[:rel_singular_query][start_index] = r0
 
     r0
   end
 
-  module AbsSingularPath0
+  module AbsSingularQuery0
     def root_identifier
       elements[0]
     end
 
-    def singular_path_segments
+    def singular_query_segments
       elements[1]
     end
   end
 
-  module AbsSingularPath1
+  module AbsSingularQuery1
     def ast
-      ["$", *singular_path_segments.ast]
+      ["$", *singular_query_segments.ast]
     end
   end
 
-  def _nt_abs_singular_path
+  def _nt_abs_singular_query
     start_index = index
-    if node_cache[:abs_singular_path].has_key?(index)
-      cached = node_cache[:abs_singular_path][index]
+    if node_cache[:abs_singular_query].has_key?(index)
+      cached = node_cache[:abs_singular_query][index]
       if cached
-        node_cache[:abs_singular_path][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:abs_singular_query][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -2993,42 +3007,42 @@ module JPTGRAMMAR
     r1 = _nt_root_identifier
     s0 << r1
     if r1
-      r2 = _nt_singular_path_segments
+      r2 = _nt_singular_query_segments
       s0 << r2
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(AbsSingularPath0)
-      r0.extend(AbsSingularPath1)
+      r0.extend(AbsSingularQuery0)
+      r0.extend(AbsSingularQuery1)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:abs_singular_path][start_index] = r0
+    node_cache[:abs_singular_query][start_index] = r0
 
     r0
   end
 
-  module SingularPathSegments0
+  module SingularQuerySegments0
     def S
       elements[0]
     end
 
   end
 
-  module SingularPathSegments1
+  module SingularQuerySegments1
     def ast
       elements.map{|el| el.elements[1]}.map(&:ast)
     end
   end
 
-  def _nt_singular_path_segments
+  def _nt_singular_query_segments
     start_index = index
-    if node_cache[:singular_path_segments].has_key?(index)
-      cached = node_cache[:singular_path_segments][index]
+    if node_cache[:singular_query_segments].has_key?(index)
+      cached = node_cache[:singular_query_segments][index]
       if cached
-        node_cache[:singular_path_segments][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:singular_query_segments][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -3059,7 +3073,7 @@ module JPTGRAMMAR
       end
       if s1.last
         r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-        r1.extend(SingularPathSegments0)
+        r1.extend(SingularQuerySegments0)
       else
         @index = i1
         r1 = nil
@@ -3071,10 +3085,10 @@ module JPTGRAMMAR
       end
     end
     r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-    r0.extend(SingularPathSegments1)
-    r0.extend(SingularPathSegments1)
+    r0.extend(SingularQuerySegments1)
+    r0.extend(SingularQuerySegments1)
 
-    node_cache[:singular_path_segments][start_index] = r0
+    node_cache[:singular_query_segments][start_index] = r0
 
     r0
   end
@@ -3869,18 +3883,24 @@ module JPTGRAMMAR
       r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
       r0 = r1
     else
-      r2 = _nt_filter_path
+      r2 = _nt_filter_query
       if r2
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
       else
-        r3 = _nt_function_expr
+        r3 = _nt_logical_expr
         if r3
           r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
           r0 = r3
         else
-          @index = i0
-          r0 = nil
+          r4 = _nt_function_expr
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            @index = i0
+            r0 = nil
+          end
         end
       end
     end
@@ -4215,19 +4235,31 @@ module JPTGRAMMAR
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
       else
-        if has_terminal?(@regexps[gr = '\A[€-􏿿]'] ||= Regexp.new(gr), :regexp, index)
+        if has_terminal?(@regexps[gr = '\A[€-퟿]'] ||= Regexp.new(gr), :regexp, index)
           r3 = true
           @index += 1
         else
-          terminal_parse_failure('[€-􏿿]')
+          terminal_parse_failure('[€-퟿]')
           r3 = nil
         end
         if r3
           r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
           r0 = r3
         else
-          @index = i0
-          r0 = nil
+          if has_terminal?(@regexps[gr = '\A[-􏿿]'] ||= Regexp.new(gr), :regexp, index)
+            r4 = true
+            @index += 1
+          else
+            terminal_parse_failure('[-􏿿]')
+            r4 = nil
+          end
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            @index = i0
+            r0 = nil
+          end
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jpt
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-23 00:00:00.000000000 Z
+date: 2023-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.2
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: JSONPath tools