matchers 0.1.0.pre.test

data/lib/matcher/messages/expected_phrasing.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ExpectedPhrasing < Phrasing
+    define(:truthy) do
+      verb = verb(negated: true)
+      truthy_or_falsy = negated ? 'truthy' : 'falsy'
+
+      "#{verb} a #{truthy_or_falsy} value but got #{actual.inspect}"
+    end
+
+    define(:same) do |object|
+      "#{verb} same as #{object.inspect} (id=#{object.object_id})" \
+        "#{" but got #{actual.inspect} (id=#{actual.object_id})" if negated}"
+    end
+
+    define(:equal) do |value|
+      if negated
+        "#{verb} #{value.inspect} but got #{actual.inspect}"
+      else
+        "#{verb} #{actual.inspect}"
+      end
+    end
+
+    define(:less_than) do |operand|
+      if negated || (actual <=> operand).nil?
+        "#{verb} a value < #{operand.inspect} but got #{actual.inspect}"
+      else
+        phrase_negated(:greater_than_or_equal, operand)
+      end
+    end
+
+    define(:greater_than) do |operand|
+      if negated || (actual <=> operand).nil?
+        "#{verb} a value > #{operand.inspect} but got #{actual.inspect}"
+      else
+        phrase_negated(:less_than_or_equal, operand)
+      end
+    end
+
+    define(:less_than_or_equal) do |operand|
+      if negated || (actual <=> operand).nil?
+        "#{verb} a value <= #{operand.inspect} but got #{actual.inspect}"
+      else
+        phrase_negated(:greater_than, operand)
+      end
+    end
+
+    define(:greater_than_or_equal) do |operand|
+      if negated || (actual <=> operand).nil?
+        "#{verb} a value >= #{operand.inspect} but got #{actual.inspect}"
+      else
+        phrase_negated(:less_than, operand)
+      end
+    end
+
+    define(:comparable_to) do |operand|
+      "#{verb} a value comparable to #{operand.inspect} but got #{actual.inspect}"
+    end
+
+    define(:between) do |min, max, exclude_end: false|
+      "#{verb} value to be between #{min.inspect} and " \
+        "#{max.inspect}#{' (exclusive)' if exclude_end} but got #{actual.inspect}"
+    end
+
+    define(:length_of) do |exp, act|
+      "#{verb} length of #{exp}#{" but was #{act}" if negated}"
+    end
+
+    define(:having_key) do |key|
+      "#{verb} to include key #{key.inspect} but got #{actual.inspect}"
+    end
+
+    define(:having_index) do |index|
+      "#{verb} to have index #{index.inspect} but got #{actual.inspect}"
+    end
+
+    define(:exist) do
+      "#{verb} to exist#{" but got #{actual.inspect}" unless negated}"
+    end
+
+    define(:in) do |collection|
+      "#{verb} object to be included in #{collection.inspect} but got #{actual.inspect}"
+    end
+
+    define(:including) do |item|
+      "#{verb} #{item.inspect} to be included but got #{actual.inspect}"
+    end
+
+    define(:duplicate) do |original_index|
+      "#{verb} duplicate originally at index #{original_index} but got #{actual.inspect}"
+    end
+
+    define(:duplicate_by) do |expression, value, original_index|
+      "#{verb} duplicate by #{expression.inspect}=#{value.inspect} originally at index #{original_index} but got #{actual.inspect}"
+    end
+
+    define(:matching) do |pattern|
+      "#{verb} value to match #{pattern.inspect} but got #{actual.inspect}"
+    end
+
+    define(:valid_format) do |format|
+      "#{verb} a valid #{format} string but got #{actual.inspect}"
+    end
+
+    define(:instance_of) do |klass|
+      "#{verb} an instance of #{klass} but got #{actual.inspect}"
+    end
+
+    define(:kind_of) do |klass|
+      "#{verb} a kind of #{klass} but got #{actual.inspect}"
+    end
+
+    define(:responding_to) do |method|
+      "#{verb} an object responding to `#{method}' but got #{actual.inspect}"
+    end
+
+    define(:predicate) do |predicate|
+      predicate = predicate.to_s.delete_suffix('?')
+
+      "#{verb} value to be #{predicate} but got #{actual.inspect}"
+    end
+
+    define(:described_by) do |description|
+      "#{verb} #{description} but got #{actual.inspect}"
+    end
+
+    namespace(:expression) do
+      define(:truthy) do |expression, value, given|
+        verb = verb(negated: true)
+        truthy_or_falsy = negated ? 'truthy' : 'falsy'
+
+        "#{verb} #{expression} to be #{truthy_or_falsy} " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      define(:same) do |left_expression, right_expression, left, right, given|
+        "#{verb} #{left_expression} to be same as #{right_expression} " \
+          "but got #{left.inspect} (id=#{left.object_id})" \
+          "#{" and #{right.inspect} (id=#{right.object_id})" if negated}" \
+          "#{where_text(given, left_expression, right_expression)}"
+      end
+
+      negated_comparisons =
+        { :== => :!=, :!= => :==, :< => :>=, :> => :<=, :<= => :>, :>= => :< }
+
+      define(:comparison) do |expression, left, right, given|
+        can_negate = !negated &&
+          (method = negated_comparisons[expression.method]) &&
+          (%i[== !=].include?(method) || left <=> right)
+
+        verb = if can_negate
+          expression = Call.new(
+            expression.receiver,
+            method,
+            expression.args,
+            expression.kwargs,
+          )
+
+          verb(negated: true)
+        else
+          self.verb
+        end
+
+        "#{verb} #{expression} but got " \
+          "#{left.inspect} #{expression.method} #{right.inspect}" \
+          "#{where_text(given, expression.receiver, expression.args[0])}"
+      end
+
+      define(:comparable_to) do |expression, value, operand, given|
+        "#{verb} #{expression} to be comparable to #{operand.inspect} " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      define(:between) do |expression, value, min, max, given|
+        "#{verb} #{expression} to be between #{min.inspect} and #{max.inspect} " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      define(:length_of) do |expression, _value, exp, act, given|
+        "#{verb} #{expression} to have length of #{exp}" \
+          "#{" but was #{act}" if negated}#{where_text(given, expression)}"
+      end
+
+      define(:having_key) do |expression, value, key, given|
+        "#{verb} #{expression} to include key #{key.inspect} " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      define(:in) do |expression, value, collection, given|
+        "#{verb} #{expression} to be included in #{collection.inspect} " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      define(:including) do |expression, value, item, given|
+        "#{verb} #{expression} to include #{item.inspect} " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      define(:matching) do |expression, value, pattern, given|
+        "#{verb} #{expression} to match #{pattern.inspect} " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      match_at_words = {
+        :== => 'at',
+        :!= => 'not at',
+        :< => 'before',
+        :> => 'after',
+        :<= => 'at or before',
+        :>= => 'at or after',
+      }
+
+      define(:match_at) do |expression, value, pattern, position, comparison, operand, given|
+        comparison_word = match_at_words[comparison]
+
+        message = String.new
+        message << "#{verb} #{expression} to match #{pattern.inspect} #{comparison_word} #{operand} "
+        message << "but was at #{position} " if
+          operand != position || comparison != (negated ? :!= : :==)
+        message << "for #{value.inspect}#{where_text(given, expression)}"
+
+        message
+      end
+
+      define(:instance_of) do |expression, value, klass, given|
+        "#{verb} #{expression} to be an instance of #{klass} " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      define(:kind_of) do |expression, value, klass, given|
+        "#{verb} #{expression} to be a kind of #{klass} " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      define(:responding_to) do |expression, value, method, given|
+        "#{verb} #{expression} to respond to `#{method}' " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      define(:predicate) do |expression, value, predicate, given|
+        predicate = predicate.to_s.delete_suffix('?')
+
+        "#{verb} #{expression} to be #{predicate} " \
+          "but got #{value.inspect}#{where_text(given, expression)}"
+      end
+
+      define(:raising) do |expression, error, given|
+        error_class = error.is_a?(Class) ? error : error.class
+        where = where_text(given, expression)
+
+        text = "#{verb} #{expression} to raise #{error_class}#{where}"
+        text += ": #{error.message}" if error.is_a?(Exception)
+
+        text
+      end
+    end
+
+    namespace(:negated) do
+      define(:valid) do |matcher|
+        "#{verb} #{matcher} to be valid but got #{actual.inspect}"
+      end
+    end
+
+    namespace(:block) do
+      define(:satisfied) do |block_location|
+        "#{verb} to satisfy condition #{block_location} but got #{actual.inspect}"
+      end
+    end
+
+    namespace(:imply_some) do
+      def x_conditions(count)
+        case count
+        when :any
+          'any condition'
+        when 1
+          'one condition'
+        else
+          "#{count} conditions"
+        end
+      end
+      private :x_conditions
+
+      define(:no_condition_satisfied) do |conditions, count|
+        "#{negated_verb} to satisfy #{x_conditions(count)} but got #{actual.inspect} and met none of these: #{join(conditions)}"
+      end
+
+      define(:x_conditions_satisfied) do |conditions, count|
+        "#{negated_verb} to satisfy #{x_conditions(count)} but got #{actual.inspect} and met these: #{join(conditions)}"
+      end
+    end
+
+    namespace(:reference) do
+      define(:cyclic) do
+        "#{verb} a cyclic structure" \
+          "#{' but actual has already been visited' unless negated}"
+      end
+
+      define(:failed_from_cache) do
+        'actual has already failed before'
+      end
+    end
+
+    namespace(:set) do
+      define(:equal) do |set|
+        "#{verb} object to be an equal set to #{set.inspect} but got #{actual.inspect}"
+      end
+    end
+
+    private
+
+    def verb(negated: self.negated)
+      # A message says what actual is but expected says what it is not. That's why
+      # the verb is counter-intuitively negated.
+
+      negated ? 'expected' : 'did not expect'
+    end
+
+    def negated_verb
+      verb(negated: !negated)
+    end
+
+    def join(objects)
+      objects.map(&:to_s).join(', ')
+    end
+
+    def where_text(values, *expressions)
+      return '' if values.empty?
+
+      except = expressions.filter_map { _1.symbol if _1.is_a?(Variable) }
+      symbols = expressions.flat_map(&:variables).uniq - except
+
+      return '' if symbols.empty?
+
+      list = symbols
+        .map { "#{_1} = #{values.fetch(_1).inspect}" }
+        .join(', ')
+
+      ", where #{list}"
+    end
+  end
+end

data/lib/matcher/messages/message.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Message
+    attr_reader :key, :negated, :actual, :args, :kwargs
+
+    def initialize(key, negated, actual, *args, **kwargs)
+      @key = key
+      @negated = negated
+      @actual = actual
+      @args = args
+      @kwargs = kwargs
+    end
+
+    def negate!
+      @negated = !@negated
+    end
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(Message) &&
+        @key.eql?(other.key) &&
+        @negated == other.negated &&
+        @actual.eql?(other.actual) &&
+        @args.eql?(other.args) &&
+        @kwargs.eql?(other.kwargs)
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [self.class, @key, @negated, @actual, @args, @kwargs].hash
+    end
+
+    def namespace
+      @key.is_a?(Array) ? @key[0] : nil
+    end
+
+    def to_standard
+      return self if namespace != :expression
+
+      key = @key[1]
+
+      case key
+      when :truthy
+        _expr, value = @args
+        Message.new(key, @negated, value)
+      when :same
+        _l_expr, _r_expr, left, right = @args
+        Message.new(:same, @negated, left, right)
+      when :comparable_to, :having_key, :in, :including, :matching, :instance_of, :kind_of, :responding_to, :predicate
+        _expr, value, operand = @args
+        Message.new(key, @negated, value, operand)
+      when :between, :length_of
+        _expr, value, operand1, operand2 = @args
+        Message.new(key, @negated, value, operand1, operand2)
+      when :comparison
+        expr, left, right = @args
+
+        case expr.method
+        when :==
+          Message.new(:equal, @negated, left, right)
+        when :!=
+          Message.new(:equal, !@negated, left, right)
+        when :<
+          Message.new(:less_than, @negated, left, right)
+        when :>
+          Message.new(:greater_than, @negated, left, right)
+        when :<=
+          Message.new(:less_than_or_equal, @negated, left, right)
+        when :>=
+          Message.new(:greater_than_or_equal, @negated, left, right)
+        else
+          raise "unexpected method: #{expr.method.inspect}"
+        end
+      else
+        self
+      end
+    end
+
+    def to_s
+      if @key.is_a?(Array)
+        namespace, key = @key
+      else
+        key = @key
+      end
+
+      args_and_kwargs = @args.map(&:inspect) + @kwargs.map do |k, v|
+        k.is_a?(Symbol) ? "#{k}: #{v.inspect}" : "#{k.inspect} => #{v.inspect}"
+      end
+
+      string = String.new("report(#{@actual.inspect})")
+      string += ".namespace(#{namespace.inspect})" if namespace
+      string += '.not' if @negated
+      string += ".#{key}"
+      string += "(#{args_and_kwargs.join(', ')})" unless args_and_kwargs.empty?
+
+      string
+    end
+    alias inspect to_s
+  end
+end

data/lib/matcher/messages/message_builder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Matcher
+  class MessageBuilder
+    def initialize(negated, actual)
+      @negated = negated
+      @actual = actual
+    end
+
+    def not
+      @negated = !@negated
+      self
+    end
+
+    def not_if(condition)
+      condition ? self.not : self
+    end
+
+    protected
+
+    def message(key, *, **)
+      Message.new(key, @negated, @actual, *, **)
+    end
+
+    private
+
+    def method_missing(method, *, **)
+      message(method, *, **)
+    end
+
+    def respond_to_missing?(_name, _include_private = false)
+      true
+    end
+  end
+end

data/lib/matcher/messages/message_rules.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Matcher
+  ExpressionMatcher.message_rules.configure do
+    # binary standard expression
+    standard_ops = %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(
+      hole(:obj).class == hole(:class),
+      hole(:class) == hole(:obj).class,
+    ) 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