jpt 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8384c2b533862dd8680c91a673db060c59f950a5f6f7e56962bb5d18913d3f54
-  data.tar.gz: f2700ad739f78beb7ed048998c7c6831c9c077a6810c723b51091b4c95176be6
+  metadata.gz: 11f0008d935a2ce891b13af68fe35da1984c733c6d36cc03a3490749ac5deaa6
+  data.tar.gz: fbe7f467057066b07c70fb6f37628f0b105b08e8da560af4f99f3a94aa3336d8
 SHA512:
-  metadata.gz: dab70f4ce946f2716d403696d750ac97ddee416c9da1a04a2bc8b375c5c93ff9bf93aff1ccce23c0431820e7e6ef39fbb00f08a6cb4ff34c8e206dea4d97d33c
-  data.tar.gz: b4c83b1a0c98652b00359a554a6f75f3fcf8ab57330425b139f6093aec70505a5061fa0036f13b5d32006486d3928035558b50a346a004cfaa3310f5f4c94bc5
+  metadata.gz: ecc6e9084048e7d9253fd14c175acc83e932caad33817790579d1f53000bca8efc89cf350fead4255b27fa9b72ec1fd67a6b67c9f0ccfbee4b1c9a23ee40b11e
+  data.tar.gz: 4a7a95f87230e35d9c5437aba5da7593f9a08bdbedabc09d56d4143dd72254e1c224c06f9fbc725d64a75a68c286db44ae601bb358af4926c8ac1c56c8708e23

data/bin/jpt

@@ -10,6 +10,8 @@ Encoding.default_external = Encoding::UTF_8
 require 'optparse'
 require 'ostruct'
 
+FUNCSIG_CHARS = {"l" => :logical, "n" => :nodes, "v" => :value}
+
 $options = OpenStruct.new
 begin
   op = OptionParser.new do |opts|
@@ -21,6 +23,14 @@ begin
     opts.on("-l", "--[no-]lines", "multi-line mode") do |v|
       $options.lines = v
     end
+    opts.on("-q", "--[no-]test", "test-file mode") do |v|
+      $options.test = v
+    end
+    opts.on("-fFUNCSIG", "--[no-]f=FUNCSIG", "add function signature name=rppp") do |v|
+      fail "funcsig format must be name=rppp" unless v =~ /\A([a-z][_a-z0-9]*)-([lnv]+)\z/
+      
+      JPTType.add_funcsig($1, $2)
+    end
     opts.on("-tFMT", "--to=FMT", [:basic, :neat, :json, :yaml, :enum, :jp], "Target format") do |v|
       $options.target = v
     end
@@ -37,7 +47,30 @@ if ARGV == []
 end
 jp_file = ARGF.read
 
-if $options.lines
+if $options.test
+  argument = query = output = nil
+  jp_file.scan(/((?:^(?:$|[^$=].*)\n)+)|([$].*)|=(.*)|#.*/) do |arg,qy,out|
+    begin
+      if arg
+        argument = JSON.parse(arg)
+        puts
+        puts JSON.dump(argument)
+      elsif qy
+        jpt = JPT.from_jp(qy)
+        output = jpt.apply(argument)
+        print jpt.tree.inspect << " "
+        puts "➔ #{JSON.dump(output)}"
+      elsif out
+        suggested = JSON.parse(out)
+        if output != suggested
+          p [:SUGGESTED, suggested]
+        end
+      end
+    rescue => e
+      warn "*** #{e.detailed_message} #{e.backtrace}"
+    end
+  end
+elsif $options.lines
   lines = jp_file.lines(chomp: true)
   col = lines.map(&:length).max
   form = "%-#{col}s %s"

data/jpt.gemspec

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

data/lib/jpt.rb

@@ -1,6 +1,9 @@
 module JPTType
   # :value, :nodes, :logical
 
+
+  FUNCSIG_CHARS = {"l" => :logical, "n" => :nodes, "v" => :value}
+
   FUNCTABLE = {
     "length" => [:value, :value],
     "count" => [:value, :nodes],
@@ -8,6 +11,10 @@ module JPTType
     "search" => [:logical, :value, :value],
   }
 
+  def self.add_funcsig(name, sig)
+    FUNCTABLE[name] = sig.chars.map {FUNCSIG_CHARS[_1]}
+  end
+
   def declared_type(ast)
     case ast
     in Numeric | String | false | true | nil
@@ -82,4 +89,249 @@ class JPT
     Marshal.load(Marshal.dump(self))
   end
 
+  def apply(arg)
+    nodes = [arg]
+    select_query(tree, nodes, nodes, :error)
+  end
+
+  def select_query(tree, nodes, root_node, curr_node)
+    case tree
+    in ["$", *segments]
+      nodes = root_node
+      segments.each do |seg|
+        nodes = select_segment(seg, nodes, root_node, curr_node)
+      end
+    in ["@", *segments]
+      nodes = curr_node
+      segments.each do |seg|
+        nodes = select_segment(seg, nodes, root_node, curr_node)
+      end
+    end
+    nodes
+  end
+
+  def select_segment(seg, nodes, root_node, curr_node)
+    case seg
+    in Integer => ix
+      nodes = nodes.flat_map do |n|
+        if Array === n
+         [n.fetch(ix, :nothing)]
+        else []
+        end
+      end
+    in String => ky
+      nodes = nodes.flat_map do |n|
+        if Hash === n
+          [n.fetch(ky, :nothing)]
+        else []
+        end
+      end
+    in ["u", *sel]
+#      nodes = sel.flat_map{ |sel1| select_segment(sel1, nodes, root_node, curr_node)}
+      nodes = nodes.flat_map do |n|
+        sel.flat_map{ |sel1| select_segment(sel1, [n], root_node, curr_node)}
+      end
+    in ["wild"]
+      nodes = nodes.flat_map do |n|
+        enumerate(n)
+      end
+    in ["desc", sel]
+      nodes = nodes.flat_map do |n|
+        containers(n)
+      end
+      nodes = select_segment(sel, nodes, root_node, curr_node)
+    in ["slice", st, en, sp]
+      nodes = nodes.flat_map do |n|
+        if (Array === n) && sp != 0
+          len = n.length
+          ret = []
+          sp ||= 1
+          if sp > 0             # weird formulae copied from spec
+            st ||= 0
+            en ||= len
+          else
+            # warn "ARR #{st} #{en} #{sp}"
+            st ||= len - 1
+            en ||= -len - 1
+            # warn "ARR2 #{st} #{en} #{sp}"
+          end
+          st, en = [st, en].map{|i| i >= 0 ? i : len + i}
+          if sp > 0
+            lo = [[st, 0].max, len].min
+            up = [[en, 0].max, len].min
+            while lo < up
+              ret << n[lo]; lo += sp
+            end
+          else
+            up = [[st, -1].max, len-1].min
+            lo = [[en, -1].max, len-1].min
+            # warn "ARR3 #{st} #{en} #{sp} #{lo} #{up}"
+            while lo < up
+              ret << n[up]; up += sp
+            end
+          end
+          ret
+        else
+          []
+        end
+      end
+    in ["filt", logexp]
+      nodes = nodes.flat_map do |n|
+        enumerate(n).flat_map do |cand|
+          a = filt_apply(logexp, root_node, [cand])
+          # warn "***A #{a.inspect}"
+          if filt_to_logical(a)
+            [cand]
+          else
+            []
+          end
+        end
+      end
+    end
+    nodes.delete(:nothing)
+    nodes
+  end
+
+  def enumerate(n)
+    case n
+    in Array
+      n
+    in Hash
+      n.map{|k, v| v}
+    else
+      []
+    end
+  end
+
+  def containers(n)
+    case n
+    in Array
+      [n, *n.flat_map{containers(_1)}]
+    in Hash
+      [n, *n.flat_map{|k, v| containers(v)}]
+    else
+      []
+    end
+  end
+
+  def filt_to_logical(val)
+    case val
+    in [:nodes, v]
+      v != []
+    in [:logical, v]
+      v
+    end
+  end
+
+  def filt_to_value(val)
+    case val
+    in [:nodes, v]
+      if v.length == 1
+        v[0]
+      else
+        :nothing
+      end
+    in [:value, v]
+      v
+    end
+  end
+
+  COMPARE_SWAP = {">" => "<", ">=" => "<="}
+
+  def filt_apply(logexp, root_node, curr_node)
+    # warn "***B #{logexp.inspect} #{root_node.inspect} #{curr_node.inspect}"
+    case logexp
+    in ["@", *]
+      [:nodes, select_query(logexp, curr_node, root_node, curr_node)]
+    in ["$", *]
+      [:nodes, 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
+      op = logexp[0]
+      # warn "***C #{op} #{lhs.inspect}, #{rhs.inspect}"
+      if sop = COMPARE_SWAP[op]
+        lhs, rhs = rhs, lhs
+        op = sop
+      end
+      # warn "***C1 #{op} #{lhs.inspect}, #{rhs.inspect}"
+      res = if op != "<" && (lhs == rhs rescue false)
+              op == "!=" ? false : true
+            else
+              if op[0] == "<"   # "<" or "<="
+                case [lhs, rhs]
+                in Numeric, Numeric
+                  lhs < rhs
+                in String, String
+                  lhs < rhs
+                else
+                  false
+                end
+              else op == "!="
+              end
+            end
+      # warn "***C9 #{res}"
+      [:logical, res]
+    in ["and" | "or", a, b]
+      lhs = filt_to_logical(filt_apply(a, root_node, curr_node))
+      rhs = filt_to_logical(filt_apply(b, root_node, curr_node))
+      op = logexp[0]
+      # warn "***C #{op} #{lhs.inspect}, #{rhs.inspect}"
+      [:logical, case op
+                 in "or"
+                   lhs || rhs
+                 in "and"
+                   lhs && rhs
+                 end]
+    in ["not", a]
+      lhs = filt_to_logical(filt_apply(a, root_node, curr_node))
+      [:logical, !lhs]
+    in ["func", "length", value]
+      value = filt_to_value(filt_apply(value, root_node, curr_node))
+      [:value,
+       case value
+       in Hash | Array | String
+         value.length
+       else
+         :nothing
+       end
+      ]
+    in ["func", "count", nodes]
+      ty, nodes = filt_apply(nodes, root_node, curr_node)
+      [:value,
+       if ty != :nodes
+         warn "*** func count ty #{ty.inspect}"
+         0
+       else
+         nodes.length
+       end]
+    in ["func", "match", str, re]
+      str = filt_to_value(filt_apply(str, root_node, curr_node))
+      re = filt_to_value(filt_apply(re, root_node, curr_node))
+      [:logical,
+       begin
+         /\A(?:#{re})\z/ === str
+       rescue => e
+         warn "*** #{e.detailed_message} #{e.backtrace}"
+         false
+       end
+      ]
+    in ["func", "search", str, re]
+      str = filt_to_value(filt_apply(str, root_node, curr_node))
+      re = filt_to_value(filt_apply(re, root_node, curr_node))
+      [:logical,
+       begin
+         /#{re}/ === str
+       rescue => e
+         warn "*** #{e.detailed_message} #{e.backtrace}"
+         false
+       end
+      ]
+    in ["func", name, *args]
+      warn "*** Unknown function extension #{name} with args #{args.inspect}"
+      [:logical, false]
+    in String | Numeric | false | true | nil
+      [:value, logexp]
+    end
+  end
 end

data/lib/parser/jptgrammar.rb

@@ -2974,7 +2974,7 @@ module JPTGRAMMAR
 
   module AbsSingularPath1
     def ast
-      ["@", *singular_path_segments.ast]
+      ["$", *singular_path_segments.ast]
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jpt
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-20 00:00:00.000000000 Z
+date: 2023-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler