matchers 0.1.0.pre.1

data/lib/matcher/patterns/pattern_building.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Matcher
+  module PatternBuilding
+    include ExpressionDsl
+
+    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,103 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+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
+
+      if message.is_a?(Message)
+        message = @phrasing.call(@path_stack.last, message)
+      end
+
+      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

data/lib/matcher/rules/message_factory.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Matcher
+  class MessageFactory
+    def initialize(value_paths, expressions, block)
+      @value_paths = value_paths
+      @expressions = expressions
+      @negate = false
+      @block = block
+    end
+
+    def negate!
+      @negate = !@negate
+    end
+
+    def create(context, value_tree)
+      # Using reduce instead of dig so it will fail if an unexpected leaf is
+      # encountered.
+      values = @value_paths.transform_values { _1.reduce(value_tree, :[]) }
+      message = context.instance_exec(values, @expressions, &@block)
+      message.negate! if @negate
+
+      message
+    end
+  end
+end

data/lib/matcher/rules/message_rule.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Matcher
+  class MessageRule
+    def initialize(patterns, block)
+      @patterns = patterns
+      @block = block
+    end
+
+    attr_reader :patterns
+
+    def apply(match)
+      expressions = @block.arity >= 2 ? match.expressions : nil
+
+      MessageFactory.new(match.value_paths, expressions, @block)
+    end
+  end
+end

data/lib/matcher/rules/message_rule_context.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Matcher
+  class MessageRuleContext
+    extend Forwardable
+
+    def initialize(matcher, state)
+      @matcher = matcher
+      @state = state
+    end
+
+    def standard_message
+      StandardMessageBuilder.new(!@matcher.negated, @state.actual)
+    end
+
+    def expression_message
+      NamespacedMessageBuilder.new(
+        !@matcher.negated, @state.actual, :expression
+      )
+    end
+
+    def given
+      @matcher.expression.given_for(@state.values)
+    end
+  end
+end

data/lib/matcher/rules/rule_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Matcher
+  class RuleBuilder
+    include PatternBuilding
+
+    def initialize(rules = [], build_session: Matcher.build_session)
+      ExpressionDsl.init(self, build_session)
+
+      @rules = rules
+    end
+
+    attr_reader :rules
+
+    def transform(*patterns, negate: false, &block)
+      patterns.map! { pattern_of(_1) }
+      @rules << TransformRule.new(patterns, negate, block)
+
+      nil
+    end
+
+    def message(*patterns, &block)
+      patterns.map! { pattern_of(_1) }
+      @rules << MessageRule.new(patterns, block)
+
+      nil
+    end
+  end
+end

data/lib/matcher/rules/rule_set.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Matcher
+  class RuleSet
+    def initialize(rules = [], &)
+      @rules = rules
+
+      configure(&) if block_given?
+    end
+
+    def configure(&)
+      Matcher.with_build_session do |build_session|
+        builder = RuleBuilder.new(@rules, build_session:)
+        builder.instance_exec(&)
+      end
+
+      self
+    end
+
+    def apply(expression)
+      cur = expression
+      mapping = AstMapping.new
+      result = nil
+      negate = false
+
+      while (rule, match = find_rule(cur, mapping))
+        result = rule.apply(match)
+
+        if rule.is_a?(MessageRule)
+          result.negate! if negate
+
+          return result
+        end
+
+        cur = result.expression
+        mapping = result.mapping
+        negate = !negate if rule.negate?
+      end
+
+      result
+    end
+
+    private
+
+    def find_rule(expression, mapping)
+      @rules.each do |rule|
+        rule.patterns.each do |pattern|
+          match = pattern.match(expression, mapping)
+
+          return [rule, match] if match
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/matcher/rules/transform_builder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Matcher
+  class TransformBuilder
+    include Singleton
+
+    def call(match, receiver, method, *args, **kwargs)
+      expression = Call.new(
+        receiver.expression,
+        method,
+        args.map(&:expression),
+        kwargs.transform_values(&:expression),
+      )
+
+      mapping = TransformMapping.new
+      mapping.path = match.mapping.path
+      mapping.receiver = receiver.mapping
+      mapping.args = args.map(&:mapping)
+      mapping.kwargs = kwargs.transform_values(&:mapping)
+
+      PatternCapture.new(expression, mapping)
+    end
+  end
+end

data/lib/matcher/rules/transform_mapping.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Matcher
+  TransformMapping = Struct.new(:path, :receiver, :args, :kwargs)
+end

data/lib/matcher/rules/transform_rule.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Matcher
+  class TransformRule
+    def initialize(patterns, negate, block)
+      @patterns = patterns
+      @negate = negate
+      @block = block
+    end
+
+    attr_reader :patterns
+
+    def negate?
+      @negate
+    end
+
+    def apply(match)
+      TransformBuilder.instance.instance_exec(match, &@block)
+    end
+  end
+end

data/lib/matcher/state.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Matcher
+  class State
+    def initialize(values, boolean: false)
+      @values = values
+      @boolean = boolean
+    end
+
+    attr_reader :values
+
+    def boolean?
+      @boolean
+    end
+
+    def actual
+      @values[:actual]
+    end
+
+    def errors
+      @errors ||= new_collector
+    end
+
+    def new_collector
+      @boolean ? BooleanCollector.new : ErrorCollector.new
+    end
+
+    def result
+      @errors&.error || EmptyError.instance
+    end
+
+    def report(actual = self.actual)
+      StandardMessageBuilder.new(false, actual)
+    end
+
+    def expected(actual = self.actual)
+      StandardMessageBuilder.new(true, actual)
+    end
+  end
+end

data/lib/matcher/testing/error_builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ErrorBuilder
+    def self.build(use_or: false, &)
+      errors = build_errors(&)
+
+      if use_or
+        OrError.from(errors)
+      else
+        AndError.from(errors)
+      end
+    end
+
+    def self.build_errors(&)
+      builder = ErrorBuilder.new
+      builder.instance_exec(&) if block_given?
+      builder.errors
+    end
+
+    attr_reader :errors
+
+    def initialize
+      @errors = []
+    end
+
+    def _or(*path, &)
+      errors = ErrorBuilder.build_errors(&)
+      error = OrError.from(errors)
+
+      @errors << nest(path, error)
+    end
+
+    def _and(*path, &)
+      errors = ErrorBuilder.build_errors(&)
+      error = AndError.from(errors)
+
+      @errors << nest(path, error)
+    end
+
+    def error(path_or_message, message = nil)
+      if message.nil?
+        @errors << ElementError.new(path_or_message)
+      else
+        path = Array(path_or_message)
+        element = ElementError.new(message)
+
+        @errors << nest(path, element)
+      end
+    end
+
+    def msg(actual)
+      StandardMessageBuilder.new(false, actual)
+    end
+
+    private
+
+    def nest(path, error)
+      path.reverse_each.reduce(error) { NestedError.from(_2, _1) }
+    end
+  end
+end