matchers 0.1.0.pre.test

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,57 @@
+# 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}"#{" (negated)" if negated}
+      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/once_before.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Matcher
+  module OnceBefore
+    def once_before(method, &)
+      original_method = "_before_once_#{method}"
+      alias_method(original_method, method)
+
+      define_method(method) do |*args, **kwargs, &block|
+        instance_exec(&)
+        send(original_method, *args, **kwargs, &block)
+      ensure
+        self.class.alias_method(method, original_method)
+        self.class.undef_method(original_method)
+      end
+    end
+  end
+end

data/lib/matcher/optional_chain.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Matcher
+  class OptionalChain
+    include NoExpression
+    include NoKey
+    extend Forwardable
+
+    def initialize(chain, fallback)
+      @chain = chain
+      @fallback = fallback
+    end
+
+    def_delegator :@chain, :^
+
+    def ~
+      OptionalChain.new(~@chain, @fallback)
+    end
+
+    def fallback
+      @chain ^ @fallback
+    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,58 @@
+# 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)
+      return false if !expression.is_a?(Call) || !match_method?(expression.method)
+
+      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
+        @method === method
+      end
+    end
+  end
+end

data/lib/matcher/patterns/pattern.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Pattern
+    class PatternBuilder
+      include PatternBuilding
+
+      def initialize(build_session: Matcher.build_session)
+        ExpressionBuilding.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 !hole.match?(expression) { |p| match_helper(expression, p, 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 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.class == 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

data/lib/matcher/patterns/pattern_building.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Matcher
+  module PatternBuilding
+    include ExpressionBuilding
+
+    def pattern_of(value)
+      Pattern.new(expression_of(value))
+    end
+
+    def capture(key, pattern)
+      pattern = expression_of(pattern)
+      hole = CaptureHole.new(key, pattern)
+
+      expr(hole)
+    end
+
+    def hole(key, &filter)
+      expr(Hole.new(key, filter))
+    end
+
+    def var(key)
+      expr(VariableHole.new(key))
+    end
+
+    def const(key)
+      expr(ConstantHole.new(key))
+    end
+
+    def method_hole(key, receiver, method, *args, **kwargs)
+      receiver = expression_of(receiver)
+      args = args.map { expression_of(_1) }
+      kwargs = kwargs.transform_values { expression_of(_1) }
+      hole = MethodHole.new(key, receiver, method, args, kwargs)
+
+      expr(hole)
+    end
+  end
+end

data/lib/matcher/patterns/pattern_capture.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Matcher
+  PatternCapture = Struct.new(:expression, :mapping) do
+    def value_path
+      identifiers = mapping.path.to_a.reverse!
+      identifiers << -1
+      identifiers
+    end
+  end
+end

data/lib/matcher/patterns/pattern_match.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Matcher
+  class PatternMatch
+    def initialize
+      @captures = {}
+    end
+
+    def [](key)
+      @captures[key]
+    end
+
+    def include?(key)
+      @captures.include?(key)
+    end
+
+    def capture(key, expression, mapping)
+      @captures[key] = PatternCapture.new(expression, mapping)
+    end
+
+    def value_paths
+      @captures.transform_values(&:value_path)
+    end
+
+    def expressions
+      @captures.transform_values(&:expression)
+    end
+  end
+end

data/lib/matcher/patterns/variable_hole.rb

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

data/lib/matcher/reporter.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Reporter
+    ##
+    # Formats an error tree as a human-readable string
+    # @example
+    #   errors = Matcher.build { Integer }.match("foo")
+    #   puts Reporter.report(errors)
+    #   # > root: expected a kind of Integer but got "foo"
+    # @param error [Error] the error tree from {Base#match}
+    # @return [String]
+    def self.report(error)
+      new.report(error)
+    end
+
+    def initialize
+      @level = 0
+      @continue_line = false
+      @path_stack = ['root']
+      @phrasing = ExpectedPhrasing.phrasing
+    end
+
+    def report(error)
+      @io = StringIO.new
+
+      report_error(error)
+
+      string = @io.string
+      @io.close
+      @io = nil
+
+      string
+    end
+
+    private
+
+    def report_error(error)
+      case error
+      when EmptyError
+        report_empty
+      when ElementError
+        report_element(error)
+      when NestedError
+        report_nested(error)
+      when AndError
+        report_and(error)
+      when OrError
+        report_or(error)
+      else
+        raise "Illegal error: #{error.inspect}"
+      end
+    end
+
+    def report_empty
+      'no error'
+    end
+
+    def report_element(element)
+      message = element.message
+      message = @phrasing.call(@path_stack.last, message) if message.is_a?(Message)
+
+      line("#{@path_stack.last}: #{message}")
+    end
+
+    def report_nested(nested)
+      path = NestedError.key_to_s(nested.key, @path_stack.last)
+
+      @path_stack.push(path)
+      report_error(nested.child)
+      @path_stack.pop
+    end
+
+    def report_and(error)
+      error.children.each { report_error(_1) }
+    end
+
+    def report_or(error)
+      line('expected at least one error to be absent:')
+
+      error.children.each do |n|
+        line('- ', newline: false)
+
+        @level += 1
+        report_error(n)
+        @level -= 1
+      end
+    end
+
+    def line(message, newline: true)
+      message = '  ' * @level + message unless @continue_line
+      message += "\n" if newline
+
+      @continue_line = !newline
+      @io.print(message)
+    end
+  end
+end