matchers 0.1.0.pre.test

data/lib/matcher/matchers/expression_matcher.rb

@@ -0,0 +1,73 @@
+# 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?
+        state.errors << 'invalid' if @negated != !@expression.evaluate(state.values)
+        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
+
+    NEGATED_COMPARISONS = {
+      :== => :!=,
+      :!= => :==,
+      :< => :>=,
+      :> => :<=,
+      :>= => :<,
+      :<= => :>,
+      :=~ => :!~,
+      :!~ => :=~,
+    }.freeze
+
+    def message_factory
+      @message_factory ||= ExpressionMatcher.message_rules.apply(@expression)
+    end
+  end
+end

data/lib/matcher/matchers/filter_matcher.rb

@@ -0,0 +1,111 @@
+# 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)]
+
+          NestedError.new(index_call_to(original_index), nested_error.child) if original_index
+        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 MatcherBuilding
+    # 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

data/lib/matcher/matchers/hash_matcher.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Matcher
+  class HashMatcher < Base
+    def initialize(hash, partial: false, negated: false)
+      super()
+
+      @hash = negated ? hash.transform_values(&:~) : hash
+      @original_hash = hash
+      @partial = partial
+      @negated = negated
+      @includes_others = hash.include?(Others.instance)
+      @includes_optionals = hash.each_key.any? { _1.is_a?(Optional) }
+      @includes_expressions = hash.each_key.any? { _1.is_a?(Expression) }
+
+      raise 'cannot use partial(others => ...)' if @partial && @includes_others
+    end
+
+    def negate
+      HashMatcher.new(@original_hash, partial: @partial, negated: !@negated)
+    end
+
+    def validate(state, &)
+      return validate_negated(state, &) if @negated
+
+      actual = state.actual
+
+      unless actual.is_a?(Hash)
+        state.errors << state.expected.kind_of(Hash)
+        return
+      end
+
+      if @includes_expressions
+        expression_values = {}
+
+        @hash.each_key.with_index do |key, i|
+          key = key.value if key.is_a?(Optional)
+          expression_values[i] = key.evaluate(state.values) if key.is_a?(Expression)
+        end
+      end
+
+      expected_keys = if @includes_optionals || @includes_expressions
+        @hash.keys.map.with_index do |k, i|
+          k = k.value if k.is_a?(Optional)
+          k = expression_values[i] if k.is_a?(Expression)
+          k
+        end
+      else
+        @hash.keys
+      end
+
+      extra_keys = actual.keys - expected_keys
+
+      if !@partial && !@includes_others
+        extra_keys.each do |key|
+          state.errors[key] << state.expected.not.having_key(key)
+        end
+      end
+
+      @hash.each_with_index do |(key, value), i|
+        if key.is_a?(Others)
+          state.errors << yield(value, actual.slice(*extra_keys))
+
+          next
+        end
+
+        is_optional = key.is_a?(Optional)
+        key = key.value if is_optional
+        error_key = key
+        key = expression_values[i] if key.is_a?(Expression)
+        actual_value = actual[key]
+
+        if actual_value.nil? && !actual.key?(key)
+          state.errors << state.expected.having_key(key) unless is_optional
+        else
+          error = yield(value, actual_value, key:, parent: actual)
+
+          next if error.valid?
+
+          error_key = key_call_for(error_key) if error_key.is_a?(Expression)
+
+          state.errors[error_key] << error
+        end
+      end
+    end
+
+    def to_s
+      if @negated
+        @partial ? "~partial(#{@original_hash})" : "neg(#{@original_hash})"
+      else
+        @partial ? "partial(#{@hash})" : @hash.to_s
+      end
+    end
+
+    private
+
+    def validate_negated(state)
+      actual = state.actual
+
+      return unless actual.is_a?(Hash)
+
+      if @hash.empty?
+        if @partial
+          state.errors << state.report.kind_of(Hash)
+        elsif actual.empty?
+          state.errors << state.report.predicate(:empty?)
+        end
+
+        return
+      end
+
+      if @includes_expressions
+        expression_values = {}
+
+        @hash.each_key.with_index do |key, i|
+          key = key.value if key.is_a?(Optional)
+          expression_values[i] = key.evaluate(state.values) if key.is_a?(Expression)
+        end
+      end
+
+      expected_keys = if @includes_optionals || @includes_expressions
+        @hash.keys.map.with_index do |k, i|
+          k = k.value if k.is_a?(Optional)
+          k = expression_values[i] if k.is_a?(Expression)
+          k
+        end
+      else
+        @hash.keys
+      end
+
+      extra_keys = actual.keys - expected_keys
+
+      return if !@partial && !@includes_others && !extra_keys.empty?
+
+      collector = state.new_collector.or!
+
+      @hash.each_with_index do |(key, value), i|
+        if key.is_a?(Others)
+          result = yield(value, actual.slice(*extra_keys))
+
+          return if result.valid?
+
+          collector << result
+
+          next
+        end
+
+        is_optional = key.is_a?(Optional)
+        key = key.value if is_optional
+        error_key = key
+        key = expression_values[i] if key.is_a?(Expression)
+        actual_value = actual[key]
+
+        if actual_value.nil? && !actual.key?(key)
+          next if is_optional
+
+          return
+        end
+
+        result = yield(value, actual_value, key:, parent: actual)
+
+        return if result.valid?
+
+        error_key = key_call_for(error_key) if error_key.is_a?(Expression)
+
+        collector[error_key] << result
+      end
+
+      state.errors << if collector.empty?
+        state.report.predicate(:empty?)
+      else
+        collector.error
+      end
+    end
+
+    def key_call_for(key)
+      Call.new(Variable.actual, :[], [key])
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Matches hash partially
+    # @example
+    #   # matches { foo: 1, bar: 2 } but not { foo: 0, bar: 2 }
+    #   partial(foo: 1)
+    # @param hash [Hash]
+    # @return [HashMatcher]
+    def partial(hash)
+      hash = hash.to_h do |k, v|
+        [expression_or_value(k), matcher_of(v)]
+      end
+
+      HashMatcher.new(hash, partial: true)
+    end
+
+    ##
+    # Matches nested hashes partially
+    # @example
+    #   # matches { foo: { bar: 1, baz: 2 }, qux: 3 }
+    #   partial_r(foo: { bar: 1 })
+    #   # equivalent to:
+    #   partial(foo: partial(bar: 1))
+    # @param hash [Hash]
+    # @return [HashMatcher]
+    def partial_r(hash)
+      hash = hash.to_h do |k, v|
+        [expression_or_value(k), partial_r_helper(v)]
+      end
+
+      HashMatcher.new(hash, partial: true)
+    end
+
+    def partial_r_helper(value)
+      if Recorder.recorder?(value) || !value.is_a?(Hash)
+        matcher_of(value)
+      else
+        partial_r(value)
+      end
+    end
+    private :partial_r_helper
+  end
+end

data/lib/matcher/matchers/imply_matcher.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ImplyMatcher < Base
+    attr_reader :condition, :matcher
+
+    def initialize(condition, matcher, negated: false)
+      super()
+
+      @condition = condition
+      @matcher = negated ? ~matcher : matcher
+      @original_matcher = matcher
+      @negated = negated
+    end
+
+    def negate
+      ImplyMatcher.new(@condition, @original_matcher, negated: !@negated)
+    end
+
+    def validate(state, &)
+      return validate_negated(state, &) if @negated
+
+      if @condition.is_a?(ExpressionMatcher)
+        begin
+          # evaluate expression directly
+          return unless @condition.expression.evaluate(state.values)
+        rescue CallError
+          return
+        end
+      else
+        return unless yield(@condition).valid?
+      end
+
+      state.errors << yield(@matcher)
+    end
+
+    def to_s
+      "#{'~' if @negated}imply(#{@condition}, #{@original_matcher})"
+    end
+
+    private
+
+    def validate_negated(state)
+      condition_errors = yield @condition
+
+      state.errors << if condition_errors.valid?
+        yield(@matcher)
+      else
+        condition_errors
+      end
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Matches only for given condition. Passes otherwise.
+    # @example
+    #   # matches "hello" and 42 but not "hi"
+    #   imply(String, _.length <= 4)
+    #   # alternatively:
+    #   imply(String) ^ (_.length <= 4)
+    # @overload imply(condition, matcher)
+    #   @param condition [Expression]
+    #   @param matcher [Base]
+    #   @return [ImplyMatcher]
+    # @overload imply(condition)
+    #   @param condition [Expression]
+    #   @return [Chain<ImplyMatcher>]
+    # @see Base#>>
+    # @see #imply_one
+    # @see #imply_any
+    def imply(condition, matcher = UNDEFINED)
+      return Chain.new { imply(condition, _1) } if Matcher.undefined?(matcher)
+
+      condition = matcher_of(condition)
+      matcher = matcher_of(matcher)
+
+      ImplyMatcher.new(condition, matcher)
+    end
+  end
+end

data/lib/matcher/matchers/imply_some_matcher.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ImplySomeMatcher < Base
+    def self.check(matchers, else_matcher, count)
+      raise "count must be a positive integer or :any. Got #{count.inspect}" if
+        count != :any && (!count.is_a?(Integer) || count <= 0)
+
+      raise 'else cannot be combined with count > 1' if
+        else_matcher && count != :any && count != 1
+
+      invalid_matcher = matchers.find { !_1.is_a?(ImplyMatcher) }
+
+      raise "Not an ImplyMatcher: #{invalid_matcher.inspect}" if invalid_matcher
+    end
+
+    def initialize(matchers, else_matcher, count)
+      ImplySomeMatcher.check(matchers, else_matcher, count)
+
+      super()
+
+      @matchers = matchers
+      @else_matcher = else_matcher
+      @count = count
+    end
+
+    def negate
+      NegatedImplySomeMatcher.new(@matchers, @else_matcher, @count)
+    end
+
+    def validate(state)
+      errors = state.errors
+      matchers = @matchers.filter { yield(_1.condition).valid? }
+
+      if matchers.empty?
+        errors << if @else_matcher
+          yield @else_matcher
+        else
+          state.report.namespace(:imply_some).no_condition_satisfied(@matchers.map(&:condition), @count)
+        end
+
+        return
+      elsif @count != :any && matchers.length != @count
+        errors << state.report.namespace(:imply_some).x_conditions_satisfied(matchers.map(&:condition), @count)
+      end
+
+      matchers.each { errors << yield(_1.matcher) }
+    end
+
+    def to_s
+      args = @matchers.map(&:to_s)
+
+      case @count
+      when :any
+        method = 'imply_any'
+      when 1
+        method = 'imply_one'
+      else
+        method = 'imply_some'
+        args << "count: #{@count}"
+      end
+
+      args << "else: #{@else_matcher}" if @else_matcher
+
+      "#{method}(#{args.join(', ')})"
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Matches exactly one implied matcher
+    # @example
+    #   # matches "foo" and 1 but not "BAR", -1, or nil
+    #   imply_one(
+    #     imply(String, _ == _.downcase),
+    #     imply(Integer, _.positive?),
+    #   )
+    # @param *matchers [ImplyMatcher]
+    # @param else [Base] if no condition passed match against +else+ matcher.
+    # @return [ImplySomeMatcher]
+    # @see #imply
+    def imply_one(*matchers, else: UNDEFINED)
+      els = { else: }[:else]
+      else_matcher = Matcher.undefined?(els) ? nil : matcher_of(els)
+
+      ImplySomeMatcher.new(matchers, else_matcher, 1)
+    end
+
+    ##
+    # Matches at least one implied matcher
+    # @example
+    #   # matches 9, 12, 40 but not 8, 21, 15.5
+    #   imply_any(
+    #     imply(_.even?, _ > 10),
+    #     imply(_ % 3 == 0, _ < 20),
+    #   )
+    # @param *matchers [ImplyMatcher]
+    # @param else [Base] if no condition passed match against +else+ matcher.
+    # @return [ImplySomeMatcher]
+    # @see #imply
+    def imply_any(*matchers, else: UNDEFINED)
+      els = { else: }[:else]
+      else_matcher = Matcher.undefined?(els) ? nil : matcher_of(els)
+
+      ImplySomeMatcher.new(matchers, else_matcher, :any)
+    end
+
+    def imply_some(*matchers, count:)
+      ImplySomeMatcher.new(matchers, nil, count)
+    end
+  end
+end