matchers 0.1.0.pre.test

data/lib/matcher/matchers/index_by_matcher.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Matcher
+  class IndexByMatcher < Base
+    include MappingUtils
+
+    def initialize(projection, matcher, negated: false)
+      super()
+
+      @projection = projection
+      @matcher = negated ? ~matcher : matcher
+      @original_matcher = matcher
+      @negated = negated
+    end
+
+    def negate
+      IndexByMatcher.new(@projection, @original_matcher, 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
+
+      values = state.values
+      failed = false
+      index = {}
+      mapping = {}
+      duplicates = []
+
+      actual.each_with_index do |item, i|
+        key = @projection.evaluate(
+          values.merge(actual: item, index: i, original: actual),
+        )
+
+        mapped_index = mapping[key]
+
+        if mapped_index
+          duplicates << [key, i, mapped_index]
+        else
+          index[key] = item
+          mapping[key] = i
+        end
+
+        key
+      rescue CallError => e
+        state.errors[i] << e.message_for_errors(item)
+        failed = true
+      end
+
+      duplicates.each do |key, i, j|
+        state.errors[i] << state.expected(actual[i]).not.duplicate_by(@projection, key, j)
+      end
+
+      return if failed
+
+      errors = yield(@matcher, index, original: actual)
+      errors = map_errors2(errors, mapping) unless state.boolean?
+
+      state.errors << errors
+    end
+
+    def to_s
+      "#{'~' if @negated}index_by(#{@projection}, #{@original_matcher})"
+    end
+
+    private
+
+    def validate_negated(state)
+      actual = state.actual
+
+      return unless actual.respond_to?(:each)
+
+      values = state.values
+      index = {}
+      mapping = {}
+
+      actual.each_with_index do |item, i|
+        key = @projection.evaluate(
+          values.merge(actual: item, index: i, original: actual),
+        )
+
+        return nil if mapping.key?(key)
+
+        index[key] = item
+        mapping[key] = i
+
+        key
+      rescue CallError
+        return nil
+      end
+
+      errors = yield(@matcher, index, original: actual)
+
+      state.errors << map_errors2(errors, mapping)
+    end
+
+    def map_errors2(error, mapping)
+      map_errors(error) do |nested_error|
+        key = nested_error.key
+
+        next unless index_call?(key)
+
+        index = mapping[operand_of(key)]
+
+        NestedError.new(index_call_to(index), nested_error.child) if index
+      end
+    end
+
+    def mapped_base
+      return @mapped_base if @mapped_base
+
+      expression = @projection
+      with_index = expression.variables.include?(:index)
+      element = expression.free_symbol(:e)
+      parameters = [[:opt, element]]
+      parameters << %i[opt index] if with_index
+      substituted = expression.substitute(actual: element, original: :actual)
+      pair = ArrayExpression.new([substituted, Variable.new(element)])
+      block = Block.new(parameters, pair)
+
+      map = if with_index
+        enum_for_map = Call.new(Variable.actual, :map)
+        Call.new(enum_for_map, :with_index, [], {}, block)
+      else
+        Call.new(Variable.actual, :map, [], {}, block)
+      end
+
+      @mapped_base = Call.new(map, :to_h)
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Matches against an indexed version of actual.
+    #
+    # This is really useful when validating an array of items where the order
+    # shouldn't matter.
+    # @example
+    #   # matches:
+    #   # [
+    #   #   { name: "bar", value: 2 },
+    #   #   { name: "foo", value: 1 },
+    #   # ]
+    #   index_by(_[:name], {
+    #     "foo" => { name: "foo", value: 1 },
+    #     "bar" => { name: "bar", value: 2 },
+    #   })
+    #   # alternatively:
+    #   index_by(_[:name]) ^ {
+    #     "foo" => { name: "foo", value: 1 },
+    #     "bar" => { name: "bar", value: 2 },
+    #   }
+    # @overload index_by(expression, matcher)
+    #   @param expression [Expression]
+    #   @param matcher [Base]
+    #   @return [IndexByMatcher]
+    # @overload index_by(expression)
+    #   @param expression [Expression]
+    #   @return [Chain<IndexByMatcher>]
+    def index_by(expression, matcher = UNDEFINED)
+      return Chain.new { index_by(expression, _1) } if Matcher.undefined?(matcher)
+
+      expression = expression_of(expression)
+      matcher = matcher_of(matcher)
+
+      IndexByMatcher.new(expression, matcher)
+    end
+  end
+end

data/lib/matcher/matchers/inline_matcher.rb

@@ -0,0 +1,99 @@
+# 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, y)
+        @matcher = matcher
+        @state = state
+        @yield = y
+      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)
+        @yield.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 MatcherBuilding
+    ##
+    # 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] optionaly 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,121 @@
+# frozen_string_literal: true
+
+module Matcher
+  class KeysMatcher < Base
+    def initialize(keys, partial: false, negated: false)
+      super()
+
+      @keys = keys
+      @partial = partial
+      @negated = negated
+      @includes_expressions = keys.any? { _1.is_a?(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 MatcherBuilding
+    ##
+    # 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,68 @@
+# 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 &(matcher)
+      matcher = Matcher.cache(matcher)
+
+      if matcher.is_a?(LazyAllMatcher)
+        LazyAllMatcher.new(@matchers + matcher.matchers)
+      else
+        LazyAllMatcher.new(@matchers + [matcher])
+      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.map(&:to_s).join(', ')})"
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # 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,68 @@
+# 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 |(matcher)
+      matcher = Matcher.cache(matcher)
+
+      if matcher.is_a?(LazyAnyMatcher)
+        LazyAnyMatcher.new(@matchers + matcher.matchers)
+      else
+        LazyAnyMatcher.new(@matchers + [matcher])
+      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.map(&:to_s).join(', ')})"
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # 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 MatcherBuilding
+    ##
+    # Sets values for 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