json_p3 0.4.1 → 1.0.0

data/lib/json_p3/path/lexer.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module JSONP3
+  # JSONPath
+  module Path
+    RE_FLOAT = /\G(?:-?\d+\.\d+(?:[eE][+-]?\d+)?)|(-?\d+[eE]-\d+)/
+    RE_INDEX = /\G-?\d+/
+    RE_INT = /\G-?\d+[eE]\+?\d+/
+
+    def self.tokenize(query)
+      tokens = [] #: Array[t_token]
+      length = query.bytesize
+      start = 0
+      pos = 0
+
+      while pos < length
+        byte = query.getbyte(pos)
+
+        case byte
+        when nil
+          break
+        when 42 # *
+          pos += 1
+          tokens << [:token_asterisk, start, pos]
+        when 64 # @
+          pos += 1
+          tokens << [:token_at, start, pos]
+        when 58 # :
+          pos += 1
+          tokens << [:token_colon, start, pos]
+        when 44 # ,
+          pos += 1
+          tokens << [:token_comma, start, pos]
+        when 36 # $
+          pos += 1
+          tokens << [:token_dollar, start, pos]
+        when 40 # (
+          pos += 1
+          tokens << [:token_lparen, start, pos]
+        when 91 # [
+          pos += 1
+          tokens << [:token_lbracket, start, pos]
+        when 41 # )
+          pos += 1
+          tokens << [:token_rparen, start, pos]
+        when 93 # ]
+          pos += 1
+          tokens << [:token_rbracket, start, pos]
+        when 63 # ?
+          pos += 1
+          tokens << [:token_question, start, pos]
+        when 38 # &
+          tokens << if query.getbyte(pos + 1) == 38
+                      pos += 2
+                      [:token_and, start, pos]
+                    else
+                      pos += 1
+                      [:token_error, start, pos]
+                    end
+        when 124 # |
+          tokens << if query.getbyte(pos + 1) == 124
+                      pos += 2
+                      [:token_or, start, pos]
+                    else
+                      pos += 1
+                      [:token_error, start, pos]
+                    end
+        when 46 # .
+          tokens << if query.getbyte(pos + 1) == 46
+                      pos += 2
+                      [:token_double_dot, start, pos]
+                    else
+                      pos += 1
+                      [:token_dot, start, pos]
+                    end
+        when 61 # =
+          tokens << if query.getbyte(pos + 1) == 61
+                      pos += 2
+                      [:token_eq, start, pos]
+                    else
+                      pos += 1
+                      [:token_error, start, pos]
+                    end
+        when 33 # !
+          tokens << if query.getbyte(pos + 1) == 61
+                      pos += 2
+                      [:token_ne, start, pos]
+                    else
+                      pos += 1
+                      [:token_not, start, pos]
+                    end
+        when 62 # >
+          tokens << if query.getbyte(pos + 1) == 61
+                      pos += 2
+                      [:token_ge, start, pos]
+                    else
+                      pos += 1
+                      [:token_gt, start, pos]
+                    end
+        when 60 # <
+          tokens << if query.getbyte(pos + 1) == 61
+                      pos += 2
+                      [:token_le, start, pos]
+                    else
+                      pos += 1
+                      [:token_lt, start, pos]
+                    end
+        when 39, 34 # ' or "
+          pos += 1
+          token, pos = scan_string_literal(query, byte, pos)
+          tokens << token
+        else
+          if name_first?(byte)
+            pos += 1 while name_ch?(query.getbyte(pos) || 0)
+            tokens << [:token_name, start, pos]
+          elsif trivia?(byte)
+            pos += 1 while trivia?(query.getbyte(pos) || 0)
+            tokens << [:token_trivia, start, pos]
+          elsif number_ch?(byte)
+            if (match = query.match(RE_FLOAT, pos))
+              pos = match.end(0) || raise
+              tokens << [:token_float, start, pos]
+            elsif (match = query.match(RE_INT, pos))
+              pos = match.end(0) || raise
+              tokens << [:token_int, start, pos]
+            elsif (match = query.match(RE_INDEX, pos))
+              pos = match.end(0) || raise
+              tokens << [:token_index, start, pos]
+            else
+              pos += 1
+              tokens << [:token_error, start, pos]
+            end
+          else
+            pos += 1
+            tokens << [:token_error, start, pos]
+          end
+        end
+
+        start = pos
+      end
+
+      tokens
+    end
+
+    def self.scan_string_literal(query, byte, pos)
+      start = pos
+      length = query.bytesize
+
+      # @type var token: t_token
+      # @type var kind: t_token_kind
+      # @type var esc_kind: t_token_kind
+
+      kind = byte == 39 ? :token_single_quoted_string : :token_double_quoted_string
+      esc_kind = byte == 39 ? :token_single_quoted_esc_string : :token_double_quoted_esc_string
+
+      while pos < length
+        ch = query.getbyte(pos)
+        case ch
+        when 92 # \
+          kind = esc_kind
+          pos += 2
+        when nil
+          break
+        when 39 # '
+          token = [kind, start, pos]
+          return [token, pos + 1] if esc_kind == :token_single_quoted_esc_string
+
+          pos += 1
+        when 34 # "
+          token = [kind, start, pos]
+          return [token, pos + 1] if esc_kind == :token_double_quoted_esc_string
+
+          pos += 1
+        else
+          # Escaped strings get scanned by the parser, where invalid characters will be caught.
+          if ch <= 0x1f
+            token = [:token_error, start, pos]
+            raise JSONP3::Path::SyntaxError.new(
+              "invalid character",
+              token,
+              query
+            )
+          end
+          pos += 1
+        end
+      end
+
+      token = [:token_error, start, pos]
+      raise JSONP3::Path::SyntaxError.new(
+        "unclosed string literal",
+        token,
+        query
+      )
+    end
+
+    def self.name_first?(ch)
+      (ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122) || ch == 95 || (ch >= 0x80 && ch <= 0xffff)
+    end
+
+    def self.name_ch?(ch)
+      (ch >= 48 && ch <= 57) ||
+        (ch >= 65 && ch <= 90) ||
+        (ch >= 97 && ch <= 122) ||
+        ch == 95 ||
+        (ch >= 0x80 && ch <= 0xffff)
+    end
+
+    def self.number_ch?(ch)
+      ch == 45 || (ch >= 48 && ch <= 57)
+    end
+
+    def self.trivia?(ch)
+      ch == 32 || ch == 9 || ch == 10 || ch == 13 # rubocop: disable Style/MultipleComparison
+    end
+
+    def self.get_token_value(token, query)
+      query.byteslice(token[1], token.last - token[1]) || raise
+    end
+  end
+end

data/lib/json_p3/path/node.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "serialize"
+
+module JSONP3
+  module Path
+    # A JSON-like value and its location.
+    class Node
+      # @dynamic value, location, root
+      attr_reader :value, :location, :root
+
+      # @param value [JSON-like] the value at this node.
+      # @param location [Array<String | Integer | Array<String | Integer>>] the sequence of
+      #   names and/or indices leading to _value_ in _root_.
+      # @param root [JSON-like] the root value containing _value_ at _location_.
+      def initialize(value, location, root)
+        @value = value
+        @location = location
+        @root = root
+      end
+
+      # Return the normalized path to this node.
+      # @return [String] the normalized path.
+      def path
+        segments = @location.flatten.map do |i|
+          i.is_a?(String) ? "[#{JSONP3::Path.canonical_string(i)}]" : "[#{i}]"
+        end
+        "$#{segments.join}"
+      end
+
+      # Return a new node that is a child of this node.
+      # @param value the JSON-like value at the new node.
+      # @param key [Integer, String] the array index or hash key associated with _value_.
+      def new_child(value, key)
+        Node.new(value, [@location, key], @root)
+      end
+
+      def to_s
+        "Node(#{value} at #{path})"
+      end
+    end
+
+    # An array of Node instances. We use this internally to differentiate arrays
+    # of Nodes and arrays of data values, which is required when calling filter
+    # functions expecting nodes as arguments. It is just an array though.
+    class NodeList < Array; end
+  end
+end