jmespath-ruby 0.1.0

data/lib/jmespath/plan.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # @api private
+  module Plan
+    BUILDERS = {
+      field: :field, current: :current, group: :group,
+      subexpression: :sequence, pipe: :sequence, index: :index,
+      multi_select_list: :list, projection: :projection,
+      value_projection: :value_projection, slice: :slice, function: :function,
+      expression_reference: :reference
+    }.freeze
+
+    def self.build(node, options = Options::DEFAULT)
+      Builder.new(options).build(node)
+    end
+
+    # @api private
+    class Builder
+      def initialize(options)
+        @functions = options.functions
+        @disable_visit_errors = options.disable_visit_errors
+        @evaluator = if @functions.equal?(Functions.default) && !@disable_visit_errors
+                       Expression::DEFAULT_EVALUATOR
+                     else
+                       Evaluator.new(functions: @functions, disable_visit_errors: @disable_visit_errors)
+                     end
+        freeze
+      end
+
+      def build(node)
+        builder = BUILDERS[node.kind]
+        (builder ? send(builder, node) : fallback(node)).freeze
+      end
+
+      private
+
+      def field(node)
+        DataAccess::FieldReader.new(node.value.to_s)
+      end
+
+      def current(_node)
+        ->(data) { data }
+      end
+
+      def group(node)
+        build(node.children.fetch(0))
+      end
+
+      def sequence(node)
+        children = node.children.map { |child| build(child) }.freeze
+        lambda do |data|
+          children.each { |child| data = child.call(data) }
+          data
+        end
+      end
+
+      def index(node)
+        child = build(node.children.fetch(0))
+        position = Integer(node.value) # : Integer
+        lambda do |data|
+          values = DataAccess.array(child.call(data))
+          values[position] if values && position.between?(-values.length, values.length - 1)
+        end
+      end
+
+      def list(node)
+        children = node.children.map { |child| build(child) }.freeze
+        ->(data) { children.map { |child| child.call(data) } unless data.nil? }
+      end
+
+      def projection(node)
+        child = build(node.children.fetch(0))
+        project = projector(node.children.fetch(1))
+        ->(data) { project.call(DataAccess.array(child.call(data))) }
+      end
+
+      def value_projection(node)
+        child = build(node.children.fetch(0))
+        project = projector(node.children.fetch(1))
+        ->(data) { project.call(DataAccess.object(child.call(data))&.values) }
+      end
+
+      def projector(node)
+        child = build(node)
+        lambda do |values|
+          if values
+            result = values.map { |value| child.call(value) }
+            result.compact!
+            result
+          end
+        end
+      end
+
+      def slice(node)
+        child = build(node.children.fetch(0))
+        start, stop, step = Array(node.value).map { |part| part.nil? ? nil : Integer(part) }
+        slice = Slice.new(start: start, stop: stop, step: step).freeze
+        lambda do |data|
+          values = DataAccess.array(child.call(data))
+          slice.apply(values) if values
+        end
+      end
+
+      def function(node)
+        name = node.value.to_s
+        unless !@disable_visit_errors && %w[length reverse].include?(name) && node.children.length == 1 &&
+               native_function?(name)
+          return function_call(name, node.children)
+        end
+
+        string_function(name, build(node.children.fetch(0)))
+      end
+
+      def native_function?(name)
+        @functions.instance_of?(Functions) && @functions.definition(name).equal?(Functions.default.definition(name))
+      end
+
+      def string_function(name, child)
+        lambda do |data|
+          value = child.call(data)
+          if value.is_a?(String)
+            name == "length" ? value.length : value.reverse
+          else
+            Functions.default.call(name, [value])
+          end
+        end
+      end
+
+      def fallback(node)
+        evaluator = @evaluator
+        ->(data) { evaluator.evaluate(node, data) }
+      end
+
+      def function_call(name, nodes)
+        arguments = nodes.map { |node| build(node) }.freeze
+        functions = @functions
+        if @disable_visit_errors
+          lambda do |data|
+            functions.call(name, arguments.map { |argument| argument.call(data) }, disable_visit_errors: true)
+          end
+        else
+          ->(data) { functions.call(name, arguments.map { |argument| argument.call(data) }) }
+        end
+      end
+
+      def reference(node)
+        operation = build(node.children.fetch(0))
+        ->(_data) { ExpressionReference.new { |value| operation.call(value) } }
+      end
+    end
+  end
+end

data/lib/jmespath/token.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # @api private
+  Token = Data.define(:type, :value, :start, :finish)
+end

data/lib/jmespath/types.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module JMESPath
+  # @api private
+  module Types
+    class << self
+      def name(value)
+        case value
+        when Integer then :number
+        when String then :string
+        when NilClass then :null
+        when TrueClass, FalseClass then :boolean
+        else other_name(value)
+        end
+      end
+
+      def number?(value)
+        value.is_a?(Integer) || (value.is_a?(Float) && value.finite?)
+      end
+
+      def falsey?(value)
+        return true if value.nil? || value.equal?(false)
+        return false if value.equal?(true)
+
+        collection = DataAccess.string(value) || DataAccess.array(value) || DataAccess.object(value)
+        collection ? collection.empty? : false
+      end
+
+      def equal?(left, right)
+        pending = [[normalize(left), normalize(right)]]
+        while (pair = pending.pop)
+          return false unless matching?(pair.fetch(0), pair.fetch(1), pending)
+        end
+        true
+      end
+
+      def normalize(value)
+        Normalizer.new.call(value)
+      end
+
+      private
+
+      def other_name(value)
+        return :number if number?(value)
+        return :expref if value.is_a?(ExpressionReference)
+
+        collection_name(value)
+      end
+
+      def collection_name(value)
+        return :string if DataAccess.string(value)
+        return :array if DataAccess.array(value)
+        return :object if DataAccess.object(value)
+
+        :unknown
+      end
+
+      def matching?(left, right, pending)
+        case left
+        when Array then arrays_match?(left, right, pending)
+        when Hash then objects_match?(left, right, pending)
+        else left == right
+        end
+      end
+
+      def arrays_match?(left, right, pending)
+        return false unless right.is_a?(Array) && left.length == right.length
+
+        left.each_with_index { |value, index| pending << [value, right[index]] }
+        true
+      end
+
+      def objects_match?(left, right, pending)
+        return false unless right.is_a?(Hash) && left.length == right.length
+        return false unless left.each_key.all? { |key| right.key?(key) }
+
+        left.each { |key, value| pending << [value, right[key]] }
+        true
+      end
+    end
+  end
+end
+
+require_relative "normalizer"

data/lib/jmespath/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Queries JSON-compatible Ruby values using JMESPath expressions.
+module JMESPath
+  # The semantic version of this implementation.
+  VERSION = "0.1.0"
+end

data/lib/jmespath.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "jmespath/version"
+require_relative "jmespath/errors"
+require_relative "jmespath/token"
+require_relative "jmespath/lexer"
+require_relative "jmespath/expression_reference"
+require_relative "jmespath/data_access"
+require_relative "jmespath/types"
+require_relative "jmespath/ast"
+require_relative "jmespath/parser"
+require_relative "jmespath/functions"
+require_relative "jmespath/evaluator"
+require_relative "jmespath/functions/scalar"
+require_relative "jmespath/functions/collections"
+require_relative "jmespath/functions/function_call"
+require_relative "jmespath/options"
+require_relative "jmespath/input"
+require_relative "jmespath/cache"
+require_relative "jmespath/plan"
+require_relative "jmespath/expression"
+
+# Search JSON-compatible Ruby values with JMESPath expressions.
+module JMESPath
+  # @api private
+  CACHE = Cache.new
+  private_constant :CACHE
+
+  class << self
+    # Search Ruby data using a JMESPath expression.
+    # @param expression [String] query text
+    # @param data [Object] Ruby values, Pathname, IO, or StringIO
+    # @param options [Hash] positional compatibility options
+    # @param keywords [Hash] keyword evaluation options
+    # @option options [Boolean] :cache_expressions (true) reuse cached syntax
+    # @option options [Boolean] :disable_visit_errors (false) suppress argument type and arity failures
+    # @option options [Functions] :functions (Functions.default) registry for this search
+    # @option options [Integer] :max_depth (128) maximum expression nesting
+    # @raise [ArgumentError] options or expression type are invalid
+    # @raise [Errors::Error] the query cannot be parsed or evaluated
+    # @example Project a field from each item
+    #   JMESPath.search("items[*].name", {items: [{name: "Ada"}]}) #=> ["Ada"]
+    # @return [Object] the query result, including nil
+    def search(expression, data, options = Options::EMPTY, **keywords)
+      config = if options.equal?(Options::EMPTY) && keywords.empty?
+                 Options::DEFAULT
+               else
+                 Options.new(options, keywords)
+               end
+      raise ArgumentError, "Expression must be a String" unless expression.is_a?(String)
+
+      compiled = compile_syntax(expression, config.cache_expressions, config.max_depth)
+      compiled.evaluate(Input.load(data), config)
+    end
+
+    # Parse an expression for repeated searches.
+    # @param expression [String] query text
+    # @param cache_expressions [Boolean] reuse bounded cached syntax
+    # @param max_depth [Integer] maximum nesting from 1 through 128
+    # @param functions [Functions] default registry for searches with this expression
+    # @param disable_visit_errors [Boolean] default suppression of argument type and arity failures
+    # @raise [ArgumentError] expression type or options are invalid
+    # @raise [Errors::SyntaxError] the expression is invalid or exceeds its nesting limit
+    # @example Reuse parsed syntax
+    #   JMESPath.compile("name").search({name: "Ada"}) #=> "Ada"
+    # @return [Expression] immutable reusable syntax
+    def compile(expression, cache_expressions: true, max_depth: 128,
+                functions: Functions.default, disable_visit_errors: false)
+      raise ArgumentError, "Expression must be a String" unless expression.is_a?(String)
+
+      config = compilation_options(cache_expressions, max_depth, functions, disable_visit_errors)
+      compiled = compile_syntax(expression, cache_expressions, max_depth)
+      config.equal?(Options::DEFAULT) ? compiled : compiled.configured(config)
+    end
+
+    private
+
+    def compile_syntax(expression, cache, depth)
+      if cache
+        CACHE.fetch(expression, max_depth: depth) { |source| build_expression(source, depth) }
+      else
+        build_expression(expression, depth)
+      end
+    end
+
+    def compilation_options(cache, depth, functions, suppress)
+      if cache.equal?(true) && depth.equal?(128) && functions.equal?(Functions.default) && suppress.equal?(false)
+        return Options::DEFAULT
+      end
+
+      Options.new({ cache_expressions: cache, max_depth: depth,
+                    functions: functions, disable_visit_errors: suppress })
+    end
+
+    def build_expression(expression, max_depth)
+      source = expression.dup.freeze
+      Expression.new(source, Parser.new(source, max_depth: max_depth).parse, max_depth: max_depth)
+    end
+  end
+end

data/sig/jmespath.rbs

@@ -0,0 +1,55 @@
+module JMESPath
+  VERSION: String
+  type value = Object?
+  type json = nil | bool | Integer | Float | String | Array[json] | Hash[String, json]
+
+  def self.search: (String, value, ?Hash[Symbol, value], **value) -> value
+  def self.compile: (String, ?cache_expressions: bool, ?max_depth: Integer, ?functions: Functions, ?disable_visit_errors: bool) -> Expression
+
+  module Errors
+    class Error < StandardError
+    end
+    class RuntimeError < Error
+    end
+    class SyntaxError < Error
+      attr_reader expression: String
+      attr_reader position: Integer
+      def initialize: (String, ?expression: String, ?position: Integer) -> void
+      def line: () -> Integer
+      def column: () -> Integer
+    end
+    class InvalidTypeError < RuntimeError
+    end
+    class InvalidValueError < RuntimeError
+    end
+    class InvalidArityError < RuntimeError
+    end
+    class UnknownFunctionError < RuntimeError
+    end
+  end
+
+  class Expression
+    attr_reader source: String
+    def search: (value, ?Hash[Symbol, value], **value) -> value
+    alias call search
+  end
+
+  class Functions
+    def initialize: () -> void
+    def self.default: () -> Functions
+    def with: (String, signature: Array[Array[Symbol]], ?variadic: bool, ?override: bool) ?{ (*value) -> value } -> Functions
+    def call: (String, Array[value], ?disable_visit_errors: bool) -> value
+  end
+
+  # Input stream protocol used by CLI.run.
+  interface _Reader
+    def read: () -> String?
+  end
+  # Output stream protocol used by CLI.run.
+  interface _Writer
+    def puts: (String) -> void
+  end
+  module CLI
+    def self.run: (Array[String], ?stdin: _Reader, ?stdout: _Writer, ?stderr: _Writer) -> Integer
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: jmespath-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Leonid Svyatov
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: stringio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Search structured Ruby data with reusable JMESPath expressions.
+executables:
+- jmespath
+- jmespath.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
+- LICENSES/python-MIT.txt
+- LICENSES/ruby-Apache-2.0.txt
+- README.md
+- SECURITY.md
+- VERSIONING.md
+- docs/guides/compatibility.md
+- docs/guides/compilation.md
+- docs/guides/errors.md
+- docs/guides/functions.md
+- docs/guides/performance.md
+- docs/guides/search.md
+- exe/jmespath
+- exe/jmespath.rb
+- lib/jmespath.rb
+- lib/jmespath/ast.rb
+- lib/jmespath/cache.rb
+- lib/jmespath/cli.rb
+- lib/jmespath/data_access.rb
+- lib/jmespath/errors.rb
+- lib/jmespath/evaluation/construction.rb
+- lib/jmespath/evaluation/logic.rb
+- lib/jmespath/evaluation/projections.rb
+- lib/jmespath/evaluation/scalars.rb
+- lib/jmespath/evaluation/slices.rb
+- lib/jmespath/evaluator.rb
+- lib/jmespath/expression.rb
+- lib/jmespath/expression_reference.rb
+- lib/jmespath/functions.rb
+- lib/jmespath/functions/coercions.rb
+- lib/jmespath/functions/collections.rb
+- lib/jmespath/functions/conversion.rb
+- lib/jmespath/functions/function_call.rb
+- lib/jmespath/functions/references.rb
+- lib/jmespath/functions/scalar.rb
+- lib/jmespath/functions/signature.rb
+- lib/jmespath/input.rb
+- lib/jmespath/lexer.rb
+- lib/jmespath/normalizer.rb
+- lib/jmespath/options.rb
+- lib/jmespath/parser.rb
+- lib/jmespath/parser/expressions.rb
+- lib/jmespath/parser/projections.rb
+- lib/jmespath/plan.rb
+- lib/jmespath/token.rb
+- lib/jmespath/types.rb
+- lib/jmespath/version.rb
+- sig/jmespath.rbs
+homepage: https://github.com/svyatov/jmespath-ruby
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/svyatov/jmespath-ruby
+  bug_tracker_uri: https://github.com/svyatov/jmespath-ruby/issues
+  changelog_uri: https://github.com/svyatov/jmespath-ruby/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: A typed Ruby implementation of the JMESPath query language
+test_files: []