matchers 0.1.0.pre.test

data/lib/matcher/expressions/expression_building.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Matcher
+  module ExpressionBuilding
+    attr_reader :assigns
+
+    def self.init(builder, build_session)
+      builder.instance_exec do
+        @expression_cache = ExpressionCache.current(build_session)
+      end
+    end
+
+    def expression_of(value)
+      Expression.of(value, expression_cache: @expression_cache)
+    end
+
+    def expression_or_value(value)
+      Expression.expression_or_value(value, expression_cache: @expression_cache)
+    end
+
+    def declare(*symbols, **assigns)
+      symbols.concat(assigns.keys - symbols)
+      conflicts = symbols & methods
+
+      raise "Cannot declare these variables: #{conflicts.join(', ')}" if conflicts.length > 1
+      raise "Cannot declare variable \"#{conflicts[0]}\"" if conflicts.length == 1
+
+      symbols.each do |symbol|
+        define_singleton_method(symbol) do
+          vars[symbol]
+        end
+      end
+
+      unless assigns.empty?
+        if @assigns
+          @assigns.merge!(assigns)
+        else
+          @assigns = assigns
+        end
+      end
+
+      UNDEFINED
+    end
+
+    ##
+    # Turns any object into a recorder, or a block into an expression
+    # @example
+    #   # turn object into recorder
+    #   expr(Time).now
+    #   expr(1) + vars[:a]
+    #   # deeply nested structures are supported
+    #   expr([{ foo: Set[vars[:a]] }])
+    #   # turn block into expression (not inspectable)
+    #   expr { |actual| actual ? 1 : 2 }
+    # @overload expr(obj)
+    #   @param obj the object to wrap
+    #   @return [Recorder]
+    # @overload expr(&block)
+    #   @return [Recorder]
+    def expr(obj = UNDEFINED, &block)
+      raise 'obj and block given' if !Matcher.undefined?(obj) && block_given?
+
+      expression = block_given? ? ProcExpression.new(block) : expression_of(obj)
+      expression.to_recorder
+    end
+
+    ##
+    # Builds a range expression where +from+ and +to+ can be expressions
+    # @example
+    #   range(0, vars[:limit])
+    #   # evaluates to 0..10 when limit: 10
+    # @param from [Expression, Object]
+    # @param to [Expression, Object]
+    # @param exclude_end [Boolean]
+    # @return [RangeExpression]
+    def range(from, to, exclude_end = false)
+      from = expression_of(from)
+      to = expression_of(to)
+
+      RangeExpression.new(from, to, exclude_end)
+    end
+
+    def rescue_exception(expression)
+      expression = expression_of(expression)
+      rescue_last_error = RescueLastErrorExpression.new(expression)
+
+      expression_of(rescue_last_error).to_recorder
+    end
+
+    ##
+    # Returns a recorder for +Kernel+, useful for calling Kernel methods
+    # @example
+    #   kernel.Integer(vars[:a]) # => Integer(a)
+    # @return [Recorder]
+    def kernel
+      expr(Kernel)
+    end
+
+    ##
+    # Concatenates expressions into a string expression
+    # @example
+    #   concat('foo=', vars[:foo])
+    #   # evaluates to "foo=23" when foo: 23
+    # @param parts [Array<Expression, Object>]
+    # @return [Recorder]
+    def concat(*parts)
+      parts = parts.map { expression_of(_1) }
+      string_expression = StringExpression.new(parts)
+
+      expression_of(string_expression).to_recorder
+    end
+
+    ##
+    # Returns a recorder for the actual value being matched
+    # @example
+    #   _ > 10
+    #   _.even?
+    #   _.length == 3
+    # @return [Recorder]
+    def actual
+      vars[:actual]
+    end
+    alias _ actual
+
+    ##
+    # Returns a recorder for the current hash key
+    # @example
+    #   each_pair(k.to_s == v)
+    # @return [Recorder]
+    def key
+      vars[:key]
+    end
+    alias k key
+
+    ##
+    # Returns a recorder for the current hash value
+    # @example
+    #   each_pair(k.to_s == v)
+    # @return [Recorder]
+    def value
+      vars[:value]
+    end
+    alias v value
+
+    ##
+    # Returns a recorder for the current element index
+    # @example
+    #   each(_ == i)
+    # @return [Recorder]
+    def index
+      vars[:index]
+    end
+    alias i index
+
+    ##
+    # Returns a recorder for the parent collection
+    # @example
+    #   each(_ < parent.length)
+    # @return [Recorder]
+    def parent
+      vars[:parent]
+    end
+
+    ##
+    # Returns a recorder for the original value before mapping
+    # @return [Recorder]
+    # @see MatcherBuilding#map
+    def original
+      vars[:original]
+    end
+
+    ##
+    # Evaluates block with +&+ and +|+ acting as +&&+ and +||+
+    #
+    # Useful because +&&+ and +||+ cannot be captured by recorders.
+    # Note that +&+ and +|+ have different precedence than +&&+ and +||+.
+    # @example
+    #   lo { vars[:foo] | vars[:bar] < 2 }
+    #   # => (foo || bar) < 2
+    # @return [Recorder]
+    def logical_operators(&)
+      Matcher.with_settings(logical_operators: true, &)
+    end
+    alias lo logical_operators
+
+    ##
+    # Passes blocks through to the actual call instead of evaluating them
+    # as expression builders
+    # @example
+    #   ptb do
+    #     _.instance_exec { @foo }
+    #   end
+    # @return [Recorder]
+    def pass_through_blocks(arg = UNDEFINED, &)
+      # Note that arg might be a recorder where #nil? won't work.
+
+      if Matcher.undefined?(arg)
+        Matcher.with_settings(pass_through_blocks: true, &)
+      else
+        Matcher.with_settings(pass_through_blocks: true) do
+          yield arg
+        end
+      end
+    end
+    alias ptb pass_through_blocks
+
+    ##
+    # Captures calls to assignment methods
+    # @example
+    #   assign { _.foo = 1 }     # => actual.foo = 1
+    #   assign { _[:foo] = 1 }   # => actual[:foo] = 1
+    # @return [Recorder]
+    def assign
+      value = expression_of(yield)
+      call = Call.last_assign
+
+      Call.reset_last_assign
+
+      status = if call&.assignment?
+        arg = call.args.last
+
+        if value.is_a?(Constant)
+          arg.is_a?(Constant) && value.value.equal?(arg.value)
+        else
+          value.equal?(arg)
+        end
+      end
+
+      raise 'Could not return last assignment' unless status
+
+      call.to_recorder
+    end
+
+    ##
+    # Returns the variable factory for accessing named variables
+    # @example
+    #   vars[:my_value]
+    #   _ == vars[:limit]
+    # @return [VariableFactory]
+    def vars
+      @vars ||= VariableFactory.new(@expression_cache)
+    end
+
+    class VariableFactory
+      include NoMatcher
+      include NoExpression
+      include NoKey
+
+      def initialize(expression_cache)
+        @expression_cache = expression_cache
+      end
+
+      def [](symbol)
+        Variable.cache(symbol, expression_cache: @expression_cache).to_recorder
+      end
+    end
+  end
+end

data/lib/matcher/expressions/expression_walker.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ExpressionWalker
+    attr_accessor :constant_visitor, :variable_visitor, :call_visitor, :block_visitor, :proc_expression_visitor
+
+    def self.each_variable(expression, &block)
+      return to_enum(:each_variable, expression) unless block_given?
+
+      walker = new(expression)
+      walker.variable_visitor = block
+      walker.walk
+    end
+
+    def self.each_block(expression, &block)
+      return to_enum(:each_block, expression) unless block_given?
+
+      walker = new(expression)
+      walker.block_visitor = block
+      walker.walk
+    end
+
+    def initialize(expression)
+      @expression = expression
+    end
+
+    def walk
+      traverse(@expression)
+    end
+
+    private
+
+    def traverse(expression)
+      case expression
+      when Constant
+        @constant_visitor&.call(expression)
+      when Variable
+        @variable_visitor&.call(expression)
+      when Call
+        @call_visitor&.call(expression)
+
+        traverse(expression.receiver)
+        expression.args.each { traverse(_1) }
+        expression.kwargs.each { traverse(_2) }
+        traverse_block(expression.block) if expression.block
+      when ProcExpression
+        @proc_expression_visitor&.call(expression)
+      when ArrayExpression, SetExpression
+        expression.items.each { traverse(_1) }
+      when HashExpression
+        expression.pairs.each do |k, v|
+          traverse(k)
+          traverse(v)
+        end
+      when RangeExpression
+        traverse(expression.begin)
+        traverse(expression.end)
+      when RescueLastErrorExpression
+        traverse(expression.expression)
+      else
+        raise "unsupported expression type: #{expression.class}"
+      end
+    end
+
+    def traverse_block(block)
+      @block_visitor&.call(block)
+
+      return unless block.is_a?(Block)
+
+      traverse(block.expression)
+    end
+  end
+end

data/lib/matcher/expressions/hash_expression.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Matcher
+  class HashExpression < Expression
+    def initialize(pairs)
+      super()
+
+      @pairs = pairs
+    end
+
+    attr_reader :pairs
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(self.class) &&
+        other.pairs.eql?(@pairs)
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [self.class, @pairs].hash
+    end
+
+    def variables
+      @variables ||= @pairs.flat_map { |k, v| k.variables + v.variables }.uniq
+    end
+
+    def evaluate(values)
+      @pairs.to_h do |k, v|
+        [k.evaluate(values), v.evaluate(values)]
+      end
+    end
+
+    def substitute(replacements)
+      return self unless replacements.keys.intersect?(variables)
+
+      substituted_pairs = @pairs.map do |k, v|
+        [k.substitute(replacements), v.substitute(replacements)]
+      end
+
+      HashExpression.new(substituted_pairs)
+    end
+
+    def to_s
+      parts = @pairs.map do |k, v|
+        key_part = if k.is_a?(Constant) && k.value.is_a?(Symbol)
+          "#{k.value}:"
+        else
+          "#{k} =>"
+        end
+
+        "#{key_part} #{v}"
+      end
+
+      "{ #{parts.join(', ')} }"
+    end
+  end
+end

data/lib/matcher/expressions/proc_expression.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ProcExpression < Expression
+    def initialize(block, substitution: nil)
+      super()
+
+      check_parameters(block.parameters)
+
+      @block = block
+      @substitution = substitution
+    end
+
+    attr_reader :block, :substitution
+
+    def check_parameters(parameters)
+      parameters.each_with_index do |(type, name), i|
+        case type
+        when :req, :opt
+          raise 'ProcExpression cannot have more than 1 arg' if i > 0
+        when :keyreq, :key
+          raise 'ProcExpression cannot have an kwarg called "actual"' if name == :actual
+        end
+      end
+    end
+
+    def variables
+      @variables ||= begin
+        variables = @block.parameters.filter_map.with_index do |(type, name), i|
+          case type
+          when :req, :opt
+            :actual if i == 0
+          when :keyreq, :key
+            name
+          end
+        end
+
+        @substitution ? variables.map { @substitution[_1] || _1 } : variables
+      end
+    end
+
+    def evaluate(values)
+      values = substitute_hash(values, @substitution) if @substitution
+
+      Utils.call_block(@block, values)
+    end
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(ProcExpression) &&
+        other.block == @block &&
+        other.substitution == @substitution
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @block].hash
+    end
+
+    def substitute(replacements)
+      replacements = replacements.slice(*variables)
+
+      return self if replacements.empty?
+
+      replacements = substitute_hash(@substitution, replacements) if @substitution
+
+      ProcExpression.new(@block, substitution: replacements)
+    end
+
+    def to_s(substitutions: nil)
+      args_and_kwargs = Utils.inspect_block_params(@block)
+
+      if args_and_kwargs.empty?
+        'expr { ... }'
+      else
+        "expr { |#{args_and_kwargs}| ... }"
+      end
+    end
+
+    private
+
+    def substitute_hash(hash, substitution)
+      hash.to_h do |k, v|
+        k2 = substitution[k]
+        v2 = k2.nil? && !substitution.key?(k2) ? v : hash[k2]
+
+        [k, v2]
+      end
+    end
+  end
+end

data/lib/matcher/expressions/range_expression.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Matcher
+  class RangeExpression < Expression
+    def initialize(from, to, exclude_end = false)
+      super()
+
+      @begin = from
+      @end = to
+      @exclude_end = exclude_end
+    end
+
+    attr_reader :begin, :end
+
+    def exclude_end?
+      @exclude_end
+    end
+
+    def ==(other)
+      equal?(other) ||
+        other.instance_of?(RangeExpression) &&
+        other.begin.eql?(@begin) &&
+        other.end.eql?(@end) &&
+        other.exclude_end?.eql?(@exclude_end)
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @begin, @end, @exclude_end].hash
+    end
+
+    def variables
+      @variables ||= (@begin.variables + @end.variables).uniq
+    end
+
+    def evaluate(values)
+      from = @begin.evaluate(values)
+      to = @end.evaluate(values)
+
+      Range.new(from, to, @exclude_end)
+    end
+
+    def substitute(replacements)
+      return self unless replacements.keys.intersect?(variables)
+
+      from = @begin.substitute(replacements)
+      to = @end.substitute(replacements)
+
+      RangeExpression.new(from, to, @exclude_end)
+    end
+
+    def to_s
+      dots = @exclude_end ? '...' : '..'
+
+      "#{@begin}#{dots}#{@end}"
+    end
+  end
+end

data/lib/matcher/expressions/recorder.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Recorder
+    def self.recorder?(object)
+      Object.instance_method(:kind_of?)
+        .bind_call(object, Recorder)
+    end
+
+    def self.to_expression(recorder)
+      Object.instance_method(:instance_variable_get)
+        .bind_call(recorder, :@expression)
+    end
+
+    # NOTE: In order for Recorder to work, it can't have any methods except for
+    # the ones below.
+
+    (instance_methods - %i[__id__ __send__ object_id])
+      .each { undef_method _1 }
+
+    def initialize(expression)
+      @expression = expression
+    end
+
+    # NOTE: That might be a really nasty thing to do. Let's see how it goes.
+    define_method(:object_id) do
+      method_missing(:object_id)
+    end
+
+    def method_missing(method, *args, **kwargs, &block)
+      # *.hash.to_int indicates that a Hash evaluates this recorder as a key.
+      if @hash_parent # @hash_parent is set if @expression is a *.hash call.
+        to_int = method == :to_int && args.empty? && kwargs.empty? && !block
+
+        # Confirm to parent that indeed a Hash called it.
+        Object.instance_method(:instance_variable_set)
+          .bind_call(@hash_parent, :@hash_confirmed, to_int)
+
+        return @expression.receiver.hash if to_int
+      end
+
+      # In "uncertain" state: Check if Hash called eql? on this recorder.
+      if @hash_caller # @hash_caller indicates the "uncertain" state.
+        if method == :eql? && @hash_confirmed && caller[0] == @hash_caller
+          # Return proper eql? result.
+          return Recorder.recorder?(args[0]) &&
+            @expression.eql?(Recorder.to_expression(args[0]))
+        else # Not a call from Hash.
+          # Leave the "uncertain" state and resume recorder behavior.
+          @hash_caller = nil
+          @hash_confirmed = false
+        end
+      end
+
+      expression_cache = ExpressionCache.current
+      args = args.map { Expression.of(_1, expression_cache:) }
+      kwargs = kwargs.transform_values { Expression.of(_1, expression_cache:) }
+      block = Block.build(expression_cache:, &block) if
+        block && !Matcher.settings[:pass_through_blocks]
+
+      expression = Call.new(@expression, method, args, kwargs, block)
+      expression = expression_cache[expression] if expression_cache
+      recorder = expression.to_recorder
+
+      # A Hash might evaluate this recorder as a key.
+      if method == :hash && args.empty? && kwargs.empty? && !block
+        # If the new recorder registers a *.to_int call then it was called by a
+        # Hash.
+
+        # Enter the "uncertain" state. Save the caller for later check against
+        # false positives.
+        @hash_caller = caller[0]
+
+        # Give reference to the new recorder for confirmation.
+        Object.instance_method(:instance_variable_set)
+          .bind_call(recorder, :@hash_parent, self)
+      end
+
+      recorder
+    end
+
+    def respond_to_missing?(...)
+      true
+    end
+  end
+end

data/lib/matcher/expressions/rescue_last_error_expression.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Matcher
+  class RescueLastErrorExpression < Expression
+    extend Forwardable
+
+    def initialize(expression)
+      super()
+
+      @expression = expression
+    end
+
+    attr_reader :expression
+
+    def_delegator :@expression, :variables
+
+    def ==(other)
+      equal?(other) ||
+        other.instance_of?(self.class) &&
+        @expression == other.expression
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @expression].hash
+    end
+
+    def evaluate(values)
+      @expression.evaluate(values)
+    rescue CallError => e
+      e.cause
+    end
+
+    def substitute(replacements)
+      substitution = @expression.substitute(replacements)
+
+      RescueLastErrorExpression.new(substitution)
+    end
+
+    def to_s(**)
+      "#{@expression.to_s(**)} rescue $!"
+    end
+  end
+end

data/lib/matcher/expressions/set_expression.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Matcher
+  class SetExpression < Expression
+    def initialize(items)
+      super()
+
+      @items = items
+    end
+
+    attr_reader :items
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(SetExpression) &&
+        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.to_set { _1.evaluate(values) }
+    end
+
+    def substitute(replacements)
+      return self unless replacements.keys.intersect?(variables)
+
+      substituted_items = @items.map { _1.substitute(replacements) }
+
+      SetExpression.new(substituted_items)
+    end
+
+    def to_s
+      "Set[#{@items.map(&:to_s).join(', ')}]"
+    end
+  end
+end