jmespath-ruby 0.1.0

data/lib/jmespath/evaluation/logic.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # @api private
+  class Evaluator
+    COMPARISONS = { lt: :<, lte: :<=, gt: :>, gte: :>= }.freeze
+
+    private
+
+    def boolean(node, data)
+      # @type var result: value
+      result = nil
+      node.children.each do |child|
+        result = evaluate(child, data)
+        break if node.kind == :or ? !Types.falsey?(result) : Types.falsey?(result)
+      end
+      result
+    end
+
+    def negation?(node, data)
+      Types.falsey?(evaluate(node.children.fetch(0), data))
+    end
+
+    def equality(node, data)
+      left, right = node.children.map { |child| evaluate(child, data) }
+      result = Types.equal?(left, right)
+      node.kind == :eq ? result : !result
+    end
+
+    def ordering(node, data)
+      left, right = node.children.map { |child| evaluate(child, data) }
+      type = Types.name(left)
+      return nil unless type == Types.name(right) && %i[number string].include?(type)
+
+      if type == :string
+        left = Functions::Coercions.string(left)
+        right = Functions::Coercions.string(right)
+      end
+      left.public_send(COMPARISONS.fetch(node.kind), right)
+    end
+  end
+end

data/lib/jmespath/evaluation/projections.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # @api private
+  class Evaluator
+    private
+
+    def projection(node, data)
+      values = DataAccess.array(evaluate(node.children.fetch(0), data))
+      project(node, values)
+    end
+
+    def value_projection(node, data)
+      mapping = DataAccess.object(evaluate(node.children.fetch(0), data))
+      project(node, mapping&.values)
+    end
+
+    def filter_projection(node, data)
+      values = DataAccess.array(evaluate(node.children.fetch(0), data))
+      selected = values&.reject { |value| Types.falsey?(evaluate(node.children.fetch(2), value)) }
+      return nil unless selected
+
+      child = node.children.fetch(1)
+      selected.map! { |value| evaluate(child, value) }
+      selected.compact!
+      selected
+    end
+
+    def project(node, values)
+      return nil unless values
+
+      child = node.children.fetch(1)
+      result = values.map { |value| evaluate(child, value) }
+      result.compact!
+      result
+    end
+
+    def flatten(node, data)
+      values = DataAccess.array(evaluate(node.children.fetch(0), data))
+      values&.flat_map { |value| DataAccess.array(value) || [value] }
+    end
+  end
+end

data/lib/jmespath/evaluation/scalars.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # @api private
+  class Evaluator
+    private
+
+    def literal(node, _data)
+      copy_literal(node.value)
+    end
+
+    def copy_literal(value)
+      case value
+      when Array then value.map { |item| copy_literal(item) }
+      when Hash then value.transform_values { |item| copy_literal(item) }
+      when String then value.dup
+      else value
+      end
+    end
+
+    def index(node, data)
+      array = DataAccess.array(evaluate(node.children.fetch(0), data))
+      position = node.value
+      raise TypeError, "Invalid array index" unless position.is_a?(Integer)
+
+      return nil unless array && position.between?(-array.length, array.length - 1)
+
+      array[position]
+    end
+
+    def group(node, data)
+      evaluate(node.children.fetch(0), data)
+    end
+
+    def sequence(node, data)
+      node.children.each { |child| data = evaluate(child, data) }
+      data
+    end
+
+    def reference(node, _data)
+      ExpressionReference.new { |value| evaluate(node.children.fetch(0), value) }
+    end
+
+    def function(node, data)
+      arguments = node.children.map { |child| evaluate(child, data) }
+      @functions.call(node.value.to_s, arguments, disable_visit_errors: @disable_visit_errors)
+    end
+  end
+end

data/lib/jmespath/evaluation/slices.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # @api private
+  class Evaluator
+    private
+
+    def slice(node, data)
+      values = DataAccess.array(evaluate(node.children.fetch(0), data))
+      return nil unless values
+
+      start, stop, step = Array(node.value).map { |part| part.nil? ? nil : Integer(part) }
+      Slice.new(start: start, stop: stop, step: step).apply(values)
+    end
+  end
+
+  # @api private
+  class Slice
+    def initialize(start:, stop:, step:)
+      @start = start
+      @stop = stop
+      @step = step || 1
+      raise Errors::InvalidValueError, "Slice step cannot be zero" if @step.zero?
+
+      @forward = @step.positive?
+    end
+
+    def apply(values)
+      length = values.length
+      index = bound(@start, length, @forward ? 0 : length - 1)
+      stop = bound(@stop, length, @forward ? length : -1)
+      # @type var result: Array[value]
+      result = []
+      while @forward ? index < stop : index > stop
+        result << values[index]
+        index += @step
+      end
+      result
+    end
+
+    private
+
+    def bound(value, length, fallback)
+      return fallback if value.nil?
+
+      index = value.negative? ? value + length : value
+      @forward ? index.clamp(0, length) : index.clamp(-1, length - 1)
+    end
+  end
+end

data/lib/jmespath/evaluator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # @api private
+  class Evaluator
+    HANDLERS = {
+      literal: :literal, index: :index,
+      group: :group, subexpression: :sequence, pipe: :sequence,
+      and: :boolean, or: :boolean, not: :negation?,
+      eq: :equality, ne: :equality, lt: :ordering, lte: :ordering, gt: :ordering, gte: :ordering,
+      multi_select_list: :list, multi_select_hash: :mapping,
+      function: :function, expression_reference: :reference,
+      projection: :projection, value_projection: :value_projection,
+      filter_projection: :filter_projection, flatten: :flatten, slice: :slice
+    }.freeze
+
+    def initialize(functions:, disable_visit_errors: false)
+      @functions = functions
+      @disable_visit_errors = disable_visit_errors
+      freeze
+    end
+
+    def evaluate(node, data)
+      case node.kind
+      when :field then DataAccess.field(data, node.value.to_s)
+      when :current then data
+      else send(HANDLERS.fetch(node.kind), node, data)
+      end
+    end
+  end
+end
+
+require_relative "evaluation/scalars"
+require_relative "evaluation/logic"
+require_relative "evaluation/construction"
+require_relative "evaluation/projections"
+require_relative "evaluation/slices"

data/lib/jmespath/expression.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # Immutable parsed syntax that can search multiple input documents.
+  class Expression
+    DEFAULT_EVALUATOR = Evaluator.new(functions: Functions.default)
+    # @return [String] an independent, frozen expression string
+    attr_reader :source
+
+    # @api private
+    def initialize(source, root, max_depth: 128, options: Options::DEFAULT)
+      @source = source.dup.freeze
+      @root = root
+      @options = options
+      @plan = Plan.build(root, options)
+      @max_depth = max_depth
+      freeze
+    end
+
+    # Search input with this parsed expression.
+    # @param data [Object] Ruby values, Pathname, IO, or StringIO
+    # @param options [Hash] positional compatibility options
+    # @param keywords [Hash] keyword evaluation options
+    # @return [Object] the query result, including nil
+    def search(data, options = Options::EMPTY, **keywords)
+      if options.equal?(Options::EMPTY) && keywords.empty?
+        return @plan.call(data.is_a?(Hash) ? data : Input.load(data))
+      end
+
+      config = Options.new(options, keywords, default_depth: @max_depth, defaults: @options)
+      evaluate(Input.load(data), config)
+    end
+
+    # Search input using the same options and behavior as {#search}.
+    # @return [Object] the query result, including nil
+    alias call search
+
+    # @api private
+    def configured(options)
+      return self if options.functions.equal?(Functions.default) && !options.disable_visit_errors
+
+      self.class.new(source, @root, max_depth: @max_depth, options: options)
+    end
+
+    # @api private
+    def evaluate(data, config)
+      if @root.depth > config.max_depth
+        raise Errors::SyntaxError.new("Expression exceeds nesting limit", expression: source)
+      end
+
+      return @plan.call(data) if config.equal?(@options) || configured_for?(config)
+
+      evaluator = Evaluator.new(functions: config.functions, disable_visit_errors: config.disable_visit_errors)
+      evaluator.evaluate(@root, data)
+    end
+
+    private
+
+    def configured_for?(config)
+      config.functions.equal?(@options.functions) && config.disable_visit_errors == @options.disable_visit_errors
+    end
+  end
+end

data/lib/jmespath/expression_reference.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # @api private
+  class ExpressionReference
+    def initialize(&block)
+      @block = block
+      freeze
+    end
+
+    def call(value)
+      @block.call(value)
+    end
+  end
+end

data/lib/jmespath/functions/coercions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module JMESPath
+  class Functions
+    # @api private
+    module Coercions
+      extend self
+
+      def number(value)
+        return value if value.is_a?(Integer)
+        return value if value.is_a?(Float) && value.finite?
+
+        raise Signature::TypeMismatch.new("Expected a finite number", origin: validation_origin)
+      end
+
+      def string(value)
+        DataAccess.string(value) || raise(Signature::TypeMismatch.new("Expected a string", origin: validation_origin))
+      end
+
+      def array(value)
+        DataAccess.array(value) || raise(Signature::TypeMismatch.new("Expected an array", origin: validation_origin))
+      end
+
+      def reference(value)
+        return value if value.is_a?(ExpressionReference)
+
+        raise Signature::TypeMismatch.new("Expected an expression reference", origin: validation_origin)
+      end
+
+      def object(value)
+        DataAccess.object(value) || raise(Signature::TypeMismatch.new("Expected an object", origin: validation_origin))
+      end
+
+      private
+
+      def validation_origin
+        nil
+      end
+    end
+  end
+end

data/lib/jmespath/functions/collections.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # Standard and custom function definitions.
+  class Functions
+    # @api private
+    module Collections
+      SIGNATURES = {
+        "avg" => [[:array_number]], "sum" => [[:array_number]],
+        "min" => [%i[array_number array_string]], "max" => [%i[array_number array_string]],
+        "sort" => [%i[array_number array_string]], "join" => [[:string], [:array_string]],
+        "keys" => [[:object]], "values" => [[:object]], "merge" => [[:object]],
+        "map" => [[:expref], [:array]], "sort_by" => [[:array], [:expref]],
+        "min_by" => [[:array], [:expref]], "max_by" => [[:array], [:expref]]
+      }.freeze
+
+      def self.register(registry)
+        SIGNATURES.reduce(registry) do |result, (name, signature)|
+          result.with_builtin(name, signature: signature, handler: name.to_sym, variadic: name == "merge")
+        end
+      end
+
+      private
+
+      def sum(value)
+        array(value).sum { |item| number(item) }
+      end
+
+      def avg(value)
+        values = array(value)
+        number(sum(value)).fdiv(values.length) unless values.empty?
+      end
+
+      def min(value)
+        array(value).min_by { |item| sort_key(item) }
+      end
+
+      def max(value)
+        array(value).max_by { |item| sort_key(item) }
+      end
+
+      def sort(value)
+        array(value).each_with_index.sort_by do |item, index|
+          [sort_key(item), index]
+        end.map(&:first)
+      end
+
+      def join(separator, value)
+        array(value).map do |item|
+          string(item)
+        end.join(string(separator))
+      end
+
+      def keys(value)
+        object(value).keys.map(&:to_s)
+      end
+
+      def values(value)
+        object(value).values
+      end
+
+      def merge(*values)
+        # @type var result: Hash[value, value]
+        result = {}
+        values.each { |value| result.merge!(object(value)) }
+        result
+      end
+
+      def sort_key(value)
+        DataAccess.string(value) || number(value)
+      end
+    end
+
+    # @api private
+    DEFAULT = Collections.register(Scalar.register(new))
+
+    # @return [Functions] immutable standard function definitions
+    def self.default
+      DEFAULT
+    end
+  end
+end
+
+require_relative "references"

data/lib/jmespath/functions/conversion.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module JMESPath
+  class Functions
+    # @api private
+    module Scalar
+      NUMBER = /\A[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?\z/
+
+      private
+
+      def to_array(value)
+        DataAccess.array(value) || [value]
+      end
+
+      def to_string(value)
+        DataAccess.string(value) || JSON.generate(Types.normalize(value))
+      rescue JSON::NestingError
+        raise Errors::InvalidValueError, "Value is too deeply nested to serialize"
+      end
+
+      def to_number(value)
+        return value if Types.number?(value)
+
+        text = DataAccess.string(value)&.strip
+        return nil unless text && NUMBER.match?(text)
+
+        number = Integer(text, 10, exception: false) || Float(text, exception: false)
+        number if Types.number?(number)
+      end
+    end
+  end
+end

data/lib/jmespath/functions/function_call.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module JMESPath
+  class Functions
+    # @api private
+    class FunctionCall
+      include Scalar
+      include Collections
+      include Coercions
+
+      private :number, :string, :array, :reference, :object
+
+      def call(definition, name, arguments, disable_visit_errors: false)
+        definition.signature.validate!(arguments, name, origin: self)
+        implementation = definition.implementation
+        implementation.is_a?(Symbol) ? send(implementation, *arguments) : implementation.call(*arguments)
+      rescue Signature::TypeMismatch, Signature::ArityMismatch => e
+        raise unless disable_visit_errors && e.origin.equal?(self)
+
+        nil
+      end
+
+      STRICT = new.freeze
+
+      private
+
+      def validation_origin
+        self
+      end
+    end
+  end
+end

data/lib/jmespath/functions/references.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module JMESPath
+  class Functions
+    # @api private
+    module Collections
+      SORTABLE_TYPES = %i[number string].freeze
+
+      private
+
+      def map(expression, value)
+        reference = reference(expression)
+        array(value).map { |item| reference.call(item) }
+      end
+
+      def sort_by(value, expression)
+        reference = reference(expression)
+        # @type var expected: Symbol?
+        expected = nil
+        index = 0
+        array(value).sort_by do |item|
+          key = reference.call(item)
+          expected = checked_type(key, expected)
+          index += 1
+          [sort_key(key), index]
+        end
+      end
+
+      def min_by(value, expression)
+        keyed(value, expression).min_by(&:first)&.last
+      end
+
+      def max_by(value, expression)
+        keyed(value, expression).max_by(&:first)&.last
+      end
+
+      def keyed(value, expression)
+        reference = reference(expression)
+        # @type var expected: Symbol?
+        expected = nil
+        array(value).map do |item|
+          key = reference.call(item)
+          expected = checked_type(key, expected)
+          [sort_key(key), item]
+        end
+      end
+
+      def checked_type(value, expected)
+        type = Types.name(value)
+        unless SORTABLE_TYPES.include?(type)
+          raise Signature::TypeMismatch.new("Expression keys must be numbers or strings", origin: validation_origin)
+        end
+        if expected && expected != type
+          raise Signature::TypeMismatch.new("Expression keys must have one type",
+                                            origin: validation_origin)
+        end
+
+        type
+      end
+    end
+  end
+end

data/lib/jmespath/functions/scalar.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module JMESPath
+  class Functions
+    # @api private
+    module Scalar
+      SIGNATURES = {
+        "abs" => [[:number]], "ceil" => [[:number]], "floor" => [[:number]],
+        "contains" => [%i[array string], [:any]],
+        "ends_with" => [[:string], [:string]], "starts_with" => [[:string], [:string]],
+        "length" => [%i[string array object]], "reverse" => [%i[string array]],
+        "type" => [[:any]], "to_array" => [[:any]], "to_string" => [[:any]],
+        "to_number" => [[:any]], "not_null" => [[:any]]
+      }.freeze
+
+      def self.register(registry)
+        SIGNATURES.reduce(registry) do |result, (name, signature)|
+          handler = %w[contains ends_with starts_with].include?(name) ? "#{name}?" : name
+          result.with_builtin(name, signature: signature, handler: handler.to_sym, variadic: name == "not_null")
+        end
+      end
+
+      private
+
+      def abs(value)
+        number(value).abs
+      end
+
+      def ceil(value)
+        number(value).ceil
+      end
+
+      def floor(value)
+        number(value).floor
+      end
+
+      def contains?(subject, search)
+        text = DataAccess.string(subject)
+        return text.include?(string(search)) if text
+
+        array(subject).any? { |item| Types.equal?(item, search) }
+      end
+
+      def ends_with?(text, suffix)
+        string(text).end_with?(string(suffix))
+      end
+
+      def starts_with?(text, prefix)
+        string(text).start_with?(string(prefix))
+      end
+
+      def length(value)
+        collection = DataAccess.string(value) || DataAccess.array(value) || object(value)
+        collection.length
+      end
+
+      def reverse(value)
+        (DataAccess.string(value) || array(value)).reverse
+      end
+
+      def type(value)
+        name = Types.name(value)
+        name.to_s unless name == :unknown
+      end
+
+      def not_null(*values)
+        values.find { |value| !value.nil? }
+      end
+    end
+  end
+end
+
+require_relative "coercions"
+require_relative "conversion"