jmespath 1.0.2 → 1.1.0

data/lib/jmespath/nodes/index.rb

@@ -0,0 +1,6 @@
+module JMESPath
+  # @api private
+  module Nodes
+    Index = Field
+  end
+end

data/lib/jmespath/nodes/literal.rb

@@ -0,0 +1,16 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Literal < Node
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def visit(value)
+        @value
+      end
+    end
+  end
+end

data/lib/jmespath/nodes/multi_select_hash.rb

@@ -0,0 +1,37 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class MultiSelectHash < Node
+      def initialize(kv_pairs)
+        @kv_pairs = kv_pairs
+      end
+
+      def visit(value)
+        if value.nil?
+          nil
+        else
+          @kv_pairs.each_with_object({}) do |pair, hash|
+            hash[pair.key] = pair.value.visit(value)
+          end
+        end
+      end
+
+      def optimize
+        self.class.new(@kv_pairs.map(&:optimize))
+      end
+
+      class KeyValuePair
+        attr_reader :key, :value
+
+        def initialize(key, value)
+          @key = key
+          @value = value
+        end
+
+        def optimize
+          self.class.new(@key, @value.optimize)
+        end
+      end
+    end
+  end
+end

data/lib/jmespath/nodes/multi_select_list.rb

@@ -0,0 +1,22 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class MultiSelectList < Node
+      def initialize(children)
+        @children = children
+      end
+
+      def visit(value)
+        if value.nil?
+          value
+        else
+          @children.map { |n| n.visit(value) }
+        end
+      end
+
+      def optimize
+        self.class.new(@children.map(&:optimize))
+      end
+    end
+  end
+end

data/lib/jmespath/nodes/or.rb

@@ -0,0 +1,24 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Or < Node
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def visit(value)
+        result = @left.visit(value)
+        if result == false || result.nil? || result.empty?
+          @right.visit(value)
+        else
+          result
+        end
+      end
+
+      def optimize
+        self.class.new(@left.optimize, @right.optimize)
+      end
+    end
+  end
+end

data/lib/jmespath/nodes/pipe.rb

@@ -0,0 +1,6 @@
+module JMESPath
+  # @api private
+  module Nodes
+    Pipe = Subexpression
+  end
+end

data/lib/jmespath/nodes/projection.rb

@@ -0,0 +1,82 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Projection < Node
+      def initialize(target, projection)
+        @target = target
+        @projection = projection
+      end
+
+      def visit(value)
+        if (targets = extract_targets(@target.visit(value)))
+          list = []
+          targets.each do |v|
+            vv = @projection.visit(v)
+            unless vv.nil?
+              list << vv
+            end
+          end
+          list
+        end
+      end
+
+      def optimize
+        if @projection.is_a?(Current)
+          fast_instance
+        else
+          self.class.new(@target.optimize, @projection.optimize)
+        end
+      end
+
+      private
+
+      def extract_targets(left_value)
+        nil
+      end
+    end
+
+    module FastProjector
+      def visit(value)
+        if (targets = extract_targets(@target.visit(value)))
+          targets.compact
+        end
+      end
+    end
+
+    class ArrayProjection < Projection
+      def extract_targets(target)
+        if Array === target
+          target
+        else
+          nil
+        end
+      end
+
+      def fast_instance
+        FastArrayProjection.new(@target.optimize, @projection.optimize)
+      end
+    end
+
+    class FastArrayProjection < ArrayProjection
+      include FastProjector
+    end
+
+    class ObjectProjection < Projection
+      def extract_targets(target)
+        if hash_like?(target)
+          target.values
+        else
+          nil
+        end
+      end
+
+      def fast_instance
+        FastObjectProjection.new(@target.optimize, @projection.optimize)
+      end
+    end
+
+    class FastObjectProjection < ObjectProjection
+      include FastProjector
+    end
+  end
+end

data/lib/jmespath/nodes/slice.rb

@@ -0,0 +1,92 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Slice < Node
+      def initialize(start, stop, step)
+        @start = start
+        @stop = stop
+        @step = step
+      end
+
+      def visit(value)
+        if String === value || Array === value
+          start, stop, step = adjust_slice(value.size, @start, @stop, @step)
+          result = []
+          if step > 0
+            i = start
+            while i < stop
+              result << value[i]
+              i += step
+            end
+          else
+            i = start
+            while i > stop
+              result << value[i]
+              i += step
+            end
+          end
+          String === value ? result.join : result
+        else
+          nil
+        end
+      end
+
+      def optimize
+        if (@step.nil? || @step == 1) && @start && @stop && @start > 0 && @stop > @start
+          SimpleSlice.new(@start, @stop)
+        else
+          self
+        end
+      end
+
+      private
+
+      def adjust_slice(length, start, stop, step)
+        if step.nil?
+          step = 1
+        elsif step == 0
+          raise Errors::InvalidValueError, 'slice step cannot be 0'
+        end
+
+        if start.nil?
+          start = step < 0 ? length - 1 : 0
+        else
+          start = adjust_endpoint(length, start, step)
+        end
+
+        if stop.nil?
+          stop = step < 0 ? -1 : length
+        else
+          stop = adjust_endpoint(length, stop, step)
+        end
+        [start, stop, step]
+      end
+
+      def adjust_endpoint(length, endpoint, step)
+        if endpoint < 0
+          endpoint += length
+          endpoint = step < 0 ? -1 : 0 if endpoint < 0
+          endpoint
+        elsif endpoint >= length
+          step < 0 ? length - 1 : length
+        else
+          endpoint
+        end
+      end
+    end
+
+    class SimpleSlice < Slice
+      def initialize(start, stop)
+        super(start, stop, 1)
+      end
+
+      def visit(value)
+        if String === value || Array === value
+          value[@start, @stop - @start]
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/jmespath/nodes/subexpression.rb

@@ -0,0 +1,63 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Subexpression < Node
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def visit(value)
+        @right.visit(@left.visit(value))
+      end
+
+      def optimize
+        Chain.new(flatten).optimize
+      end
+
+      protected
+
+      attr_reader :left, :right
+
+      def flatten
+        nodes = [@left, @right]
+        until nodes.none? { |node| node.is_a?(Subexpression) }
+          nodes = nodes.flat_map do |node|
+            if node.is_a?(Subexpression)
+              [node.left, node.right]
+            else
+              [node]
+            end
+          end
+        end
+        nodes.map(&:optimize)
+      end
+    end
+
+    class Chain
+      def initialize(children)
+        @children = children
+      end
+
+      def visit(value)
+        @children.reduce(value) do |v, child|
+          child.visit(v)
+        end
+      end
+
+      def optimize
+        children = @children.map(&:optimize)
+        index = 0
+        while index < children.size - 1
+          if children[index].chains_with?(children[index + 1])
+            children[index] = children[index].chain(children[index + 1])
+            children.delete_at(index + 1)
+          else
+            index += 1
+          end
+        end
+        Chain.new(children)
+      end
+    end
+  end
+end

data/lib/jmespath/parser.rb

@@ -4,29 +4,39 @@ module JMESPath
   # @api private
   class Parser
 
-    # @api private
     AFTER_DOT = Set.new([
-        :identifier,        # foo.bar
-        :quoted_identifier, # foo."bar"
-        :star,              # foo.*
-        :lbrace,            # foo[1]
-        :lbracket,          # foo{a: 0}
-        :function,          # foo.*.to_string(@)
-        :filter,            # foo.[?bar==10]
+      Lexer::T_IDENTIFIER,        # foo.bar
+      Lexer::T_QUOTED_IDENTIFIER, # foo."bar"
+      Lexer::T_STAR,              # foo.*
+      Lexer::T_LBRACE,            # foo{a: 0}
+      Lexer::T_LBRACKET,          # foo[1]
+      Lexer::T_FILTER,            # foo.[?bar==10]
+    ])
+
+    NUM_COLON_RBRACKET = Set.new([
+      Lexer::T_NUMBER,
+      Lexer::T_COLON,
+      Lexer::T_RBRACKET,
     ])
 
-    CURRENT_NODE = { type: :current }
+    COLON_RBRACKET = Set.new([
+      Lexer::T_COLON,
+      Lexer::T_RBRACKET,
+    ])
+
+    CURRENT_NODE = Nodes::Current.new
 
     # @option options [Lexer] :lexer
     def initialize(options = {})
-      @lexer = options[:lexer] || Lexer.new()
+      @lexer = options[:lexer] || Lexer.new
     end
 
     # @param [String<JMESPath>] expression
     def parse(expression)
-      stream = TokenStream.new(expression, @lexer.tokenize(expression))
+      tokens =  @lexer.tokenize(expression)
+      stream = TokenStream.new(expression, tokens)
       result = expr(stream)
-      if stream.token.type != :eof
+      if stream.token.type != Lexer::T_EOF
         raise Errors::SyntaxError, "expected :eof got #{stream.token.type}"
       else
         result
@@ -61,10 +71,7 @@ module JMESPath
 
     def nud_expref(stream)
       stream.next
-      {
-        type: :expression,
-        children: [expr(stream, 2)]
-      }
+      Nodes::Expression.new(expr(stream, 2))
     end
 
     def nud_filter(stream)
@@ -77,8 +84,12 @@ module JMESPath
 
     def nud_identifier(stream)
       token = stream.token
-      stream.next
-      { type: :field, key: token.value }
+      n = stream.next
+      if n.type == :lparen
+        Nodes::Function::FunctionName.new(token.value)
+      else
+        Nodes::Field.new(token.value)
+      end
     end
 
     def nud_lbrace(stream)
@@ -92,10 +103,7 @@ module JMESPath
         end
       end while stream.token.type != :rbrace
       stream.next
-      {
-        type: :multi_select_hash,
-        children: pairs
-      }
+      Nodes::MultiSelectHash.new(pairs)
     end
 
     def nud_lbracket(stream)
@@ -113,10 +121,7 @@ module JMESPath
     def nud_literal(stream)
       value = stream.token.value
       stream.next
-      {
-        type: :literal,
-        value: value
-      }
+      Nodes::Literal.new(value)
     end
 
     def nud_quoted_identifier(stream)
@@ -126,7 +131,7 @@ module JMESPath
         msg = 'quoted identifiers are not allowed for function names'
         raise Errors::SyntaxError, msg
       else
-        { type: :field, key: token[:value] }
+        Nodes::Field.new(token[:value])
       end
     end
 
@@ -137,14 +142,8 @@ module JMESPath
     def led_comparator(stream, left)
       token = stream.token
       stream.next
-      {
-        type: :comparator,
-        relation: token.value,
-        children: [
-          left,
-          expr(stream),
-        ]
-      }
+      right = expr(stream)
+      Nodes::Comparator.create(token.value, left, right)
     end
 
     def led_dot(stream, left)
@@ -152,60 +151,37 @@ module JMESPath
       if stream.token.type == :star
         parse_wildcard_object(stream, left)
       else
-        {
-          type: :subexpression,
-          children: [
-            left,
-            parse_dot(stream, Token::BINDING_POWER[:dot])
-          ]
-        }
+        right = parse_dot(stream, Token::BINDING_POWER[:dot])
+        Nodes::Subexpression.new(left, right)
       end
     end
 
     def led_filter(stream, left)
       stream.next
       expression = expr(stream)
-      if stream.token.type != :rbracket
+      if stream.token.type != Lexer::T_RBRACKET
         raise Errors::SyntaxError, 'expected a closing rbracket for the filter'
       end
       stream.next
-      rhs = parse_projection(stream, Token::BINDING_POWER[:filter])
-      {
-        type: :projection,
-        from: :array,
-        children: [
-          left ? left : CURRENT_NODE,
-          {
-            type: :condition,
-            children: [expression, rhs],
-          }
-        ]
-      }
+      rhs = parse_projection(stream, Token::BINDING_POWER[Lexer::T_FILTER])
+      left ||= CURRENT_NODE
+      right = Nodes::Condition.new(expression, rhs)
+      Nodes::ArrayProjection.new(left, right)
     end
 
     def led_flatten(stream, left)
       stream.next
-      {
-        type: :projection,
-        from: :array,
-        children: [
-          { type: :flatten, children: [left] },
-          parse_projection(stream, Token::BINDING_POWER[:flatten])
-        ]
-      }
+      left = Nodes::Flatten.new(left)
+      right = parse_projection(stream, Token::BINDING_POWER[:flatten])
+      Nodes::ArrayProjection.new(left, right)
     end
 
     def led_lbracket(stream, left)
       stream.next(match: Set.new([:number, :colon, :star]))
       type = stream.token.type
       if type == :number || type == :colon
-        {
-          type: :subexpression,
-          children: [
-            left,
-            parse_array_index_expression(stream)
-          ]
-        }
+        right = parse_array_index_expression(stream)
+        Nodes::Subexpression.new(left, right)
       else
         parse_wildcard_array(stream, left)
       end
@@ -213,7 +189,7 @@ module JMESPath
 
     def led_lparen(stream, left)
       args = []
-      name = left[:key]
+      name = left.name
       stream.next
       while stream.token.type != :rparen
         args << expr(stream, 0)
@@ -222,47 +198,50 @@ module JMESPath
         end
       end
       stream.next
-      {
-        type: :function,
-        fn: name,
-        children: args,
-      }
+      Nodes::Function.create(name, args)
     end
 
     def led_or(stream, left)
       stream.next
-      {
-        type: :or,
-        children: [left, expr(stream, Token::BINDING_POWER[:or])]
-      }
+      right = expr(stream, Token::BINDING_POWER[:or])
+      Nodes::Or.new(left, right)
     end
 
     def led_pipe(stream, left)
       stream.next
-      {
-        type: :pipe,
-        children: [left, expr(stream, Token::BINDING_POWER[:pipe])],
-      }
+      right = expr(stream, Token::BINDING_POWER[:pipe])
+      Nodes::Pipe.new(left, right)
     end
 
+    # parse array index expressions, for example [0], [1:2:3], etc.
     def parse_array_index_expression(stream)
       pos = 0
       parts = [nil, nil, nil]
+      expected = NUM_COLON_RBRACKET
+
       begin
-        if stream.token.type == :colon
+        if stream.token.type == Lexer::T_COLON
           pos += 1
-        else
+          expected = NUM_COLON_RBRACKET
+        elsif stream.token.type == Lexer::T_NUMBER
           parts[pos] = stream.token.value
+          expected = COLON_RBRACKET
         end
-        stream.next(match:Set.new([:number, :colon, :rbracket]))
-      end while stream.token.type != :rbracket
-      stream.next
+        stream.next(match: expected)
+      end while stream.token.type != Lexer::T_RBRACKET
+
+      stream.next # consume the closing bracket
+
       if pos == 0
-        { type: :index, index: parts[0] }
+        # no colons found, this is a single index extraction
+        Nodes::Index.new(parts[0])
       elsif pos > 2
         raise Errors::SyntaxError, 'invalid array slice syntax: too many colons'
       else
-        { type: :slice, args: parts }
+        Nodes::ArrayProjection.new(
+          Nodes::Slice.new(*parts),
+          parse_projection(stream, Token::BINDING_POWER[Lexer::T_STAR])
+        )
       end
     end
 
@@ -279,11 +258,7 @@ module JMESPath
       key = stream.token.value
       stream.next(match:Set.new([:colon]))
       stream.next
-      {
-        type: :key_value_pair,
-        key: key,
-        children: [expr(stream)]
-      }
+      Nodes::MultiSelectHash::KeyValuePair.new(key, expr(stream))
     end
 
     def parse_multi_select_list(stream)
@@ -298,10 +273,7 @@ module JMESPath
         end
       end while stream.token.type != :rbracket
       stream.next
-      {
-        type: :multi_select_list,
-        children: nodes
-      }
+      Nodes::MultiSelectList.new(nodes)
     end
 
     def parse_projection(stream, binding_power)
@@ -321,26 +293,16 @@ module JMESPath
     def parse_wildcard_array(stream, left = nil)
       stream.next(match:Set.new([:rbracket]))
       stream.next
-      {
-        type: :projection,
-        from: :array,
-        children: [
-          left ? left : CURRENT_NODE,
-          parse_projection(stream, Token::BINDING_POWER[:star])
-        ]
-      }
+      left ||= CURRENT_NODE
+      right = parse_projection(stream, Token::BINDING_POWER[:star])
+      Nodes::ArrayProjection.new(left, right)
     end
 
     def parse_wildcard_object(stream, left = nil)
       stream.next
-      {
-        type: :projection,
-        from: :object,
-        children: [
-          left ? left : CURRENT_NODE,
-          parse_projection(stream, Token::BINDING_POWER[:star])
-        ]
-      }
+      left ||= CURRENT_NODE
+      right = parse_projection(stream, Token::BINDING_POWER[:star])
+      Nodes::ObjectProjection.new(left, right)
     end
 
   end