matchers 0.1.0.pre.test

data/lib/matcher/matchers/map_matcher.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Matcher
+  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 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 MatcherBuilding
+    ##
+    # 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/matcher_building.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Matcher
+  module MatcherBuilding 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 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 if result.valid?
+
+        collector[i] << result
+      end
+
+      state.errors << collector.error
+    end
+
+    def to_s
+      "~each(#{@matcher})"
+    end
+  end
+end

data/lib/matcher/matchers/negated_each_pair_matcher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Matcher
+  class NegatedEachPairMatcher < Base
+    def initialize(matcher)
+      super()
+
+      @matcher = matcher
+      @neg_matcher = ~matcher
+    end
+
+    def negate
+      EachPairMatcher.new(@matcher)
+    end
+
+    def validate(state)
+      actual = state.actual
+
+      return unless actual.respond_to?(:each_pair)
+
+      collector = state.new_collector.or!
+
+      actual.each do |key, value|
+        result = yield(@neg_matcher, [key, value], key:, value:, parent: actual)
+
+        return if result.valid?
+
+        collector[key] << result
+      end
+
+      state.errors << collector.error
+    end
+
+    def to_s
+      "~each_pair(#{@matcher})"
+    end
+  end
+end

data/lib/matcher/matchers/negated_imply_some_matcher.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Matcher
+  class NegatedImplySomeMatcher < Base
+    def initialize(matchers, else_matcher, count)
+      ImplySomeMatcher.check(matchers, else_matcher, count)
+
+      super()
+
+      @matchers = matchers
+      @neg_matchers = matchers.map(&:~)
+      @count = count
+      @else_matcher = else_matcher
+      @neg_else_matcher = @else_matcher&.~
+    end
+
+    def negate
+      ImplySomeMatcher.new(@matchers, @else_matcher, @count)
+    end
+
+    def validate(state)
+      matchers = @neg_matchers.filter { yield(_1.condition).valid? }
+
+      if matchers.empty?
+        state.errors << yield(@neg_else_matcher) if @else_matcher
+      elsif @count == :any || matchers.length == @count
+        state.errors.or!
+
+        matchers.each do |matcher|
+          error = yield(matcher)
+
+          if error.valid?
+            state.errors.clear
+            break
+          end
+
+          state.errors << error
+        end
+      end
+    end
+
+    def to_s
+      "~#{self.~}"
+    end
+  end
+end

data/lib/matcher/matchers/negated_matcher.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Matcher
+  class NegatedMatcher < Base
+    def initialize(matcher)
+      super()
+
+      @matcher = matcher
+    end
+
+    def negate
+      @matcher
+    end
+
+    def validate(state)
+      state.errors << state.expected.namespace(:negated).not.valid(@matcher) if yield(@matcher).valid?
+    end
+
+    def to_s
+      "neg(#{@matcher})"
+    end
+  end
+end

data/lib/matcher/matchers/negated_project_matcher.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Matcher
+  class NegatedProjectMatcher < Base
+    def initialize(expression, matcher)
+      super()
+
+      @expression = expression
+      @matcher = matcher
+      @neg_matcher = ~matcher
+    end
+
+    def negate
+      ProjectMatcher.new(@expression, @matcher)
+    end
+
+    def validate(state)
+      begin
+        result = @expression.evaluate(state.values)
+      rescue CallError
+        return
+      end
+
+      state.errors[@expression] << yield(@neg_matcher, result)
+    end
+
+    def to_s
+      "~project(#{@expression} => #{@matcher})"
+    end
+  end
+end

data/lib/matcher/matchers/never_matcher.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Matcher
+  class NeverMatcher < Base
+    include Singleton
+
+    def ~
+      AlwaysMatcher.instance
+    end
+
+    def validate(state)
+      state.errors << state.report.exist
+    end
+
+    def to_s
+      'never'
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Never matches. Opposite of {#always}
+    # @return [NeverMatcher]
+    # @see #always
+    def never
+      NeverMatcher.instance
+    end
+  end
+end

data/lib/matcher/matchers/one_matcher.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Matcher
+  class OneMatcher < Base
+    def initialize(matchers, negated: false)
+      super()
+
+      @matchers = matchers
+      @negated = negated
+    end
+
+    def negate
+      OneMatcher.new(@matchers, negated: !@negated)
+    end
+
+    def validate(state)
+      valid_matchers = []
+      invalid_errors = []
+
+      @matchers.each do |matcher|
+        error = yield matcher
+
+        if error.valid?
+          valid_matchers << matcher
+        else
+          invalid_errors << error
+        end
+      end
+
+      if @negated
+        state.errors << yield(~valid_matchers[0]) if valid_matchers.length == 1
+      else
+        if valid_matchers.length == 0
+          state.errors << OrError.from(invalid_errors)
+        elsif valid_matchers.length > 1
+          negated_matchers = valid_matchers.map(&:~)
+          any_matcher = AnyMatcher.new(negated_matchers)
+
+          state.errors << yield(any_matcher)
+        end
+      end
+    end
+
+    def to_s
+      "#{'~' if @negated}one(#{@matchers.map(&:to_s).join(', ')})"
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Matches exactly one matcher
+    # @example
+    #   # matches [1] and [2] but not [] or [1, 2]
+    #   one(_.include?(1), _.include?(2))
+    # @param matchers [Array<Base>]
+    # @return [OneMatcher]
+    def one(*matchers)
+      matchers = matchers.map { matcher_of(_1) }
+
+      case matchers.count
+      when 0
+        NeverMatcher.instance
+      when 1
+        matchers[0]
+      else
+        OneMatcher.new(matchers)
+      end
+    end
+  end
+end

data/lib/matcher/matchers/optional_matcher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Matcher
+  class OptionalMatcher < Base
+    def self.cache(matcher, matcher_cache = MatcherCache.current)
+      return new(matcher) unless matcher_cache
+
+      cache = (matcher_cache.optional_matchers ||= {}.compare_by_identity)
+      cache[matcher] ||= new(matcher)
+    end
+
+    def initialize(matcher, negated: false)
+      super()
+
+      @matcher = negated ? ~matcher : matcher
+      @original_matcher = matcher
+      @negated = negated
+    end
+
+    def negate
+      OptionalMatcher.new(@original_matcher, negated: !@negated)
+    end
+
+    def validate(state)
+      if state.actual.nil?
+        state.errors << state.expected.not.equal(nil) if @negated
+      else
+        state.errors << yield(@matcher)
+      end
+    end
+
+    def to_s
+      "#{'~' if @negated}optional(#{@original_matcher})"
+    end
+  end
+
+  # see Optional for optional helper
+end

data/lib/matcher/matchers/parse_float_matcher.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ParseFloatMatcher < Base
+    def initialize(matcher, negated: false)
+      super()
+
+      @matcher = negated ? ~matcher : matcher
+      @original_matcher = matcher
+      @negated = negated
+    end
+
+    def negate
+      ParseFloatMatcher.new(@original_matcher, negated: !@negated)
+    end
+
+    def validate(state, &)
+      actual = state.actual
+
+      unless actual.is_a?(String)
+        state.errors << state.expected.kind_of(String) unless @negated
+        return
+      end
+
+      value = Float(actual)
+
+      if @matcher.is_a?(NeverMatcher)
+        state.errors << state.expected.not.valid_format(:float)
+        return
+      end
+
+      result = yield(@matcher, value)
+
+      return if result.valid?
+
+      float_of = Call.new(Constant.new(Kernel), :Float, [Variable.actual])
+      state.errors[float_of] << result
+    rescue ArgumentError
+      state.errors << state.expected.valid_format(:float) unless @negated
+    end
+
+    def to_s
+      prefix = @negated ? '~' : ''
+
+      return "#{prefix}float_format" if @original_matcher.is_a?(AlwaysMatcher)
+
+      "#{prefix}parse_float(#{@original_matcher})"
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Parses float and matches with given matcher.
+    # @example
+    #   # matches "1.0"
+    #   parse_float(_ > 0.0)
+    #   # alternatively:
+    #   parse_float ^ (_ > 0.0)
+    #   # without matcher matches any float string
+    #   parse_float
+    # @overload parse_float(matcher)
+    #   @param matcher [Base]
+    #   @return [ParseFloatMatcher]
+    # @overload parse_float
+    #   @return [OptionalChain<ParseFloatMatcher>]
+    # @see #float_format
+    def parse_float(matcher = UNDEFINED)
+      return Chain.new { parse_float(_1) }.optional if
+        Matcher.undefined?(matcher)
+
+      matcher = matcher_of(matcher)
+
+      ParseFloatMatcher.new(matcher)
+    end
+
+    ##
+    # Matches float strings
+    # @example
+    #   # matches { payload: "1.5" }
+    #   { payload: float_format }
+    # @return [ParseFloatMatcher]
+    def float_format
+      @float_format ||= ParseFloatMatcher.new(AlwaysMatcher.instance)
+    end
+  end
+end

data/lib/matcher/matchers/parse_integer_matcher.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Matcher
+  class ParseIntegerMatcher < Base
+    def initialize(matcher, base: 0, negated: false)
+      super()
+
+      @matcher = negated ? ~matcher : matcher
+      @original_matcher = matcher
+      @base = base
+      @negated = negated
+    end
+
+    def negate
+      ParseIntegerMatcher.new(@original_matcher, base: @base, negated: !@negated)
+    end
+
+    def validate(state, &)
+      actual = state.actual
+
+      unless actual.is_a?(String)
+        state.errors << state.expected.kind_of(String) unless @negated
+        return
+      end
+
+      value = Integer(actual)
+
+      if @matcher.is_a?(NeverMatcher)
+        state.errors << state.expected.not.valid_format(:integer)
+        return
+      end
+
+      result = yield(@matcher, value)
+
+      return if result.valid?
+
+      integer_of = Call.new(Constant.new(Kernel), :Integer, [Variable.actual])
+      state.errors[integer_of] << result
+    rescue ArgumentError
+      state.errors << state.expected.valid_format(:integer) unless @negated
+    end
+
+    def to_s
+      prefix = @negated ? '~' : ''
+
+      if @original_matcher.is_a?(AlwaysMatcher)
+        args = @base == 0 ? '' : "(base: #{@base})"
+        return "#{prefix}integer_format#{args}"
+      end
+
+      base_arg = @base == 0 ? '' : ", base: #{@base}"
+
+      "#{'~' if @negated}parse_integer(#{@original_matcher}#{base_arg})"
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Parses integer and matches with given matcher
+    # @example
+    #   # matches "7"
+    #   parse_integer(_.odd?)
+    #   # alternatively:
+    #   parse_integer ^ (_.odd?)
+    #   # without matcher matches any integer string
+    #   parse_integer
+    # @overload parse_integer(matcher, base: 0)
+    #   @param matcher [Base]
+    #   @param base [Integer]
+    #   @return [ParseIntegerMatcher]
+    # @overload parse_integer(base: 0)
+    #   @return [OptionalChain<ParseIntegerMatcher>]
+    # @see #integer_format
+    def parse_integer(matcher = UNDEFINED, base: 0)
+      return Chain.new { parse_integer(_1, base:) }.optional if
+        Matcher.undefined?(matcher)
+
+      matcher = matcher_of(matcher)
+
+      ParseIntegerMatcher.new(matcher, base:)
+    end
+
+    ##
+    # Matches integer strings
+    # @example
+    #   # matches { payload: "42" }
+    #   { payload: integer_format }
+    # @param base [Integer]
+    # @return [ParseIntegerMatcher]
+    def integer_format(base: 0)
+      if base == 0
+        @integer_format ||= ParseIntegerMatcher.new(AlwaysMatcher.instance, base:)
+      else
+        ParseIntegerMatcher.new(AlwaysMatcher.instance, base:)
+      end
+    end
+  end
+end