matchers 0.1.0.pre.1

data/lib/matcher/messages/message_rules.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Matcher
+  ExpressionMatcher.message_rules.configure do
+    # binary standard expression
+    standard_ops = %i[== != < > <= >= <=> =~ !~] +
+      %i[equal? is_a? kind_of? instance_of? respond_to? key? include? in?]
+
+    message method_hole(:call, _, standard_ops, const(:operand)) do |v, e|
+      case e[:call].method
+      when :<
+        standard_message.less_than(v[:operand])
+      when :>
+        standard_message.greater_than(v[:operand])
+      when :<=
+        standard_message.less_than_or_equal(v[:operand])
+      when :>=
+        standard_message.greater_than_or_equal(v[:operand])
+      when :<=>
+        # <=> returns nil if operands are not comparable
+        standard_message.comparable_to(v[:operand])
+      when :==
+        standard_message.equal(v[:operand])
+      when :!=
+        standard_message.not.equal(v[:operand])
+      when :=~
+        standard_message.matching(v[:operand])
+      when :!~
+        standard_message.not.matching(v[:operand])
+      when :equal?
+        standard_message.same(v[:operand])
+      when :is_a?, :kind_of?
+        standard_message.kind_of(v[:operand])
+      when :instance_of?
+        standard_message.instance_of(v[:operand])
+      when :respond_to?
+        standard_message.responding_to(v[:operand])
+      when :key?
+        standard_message.having_key(v[:operand])
+      when :include?
+        standard_message.including(v[:operand])
+      when :in?
+        standard_message.in(v[:operand])
+      else
+        raise "Unexpected method: #{e[:call].method}"
+      end
+    end
+
+    # predicate
+    message method_hole(:predicate, _, -> { _1.end_with?("?") }) do |_v, e|
+      standard_message.predicate(e[:predicate].method)
+    end
+
+    # flip
+    transform(
+      method_hole(
+        :call,
+        hole(:operand) { !_1.variables.include?(:actual) },
+        %i[== != < > <= >= equal? include? in?],
+        hole(:actual) { _1.variables.include?(:actual) },
+      ),
+    ) do |m|
+      method = m[:call].expression.method
+
+      flipped_method =
+        case method
+        when :< then :>
+        when :> then :<
+        when :<= then :>=
+        when :>= then :<=
+        when :include? then :in?
+        when :in? then :include?
+        else
+          method
+        end
+
+      call(m[:call], m[:actual], flipped_method, m[:operand])
+    end
+
+    # length
+    message capture(:act, _.length) == const(:exp) do |v|
+      standard_message.length_of(v[:exp], v[:act])
+    end
+
+    # between
+    message _.between?(const(:min), const(:max)) do |v|
+      standard_message.between(v[:min], v[:max])
+    end
+
+    # truthy
+    message _ do
+      standard_message.truthy
+    end
+
+    # transform !
+    transform !hole(:expression), negate: true do |m|
+      m[:expression]
+    end
+
+    # transform instance_of?
+    transform(
+      # rubocop:disable Style/ClassEqualityComparison
+      hole(:obj).class == hole(:class),
+      hole(:class) == hole(:obj).class,
+      # rubocop:enable Style/ClassEqualityComparison
+    ) do |m|
+      call(m[:root], m[:obj], :instance_of?, m[:class])
+    end
+
+    # transform between?
+    transform(
+      lo { (hole(:value) >= hole(:min)) & (hole(:value) <= hole(:max)) },
+    ) do |m|
+      call(m[:root], m[:value], :between?, m[:min], m[:max])
+    end
+
+    # transform comparison
+    transform(
+      method_hole(:compare, hole(:lhs) <=> hole(:rhs), %i[== != < > <= >=], 0),
+    ) do |m|
+      call(m[:compare], m[:lhs], m[:compare].expression.method, m[:rhs])
+    end
+
+    # length expression
+    message capture(:act, hole(:object).length) == hole(:exp) do |v, e|
+      expression_message.length_of(
+        e[:object], v[:object], v[:exp], v[:act], given
+      )
+    end
+
+    # match regexp at
+    message(
+      method_hole(
+        :comparison,
+        capture(:pos, hole(:lhs) =~ hole(:rhs)),
+        %i[== != < > <= >=],
+        hole(:operand),
+      ),
+    ) do |v, e|
+      expression, value, pattern =
+        MessageRules.decompose_pattern_matching(
+          e[:lhs], e[:rhs], v[:lhs], v[:rhs]
+        )
+
+      if expression
+        expression_message.match_at(
+          expression,
+          value,
+          pattern,
+          v[:pos],
+          e[:comparison].method,
+          v[:operand],
+          given,
+        )
+      else
+        expression_message.truthy(e[:comparison], v[:comparison], given)
+      end
+    end
+
+    # comparison expression
+    message method_hole(
+      :comparison, hole(:lhs), %i[== != < > <= >=], hole(:rhs)
+    ) do |v, e|
+      expression_message.comparison(e[:comparison], v[:lhs], v[:rhs], given)
+    end
+
+    # general binary expression
+    general_ops =
+      %i[<=> equal? is_a? kind_of? instance_of? respond_to? key? include? in?]
+
+    message method_hole(:call, hole(:lhs), general_ops, hole(:rhs)) do |v, e|
+      case e[:call].method
+      when :<=>
+        # <=> returns nil if operands are not comparable
+        expression_message.comparable_to(e[:lhs], v[:lhs], v[:rhs], given)
+      when :equal?
+        expression_message.same(e[:lhs], e[:rhs], v[:lhs], v[:rhs], given)
+      when :is_a?, :kind_of?
+        expression_message.kind_of(e[:lhs], v[:lhs], v[:rhs], given)
+      when :instance_of?
+        expression_message.instance_of(e[:lhs], v[:lhs], v[:rhs], given)
+      when :respond_to?
+        expression_message.responding_to(e[:lhs], v[:lhs], v[:rhs], given)
+      when :key?
+        expression_message.having_key(e[:lhs], v[:lhs], v[:rhs], given)
+      when :include?
+        expression_message.including(e[:lhs], v[:lhs], v[:rhs], given)
+      when :in?
+        expression_message.in(e[:lhs], v[:lhs], v[:rhs], given)
+      else
+        raise "Unexpected method: #{e[:call].method}"
+      end
+    end
+
+    # predicate expression
+    message method_hole(
+      :predicate, hole(:receiver), -> { _1.end_with?("?") }
+    ) do |v, e|
+      expression_message.predicate(
+        e[:receiver], v[:receiver], e[:predicate].method, given
+      )
+    end
+
+    # match regexp
+    message method_hole(:operator, hole(:lhs), %i[=~ !~], hole(:rhs)) do |v, e|
+      expression, value, pattern = MessageRules.decompose_pattern_matching(
+        e[:lhs], e[:rhs], v[:lhs], v[:rhs]
+      )
+
+      if expression
+        expression_message.not_if(e[:operator].method == :!~)
+          .matching(expression, value, pattern, given)
+      else
+        expression_message.truthy(e[:operator], v[:operator], given)
+      end
+    end
+
+    # between expression
+    message hole(:value).between?(hole(:min), hole(:max)) do |v, e|
+      expression_message.between(e[:value], v[:value], v[:min], v[:max], given)
+    end
+
+    # any expression
+    message hole(:expression) do |v, e|
+      expression_message.truthy(e[:expression], v[:expression], given)
+    end
+  end
+
+  module MessageRules
+    def self.decompose_pattern_matching(e_lhs, e_rhs, v_lhs, v_rhs)
+      if v_lhs.is_a?(String) && v_rhs.is_a?(Regexp)
+        [e_lhs, v_lhs, v_rhs]
+      elsif v_lhs.is_a?(Regexp) && v_rhs.is_a?(String)
+        [e_rhs, v_rhs, v_lhs]
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/matcher/messages/namespaced_message_builder.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Matcher
+  class NamespacedMessageBuilder < MessageBuilder
+    def initialize(negated, actual, namespace)
+      super(negated, actual)
+
+      @namespace = namespace
+    end
+
+    protected
+
+    def message(key, *, **)
+      key = [@namespace, key]
+
+      super
+    end
+  end
+end

data/lib/matcher/messages/phrasing.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Phrasing
+    extend Forwardable
+
+    attr_reader :path, :message
+
+    def_delegator :@message, :actual
+    def_delegator :@message, :negated
+
+    def self.namespace(value)
+      @namespace = value
+      yield
+    ensure
+      @namespace = nil
+    end
+
+    def self.define(key, &block)
+      key = [@namespace, key] if @namespace
+
+      dict[key] = block
+    end
+
+    def self.dict
+      @dict ||= {}
+    end
+
+    def self.phrasing
+      ->(path, message) { new(path, message).apply }
+    end
+
+    def initialize(path, message)
+      @path = path
+      @message = message
+    end
+
+    def apply
+      phrase(@message.key, *@message.args, **@message.kwargs)
+    end
+
+    def phrase(key, *, **)
+      block = self.class.dict[key]
+
+      if block
+        instance_exec(*, **, &block)
+      else
+        "got #{actual.inspect} but found no message for " \
+          "#{'*NOT* ' if negated}#{key.inspect}"
+      end
+    end
+
+    def phrase_negated(key, *, **)
+      message = Message.new(key, !negated, actual, *, **)
+
+      self.class.new(@path, message).apply
+    end
+  end
+end

data/lib/matcher/messages/standard_message_builder.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Matcher
+  class StandardMessageBuilder < MessageBuilder
+    def namespace(namespace)
+      NamespacedMessageBuilder.new(@negated, @actual, namespace)
+    end
+
+    def truthy
+      message(:truthy)
+    end
+
+    def same(object)
+      message(:same, object)
+    end
+
+    def equal(value)
+      message(:equal, value)
+    end
+
+    def less_than(operand)
+      message(:less_than, operand)
+    end
+
+    def greater_than(operand)
+      message(:greater_than, operand)
+    end
+
+    def less_than_or_equal(operand)
+      message(:less_than_or_equal, operand)
+    end
+
+    def greater_than_or_equal(operand)
+      message(:greater_than_or_equal, operand)
+    end
+
+    def comparable_to(operand)
+      message(:comparable_to, operand)
+    end
+
+    def between(min, max, exclude_end: false)
+      message(:between, min, max, exclude_end:)
+    end
+
+    def length_of(exp, act)
+      message(:length_of, exp, act)
+    end
+
+    def having_key(key)
+      message(:having_key, key)
+    end
+
+    def having_index(index)
+      message(:having_index, index)
+    end
+
+    def exist
+      message(:exist)
+    end
+
+    def in(collection)
+      message(:in, collection)
+    end
+
+    def including(item)
+      message(:including, item)
+    end
+
+    def duplicate(original_index)
+      message(:duplicate, original_index)
+    end
+
+    def duplicate_by(expression, value, original_index)
+      message(:duplicate_by, expression, value, original_index)
+    end
+
+    def matching(pattern)
+      message(:matching, pattern)
+    end
+
+    def valid_format(format)
+      message(:valid_format, format)
+    end
+
+    def instance_of(klass)
+      message(:instance_of, klass)
+    end
+
+    def kind_of(klass)
+      message(:kind_of, klass)
+    end
+
+    def responding_to(method)
+      message(:responding_to, method)
+    end
+
+    def predicate(name)
+      message(:predicate, name)
+    end
+
+    def described_by(description)
+      message(:described_by, description)
+    end
+  end
+end

data/lib/matcher/patterns/ast_mapping.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Matcher
+  class AstMapping
+    RECEIVER = 0
+    ARGS = 1
+    KWARGS = 2
+
+    def initialize(path = List.empty)
+      @path = path
+    end
+
+    attr_reader :path
+
+    def receiver
+      @receiver ||= AstMapping.new(@path << RECEIVER)
+    end
+
+    def args
+      @args ||= Args.new(@path << ARGS, [])
+    end
+
+    def kwargs
+      @kwargs ||= Args.new(@path << KWARGS, {})
+    end
+
+    class Args
+      extend Forwardable
+
+      def initialize(path, data)
+        @path = path
+        @data = data
+      end
+
+      attr_reader :path, :data
+
+      def [](index)
+        @data[index] ||= AstMapping.new(@path << index)
+      end
+    end
+  end
+end

data/lib/matcher/patterns/capture_hole.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Matcher
+  class CaptureHole < Hole
+    def initialize(key, pattern)
+      super(key)
+
+      @pattern = pattern
+    end
+
+    attr_reader :pattern
+
+    def match?(_expression)
+      yield @pattern
+
+      true
+    end
+
+    def ==(other)
+      super && @pattern == other.pattern
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [self.class, @key, @pattern].hash
+    end
+
+    def to_s
+      "capture(#{@key.inspect}, #{@pattern})"
+    end
+    alias inspect to_s
+  end
+end

data/lib/matcher/patterns/constant_hole.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ConstantHole < Hole
+    def match?(expression)
+      expression.is_a?(Constant)
+    end
+
+    def to_s
+      "const(#{@key.inspect})"
+    end
+    alias inspect to_s
+  end
+end

data/lib/matcher/patterns/hole.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Hole
+    def initialize(key, filter = nil)
+      @key = key
+      @filter = filter
+    end
+
+    attr_reader :key
+
+    def match?(expression)
+      !@filter || @filter.call(expression)
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) && key == other.key
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @key].hash
+    end
+
+    def to_s
+      "hole(#{@key.inspect})"
+    end
+    alias inspect to_s
+  end
+end

data/lib/matcher/patterns/method_hole.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Matcher
+  class MethodHole < Hole
+    def initialize(key, receiver, method, args, kwargs)
+      super(key)
+
+      @receiver = receiver
+      @method = method
+      @args = args
+      @kwargs = kwargs
+    end
+
+    attr_reader :receiver, :method, :args, :kwargs
+
+    def match?(expression)
+      if !expression.is_a?(Call) || !match_method?(expression.method)
+        return false
+      end
+
+      yield Call.new(@receiver, expression.method, @args, @kwargs)
+
+      true
+    end
+
+    def ==(other)
+      return true if other.equal?(self)
+
+      super &&
+        @receiver == other.receiver &&
+        @method == other.method &&
+        @args.eql?(other.receiver) &&
+        @kwargs.eql?(other.receiver)
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [self.class, @key, @receiver, @method, @args, @kwargs].hash
+    end
+
+    def to_s
+      args = @args.map(&:inspect)
+      kwargs = @kwargs.map { "#{_1}: #{_2.inspect}" }
+      list = [@key.inspect, @receiver, @method.inspect].concat(args, kwargs)
+
+      "method_hole(#{list.join(', ')})"
+    end
+    alias inspect to_s
+
+    private
+
+    def match_method?(method)
+      if @method.is_a?(Array)
+        @method.include?(method)
+      else
+        # rubocop:disable Style/CaseEquality
+        @method === method
+        # rubocop:enable Style/CaseEquality
+      end
+    end
+  end
+end

data/lib/matcher/patterns/pattern.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Pattern
+    class PatternBuilder
+      include PatternBuilding
+
+      def initialize(build_session: Matcher.build_session)
+        ExpressionDsl.init(self, build_session)
+      end
+    end
+
+    def self.build(&)
+      Matcher.with_build_session do |build_session|
+        builder = PatternBuilder.new(build_session:)
+        result = builder.instance_exec(&)
+        builder.pattern_of(result)
+      end
+    end
+
+    extend Forwardable
+
+    def initialize(expression)
+      @expression = expression
+    end
+
+    attr_reader :expression
+
+    def_delegator :@expression, :to_s
+    def_delegator :@expression, :inspect
+
+    def match(expression, mapping = AstMapping.new)
+      result = PatternMatch.new
+
+      catch(:mismatch) do
+        match_helper(expression, @expression, mapping, result)
+
+        result.capture(:root, expression, mapping) unless result.include?(:root)
+
+        return result
+      end
+
+      nil
+    end
+
+    private
+
+    def match_helper(expression, pattern, mapping, result)
+      if (hole = get_hole(pattern))
+        key = hole.key
+        capture = result[key]
+
+        if capture
+          throw(:mismatch) if capture.expression != expression
+        elsif !match?(hole, expression, mapping, result)
+          throw(:mismatch)
+        else
+          result.capture(key, expression, mapping)
+        end
+      elsif expression.is_a?(Call)
+        throw(:mismatch) unless similar_call?(expression, pattern)
+
+        match_helper(
+          expression.receiver, pattern.receiver, mapping.receiver, result
+        )
+
+        expression.args.each_index do |i|
+          match_helper(
+            expression.args[i], pattern.args[i], mapping.args[i], result
+          )
+        end
+
+        expression.kwargs.each_key do |k|
+          match_helper(
+            expression.kwargs[k], pattern.kwargs[k], mapping.kwargs[k], result
+          )
+        end
+      elsif expression != pattern
+        throw(:mismatch)
+      end
+    end
+
+    def match?(pattern, expression, mapping, result)
+      pattern.match?(expression) do |p|
+        match_helper(expression, p, mapping, result)
+      end
+    end
+
+    def get_hole(expression)
+      return unless expression.is_a?(Constant)
+
+      constant = expression.value
+      constant if constant.is_a?(Hole)
+    end
+
+    def similar_call?(expression, pattern)
+      expression.instance_of?(pattern.class) &&
+        expression.method == pattern.method &&
+        expression.args.length == pattern.args.length &&
+        expression.kwargs.size == pattern.kwargs.size &&
+        expression.kwargs.keys.sort == pattern.kwargs.keys.sort
+    end
+  end
+end