matchers 0.1.0.pre.test

data/lib/matcher/rules/message_factory.rb

@@ -0,0 +1,25 @@
+# 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,24 @@
+# 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)
+      ExpressionBuilding.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
+      @error_collector ||= new_collector
+    end
+
+    def new_collector
+      @boolean ? BooleanCollector.new : ErrorCollector.new
+    end
+
+    def result
+      @error_collector&.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