matchers 0.1.0.pre.1

data/lib/matcher/matchers/each_pair_matcher.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Matcher
+  class EachPairMatcher < Base
+    def initialize(matcher)
+      super()
+
+      @matcher = matcher
+    end
+
+    def negate
+      NegatedEachPairMatcher.new(@matcher)
+    end
+
+    def validate(state)
+      actual = state.actual
+
+      unless actual.respond_to?(:each_pair)
+        state.errors << state.expected.responding_to(:each_pair)
+        return
+      end
+
+      actual.each_pair do |key, value|
+        state.errors[key] << yield(
+          @matcher,
+          [key, value],
+          key: key,
+          value: value,
+          parent: actual
+        )
+      end
+    end
+
+    def to_s
+      "each_pair(#{@matcher})"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches each hash entry
+    # == +matcher+ values
+    # - key
+    # - value
+    # - parent
+    # @example
+    #   # matches { foo: "foo" } but not { foo: "bar" }
+    #   each_pair(k.to_s == v)
+    #   # alternatively:
+    #   each_pair ^ (k.to_s == v)
+    # @overload each_pair(matcher)
+    #   @param matcher [Base]
+    #   @return [EachPairMatcher]
+    # @overload each_pair
+    #   @return [Chain<EachPairMatcher>]
+    # @see #each_key
+    # @see #each_value
+    def each_pair(matcher = UNDEFINED)
+      return Chain.new { each_pair(_1) } if Matcher.undefined?(matcher)
+
+      EachPairMatcher.new(matcher_of(matcher))
+    end
+
+    ##
+    # Matches each hash key
+    # == +matcher+ values
+    # - key
+    # - value
+    # - parent
+    # @example
+    #   # matches { foo: 1, bar: 2 } but not { "foo" => 1, "bar" => 2 }
+    #   each_key(Symbol)
+    #   # alternatively:
+    #   each_key ^ Symbol
+    # @overload each_key(matcher)
+    #   @param matcher [Base]
+    #   @return [EachPairMatcher]
+    # @overload each_key
+    #   @return [Chain<EachPairMatcher>]
+    # @see #each_pair
+    def each_key(matcher = UNDEFINED)
+      return Chain.new { each_key(_1) } if Matcher.undefined?(matcher)
+
+      matcher = matcher_of(matcher)
+
+      EachPairMatcher.new(
+        ProjectMatcher.new(Variable.key, matcher),
+      )
+    end
+
+    ##
+    # Matches each hash value
+    # == +matcher+ values
+    # - key
+    # - value
+    # - parent
+    # @example
+    #   # matches { a: "foo", b: "bar" } but not { a: 1, b: 2 }
+    #   each_value(String)
+    #   # alternatively:
+    #   each_value ^ String
+    # @overload each_value(matcher)
+    #   @param matcher [Base]
+    #   @return [EachPairMatcher]
+    # @overload each_value
+    #   @return [Chain<EachPairMatcher>]
+    # @see #each_pair
+    def each_value(matcher = UNDEFINED)
+      return Chain.new { each_value(_1) } if Matcher.undefined?(matcher)
+
+      assigns = { actual: Variable.value }
+      matcher = matcher_of(matcher)
+
+      EachPairMatcher.new(
+        LetMatcher.new(assigns, matcher),
+      )
+    end
+  end
+end

data/lib/matcher/matchers/equal_matcher.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Matcher
+  class EqualMatcher < Base
+    CACHEABLE_CLASSES = [
+      NilClass,
+      FalseClass,
+      TrueClass,
+      Integer,
+      Float,
+      Symbol,
+      String,
+      Regexp,
+      Module,
+    ].freeze
+
+    def self.cache(value, matcher_cache = MatcherCache.current)
+      return new(value) if !matcher_cache ||
+        !CACHEABLE_CLASSES.include?(value) ||
+        value.is_a?(String) && !value.frozen?
+
+      (matcher_cache.equal_matchers ||= {})[value] ||= new(value)
+    end
+
+    def initialize(value, negated: false)
+      super()
+
+      @value = value
+      @negated = negated
+    end
+
+    def negate
+      EqualMatcher.new(@value, negated: !@negated)
+    end
+
+    def validate(state)
+      value = @value.is_a?(Expression) ? @value.evaluate(state.values) : @value
+
+      if @negated
+        errors = state.errors.or!
+
+        catch(:valid) do
+          validate_negated_helper(state, errors, value, state.actual)
+
+          # prevent clearing errors
+          return
+        end
+
+        # caught :valid
+        errors.clear
+      else
+        validate_helper(state, state.errors, value, state.actual)
+      end
+    end
+
+    IMPLICIT_MATCHER_CLASSES =
+      [Module, Range, Regexp, Hash, Array, Expression].freeze
+
+    def to_s
+      if IMPLICIT_MATCHER_CLASSES.any? { @value.is_a?(_1) }
+        "#{'~' if @negated}equal(#{@value.inspect})"
+      else
+        @negated ? "neg(#{@value.inspect})" : @value.inspect
+      end
+    end
+
+    private
+
+    def validate_helper(state, errors, exp, act)
+      case exp
+      when Array
+        validate_array(state, errors, exp, act)
+      when Hash
+        validate_hash(state, errors, exp, act)
+      when Set
+        validate_set(state, errors, exp, act)
+      else
+        errors << state.expected(act).not_if(@negated).equal(exp) if
+          @negated ^ (act != exp)
+      end
+    end
+
+    def validate_array(state, errors, exp, act)
+      unless act.is_a?(Array)
+        errors << state.expected(act).kind_of(Array)
+        return
+      end
+
+      errors << state.expected(act).length_of(exp.length, act.length) if
+        exp.length != act.length
+
+      [exp.length, act.length].min.times do |i|
+        validate_helper(state, errors[i], exp[i], act[i])
+      end
+    end
+
+    def validate_hash(state, errors, exp, act)
+      unless act.is_a?(Hash)
+        errors << state.expected(act).kind_of(Hash)
+        return
+      end
+
+      (act.keys - exp.keys).each do |key|
+        errors[key] << state.expected(act).not.having_key(key)
+      end
+
+      exp.each do |key, exp_value|
+        act_value = act[key]
+
+        if act_value.nil? && !act.key?(key)
+          errors << state.expected(act).having_key(key)
+        else
+          validate_helper(state, errors[key], exp_value, act_value)
+        end
+      end
+    end
+
+    def validate_set(state, errors, exp, act)
+      unless act.is_a?(Set)
+        errors << state.expected(act).kind_of(Set)
+        return
+      end
+
+      (exp - act).each do |item|
+        errors << state.expected(act).including(item)
+      end
+
+      (act - exp).each do |item|
+        errors << state.expected(act).not.including(item)
+      end
+    end
+
+    def validate_negated_helper(state, errors, exp, act)
+      case exp
+      when Array
+        validate_array_negated(state, errors, exp, act)
+      when Hash
+        validate_hash_negated(state, errors, exp, act)
+      when Set
+        validate_set_negated(state, errors, exp, act)
+      else
+        if act == exp
+          errors << state.expected(act).not.equal(exp)
+        else
+          throw(:valid)
+        end
+      end
+    end
+
+    def validate_array_negated(state, errors, exp, act)
+      throw(:valid) if !act.is_a?(Array) || exp.length != act.length
+
+      exp.length.times do |i|
+        validate_negated_helper(state, errors[i], exp[i], act[i])
+      end
+    end
+
+    def validate_hash_negated(state, errors, exp, act)
+      throw(:valid) unless act.is_a?(Hash)
+
+      exp_keys_set = Set.new(exp.keys)
+      throw(:valid) unless act.keys.all? { exp_keys_set.include?(_1) }
+
+      exp.each do |key, exp_value|
+        act_value = act[key]
+
+        if act_value.nil? && !act.key?(key)
+          throw(:valid)
+        else
+          validate_negated_helper(state, errors[key], exp_value, act_value)
+        end
+      end
+    end
+
+    def validate_set_negated(state, errors, exp, act)
+      throw(:valid) if !act.is_a?(Set) || act != exp
+
+      exp.each do |item|
+        errors << state.expected(act).not.including(item)
+      end
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches equal value
+    # @example
+    #   # matches String but not "foo"
+    #   equal(String)
+    # @param value
+    # @return [EqualMatcher]
+    def equal(value)
+      value = expression_or_value(value)
+
+      EqualMatcher.cache(value, @matcher_cache)
+    end
+  end
+end

data/lib/matcher/matchers/equal_set_matcher.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Matcher
+  ##
+  # Match array elements like a set.
+  # @example
+  #   m = Matcher.build { equal_set(1, 2, 3) }
+  #
+  #   m.match?([1, 2, 3]) # => true
+  #   m.match?([3, 2, 1]) # => true
+  #
+  #   m.match([1, 1, 3])
+  #   # > root[1]: did not expect duplicate originally at index 0 but got 1
+  #   # > root: expected 2 to be included but got [1, 1, 3]
+  class EqualSetMatcher < Base
+    def initialize(items, negated: false)
+      super()
+
+      @items = items
+      @negated = negated
+      @includes_expressions = items.any?(Expression)
+    end
+
+    def negate
+      EqualSetMatcher.new(@items, negated: !@negated)
+    end
+
+    def validate(state)
+      return validate_negated(state) if @negated
+
+      actual = state.actual
+
+      unless actual.respond_to?(:each)
+        state.errors << state.expected.responding_to(:each)
+        return
+      end
+
+      expected_set = item_set(state.values)
+      missing = expected_set.dup
+
+      actual.each_with_index do |act, i|
+        if expected_set.include?(act)
+          unless missing.delete?(act)
+            original_index = index_of(actual, act)
+            state.errors[i] << state.expected(act).not.duplicate(original_index)
+          end
+        else
+          state.errors[i] << state.expected(act).not.in(state.actual)
+        end
+      end
+
+      missing.each do |m|
+        state.errors << state.expected.including(m)
+      end
+    end
+
+    def to_s
+      "#{'~' if @negated}equal_set(#{@items.join(', ')})"
+    end
+
+    private
+
+    def item_set(values)
+      if @includes_expressions
+        @items.to_set do |item|
+          item.is_a?(Expression) ? item.evaluate(values) : item
+        end
+      else
+        @item_set ||= Set.new(@items)
+      end
+    end
+
+    def validate_negated(state)
+      actual = state.actual
+
+      return unless actual.respond_to?(:each)
+
+      expected_set = item_set(state.values)
+      missing = expected_set.dup
+
+      actual.each do |act|
+        return nil if !expected_set.include?(act) || !missing.delete?(act)
+      end
+
+      return unless missing.empty?
+
+      state.errors << state.expected.namespace(:set).not.equal(@items)
+    end
+
+    def index_of(collection, item)
+      collection = collection.enum_for(:each) unless
+        collection.respond_to?(:find_index)
+
+      collection.find_index(item)
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches array elements like a set
+    # @example
+    #   # matches [1, 2, 3] and [3, 2, 1] but neither [0, 1, 2] nor [1, 1, 2, 3]
+    #   equal_set(1, 2, 3)
+    # @param items [Array]
+    # @return [EqualSetMatcher]
+    def equal_set(*items)
+      items.map! { expression_or_value(_1) }
+
+      EqualSetMatcher.new(items)
+    end
+  end
+end

data/lib/matcher/matchers/expression_matcher.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ExpressionMatcher < Base
+    def self.cache(
+      value,
+      matcher_cache = MatcherCache.current,
+      expression_cache = ExpressionCache.current
+    )
+      return new(value) unless matcher_cache
+
+      cache = (matcher_cache.expression_matchers ||= {})
+      label = expression_cache.label(value)
+
+      cache[label] ||= new(value)
+    end
+
+    def self.message_rules
+      @message_rules ||= RuleSet.new
+    end
+
+    attr_reader :expression, :negated
+
+    def initialize(expression, negated: false)
+      super()
+
+      @expression = expression
+      @negated = negated
+    end
+
+    def negate
+      ExpressionMatcher.new(@expression, negated: !@negated)
+    end
+
+    def validate(state)
+      if state.boolean?
+        if @negated != !@expression.evaluate(state.values)
+          state.errors << "invalid"
+        end
+
+        return
+      end
+
+      value_tree = @expression.evaluate_tree(state.values)
+      evaluation = value_tree[-1]
+
+      if @negated != !evaluation
+        rule_context = MessageRuleContext.new(self, state)
+        state.errors << message_factory.create(rule_context, value_tree)
+      end
+    rescue CallError => e
+      state.errors << e.message_for_errors(state.actual) unless @negated
+    end
+
+    def to_s
+      if @negated
+        "neg(#{@expression})"
+      else
+        @expression.to_s
+      end
+    end
+
+    private
+
+    def message_factory
+      @message_factory ||= ExpressionMatcher.message_rules.apply(@expression)
+    end
+  end
+end

data/lib/matcher/matchers/filter_matcher.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Matcher
+  class FilterMatcher < Base
+    include MappingUtils
+
+    def initialize(filter, matcher, negated: false)
+      super()
+
+      @filter = filter
+      @matcher = negated ? ~matcher : matcher
+      @original_matcher = matcher
+      @negated = negated
+    end
+
+    def negate
+      FilterMatcher.new(@filter, @original_matcher, negated: !@negated)
+    end
+
+    def validate(state)
+      actual = state.actual
+
+      unless actual.respond_to?(:each)
+        state.errors << state.expected.responding_to(:each) unless @negated
+        return
+      end
+
+      i = 0
+      mapping = {}
+      items = []
+      failed = false
+
+      actual.each do |act|
+        filter_value = @filter.evaluate(
+          state.values.merge(actual: act, index: i, original: actual),
+        )
+
+        if filter_value
+          mapping[items.length] = i
+          items << act
+        end
+      rescue CallError => e
+        return nil if @negated
+
+        state.errors[i] << e.message_for_errors(act)
+        failed = true
+      ensure
+        i += 1
+      end
+
+      return if failed
+
+      errors = yield(@matcher, items, original: actual)
+
+      unless state.boolean?
+        errors = map_errors(errors) do |nested_error|
+          key = nested_error.key
+
+          next unless index_call?(key)
+
+          original_index = mapping[operand_of(key)]
+
+          if original_index
+            NestedError.new(index_call_to(original_index), nested_error.child)
+          end
+        end
+      end
+
+      state.errors << errors
+    end
+
+    def to_s
+      "#{'~' if @negated}filter(#{@filter}, #{@original_matcher})"
+    end
+
+    private
+
+    def mapped_base
+      @mapped_base ||= map_base(:filter, @filter)
+    end
+  end
+
+  module MatcherDsl
+    # Matches only filtered elements
+    # == +expression+ values
+    # - actual
+    # - index
+    # - original
+    # == +matcher+ values
+    # - original
+    # @example
+    #   # matches [1, 2, 3, 4, 5]
+    #   filter(_.odd?, [1, 3, 5])
+    #   # alternatively:
+    #   filter(_.odd?) ^ [1, 3, 5]
+    # @overload filter(expression, matcher)
+    #   @param expression [Expression] matches elements for which +expression+
+    #     is truthy
+    #   @param matcher
+    #   @return [FilterMatcher]
+    # @overload filter(expression)
+    #   @param expression [Expression] matches elements for which +expression+
+    #     is truthy
+    #   @return [Chain<FilterMatcher>]
+    def filter(expression, matcher = UNDEFINED)
+      return Chain.new { filter(expression, _1) } if
+        Matcher.undefined?(matcher)
+
+      expression = expression_of(expression)
+      matcher = matcher_of(matcher)
+
+      FilterMatcher.new(expression, matcher)
+    end
+  end
+end