jmespath 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1dbe0a2b46b3a401846035f1c310a6d9e3e90aeb
+  data.tar.gz: c25be88050e43b57d065b976cce0fd6b6eebcff0
+SHA512:
+  metadata.gz: bea4a7c9e7d4013eefb09b186e30c8012d44ebf56fed7611cb5df19ee533e0a0b9b183bc031268e224d36b7c2afb96a4ff092cc8db22ba5d4e295169ee8afe7c
+  data.tar.gz: f94c1a2a49ee75d6f86a345d0ac2f31d799c407e376697302ed29814d5733b3612ba822b1151b2f19bba9814eb95e9f175e7b75ba399a5ba629d3d5af5eb35d7

data/lib/jmespath.rb

@@ -0,0 +1,23 @@
+module JMESPath
+
+  autoload :Errors, 'jmespath/errors'
+  autoload :ExprNode, 'jmespath/expr_node'
+  autoload :Lexer, 'jmespath/lexer'
+  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
+
+    # @param [String<JMESPath>] expression
+    # @param [Hash] data
+    # @return [Mixed,nil]
+    def search(expression, data)
+      Runtime.new.search(expression, data)
+    end
+
+  end
+end

data/lib/jmespath/errors.rb

@@ -0,0 +1,17 @@
+module JMESPath
+  module Errors
+
+    class Error < StandardError; end
+
+    class RuntimeError < Error; end
+
+    class SyntaxError < Error; end
+
+    class InvalidTypeError < Error; end
+
+    class InvalidArityError < Error; end
+
+    class UnknownFunctionError < Error; end
+
+  end
+end

data/lib/jmespath/expr_node.rb

@@ -0,0 +1,15 @@
+module JMESPath
+  # @api private
+  class ExprNode
+
+    def initialize(interpreter, node)
+      @interpreter = interpreter
+      @node = node
+    end
+
+    attr_reader :interpreter
+
+    attr_reader :node
+
+  end
+end

data/lib/jmespath/lexer.rb

@@ -0,0 +1,118 @@
+require 'multi_json'
+
+module JMESPath
+  # @api private
+  class Lexer
+
+    # @api private
+    TOKEN_PATTERNS = {}
+
+    # @api private
+    TOKEN_TYPES = {}
+
+    {
+      '[a-zA-Z_][a-zA-Z_0-9]*'     => :identifier,
+      '\.'                         => :dot,
+      '\*'                         => :star,
+      '\[\]'                       => :flatten,
+      '-?\d+'                      => :number,
+      '\|\|'                       => :or,
+      '\|'                         => :pipe,
+      '\[\?'                       => :filter,
+      '\['                         => :lbracket,
+      '\]'                         => :rbracket,
+      '"(?:\\\\\\\\|\\\\"|[^"])*"' => :quoted_identifier,
+      '`(?:\\\\\\\\|\\\\`|[^`])*`' => :literal,
+      ','                          => :comma,
+      ':'                          => :colon,
+      '@'                          => :current,
+      '&'                          => :expref,
+      '\('                         => :lparen,
+      '\)'                         => :rparen,
+      '\{'                         => :lbrace,
+      '\}'                         => :rbrace,
+      '!='                         => :comparator,
+      '=='                         => :comparator,
+      '<='                         => :comparator,
+      '>='                         => :comparator,
+      '<'                          => :comparator,
+      '>'                          => :comparator,
+      '[ \t]'                      => :skip,
+    }.each.with_index do |(pattern, type), n|
+      TOKEN_PATTERNS[n] = pattern
+      TOKEN_TYPES[n] = type
+    end
+
+    # @api private
+    TOKEN_REGEX = /(#{TOKEN_PATTERNS.values.join(')|(')})/
+
+    # @api private
+    JSON_VALUE = /^[\["{]/
+
+    # @api private
+    JSON_NUMBER = /^\-?[0-9]*(\.[0-9]+)?([e|E][+|\-][0-9]+)?$/
+
+    # @param [String<JMESPath>] expression
+    # @return [Array<Hash>]
+    def tokenize(expression)
+      offset = 0
+      tokens = []
+      expression.scan(TOKEN_REGEX).each do |match|
+        match_index = match.find_index { |token| !token.nil? }
+        match_value = match[match_index]
+        type = TOKEN_TYPES[match_index]
+        token = Token.new(type, match_value, offset)
+        if token.type != :skip
+          case token.type
+          when :number then token_number(token, expression, offset)
+          when :literal then token_literal(token, expression, offset)
+          when :quoted_identifier
+            token_quoted_identifier(token, expression, offset)
+          end
+          tokens << token
+        end
+        offset += match_value.size
+      end
+      tokens << Token.new(:eof, nil, offset)
+      unless expression.size == offset
+        syntax_error('invalid expression', expression, offset) 
+      end
+      tokens
+    end
+
+    private
+
+    def token_number(token, expression, offset)
+      token[:value] = token[:value].to_i
+    end
+
+    def token_literal(token, expression, offset)
+      token[:value] = token[:value][1..-2].lstrip.gsub('\`', '`')
+      token[:value] =
+        case token[:value]
+        when 'true', 'false' then token[:value] == 'true'
+        when 'null' then nil
+        when '' then syntax_error("empty json literal", expression, offset)
+        when JSON_VALUE then decode_json(token[:value], expression, offset)
+        when JSON_NUMBER then decode_json(token[:value], expression, offset)
+        else decode_json('"' + token[:value] + '"', expression, offset)
+        end
+    end
+
+    def token_quoted_identifier(token, expression, offset)
+      token[:value] = decode_json(token[:value], expression, offset)
+    end
+
+    def decode_json(json, expression, offset)
+      MultiJson.load(json)
+    rescue MultiJson::ParseError => e
+      syntax_error(e.message, expression, offset)
+    end
+
+    def syntax_error(message, expression, offset)
+      msg = message + "in #{expression.inspect} at #{offset}"
+      raise Errors::SyntaxError.new(msg)
+    end
+
+  end
+end

data/lib/jmespath/parser.rb

@@ -0,0 +1,350 @@
+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 = { type: :current }
+
+    # @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))
+      #puts "\n" + stream.inspect + "\n\n"
+      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)
+      #puts "nud_#{stream.token.type}"
+      left = send("nud_#{stream.token.type}", stream)
+      while rbp < stream.token.binding_power
+      #puts "#{rbp} #{stream.token.binding_power} led_#{stream.token.type}"
+        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
+      {
+        type: :expression,
+        children: [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
+      stream.next
+      { type: :field, key: token.value }
+    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
+      {
+        type: :multi_select_hash,
+        children: 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
+      {
+        type: :literal,
+        value: 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
+        { type: :field, key: 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
+      {
+        type: :comparator,
+        relation: token.value,
+        children: [
+          left,
+          expr(stream),
+        ]
+      }
+    end
+
+    def led_dot(stream, left)
+      stream.next(match:AFTER_DOT)
+      if stream.token.type == :star
+        parse_wildcard_object(stream, left)
+      else
+        {
+          type: :subexpression,
+          children: [
+            left,
+            parse_dot(stream, Token::BINDING_POWER[:dot])
+          ]
+        }
+      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])
+      {
+        type: :projection,
+        from: :array,
+        children: [
+          left ? left : CURRENT_NODE,
+          {
+            type: :condition,
+            children: [expression, rhs],
+          }
+        ]
+      }
+    end
+
+    def led_flatten(stream, left)
+      stream.next
+      {
+        type: :projection,
+        from: :array,
+        children: [
+          { type: :flatten, children: [left] },
+          parse_projection(stream, Token::BINDING_POWER[:flatten])
+        ]
+      }
+    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)
+          ]
+        }
+      else
+        parse_wildcard_array(stream, left)
+      end
+    end
+
+    def led_lparen(stream, left)
+      args = []
+      name = left[:key]
+      stream.next
+      while stream.token.type != :rparen
+        args << expr(stream, 0)
+        if stream.token.type == :comma
+          stream.next
+        end
+      end
+      stream.next
+      {
+        type: :function,
+        fn: name,
+        children: args,
+      }
+    end
+
+    def led_or(stream, left)
+      stream.next
+      {
+        type: :or,
+        children: [left, expr(stream, Token::BINDING_POWER[:or])]
+      }
+    end
+
+    def led_pipe(stream, left)
+      stream.next
+      {
+        type: :pipe,
+        children: [left, expr(stream, Token::BINDING_POWER[:pipe])],
+      }
+    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
+        { type: :index, index: parts[0] }
+      elsif pos > 2
+        raise Errors::SyntaxError, 'invalid array slice syntax: too many colons'
+      else
+        { type: :slice, args: 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
+      {
+        type: :key_value_pair,
+        key: key,
+        children: [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
+      {
+        type: :multi_select_list,
+        children: 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
+      {
+        type: :projection,
+        from: :array,
+        children: [
+          left ? left : CURRENT_NODE,
+          parse_projection(stream, Token::BINDING_POWER[:star])
+        ]
+      }
+    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])
+        ]
+      }
+    end
+
+  end
+end

data/lib/jmespath/runtime.rb

@@ -0,0 +1,20 @@
+module JMESPath
+  # @api private
+  class Runtime
+
+    # @option options [Parser] :parser
+    # @option options [Interpreter] :interpreter
+    def initialize(options = {})
+      @parser = options[:parser] || Parser.new
+      @interpreter = options[:interpreter] || TreeInterpreter.new
+    end
+
+    # @param [String<JMESPath>] expression
+    # @param [Hash] data
+    # @return [Mixed,nil]
+    def search(expression, data)
+      @interpreter.visit(@parser.parse(expression), data)
+    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/tree_interpreter.rb

@@ -0,0 +1,525 @@
+module JMESPath
+  # @api private
+  class TreeInterpreter
+
+    def visit(node, data)
+      dispatch(node, data)
+    end
+
+    # @api private
+    def method_missing(method_name, *args)
+      if matches = method_name.to_s.match(/^function_(.*)/)
+        raise Errors::UnknownFunctionError, "unknown function #{matches[1]}()"
+      else
+        super
+      end
+    end
+
+    private
+
+    def dispatch(node, value)
+      case node[:type]
+
+      when :field
+        if hash_like?(value)
+          value[node[:key]]
+        else
+          nil
+        end
+
+      when :subexpression
+        dispatch(node[:children][1], dispatch(node[:children][0], value))
+
+      when :index
+        if array_like?(value)
+          value[node[:index]]
+        else
+          nil
+        end
+
+      when :projection
+        # Interprets a projection node, passing the values of the left
+        # child through the values of the right child and aggregating
+        # the non-null results into the return value.
+        left = dispatch(node[:children][0], value)
+        if node[:from] == :object && hash_like?(left)
+          projection(left.values, node)
+        elsif node[:from] == :object && left == []
+          projection(left, node)
+        elsif node[:from] == :array && array_like?(left)
+          projection(left, node)
+        else
+          nil
+        end
+
+      when :flatten
+        value = dispatch(node[:children][0], value)
+        if array_like?(value)
+          value.inject([]) do |values, v|
+            values + (array_like?(v) ? v : [v])
+          end
+        else
+          nil
+        end
+
+      when :literal
+        node[:value]
+
+      when :current
+        value
+
+      when :or
+        result = dispatch(node[:children][0], value)
+        if result.nil? or result.empty?
+          dispatch(node[:children][1], value)
+        else
+          result
+        end
+
+      when :pipe
+        dispatch(node[:children][1], dispatch(node[:children][0], value))
+
+      when :multi_select_list
+        if value.nil?
+          value
+        else
+          node[:children].map { |n| dispatch(n, value) }
+        end
+
+      when :multi_select_hash
+        if value.nil?
+          nil
+        else
+          node[:children].each.with_object({}) do |child, hash|
+            hash[child[:key]] = dispatch(child[:children][0], value)
+          end
+        end
+
+
+      when :comparator
+        left = dispatch(node[:children][0], value)
+        right = dispatch(node[:children][1], value)
+        case node[:relation]
+        when '==' then compare_values(left, right)
+        when '!=' then !compare_values(left, right)
+        when '>' then is_int(left) && is_int(right) && left > right
+        when '>=' then is_int(left) && is_int(right) && left >= right
+        when '<' then is_int(left) && is_int(right) && left < right
+        when '<=' then is_int(left) && is_int(right) && left <= right
+        end
+
+      when :condition
+        true == dispatch(node[:children][0], value) ?
+          dispatch(node[:children][1], value) :
+          nil
+
+      when :function
+        args = node[:children].map { |child| dispatch(child, value) }
+        send("function_#{node[:fn]}", *args)
+
+      when :slice
+        function_slice(value, *node[:args])
+
+      when :expression
+        ExprNode.new(self, node[:children][0])
+
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def hash_like?(value)
+      Hash === value || Struct === value
+    end
+
+    def array_like?(value)
+      Array === value
+    end
+
+    def projection(values, node)
+      values.inject([]) do |list, v|
+        list << dispatch(node[:children][1], v)
+      end.compact
+    end
+
+    def function_abs(*args)
+      if args.count == 1
+        value = args.first
+      else
+        raise Errors::InvalidArityError, "function abs() expects one argument"
+      end
+      if Numeric === value
+        value.abs
+      else
+        raise Errors::InvalidTypeError, "function abs() expects a number"
+      end
+    end
+
+    def function_avg(*args)
+      if args.count == 1
+        values = args.first
+      else
+        raise Errors::InvalidArityError, "function avg() expects one argument"
+      end
+      if Array === values
+        values.inject(0) do |total,n|
+          if Numeric === n
+            total + n
+          else
+            raise Errors::InvalidTypeError, "function avg() expects numeric values"
+          end
+        end / values.size.to_f
+      else
+        raise Errors::InvalidTypeError, "function avg() expects a number"
+      end
+    end
+
+    def function_ceil(*args)
+      if args.count == 1
+        value = args.first
+      else
+        raise Errors::InvalidArityError, "function ceil() expects one argument"
+      end
+      if Numeric === value
+        value.ceil
+      else
+        raise Errors::InvalidTypeError, "function ceil() expects a numeric value"
+      end
+    end
+
+    def function_contains(*args)
+      if args.count == 2
+        if String === args[0] || Array === args[0]
+          args[0].include?(args[1])
+        else
+          raise Errors::InvalidTypeError, "contains expects 2nd arg to be a list"
+        end
+      else
+        raise Errors::InvalidArityError, "function contains() expects 2 arguments"
+      end
+    end
+
+    def function_floor(*args)
+      if args.count == 1
+        value = args.first
+      else
+        raise Errors::InvalidArityError, "function floor() expects one argument"
+      end
+      if Numeric === value
+        value.floor
+      else
+        raise Errors::InvalidTypeError, "function floor() expects a numeric value"
+      end
+    end
+
+    def function_length(*args)
+      if args.count == 1
+        value = args.first
+      else
+        raise Errors::InvalidArityError, "function length() expects one argument"
+      end
+      case value
+      when Hash, Array, String then value.size
+      else raise Errors::InvalidTypeError, "function length() expects string, array or object"
+      end
+    end
+
+    def function_max(*args)
+      if args.count == 1
+        values = args.first
+      else
+        raise Errors::InvalidArityError, "function max() expects one argument"
+      end
+      if Array === values
+        values.inject(values.first) do |max, v|
+          if Numeric === v
+            v > max ? v : max
+          else
+            raise Errors::InvalidTypeError, "function max() expects numeric values"
+          end
+        end
+      else
+        raise Errors::InvalidTypeError, "function max() expects an array"
+      end
+    end
+
+    def function_min(*args)
+      if args.count == 1
+        values = args.first
+      else
+        raise Errors::InvalidArityError, "function min() expects one argument"
+      end
+      if Array === values
+        values.inject(values.first) do |min, v|
+          if Numeric === v
+            v < min ? v : min
+          else
+            raise Errors::InvalidTypeError, "function min() expects numeric values"
+          end
+        end
+      else
+        raise Errors::InvalidTypeError, "function min() expects an array"
+      end
+    end
+
+    def function_type(*args)
+      if args.count == 1
+        get_type(args.first)
+      else
+        raise Errors::InvalidArityError, "function type() expects one argument"
+      end
+    end
+
+    def function_keys(*args)
+      if args.count == 1
+        value = args.first
+        if hash_like?(value)
+          case value
+          when Hash then value.keys.map(&:to_s)
+          when Struct then value.members.map(&:to_s)
+          else raise NotImplementedError
+          end
+        else
+          raise Errors::InvalidTypeError, "function keys() expects a hash"
+        end
+      else
+        raise Errors::InvalidArityError, "function keys() expects one argument"
+      end
+    end
+
+    def function_values(*args)
+      if args.count == 1
+        value = args.first
+        if hash_like?(value)
+          value.values
+        elsif array_like?(value)
+          value
+        else
+          raise Errors::InvalidTypeError, "function values() expects an array or a hash"
+        end
+      else
+        raise Errors::InvalidArityError, "function values() expects one argument"
+      end
+    end
+
+    def function_join(*args)
+      if args.count == 2
+        glue = args[0]
+        values = args[1]
+        if !(String === glue)
+          raise Errors::InvalidTypeError, "function join() expects the first argument to be a string"
+        elsif array_like?(values) && values.all? { |v| String === v }
+          values.join(glue)
+        else
+          raise Errors::InvalidTypeError, "function join() expects values to be an array of strings"
+        end
+      else
+        raise Errors::InvalidArityError, "function join() expects an array of strings"
+      end
+    end
+
+    def function_to_string(*args)
+      if args.count == 1
+        value = args.first
+        String === value ? value : MultiJson.dump(value)
+      else
+        raise Errors::InvalidArityError, "function to_string() expects one argument"
+      end
+    end
+
+    def function_to_number(*args)
+      if args.count == 1
+        begin
+          value = Float(args.first)
+          Integer(value) === value ? value.to_i : value
+        rescue
+          nil
+        end
+      else
+        raise Errors::InvalidArityError, "function to_number() expects one argument"
+      end
+    end
+
+    def function_sum(*args)
+      if args.count == 1 && array_like?(args.first)
+        args.first.inject(0) do |sum,n|
+          if Numeric === n
+            sum + n
+          else
+            raise Errors::InvalidTypeError, "function sum() expects values to be numeric"
+          end
+        end
+      else
+        raise Errors::InvalidArityError, "function sum() expects one argument"
+      end
+    end
+
+    def function_not_null(*args)
+      if args.count > 0
+        args.find { |value| !value.nil? }
+      else
+        raise Errors::InvalidArityError, "function not_null() expects one or more arguments"
+      end
+    end
+
+    def function_sort(*args)
+      if args.count == 1
+        value = args.first
+        if array_like?(value)
+          value.sort do |a, b|
+            a_type = get_type(a)
+            b_type = get_type(b)
+            if ['string', 'number'].include?(a_type) && a_type == b_type
+              a <=> b
+            else
+              raise Errors::InvalidTypeError, "function sort() expects values to be an array of numbers or integers"
+            end
+          end
+        else
+          raise Errors::InvalidTypeError, "function sort() expects values to be an array of numbers or integers"
+        end
+      else
+        raise Errors::InvalidArityError, "function sort() expects one argument"
+      end
+    end
+
+    def function_sort_by(*args)
+      if args.count == 2
+        if get_type(args[0]) == 'array' && get_type(args[1]) == 'expression'
+          values = args[0]
+          expression = args[1]
+          values.sort do |a,b|
+            a_value = expression.interpreter.visit(expression.node, a)
+            b_value = expression.interpreter.visit(expression.node, b)
+            a_type = get_type(a_value)
+            b_type = get_type(b_value)
+            if ['string', 'number'].include?(a_type) && a_type == b_type
+              a_value <=> b_value
+            else
+              raise Errors::InvalidTypeError, "function sort() expects values to be an array of numbers or integers"
+            end
+          end
+        else
+          raise Errors::InvalidTypeError, "function sort_by() expects an array and an expression"
+        end
+      else
+        raise Errors::InvalidArityError, "function sort_by() expects two arguments"
+      end
+    end
+
+    def function_max_by(*args)
+      number_compare(:max, *args)
+    end
+
+    def function_min_by(*args)
+      number_compare(:min, *args)
+    end
+
+    def number_compare(mode, *args)
+      if args.count == 2
+        if get_type(args[0]) == 'array' && get_type(args[1]) == 'expression'
+          values = args[0]
+          expression = args[1]
+          args[0].send("#{mode}_by") do |entry|
+            value = expression.interpreter.visit(expression.node, entry)
+            if get_type(value) == 'number'
+              value
+            else
+              raise Errors::InvalidTypeError, "function #{mode}_by() expects values to be an numbers"
+            end
+          end
+        else
+          raise Errors::InvalidTypeError, "function #{mode}_by() expects an array and an expression"
+        end
+      else
+        raise Errors::InvalidArityError, "function #{mode}_by() expects two arguments"
+      end
+    end
+
+    def function_slice(values, *args)
+      if String === values || array_like?(values)
+        _slice(values, *args)
+      else
+        nil
+      end
+    end
+
+    def _slice(values, start, stop, step)
+      start, stop, step = _adjust_slice(values.size, start, stop, step)
+      result = []
+      if step > 0
+        i = start
+        while i < stop
+          result << values[i]
+          i += step
+        end
+      else
+        i = start
+        while i > stop
+          result << values[i]
+          i += step
+        end
+      end
+      String === values ? result.join : result
+    end
+
+    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
+
+    def compare_values(a, b)
+      if a == b
+        true
+      else
+        false
+      end
+    end
+
+    def is_int(value)
+      Integer === value
+    end
+
+    def get_type(value)
+      case
+      when ExprNode === value then 'expression'
+      when String === value then 'string'
+      when hash_like?(value) then 'object'
+      when array_like?(value) then 'array'
+      when [true, false].include?(value) then 'boolean'
+      when value.nil? then 'null'
+      when Numeric === value then 'number'
+      end
+    end
+
+  end
+end

data/lib/jmespath/version.rb

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

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: jmespath
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Trevor Rowe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Implementes JMESPath for Ruby
+email: trevorrowe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/jmespath/errors.rb
+- lib/jmespath/expr_node.rb
+- lib/jmespath/lexer.rb
+- lib/jmespath/parser.rb
+- lib/jmespath/runtime.rb
+- lib/jmespath/token.rb
+- lib/jmespath/token_stream.rb
+- lib/jmespath/tree_interpreter.rb
+- lib/jmespath/version.rb
+- lib/jmespath.rb
+homepage: http://github.com/trevorrowe/jmespath.rb
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: JMESPath - Ruby Edition
+test_files: []
+has_rdoc: