Rewritten interpreter and AST optimizations

lib/jmespath.rb

@@ -7,11 +7,11 @@ module JMESPath
   autoload :Errors, 'jmespath/errors'
   autoload :ExprNode, 'jmespath/expr_node'
   autoload :Lexer, 'jmespath/lexer'
+  autoload :Nodes, 'jmespath/nodes'
   autoload :Parser, 'jmespath/parser'
   autoload :Runtime, 'jmespath/runtime'
   autoload :Token, 'jmespath/token'
   autoload :TokenStream, 'jmespath/token_stream'
-  autoload :TreeInterpreter, 'jmespath/tree_interpreter'
   autoload :VERSION, 'jmespath/version'
 
   class << self

lib/jmespath/nodes.rb

@@ -0,0 +1,40 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Node
+      def visit(value)
+      end
+
+      def hash_like?(value)
+        Hash === value || Struct === value
+      end
+
+      def optimize
+        self
+      end
+
+      def chains_with?(other)
+        false
+      end
+    end
+
+    autoload :Comparator, 'jmespath/nodes/comparator'
+    autoload :Condition, 'jmespath/nodes/condition'
+    autoload :Current, 'jmespath/nodes/current'
+    autoload :Expression, 'jmespath/nodes/expression'
+    autoload :Field, 'jmespath/nodes/field'
+    autoload :Flatten, 'jmespath/nodes/flatten'
+    autoload :Function, 'jmespath/nodes/function'
+    autoload :Index, 'jmespath/nodes/index'
+    autoload :Literal, 'jmespath/nodes/literal'
+    autoload :MultiSelectHash, 'jmespath/nodes/multi_select_hash'
+    autoload :MultiSelectList, 'jmespath/nodes/multi_select_list'
+    autoload :Or, 'jmespath/nodes/or'
+    autoload :Pipe, 'jmespath/nodes/pipe'
+    autoload :Projection, 'jmespath/nodes/projection'
+    autoload :ArrayProjection, 'jmespath/nodes/projection'
+    autoload :ObjectProjection, 'jmespath/nodes/projection'
+    autoload :Slice, 'jmespath/nodes/slice'
+    autoload :Subexpression, 'jmespath/nodes/subexpression'
+  end
+end

lib/jmespath/nodes/comparator.rb

@@ -0,0 +1,77 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Comparator < Node
+      attr_reader :left, :right
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def self.create(relation, left, right)
+        type = begin
+          case relation
+          when '==' then EqComparator
+          when '!=' then NeqComparator
+          when '>' then GtComparator
+          when '>=' then GteComparator
+          when '<' then LtComparator
+          when '<=' then LteComparator
+          end
+        end
+        type.new(left, right)
+      end
+
+      def visit(value)
+        check(@left.visit(value), @right.visit(value))
+      end
+
+      def optimize
+        self.class.new(@left.optimize, @right.optimize)
+      end
+
+      private
+
+      def check(left_value, right_value)
+        nil
+      end
+    end
+
+    class EqComparator < Comparator
+      def check(left_value, right_value)
+        left_value == right_value
+      end
+    end
+
+    class NeqComparator < Comparator
+      def check(left_value, right_value)
+        left_value != right_value
+      end
+    end
+
+    class GtComparator < Comparator
+      def check(left_value, right_value)
+        left_value.is_a?(Integer) && right_value.is_a?(Integer) && left_value > right_value
+      end
+    end
+
+    class GteComparator < Comparator
+      def check(left_value, right_value)
+        left_value.is_a?(Integer) && right_value.is_a?(Integer) && left_value >= right_value
+      end
+    end
+
+    class LtComparator < Comparator
+      def check(left_value, right_value)
+        left_value.is_a?(Integer) && right_value.is_a?(Integer) && left_value < right_value
+      end
+    end
+
+    class LteComparator < Comparator
+      def check(left_value, right_value)
+        left_value.is_a?(Integer) && right_value.is_a?(Integer) && left_value <= right_value
+      end
+    end
+  end
+end

lib/jmespath/nodes/condition.rb

@@ -0,0 +1,136 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Condition < Node
+      def initialize(test, child)
+        @test = test
+        @child = child
+      end
+
+      def visit(value)
+        if @test.visit(value)
+          @child.visit(value)
+        else
+          nil
+        end
+      end
+
+      def optimize
+        test = @test.optimize
+        if (new_type = ComparatorCondition::COMPARATOR_TO_CONDITION[@test.class])
+          new_type.new(test.left, test.right, @child).optimize
+        else
+          self.class.new(test, @child.optimize)
+        end
+      end
+    end
+
+    class ComparatorCondition < Node
+      COMPARATOR_TO_CONDITION = {}
+
+      def initialize(left, right, child)
+        @left = left
+        @right = right
+        @child = child
+      end
+
+      def visit(value)
+        nil
+      end
+    end
+
+    class EqCondition < ComparatorCondition
+      COMPARATOR_TO_CONDITION[EqComparator] = self
+
+      def visit(value)
+        @left.visit(value) == @right.visit(value) ? @child.visit(value) : nil
+      end
+
+      def optimize
+        if @right.is_a?(Literal)
+          LiteralRightEqCondition.new(@left, @right, @child)
+        else
+          self
+        end
+      end
+    end
+
+    class LiteralRightEqCondition < EqCondition
+      def initialize(left, right, child)
+        super
+        @right = @right.value
+      end
+
+      def visit(value)
+        @left.visit(value) == @right ? @child.visit(value) : nil
+      end
+    end
+
+    class NeqCondition < ComparatorCondition
+      COMPARATOR_TO_CONDITION[NeqComparator] = self
+
+      def visit(value)
+        @left.visit(value) != @right.visit(value) ? @child.visit(value) : nil
+      end
+
+      def optimize
+        if @right.is_a?(Literal)
+          LiteralRightNeqCondition.new(@left, @right, @child)
+        else
+          self
+        end
+      end
+    end
+
+    class LiteralRightNeqCondition < NeqCondition
+      def initialize(left, right, child)
+        super
+        @right = @right.value
+      end
+
+      def visit(value)
+        @left.visit(value) != @right ? @child.visit(value) : nil
+      end
+    end
+
+    class GtCondition < ComparatorCondition
+      COMPARATOR_TO_CONDITION[GtComparator] = self
+
+      def visit(value)
+        left_value = @left.visit(value)
+        right_value = @right.visit(value)
+        left_value.is_a?(Integer) && right_value.is_a?(Integer) && left_value > right_value ? @child.visit(value) : nil
+      end
+    end
+
+    class GteCondition < ComparatorCondition
+      COMPARATOR_TO_CONDITION[GteComparator] = self
+
+      def visit(value)
+        left_value = @left.visit(value)
+        right_value = @right.visit(value)
+        left_value.is_a?(Integer) && right_value.is_a?(Integer) && left_value >= right_value ? @child.visit(value) : nil
+      end
+    end
+
+    class LtCondition < ComparatorCondition
+      COMPARATOR_TO_CONDITION[LtComparator] = self
+
+      def visit(value)
+        left_value = @left.visit(value)
+        right_value = @right.visit(value)
+        left_value.is_a?(Integer) && right_value.is_a?(Integer) && left_value < right_value ? @child.visit(value) : nil
+      end
+    end
+
+    class LteCondition < ComparatorCondition
+      COMPARATOR_TO_CONDITION[LteComparator] = self
+
+      def visit(value)
+        left_value = @left.visit(value)
+        right_value = @right.visit(value)
+        left_value.is_a?(Integer) && right_value.is_a?(Integer) && left_value <= right_value ? @child.visit(value) : nil
+      end
+    end
+  end
+end

lib/jmespath/nodes/current.rb

@@ -0,0 +1,10 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Current < Node
+      def visit(value)
+        value
+      end
+    end
+  end
+end

lib/jmespath/nodes/expression.rb

@@ -0,0 +1,25 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Expression < Node
+      attr_reader :expression
+
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def visit(value)
+        self
+      end
+
+      def eval(value)
+        @expression.visit(value)
+      end
+
+      def optimize
+        self.class.new(@expression.optimize)
+      end
+    end
+  end
+end
+

lib/jmespath/nodes/field.rb

@@ -0,0 +1,74 @@
+module JMESPath
+  # @api private
+  module Nodes
+    class Field < Node
+      def initialize(key)
+        @key = key
+        @key_sym = key.respond_to?(:to_sym) ? key.to_sym : nil
+      end
+
+      def visit(value)
+        if value.is_a?(Array) && @key.is_a?(Integer)
+          value[@key]
+        elsif value.is_a?(Hash)
+          if !(v = value[@key]).nil?
+            v
+          elsif @key_sym && !(v = value[@key_sym]).nil?
+            v
+          end
+        elsif value.is_a?(Struct) && value.respond_to?(@key)
+          value[@key]
+        end
+      end
+
+      def chains_with?(other)
+        other.is_a?(Field)
+      end
+
+      def chain(other)
+        ChainedField.new([@key, *other.keys])
+      end
+
+      protected
+
+      def keys
+        [@key]
+      end
+    end
+
+    class ChainedField < Field
+      def initialize(keys)
+        @keys = keys
+        @key_syms = keys.each_with_object({}) do |k, syms|
+          if k.respond_to?(:to_sym)
+            syms[k] = k.to_sym
+          end
+        end
+      end
+
+      def visit(value)
+        @keys.reduce(value) do |value, key|
+          if value.is_a?(Array) && key.is_a?(Integer)
+            value[key]
+          elsif value.is_a?(Hash)
+            if !(v = value[key]).nil?
+              v
+            elsif (sym = @key_syms[key]) && !(v = value[sym]).nil?
+              v
+            end
+          elsif value.is_a?(Struct) && value.respond_to?(key)
+            value[key]
+          end
+        end
+      end
+
+      def chain(other)
+        ChainedField.new([*@keys, *other.keys])
+      end
+
+      private
+
+      attr_reader :keys
+    end
+  end
+end