matchers 0.1.0.pre.1

data/lib/matcher/errors/error_collector.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ErrorCollector
+    def self.error_from(obj)
+      case obj
+      when String, Message
+        ElementError.new(obj)
+      when Error
+        obj
+      else
+        "Unexpected error object: #{obj.inspect}"
+      end
+    end
+
+    attr_reader :error
+
+    def initialize
+      @error = EmptyError.instance
+      @mode = :and
+    end
+
+    def empty?
+      @error.valid?
+    end
+
+    def or!
+      @mode = :or
+      self
+    end
+
+    def or?
+      @mode == :or
+    end
+
+    def and?
+      @mode == :and
+    end
+
+    class Brackets
+      def initialize(parent, key)
+        @parent = parent
+        @key = key
+      end
+
+      def error
+        @parent.error
+      end
+
+      def <<(error)
+        error = ErrorCollector.error_from(error)
+
+        return error if error.is_a?(EmptyError) || @key == Variable.actual
+
+        key = if @key.is_a?(Expression)
+          @key
+        else
+          Call.new(Variable.actual, :[], [Constant.new(@key)])
+        end
+
+        @parent << NestedError.new(key, error)
+
+        @parent.error
+      end
+
+      def [](key)
+        Brackets.new(self, key)
+      end
+    end
+
+    def <<(error)
+      return @error if error.is_a?(EmptyError)
+
+      error = ErrorCollector.error_from(error)
+
+      case @error
+      when EmptyError
+        @error = error
+      when and? ? AndError : OrError
+        @error << error
+      else
+        if and?
+          @error &= error
+        else
+          @error |= error
+        end
+      end
+
+      @error
+    end
+
+    def [](key)
+      Brackets.new(self, key)
+    end
+
+    def clear
+      @error = EmptyError.instance
+    end
+  end
+end

data/lib/matcher/errors/nested_error.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Matcher
+  class NestedError < Error
+    def self.from(key, child)
+      return child if child.is_a?(EmptyError) || key == Variable.actual
+
+      unless key.is_a?(Expression)
+        key = Call.new(Variable.actual, :[], [Constant.new(key)])
+      end
+
+      NestedError.new(key, child)
+    end
+
+    def self.key_to_s(key, path)
+      remaining = 20 + path.length
+      key.visit do |expr|
+        next if !expr.is_a?(Variable) || expr.symbol != :actual
+
+        remaining -= path.length
+        break if remaining < 0
+      end
+
+      if remaining >= 0 && key.variables.include?(:actual)
+        Variable.with_substitutions(actual: path) do
+          key.to_s
+        end
+      else
+        "#{path} -> #{key}"
+      end
+    end
+
+    attr_reader :key, :child
+
+    def initialize(key, child)
+      super()
+
+      @key = key
+      @child = child
+    end
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(NestedError) &&
+        @key.eql?(other.key) &&
+        @child == other.child
+    end
+
+    def &(other)
+      return self if other.is_a?(EmptyError)
+
+      if other.is_a?(NestedError) && @key == other.key
+        NestedError.new(@key, @child & other.child)
+      elsif other.is_a?(AndError)
+        errors = other.children
+        index = errors.find_index { _1.is_a?(NestedError) && _1.key == @key }
+
+        if index
+          new_errors = errors.dup
+          new_errors[index] = self & errors[index]
+        else
+          new_errors = [self] + errors
+        end
+
+        AndError.new(new_errors)
+      else
+        AndError.new([self, other])
+      end
+    end
+
+    def |(other)
+      return self if other.is_a?(EmptyError)
+
+      if other.is_a?(NestedError) && other.key == @key
+        NestedError.new(@key, @child | other.child)
+      elsif other.is_a?(OrError)
+        errors = other.children
+        index = errors.find_index { _1.is_a?(NestedError) && _1.key == @key }
+
+        if index
+          new_errors = errors.dup
+          new_errors[index] = self | errors[index]
+        else
+          new_errors = [self] + errors
+        end
+
+        OrError.new(new_errors)
+      else
+        OrError.new([self, other])
+      end
+    end
+
+    def to_s
+      "#{@key} -> #{@child}"
+    end
+  end
+end

data/lib/matcher/errors/or_error.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Matcher
+  class OrError < Error
+    attr_reader :children
+
+    def self.from(children)
+      length = children.length
+
+      return EmptyError.instance if length == 0
+
+      children.reduce do |left, right|
+        if left.is_a?(OrError)
+          left << right
+        else
+          left | right
+        end
+      end
+    end
+
+    def initialize(children)
+      raise "children fewer than 2" if children.length < 2
+
+      super()
+
+      @children = children
+    end
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(OrError) &&
+        @children == other.children
+    end
+
+    def |(other)
+      return self if other.is_a?(EmptyError)
+
+      clone << other
+    end
+
+    def add(other)
+      case other
+      when OrError
+        right = other.children.dup
+
+        @children.each_with_index do |l, i|
+          next unless l.is_a?(NestedError)
+
+          index = right.find_index { _1.is_a?(NestedError) && _1.key == l.key }
+
+          @children[i] = l | right.delete_at(index) if index
+        end
+
+        @children.concat(right)
+      when NestedError
+        index = @children.find_index do |child|
+          child.is_a?(NestedError) && child.key == other.key
+        end
+
+        if index
+          @children[index] |= other
+        else
+          @children << other
+        end
+      else
+        @children << other
+      end
+
+      self
+    end
+    alias << add
+
+    def clone
+      klone = super
+      klone.instance_exec do
+        @children = @children.dup
+      end
+
+      klone
+    end
+    alias dup clone
+
+    def to_s
+      "(#{@children.join(' | ')})"
+    end
+  end
+end

data/lib/matcher/expression_cache.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ExpressionCache < ExpressionLabeler
+    def self.current(build_session = Matcher.build_session)
+      build_session[:_expression_cache] ||= new if build_session
+    end
+
+    def initialize
+      super
+
+      @cache = {}.compare_by_identity
+      @index = [Variable.actual]
+    end
+
+    def [](expression)
+      @index[label(expression)]
+    end
+
+    def label(expression, actual_label = ROOT)
+      cached_label = @cache[expression]
+
+      return cached_label if cached_label
+
+      count = @label_count
+      label = super
+
+      if label > count
+        if expression.is_a?(Variable)
+          symbol = expression.symbol
+          expression = Variable.send(symbol) if Variable.well_known?(symbol)
+        end
+
+        @cache[expression] = label
+        @index[label] = expression
+      end
+
+      label
+    end
+
+    def constant_for(value)
+      label = label_for(@constant_labels, value)
+      @index[label] ||= Constant.new(value)
+    end
+
+    def variable_for(symbol)
+      return Variable.send(symbol) if Variable.well_known?(symbol)
+
+      less_known_variable_for(symbol)
+    end
+
+    def less_known_variable_for(symbol)
+      label = label_for(@variable_labels, symbol)
+      @index[label] ||= Variable.new(symbol)
+    end
+  end
+end

data/lib/matcher/expression_labeler.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ExpressionLabeler
+    ROOT = 0
+
+    def initialize
+      @label_count = 0
+
+      @constant_labels = {}
+      @variable_labels = {}
+      @call_labels = {}
+      @block_labels = {}
+      @proc_labels = {}
+      @array_labels = {}
+      @set_labels = {}
+      @hash_labels = {}
+      @range_labels = {}
+      @string_labels = {}
+      @rescue_labels = {}
+    end
+
+    def label(expression, actual_label = ROOT)
+      case expression
+      when Constant
+        label_for(@constant_labels, expression.value)
+      when Variable
+        if expression.symbol == :actual
+          actual_label
+        else
+          label_for(@variable_labels, expression.symbol)
+        end
+      when Call
+        receiver_l = label(expression.receiver, actual_label)
+        args_l = expression.args
+          .map { label(_1, actual_label) }
+        kwargs_l = expression.kwargs
+          .transform_values { label(_1, actual_label) }
+        block_l = label_for_block(expression.block)
+
+        label_for(
+          @call_labels,
+          [receiver_l, expression.method, args_l, kwargs_l, block_l],
+        )
+      when ProcExpression
+        label_for(@proc_labels, expression.block)
+      when ArrayExpression
+        items_l = expression.items.map { label(_1, actual_label) }
+
+        label_for(@array_labels, items_l)
+      when SetExpression
+        items_l = expression.items.map { label(_1, actual_label) }
+
+        label_for(@set_labels, items_l)
+      when HashExpression
+        pairs_l = expression.pairs.flat_map do |k, v|
+          [label(k, actual_label), label(v, actual_label)]
+        end
+
+        label_for(@hash_labels, pairs_l)
+      when RangeExpression
+        begin_l = label(expression.begin, actual_label)
+        end_l = label(expression.end, actual_label)
+
+        label_for(@range_labels, [begin_l, end_l, expression.exclude_end?])
+      when StringExpression
+        parts_l = expression.parts.map { label(_1, actual_label) }
+
+        label_for(@string_labels, parts_l)
+      when RescueLastErrorExpression
+        expression_l = label(expression.expression, actual_label)
+
+        label_for(@rescue_labels, expression_l)
+      else
+        raise "unexpected expression: #{expression.inspect}"
+      end
+    end
+
+    private
+
+    def label_for(index, key)
+      index[key] ||= (@label_count += 1)
+    end
+
+    def label_for_block(block)
+      case block
+      when Block
+        label_for(@block_labels, [block.parameters, label(block.expression)])
+      when SymbolProc
+        label_for(@block_labels, block.symbol)
+      else # nil, Proc
+        label_for(@block_labels, block)
+      end
+    end
+  end
+end

data/lib/matcher/expressions/array_expression.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ArrayExpression < Expression
+    def initialize(items)
+      super()
+
+      @items = items
+    end
+
+    attr_reader :items
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(ArrayExpression) &&
+        other.items.eql?(@items)
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [self.class, @items].hash
+    end
+
+    def variables
+      @variables ||= @items.flat_map(&:variables).uniq
+    end
+
+    def evaluate(values)
+      @items.map { _1.evaluate(values) }
+    end
+
+    def substitute(replacements)
+      return self unless replacements.keys.intersect?(variables)
+
+      substituted_items = @items.map { _1.substitute(replacements) }
+
+      ArrayExpression.new(substituted_items)
+    end
+
+    def to_s
+      "[#{@items.join(', ')}]"
+    end
+  end
+end

data/lib/matcher/expressions/block.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Matcher
+  ##
+  # It's possible to build calls with a block:
+  #
+  #   exp = Matcher::Expression.build do
+  #     _.map { |x| x * 2 }
+  #   end
+  #
+  #   exp.evaluate(actual: [1, 2]) # => [2, 4]
+  #
+  # During build time the block acts like an expression builder
+  # (e.g. like `Expression.build`), where its arguments are recorders. So the
+  # inside of a block cannot be arbitrary but must follow the same rules as for
+  # building other expressions.
+  #
+  #   # WRONG
+  #   Matcher::Expression.build do
+  #     _.map { |x| 2 * x } # cannot multiply 2 with a recorder
+  #   end
+  #
+  # == Support for symbol procs
+  #
+  #   exp = Matcher::Expression.build do
+  #     _.map(&:to_i)
+  #   end
+  #
+  #   exp.evaluate(actual: ['1', '2']) # => [1, 2]
+  #
+  # @see ExpressionDsl#pass_through_blocks
+  class Block
+    extend Compatibility
+
+    class Context
+      attr_reader :expression, :values
+
+      def initialize(expression, values)
+        @expression = expression
+        @values = values
+      end
+
+      def evaluate(values)
+        values.merge!(@values) { |_k, _l, r| r }
+
+        @expression.evaluate(values)
+      end
+    end
+
+    def self.build(expression_cache: nil, &block)
+      return SymbolProc.new(block) if
+        block.parameters == [[:req], [:rest]] &&
+          /\(&:(\w+[!?]?|".*")\)/.match?(block.to_s)
+
+      parameters = block.parameters
+      args = []
+      kwargs = {}
+      parameter_names = Set.new
+      variable_object_ids = Set.new
+
+      parameters.each do |type, name|
+        parameter_names << name
+        variable = Variable.cache(name, expression_cache:)
+        variable_object_ids << variable.object_id
+
+        case type
+        when :req, :opt
+          args << variable.to_recorder
+        when :key, :keyreq
+          kwargs[name] = variable.to_recorder
+        when :rest
+          raise "*#{name unless name == :*} not allowed"
+        when :keyrest
+          raise "**#{name unless name == :**} not allowed"
+        when :block
+          raise "&#{name unless name == :&} not allowed"
+        end
+      end
+
+      result = block.call(*args, **kwargs)
+      expression = Expression.of(result, expression_cache:)
+
+      return SymbolProc.new(expression.method) if
+        args.length == 1 &&
+          expression.is_a?(Call) &&
+          expression.unary? &&
+          expression.receiver == Recorder.to_expression(args[0])
+
+      ExpressionWalker.each_variable(expression) do |variable|
+        shadowed = !parameter_names.include?(variable.symbol) ||
+          variable_object_ids.include?(variable.object_id)
+
+        next if shadowed
+
+        quoted_method = quote_method(variable.symbol)
+
+        raise "parameter #{quoted_method} shadows an outer variable"
+      end
+
+      new(parameters, expression)
+    end
+
+    attr_reader :parameters, :expression
+
+    def initialize(parameters, expression)
+      @parameters = parameters
+      @expression = expression
+    end
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(Block) &&
+        @parameters.eql?(other.parameters) &&
+        @expression == other.expression
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @parameters, @expression].hash
+    end
+
+    def variables
+      @variables ||= @expression.variables - @parameters.map { _2 }
+    end
+
+    def substitute(replacements)
+      replacements = replacements.slice(*variables)
+
+      return self if replacements.empty?
+
+      expression = @expression.substitute(replacements)
+
+      Block.new(@parameters, expression)
+    end
+
+    def to_proc(values: nil)
+      @proc ||= begin
+        kwlist = @parameters.map { |_type, name| "#{name}:" }.join(", ")
+
+        instance_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          ->(#{arg_list}) { evaluate({ #{kwlist} }) }                           # ->(arg, kwarg:) { evaluate({ arg:, kwarg: }) }
+        RUBY
+      end
+
+      if values && !variables.empty?
+        values = values.slice(*variables)
+
+        return @proc if values.empty?
+
+        context = Context.new(@expression, values)
+
+        lambda do |*args, **kwargs|
+          context.instance_exec(*args, **kwargs, &@proc)
+        end
+      else
+        @proc
+      end
+    end
+
+    def to_s(as_block: false)
+      if @parameters.empty?
+        as_block ? "{ #{@expression} }" : "-> { #{@expression} }"
+      elsif as_block
+        "{ |#{arg_list}| #{@expression} }"
+      else
+        "->(#{arg_list}) { #{@expression} }"
+      end
+    end
+    alias inspect to_s
+
+    private
+
+    def arg_list
+      @parameters.map do |type, name|
+        case type
+        when :req, :opt
+          name
+        when :key, :keyreq
+          "#{name}:"
+        end
+      end.join(", ")
+    end
+
+    def evaluate(values)
+      @expression.evaluate(**values)
+    end
+  end
+end