burtpath 1.1.0

data/lib/jmespath/nodes/slice.rb

@@ -0,0 +1,93 @@
+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::RuntimeError, '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 = 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/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

data/lib/jmespath/optimizing_parser.rb

@@ -0,0 +1,12 @@
+module JMESPath
+  class OptimizingParser
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def parse(expression)
+      @parser.parse(expression).optimize
+    end
+  end
+end

data/lib/jmespath/parser.rb

@@ -0,0 +1,288 @@
+require 'set'
+
+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]
+    ])
+
+    CURRENT_NODE = Nodes::Current.new
+
+    # @option options [Lexer] :lexer
+    def initialize(options = {})
+      @lexer = options[:lexer] || Lexer.new()
+    end
+
+    # @param [String<JMESPath>] expression
+    def parse(expression)
+      stream = TokenStream.new(expression, @lexer.tokenize(expression))
+      result = expr(stream)
+      if stream.token.type != :eof
+        raise Errors::SyntaxError, "expected :eof got #{stream.token.type}"
+      else
+        result
+      end
+    end
+
+    # @api private
+    def method_missing(method_name, *args)
+      if matches = method_name.match(/^(nud_|led_)(.*)/)
+        raise Errors::SyntaxError, "unexpected token #{matches[2]}"
+      else
+        super
+      end
+    end
+
+    private
+
+    # @param [TokenStream] stream
+    # @param [Integer] rbp Right binding power
+    def expr(stream, rbp = 0)
+      left = send("nud_#{stream.token.type}", stream)
+      while rbp < stream.token.binding_power
+        left = send("led_#{stream.token.type}", stream, left)
+      end
+      left
+    end
+
+    def nud_current(stream)
+      stream.next
+      CURRENT_NODE
+    end
+
+    def nud_expref(stream)
+      stream.next
+      Nodes::Expression.new(expr(stream, 2))
+    end
+
+    def nud_filter(stream)
+      led_filter(stream, CURRENT_NODE)
+    end
+
+    def nud_flatten(stream)
+      led_flatten(stream, CURRENT_NODE)
+    end
+
+    def nud_identifier(stream)
+      token = stream.token
+      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)
+      valid_keys = Set.new([:quoted_identifier, :identifier])
+      stream.next(match:valid_keys)
+      pairs = []
+      begin
+        pairs << parse_key_value_pair(stream)
+        if stream.token.type == :comma
+          stream.next(match:valid_keys)
+        end
+      end while stream.token.type != :rbrace
+      stream.next
+      Nodes::MultiSelectHash.new(pairs)
+    end
+
+    def nud_lbracket(stream)
+      stream.next
+      type = stream.token.type
+      if type == :number || type == :colon
+        parse_array_index_expression(stream)
+      elsif type == :star && stream.lookahead(1).type == :rbracket
+        parse_wildcard_array(stream)
+      else
+        parse_multi_select_list(stream)
+      end
+    end
+
+    def nud_literal(stream)
+      value = stream.token.value
+      stream.next
+      Nodes::Literal.new(value)
+    end
+
+    def nud_quoted_identifier(stream)
+      token = stream.token
+      next_token = stream.next
+      if next_token.type == :lparen
+        msg = 'quoted identifiers are not allowed for function names'
+        raise Errors::SyntaxError, msg
+      else
+        Nodes::Field.new(token[:value])
+      end
+    end
+
+    def nud_star(stream)
+      parse_wildcard_object(stream, CURRENT_NODE)
+    end
+
+    def led_comparator(stream, left)
+      token = stream.token
+      stream.next
+      right = expr(stream)
+      Nodes::Comparator.create(token.value, left, right)
+    end
+
+    def led_dot(stream, left)
+      stream.next(match:AFTER_DOT)
+      if stream.token.type == :star
+        parse_wildcard_object(stream, left)
+      else
+        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
+        raise Errors::SyntaxError, 'expected a closing rbracket for the filter'
+      end
+      stream.next
+      rhs = parse_projection(stream, Token::BINDING_POWER[:filter])
+      left ||= CURRENT_NODE
+      right = Nodes::Condition.new(expression, rhs)
+      Nodes::ArrayProjection.new(left, right)
+    end
+
+    def led_flatten(stream, left)
+      stream.next
+      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
+        right = parse_array_index_expression(stream)
+        Nodes::Subexpression.new(left, right)
+      else
+        parse_wildcard_array(stream, left)
+      end
+    end
+
+    def led_lparen(stream, left)
+      args = []
+      name = left.name
+      stream.next
+      while stream.token.type != :rparen
+        args << expr(stream, 0)
+        if stream.token.type == :comma
+          stream.next
+        end
+      end
+      stream.next
+      Nodes::Function.create(name, args)
+    end
+
+    def led_or(stream, left)
+      stream.next
+      right = expr(stream, Token::BINDING_POWER[:or])
+      Nodes::Or.new(left, right)
+    end
+
+    def led_pipe(stream, left)
+      stream.next
+      right = expr(stream, Token::BINDING_POWER[:pipe])
+      Nodes::Pipe.new(left, right)
+    end
+
+    def parse_array_index_expression(stream)
+      pos = 0
+      parts = [nil, nil, nil]
+      begin
+        if stream.token.type == :colon
+          pos += 1
+        else
+          parts[pos] = stream.token.value
+        end
+        stream.next(match:Set.new([:number, :colon, :rbracket]))
+      end while stream.token.type != :rbracket
+      stream.next
+      if pos == 0
+        Nodes::Index.new(parts[0])
+      elsif pos > 2
+        raise Errors::SyntaxError, 'invalid array slice syntax: too many colons'
+      else
+        Nodes::Slice.new(*parts)
+      end
+    end
+
+    def parse_dot(stream, binding_power)
+      if stream.token.type == :lbracket
+        stream.next
+        parse_multi_select_list(stream)
+      else
+        expr(stream, binding_power)
+      end
+    end
+
+    def parse_key_value_pair(stream)
+      key = stream.token.value
+      stream.next(match:Set.new([:colon]))
+      stream.next
+      Nodes::MultiSelectHash::KeyValuePair.new(key, expr(stream))
+    end
+
+    def parse_multi_select_list(stream)
+      nodes = []
+      begin
+        nodes << expr(stream)
+        if stream.token.type == :comma
+          stream.next
+          if stream.token.type == :rbracket
+            raise Errors::SyntaxError, 'expression epxected, found rbracket'
+          end
+        end
+      end while stream.token.type != :rbracket
+      stream.next
+      Nodes::MultiSelectList.new(nodes)
+    end
+
+    def parse_projection(stream, binding_power)
+      type = stream.token.type
+      if stream.token.binding_power < 10
+        CURRENT_NODE
+      elsif type == :dot
+        stream.next(match:AFTER_DOT)
+        parse_dot(stream, binding_power)
+      elsif type == :lbracket || type == :filter
+        expr(stream, binding_power)
+      else
+        raise Errors::SyntaxError, 'syntax error after projection'
+      end
+    end
+
+    def parse_wildcard_array(stream, left = nil)
+      stream.next(match:Set.new([:rbracket]))
+      stream.next
+      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
+      left ||= CURRENT_NODE
+      right = parse_projection(stream, Token::BINDING_POWER[:star])
+      Nodes::ObjectProjection.new(left, right)
+    end
+
+  end
+end

data/lib/jmespath/runtime.rb

@@ -0,0 +1,82 @@
+module JMESPath
+  # @api private
+  class Runtime
+
+    # Constructs a new runtime object for evaluating JMESPath expressions.
+    #
+    #     runtime = JMESPath::Runtime.new
+    #     runtime.search(expression, data)
+    #     #=> ...
+    #
+    # ## Caching
+    #
+    # When constructing a {Runtime}, the default parser caches expressions.
+    # This significantly speeds up calls to {#search} multiple times
+    # with the same expression but different data. To disable caching, pass
+    # `:cache_expressions => false` to the constructor or pass a custom
+    # `:parser`.
+    #
+    # ## Optimizing
+    #
+    # By default the runtime will perform optimizations on the expression to
+    # try to make it run searches as fast as possible. If all your searches
+    # use different expressions this might not be worth the extra work, so you
+    # can disable the optimizer by passing `:optimize_expression => false`. If
+    # you disable caching it is also recommended that you disable optimizations,
+    # but you don't have to The optimizer will be disabled if you pass a custom
+    # parser with the `:parser` option.
+    #
+    # @example Re-use a Runtime, caching enabled by default
+    #
+    #   runtime = JMESPath::Runtime.new
+    #   runtime.parser
+    #   #=> #<JMESPath::CachingParser ...>
+    #
+    # @example Disable caching
+    #
+    #   runtime = JMESPath::Runtime.new(cache_expressions: false)
+    #   runtime.parser
+    #   #=> #<JMESPath::Parser ...>
+    #
+    # @option options [Boolean] :cache_expressions (true) When `false`, a non
+    #   caching parser will be used. When `true`, a shared instance of
+    #   {CachingParser} is used.  Defaults to `true`.
+    #
+    # @option options [Boolean] :optimize_expressions (true) When `false`,
+    #   no additional optimizations will be performed on the expression,
+    #   when `true` the expression will be analyzed and optimized. This
+    #   increases the time it takes to parse, but improves the speed of
+    #   searches, so it's highly recommended if you're using the same expression
+    #   multiple times and have not disabled caching. Defaults to `true`.
+    #
+    # @option options [Parser] :parser
+    #
+    def initialize(options = {})
+      @parser = options[:parser] || create_parser(options)
+    end
+
+    # @return [Parser]
+    attr_reader :parser
+
+    # @param [String<JMESPath>] expression
+    # @param [Hash] data
+    # @return [Mixed,nil]
+    def search(expression, data)
+      @parser.parse(expression).visit(data)
+    end
+
+    private
+
+    def create_parser(options)
+      parser = Parser.new
+      unless options[:optimize_expression] == false
+        parser = OptimizingParser.new(parser)
+      end
+      unless options[:cache_expressions] == false
+        parser = CachingParser.new(parser)
+      end
+      parser
+    end
+
+  end
+end

data/lib/jmespath/token.rb

@@ -0,0 +1,41 @@
+module JMESPath
+  # @api private
+  class Token < Struct.new(:type, :value, :position, :binding_power)
+
+    # @api private
+    NULL_TOKEN = Token.new(:eof, '', nil)
+
+    # binding power
+    # @api private
+    BINDING_POWER = {
+      :eof               => 0,
+      :quoted_identifier => 0,
+      :identifier        => 0,
+      :rbracket          => 0,
+      :rparen            => 0,
+      :comma             => 0,
+      :rbrace            => 0,
+      :number            => 0,
+      :current           => 0,
+      :expref            => 0,
+      :pipe              => 1,
+      :comparator        => 2,
+      :or                => 5,
+      :flatten           => 6,
+      :star              => 20,
+      :dot               => 40,
+      :lbrace            => 50,
+      :filter            => 50,
+      :lbracket          => 50,
+      :lparen            => 60,
+    }
+
+    # @param [Symbol] type
+    # @param [Mixed] value
+    # @param [Integer] position
+    def initialize(type, value, position)
+      super(type, value, position, BINDING_POWER[type])
+    end
+
+  end
+end

data/lib/jmespath/token_stream.rb

@@ -0,0 +1,60 @@
+module JMESPath
+  # @api private
+  class TokenStream
+
+    # @param [String<JMESPath>] expression
+    # @param [Array<Token>] tokens
+    def initialize(expression, tokens)
+      @expression = expression
+      @tokens = tokens
+      @token = nil
+      @position = -1
+      self.next
+    end
+
+    # @return [String<JMESPath>]
+    attr_reader :expression
+
+    # @return [Token]
+    attr_reader :token
+
+    # @return [Integer]
+    attr_reader :position
+
+    # @option options [Array<Symbol>] :match Requires the next token to be
+    #   one of the given symbols or an error is raised.
+    def next(options = {})
+      validate_match(_next, options[:match])
+    end
+
+    def lookahead(count)
+      @tokens[@position + count] || Token::NULL_TOKEN
+    end
+
+    # @api private
+    def inspect
+      str = []
+      @tokens.each do |token|
+        str << "%3d  %-15s %s" %
+         [token.position, token.type, token.value.inspect]
+      end
+      str.join("\n")
+    end
+
+    private
+
+    def _next
+      @position += 1
+      @token = @tokens[@position] || Token::NULL_TOKEN
+    end
+
+    def validate_match(token, match)
+      if match && !match.include?(token.type)
+        raise Errors::SyntaxError, "type missmatch"
+      else
+        token
+      end
+    end
+
+  end
+end

data/lib/jmespath/version.rb

@@ -0,0 +1,3 @@
+module JMESPath
+  VERSION = '1.1.0'
+end