matchers 0.1.0.pre.1

data/lib/matcher/matchers/inline_matcher.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Matcher
+  class InlineMatcher < Base
+    def initialize(matcher = nil, negatable: false, negated: false, &block)
+      raise "no block given" unless block_given?
+
+      super()
+
+      @matcher = matcher
+      @negated = negated
+      @negatable = negatable
+      @block = block
+    end
+
+    attr_reader :matcher, :negated
+
+    def negate
+      return super unless @negatable
+
+      InlineMatcher.new(
+        @matcher&.~, negatable: @negatable, negated: !@negated, &@block
+      )
+    end
+
+    def receiver
+      @block.binding.receiver
+    end
+
+    class InlineContext
+      extend Forwardable
+
+      def initialize(matcher, state, block)
+        @matcher = matcher
+        @state = state
+        @block = block
+      end
+
+      attr_reader :state
+
+      def_delegators :@state, *State.public_instance_methods(false) - %i[result]
+      def_delegators :@matcher, :receiver, :matcher, :negated
+
+      def _yield(matcher, act = @state.actual, **values)
+        @block.call(matcher, act, **values)
+      end
+    end
+
+    def validate(state, &block)
+      context = InlineContext.new(self, state, block)
+      context.instance_exec(&@block)
+    end
+
+    def to_s
+      args = if @matcher
+        "(#{@negated ? ~@matcher : @matcher})"
+      else
+        ""
+      end
+
+      "#{'~' if @negated}inline#{args} { #{Utils.block_location(@block)} }"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Creates an anonymous custom matcher
+    #
+    # If you need more control to define your matching logic then +inline+
+    # may give you an alternative to implementing a new matcher class. Within
+    # the +inline+ block you have direct access to +actual+, +errors+, +_yield+,
+    # and other state methods.
+    #
+    # @example
+    #   # matches distinct arrays
+    #   inline do
+    #     indices = Hash.new
+    #
+    #     actual.each_with_index do |e, i|
+    #       if (original_index = indices[e])
+    #         errors[i] << expected.not.duplicate(original_index)
+    #       else
+    #         indices[e] = i
+    #       end
+    #     end
+    #   end
+    #
+    # @param matcher [Base] optionally provide a child matcher. Call the matcher
+    #   with +_yield matcher, actual, **values+
+    # @param negatable [true, false] set to true if your matching logic respects
+    #   the negated flag. Otherwise, the default negation implementation is
+    #   used. When +negated = true+ the child matcher is automatically negated.
+    # @yield inline context
+    # @return [InlineMatcher]
+    def inline(matcher = UNDEFINED, negatable: false, &)
+      matcher = Matcher.undefined?(matcher) ? nil : matcher_of(matcher)
+
+      InlineMatcher.new(matcher, negatable:, &)
+    end
+  end
+end

data/lib/matcher/matchers/keys_matcher.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Matcher
+  ##
+  # Match hash keys.
+  # @example
+  #   m = Matcher.build { keys(:foo, :bar) }
+  #
+  #   m.match?({ foo: 1, bar: 2 })
+  #   # => true
+  #   m.match({ foo: 1, qux: 3 })
+  #   # > root: expected to include key :bar but got {:foo=>1, :qux=>3}
+  #   # > root: did not expect to include key :qux but got {:foo=>1, :qux=>3}
+  class KeysMatcher < Base
+    def initialize(keys, partial: false, negated: false)
+      super()
+
+      @keys = keys
+      @partial = partial
+      @negated = negated
+      @includes_expressions = keys.any?(Expression)
+    end
+
+    def negate
+      KeysMatcher.new(@keys, 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
+
+      actual_keys = actual.keys
+
+      expected_keys = if @includes_expressions
+        @keys.map { _1.is_a?(Expression) ? _1.evaluate(state.values) : _1 }
+      else
+        @keys
+      end
+
+      (expected_keys - actual_keys).each do |key|
+        state.errors << state.expected.having_key(key)
+      end
+
+      return if @partial
+
+      (actual_keys - expected_keys).each do |key|
+        state.errors << state.expected.not.having_key(key)
+      end
+    end
+
+    def to_s
+      helper = @partial ? "partial_keys" : "keys"
+      args = @keys.map(&:inspect).join(", ")
+
+      "#{'~' if @negated}#{helper}(#{args})"
+    end
+
+    private
+
+    def validate_negated(state)
+      actual = state.actual
+
+      return unless actual.is_a?(Hash)
+
+      actual_keys = actual.keys
+
+      expected_keys = if @includes_expressions
+        @keys.map { _1.is_a?(Expression) ? _1.evaluate(state.values) : _1 }
+      else
+        @keys
+      end
+
+      if @partial
+        return unless (expected_keys - actual_keys).empty?
+
+        state.errors.or!
+
+        (actual_keys & expected_keys).each do |key|
+          state.errors << state.expected.not.having_key(key)
+        end
+      else
+        return if actual_keys != expected_keys
+
+        state.errors.or!
+
+        actual_keys.each do |key|
+          state.errors << state.expected.not.having_key(key)
+        end
+      end
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches all keys of a hash
+    # @example
+    #   # matches { foo: 1, bar: 2 } but not { foo: 1, qux: 3 }
+    #   keys(:foo, :bar)
+    #   # using key expression, matches { "the_key" => 23 }
+    #   let(my_key: :the_key) ^ keys(vars[:my_key].to_s)
+    # @param keys [Array] supports expressions
+    # @param partial [true, false] ignores extra keys when +true+
+    # @return [KeysMatcher]
+    # @see #partial_keys
+    def keys(*keys, partial: false)
+      keys.each_with_index do |key, i|
+        keys[i] = expression_or_value(key)
+      end
+
+      KeysMatcher.new(keys, partial:)
+    end
+
+    ##
+    # Matches hash if all given keys are included. Ignores extra keys.
+    # @example
+    #   # matches { foo: 1, bar: 2 } but not { bar: 2 }
+    #   partial_keys(:foo)
+    # @param keys [Array] supports expressions
+    # @return [KeysMatcher]
+    # @see #keys
+    def partial_keys(*keys)
+      keys(*keys, partial: true)
+    end
+  end
+end

data/lib/matcher/matchers/kind_of_matcher.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Matcher
+  class KindOfMatcher < Base
+    def self.cache(kind, matcher_cache = MatcherCache.current)
+      return new(kind) unless matcher_cache
+
+      (matcher_cache.kind_of_matchers ||= {})[kind] ||= new(kind)
+    end
+
+    def initialize(kind, negated: false)
+      super()
+
+      @kind = kind
+      @negated = negated
+    end
+
+    def negate
+      KindOfMatcher.new(@kind, negated: !@negated)
+    end
+
+    def validate(state)
+      state.errors << state.expected.not_if(@negated).kind_of(@kind) if
+        state.actual.is_a?(@kind) == @negated
+    end
+
+    def to_s
+      if @negated
+        "neg(#{@kind})"
+      else
+        @kind.to_s
+      end
+    end
+  end
+end

data/lib/matcher/matchers/lazy_all_matcher.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Matcher
+  class LazyAllMatcher < Base
+    def initialize(matchers)
+      super()
+
+      @matchers = matchers
+    end
+
+    attr_reader :matchers
+
+    def negate
+      LazyAnyMatcher.new(@matchers.map(&:~))
+    end
+
+    def &(other)
+      other = Matcher.cache(other)
+
+      if other.is_a?(LazyAllMatcher)
+        LazyAllMatcher.new(@matchers + other.matchers)
+      else
+        LazyAllMatcher.new(@matchers + [other])
+      end
+    end
+
+    def validate(state)
+      last_error = EmptyError.instance
+
+      @matchers.each do |matcher|
+        last_error = yield matcher
+
+        break unless last_error.valid?
+      end
+
+      state.errors << last_error
+    end
+
+    def to_s
+      "lazy_all(#{@matchers.join(', ')})"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches all matchers lazily. Returns only the last match result
+    # (similar to &&).
+    # @example
+    #   # matches 3 but not "foo"
+    #   lazy_all(Integer, _ % 3 == 0)
+    #   # alternatively:
+    #   of(Integer) & _.positive?
+    # @param matchers [Array<Base>]
+    # @return [LazyAllMatcher]
+    # @see Base#&
+    # @see #lazy_any
+    # @see #all
+    def lazy_all(*matchers)
+      case matchers.length
+      when 0
+        AlwaysMatcher.instance
+      when 1
+        matcher_of(matchers[0])
+      else
+        LazyAllMatcher.new(matchers.map { matcher_of(_1) })
+      end
+    end
+  end
+end

data/lib/matcher/matchers/lazy_any_matcher.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Matcher
+  class LazyAnyMatcher < Base
+    def initialize(matchers)
+      super()
+
+      @matchers = matchers
+    end
+
+    attr_reader :matchers
+
+    def negate
+      LazyAllMatcher.new(@matchers.map(&:~))
+    end
+
+    def |(other)
+      other = Matcher.cache(other)
+
+      if other.is_a?(LazyAnyMatcher)
+        LazyAnyMatcher.new(@matchers + other.matchers)
+      else
+        LazyAnyMatcher.new(@matchers + [other])
+      end
+    end
+
+    def validate(state)
+      last_error = EmptyError.instance
+
+      @matchers.each do |matcher|
+        last_error = yield matcher
+
+        break if last_error.valid?
+      end
+
+      state.errors << last_error
+    end
+
+    def to_s
+      "lazy_any(#{@matchers.join(', ')})"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches any matcher lazily. Returns only the last match result
+    # (similar to ||).
+    # @example
+    #   # matches "foo" and 42 but not +nil+ or +true+
+    #   lazy_any(String, Integer)
+    #   # alternatively:
+    #   of(String) | of(Integer)
+    # @param matchers [Array<Base>]
+    # @return [LazyAnyMatcher]
+    # @see Base#|
+    # @see #lazy_all
+    # @see #any
+    def lazy_any(*matchers)
+      case matchers.length
+      when 0
+        AlwaysMatcher.instance
+      when 1
+        matcher_of(matchers[0])
+      else
+        LazyAnyMatcher.new(matchers.map { matcher_of(_1) })
+      end
+    end
+  end
+end

data/lib/matcher/matchers/let_matcher.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Matcher
+  class LetMatcher < Base
+    def initialize(assigns, matcher)
+      super()
+
+      @assigns = assigns
+      @matcher = matcher
+    end
+
+    def negate
+      LetMatcher.new(@assigns, ~@matcher)
+    end
+
+    def validate(state)
+      assigns = @assigns.transform_values do |v|
+        v = Expression.try_recorder(v)
+
+        case v
+        when Proc
+          Utils.call_block(v, state.values)
+        when Expression
+          v.evaluate(state.values)
+        else
+          v
+        end
+      end
+
+      state.errors << yield(@matcher, **assigns)
+    end
+
+    def to_s
+      assign_parts = @assigns.map do |key, value|
+        if value.is_a?(Proc)
+          "#{key}: ->(#{Utils.inspect_block_params(value)}) { ... }"
+        else
+          "#{key}: #{value.inspect}"
+        end
+      end
+
+      "let(#{assign_parts.join(', ')}) ^ #{Matcher.parenthesize(@matcher)}"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Sets values for the given matcher
+    # @example
+    #   # matches 1
+    #   let({ a: 1 }, _ == vars[:a])
+    #   # alternatively:
+    #   let(a: 1) ^ (_ == vars[:a])
+    # @overload let(assigns, matcher)
+    #   @param assigns [Hash]
+    #   @param matcher [Base]
+    #   @return [LetMatcher]
+    # @overload let(**kwargs)
+    #   @param kwargs [Hash] same as assigns
+    #   @return [Chain<LetMatcher>]
+    def let(assigns = nil, matcher = UNDEFINED, **kwargs)
+      raise "Cannot set both assigns and kwargs" if assigns && !kwargs.empty?
+
+      assigns ||= kwargs
+
+      return Chain.new { let(assigns, _1) } if Matcher.undefined?(matcher)
+
+      matcher = matcher_of(matcher)
+
+      LetMatcher.new(assigns, matcher)
+    end
+  end
+end

data/lib/matcher/matchers/map_matcher.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Matcher
+  ##
+  # Map items to another value before matching.
+  # @example
+  #   m = Matcher.build { map(_.to_i, [1, 2]) } # OR
+  #   m = Matcher.build { map(_.to_i) ^ [1, 2] }
+  #
+  #   m.match?(["1", "2"])
+  #   # => true
+  #   m.match(["1", :foo])
+  #   # > root[1]: expected an object responding to 'to_i' but got :foo
+  #   m.match(["1", "3"])
+  #   # > root[1].to_i: expected 2 but got 3
+  #
+  #   m = Matcher.build { map(_.to_i, _.sum == 3) }
+  #   m.match?(["1", "2"])
+  #   # => true
+  #   m.match(["1", "2", "3"])
+  #   # > root.map(&:to_i): expected actual.sum == 3 but got 6 == 3,
+  #   #   where actual = [1, 2, 3]
+  class MapMatcher < Base
+    include MappingUtils
+
+    def initialize(projection, matcher, negated: false)
+      super()
+
+      @projection = projection
+      @matcher = negated ? ~matcher : matcher
+      @original_matcher = matcher
+      @negated = negated
+    end
+
+    def negate
+      MapMatcher.new(@projection, @original_matcher, negated: !@negated)
+    end
+
+    def validate(state, &)
+      return validate_negated(state, &) if @negated
+
+      actual = state.actual
+      values = state.values
+
+      unless actual.respond_to?(:each)
+        state.errors << state.expected.responding_to(:each)
+        return
+      end
+
+      i = 0
+      mapped = []
+      mapping_failed = false
+
+      actual.each do |act|
+        mapped << @projection.evaluate(
+          values.merge(actual: act, index: i, original: actual),
+        )
+      rescue CallError => e
+        state.errors[i] << e.message_for_errors(act)
+        mapping_failed = true
+      ensure
+        i += 1
+      end
+
+      return if mapping_failed
+
+      errors = yield @matcher, mapped, original: actual
+      errors = map_errors2(errors) unless state.boolean?
+
+      state.errors << errors
+    end
+
+    def to_s
+      "#{'~' if @negated}map(#{@projection}, #{@original_matcher})"
+    end
+
+    private
+
+    def validate_negated(state)
+      actual = state.actual
+      values = state.values
+
+      return unless actual.respond_to?(:map)
+
+      mapped = []
+
+      actual.map.with_index do |item, i|
+        mapped << @projection.evaluate(
+          values.merge(actual: item, index: i, original: actual),
+        )
+      rescue CallError
+        return nil if @negated
+      end
+
+      mapped_errors = yield @matcher, mapped, original: actual
+
+      state.errors << map_errors2(mapped_errors)
+    end
+
+    def map_errors2(errors)
+      map_errors(errors) do |nested_error|
+        key = nested_error.key
+
+        next unless index_call?(key)
+
+        NestedError.new(
+          key,
+          NestedError.new(@projection, nested_error.child),
+        )
+      end
+    end
+
+    def mapped_base
+      @mapped_base ||= map_base(:map, @projection)
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Maps items to another value before matching
+    # == +expression+ values
+    # - actual
+    # - index
+    # - original
+    # == +matcher+ values
+    # - original
+    # @example
+    #   # matches ["1", "2"]
+    #   map(_.to_i, [1, 2])
+    #   # alternatively:
+    #   map(_.to_i) ^ [1, 2]
+    # @overload map(expression, matcher)
+    #   @param expression [Expression]
+    #   @param matcher [Base]
+    #   @return [MapMatcher]
+    # @overload map(expression)
+    #   @param expression [Expression]
+    #   @return [Chain<MapMatcher>]
+    def map(expression, matcher = UNDEFINED)
+      return Chain.new { map(expression, _1) } if Matcher.undefined?(matcher)
+
+      expression = expression_of(expression)
+      matcher = matcher_of(matcher)
+
+      MapMatcher.new(expression, matcher)
+    end
+  end
+end

data/lib/matcher/matchers/negated_array_matcher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Matcher
+  class NegatedArrayMatcher < Base
+    def initialize(array)
+      super()
+
+      @array = array
+      @neg_array = @array.map(&:~)
+    end
+
+    def negate
+      ArrayMatcher.new(@array)
+    end
+
+    def validate(state)
+      actual = state.actual
+
+      return if !actual.is_a?(Array) || @array.length != actual.length
+
+      collector = state.new_collector.or!
+
+      @array.length.times do |i|
+        result = yield @neg_array[i], actual[i], index: i, parent: actual
+
+        return nil if result.valid?
+
+        collector[i] << result
+      end
+
+      state.errors << collector.error
+    end
+
+    def to_s
+      "neg(#{@array})"
+    end
+  end
+end

data/lib/matcher/matchers/negated_each_matcher.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Matcher
+  class NegatedEachMatcher < Base
+    def initialize(matcher)
+      super()
+
+      @matcher = matcher
+      @neg_matcher = ~matcher
+    end
+
+    def negate
+      EachMatcher.new(@matcher)
+    end
+
+    def validate(state)
+      return unless state.actual.respond_to?(:each)
+
+      collector = state.new_collector.or!
+
+      state.actual.each.with_index do |item, i|
+        result = yield @neg_matcher, item, index: i, parent: state.actual
+
+        return nil if result.valid?
+
+        collector[i] << result
+      end
+
+      state.errors << collector.error
+    end
+
+    def to_s
+      "~each(#{@matcher})"
+    end
+  end
+end