matchers 0.1.0.pre.1

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,96 @@
+# 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
+          if name == :actual
+            raise 'ProcExpression cannot have a kwarg called "actual"'
+          end
+        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?
+
+      if @substitution
+        replacements = substitute_hash(@substitution, replacements)
+      end
+
+      ProcExpression.new(@block, substitution: replacements)
+    end
+
+    def to_s
+      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,65 @@
+# 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)
+      return true if 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
+
+    PRECEDENCE = OPERATOR_PRECEDENCE[:".."]
+
+    def precedence
+      PRECEDENCE
+    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: @exclude_end)
+    end
+
+    def to_s
+      dots = @exclude_end ? "..." : ".."
+
+      "#{@begin}#{dots}#{@end}"
+    end
+  end
+end

data/lib/matcher/expressions/recorder.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Matcher
+  ##
+  # The core building block of composing expressions is a method *call*. For
+  # instance, <tt>a + b</tt> is a call where +a+ receives +b+ via its method
+  # <tt>+</tt>.
+  #
+  # Our expression builder tracks Ruby calls with Recorder objects which work
+  # like this:
+  #   # let's build an AST for "Hello".upcase
+  #
+  #   # explicitly by hand
+  #   hello = Matcher::Constant.new("Hello")
+  #   hello_upcase = Matcher::Call.new(hello, :upcase)
+  #   hello_upcase.evaluate({}) # => "HELLO"
+  #
+  #   # with recorder
+  #   hello = Matcher::Constant.new("Hello")
+  #   hello_rec = Matcher::Recorder.new(hello)
+  #   hello_upcase_rec = hello_rec.upcase # the magic
+  #   hello_upcase = Matcher::Recorder.to_expression(hello_upcase_rec)
+  #   # => "Hello".upcase
+  #   hello_upcase.evaluate({})
+  #   # => "HELLO"
+  #
+  #   # with builder
+  #   Matcher::Expression.build do
+  #     expr("Hello").upcase
+  #   end
+  #
+  # == Recorders are nasty
+  #
+  # To do their job any call to a recorder must return a new recorder. But this
+  # also makes them ill-behaved because methods like <tt>==</tt> or
+  # <tt>is_a?</tt> don't behave like you expect them to. They don't have any
+  # methods defined (except +__id__+ and +__send__+). Instead, all calls are
+  # handled by +method_missing+.
+  #
+  # The consequence:
+  #   # let r be a recorder
+  #   r = Matcher::Recorder.new(Matcher::Variable.actual)
+  #
+  #   # everything below returns a recorder
+  #
+  #   r == nil # truthy
+  #   r != r # truthy
+  #   !r # truthy
+  #   !!r # still truthy
+  #   r.class # not Recorder (but a Recorder instance)
+  #   r.object_id # not an integer
+  #   r.to_s # not a string
+  #
+  # This makes them very hard to deal with, should you encounter them where you
+  # wouldn't expect them.
+  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
+
+    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.
+
+          result = Recorder.recorder?(args[0]) &&
+            @expression.eql?(Recorder.to_expression(args[0]))
+
+          return result
+        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,49 @@
+# 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
+
+    PRECEDENCE = OPERATOR_PRECEDENCE[:modifier_rescue]
+
+    def precedence
+      PRECEDENCE
+    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.join(', ')}]"
+    end
+  end
+end

data/lib/matcher/expressions/string_expression.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Matcher
+  class StringExpression < Expression
+    def initialize(parts)
+      super()
+
+      @parts = parts
+    end
+
+    attr_reader :parts
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(StringExpression) &&
+        @parts.eql?(other.parts)
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [self.class, @parts].hash
+    end
+
+    def variables
+      @variables ||= @parts.flat_map(&:variables).uniq
+    end
+
+    def evaluate(values)
+      @parts.map { _1.evaluate(values) }.join
+    end
+
+    def substitute(replacements)
+      return self unless replacements.keys.intersect?(variables)
+
+      substituted_parts = @parts.map { _1.substitute(replacements) }
+
+      StringExpression.new(substituted_parts)
+    end
+
+    def to_s
+      parts = @parts.map do |part|
+        if part.is_a?(Constant) && part.value.is_a?(String)
+          part.value
+        else
+          "\#{#{part}}"
+        end
+      end
+
+      "\"#{parts.join}\""
+    end
+  end
+end

data/lib/matcher/expressions/symbol_proc.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Matcher
+  class SymbolProc
+    def initialize(proc_or_symbol)
+      case proc_or_symbol
+      when Symbol
+        @symbol = proc_or_symbol
+        @proc = proc_or_symbol.to_proc
+      when Proc
+        @proc = proc_or_symbol
+        @symbol = get_symbol(proc_or_symbol)
+      else
+        raise "Expected Proc or Symbol, got #{proc_or_symbol.inspect}"
+      end
+    end
+
+    attr_reader :symbol
+
+    def ==(other)
+      equal?(other) || other.instance_of?(SymbolProc) && @symbol == other.symbol
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @symbol].hash
+    end
+
+    def variables
+      []
+    end
+
+    def to_proc
+      @proc
+    end
+
+    def to_s
+      "&#{@symbol.inspect}"
+    end
+    alias inspect to_s
+
+    private
+
+    def get_symbol(proc)
+      receiver = Variable.actual # could be any
+      recorder = Recorder.new(receiver)
+      result = proc.call(recorder)
+      expression = Recorder.to_expression(result)
+
+      expression.method
+    end
+  end
+end

data/lib/matcher/expressions/variable.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Variable < Expression
+    WELL_KNOWN = %i[actual key value index parent original].freeze
+
+    WELL_KNOWN.each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{method}                                                      # def self.actual
+          @#{method} ||= Variable.new(:#{method})                               #   @actual ||= Variable.actual
+        end                                                                     # end
+      RUBY
+    end
+
+    def self.well_known?(symbol)
+      WELL_KNOWN.include?(symbol)
+    end
+
+    def self.cache(symbol, expression_cache: true)
+      return send(symbol) if well_known?(symbol)
+
+      expression_cache = ExpressionCache.current if expression_cache == true
+
+      if expression_cache
+        expression_cache.less_known_variable_for(symbol)
+      else
+        new(symbol)
+      end
+    end
+
+    def self.substitutions
+      Thread.current[:matcher_variable_substitutions]
+    end
+
+    def self.with_substitutions(**substitutions)
+      stack = Thread.current[:matcher_variable_substitutions] ||= HashStack.new
+      stack.push(substitutions)
+
+      begin
+        yield
+      ensure
+        stack.pop(substitutions)
+        Thread.current[:matcher_variable_substitutions] = nil if stack.empty?
+      end
+    end
+
+    attr_reader :symbol
+
+    def initialize(symbol)
+      super()
+
+      @symbol = symbol
+    end
+
+    def variables
+      [@symbol]
+    end
+
+    def evaluate(values)
+      value = values[@symbol]
+
+      if value.nil? && !values.key?(@symbol)
+        raise "no value for #{@symbol.inspect}"
+      end
+
+      value
+    end
+
+    def ==(other)
+      other.instance_of?(Variable) && other.symbol == @symbol
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @symbol].hash
+    end
+
+    def substitute(replacements)
+      symbol = replacements[@symbol]
+      symbol ? Variable.new(symbol) : self
+    end
+
+    def to_s
+      Variable.substitutions&.[](@symbol) || @symbol.to_s
+    end
+  end
+end

data/lib/matcher/hash_stack.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Matcher
+  class HashStack
+    extend Forwardable
+
+    def initialize
+      @stacks = {}
+    end
+
+    def_delegators :@stacks, :empty?, :key?, :keys
+
+    def [](key)
+      @stacks[key]&.last
+    end
+
+    def push(hash)
+      hash.each do |k, v|
+        (@stacks[k] ||= []) << v
+      end
+    end
+
+    def pop(hash)
+      hash.each_key do |k|
+        array = @stacks[k]
+        array.pop
+
+        @stacks.delete(k) if array.empty?
+      end
+    end
+
+    def slice(*keys)
+      keys.each_with_object({}) do |k, h|
+        pair = @stacks.assoc(k)
+
+        next unless pair
+
+        h[k] = pair[1].last
+      end
+    end
+
+    def merge(hash)
+      hash.default_proc = ->(h, k) { h[k] = self[k] }
+      hash
+    end
+
+    def to_h
+      @stacks.transform_values(&:last)
+    end
+    alias to_hash to_h
+  end
+end