matchers 0.1.0.pre.1

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 nil 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,25 @@
+# frozen_string_literal: true
+
+module Matcher
+  class NegatedMatcher < Base
+    def initialize(matcher)
+      super()
+
+      @matcher = matcher
+    end
+
+    def negate
+      @matcher
+    end
+
+    def validate(state)
+      return unless yield(@matcher).valid?
+
+      state.errors << state.expected.namespace(:negated).not.valid(@matcher)
+    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,35 @@
+# 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 MatcherDsl
+    ##
+    # Never matches. Opposite of {#always}
+    #
+    # Where is the use-case for +never+? Can't think of one other than it's
+    # +~always+, and we really want to be able to negate matchers. Some matchers
+    # check whether their child matcher is a NeverMatcher to provide a fitting
+    # error message.
+    #
+    # @return [NeverMatcher]
+    # @see #always
+    def never
+      NeverMatcher.instance
+    end
+  end
+end

data/lib/matcher/matchers/one_matcher.rb

@@ -0,0 +1,68 @@
+# 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
+      elsif 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
+
+    def to_s
+      "#{'~' if @negated}one(#{@matchers.join(', ')})"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # 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 MatcherDsl
+    ##
+    # 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,101 @@
+# 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 MatcherDsl
+    ##
+    # 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

data/lib/matcher/matchers/parse_iso8601_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Matcher
+  autoload :ParseIso8601Matcher, "matcher/matchers/parse_iso8601_matcher"
+
+  module MatcherDsl
+    ##
+    # Parses ISO 8601 time and matches with given matcher
+    # @example
+    #   # matches "1999-12-31T23:59:00+01:00"
+    #   parse_iso8601(_ < expr { Time.now })
+    #   # alternatively:
+    #   parse_iso8601 ^ (_ < expr { Time.now })
+    #   # without matcher matches any valid ISO 8601 string
+    #   parse_iso8601
+    # @overload parse_iso8601(matcher)
+    #   @param matcher [Base]
+    #   @return [ParseIso8601Matcher]
+    # @overload parse_iso8601
+    #   @return [OptionalChain<ParseIso8601Matcher>]
+    # @see #iso8601_format
+    def parse_iso8601(matcher = UNDEFINED)
+      return Chain.new { parse_iso8601(_1) }.optional if
+        Matcher.undefined?(matcher)
+
+      matcher = matcher_of(matcher)
+
+      ParseIso8601Matcher.new(matcher)
+    end
+
+    ##
+    # Matches valid ISO 8601 strings
+    # @example
+    #   # matches { timestamp: "2025-11-16T21:13:33+01:00" }
+    #   { timestamp: iso8601_format }
+    # @return [ParseIso8601Matcher]
+    def iso8601_format
+      @iso8601_format ||= ParseIso8601Matcher.new(AlwaysMatcher.instance)
+    end
+  end
+end

data/lib/matcher/matchers/parse_iso8601_matcher.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Matcher
+  class ParseIso8601Matcher < Base
+    def initialize(matcher, negated: false)
+      super()
+
+      @matcher = negated ? ~matcher : matcher
+      @original_matcher = matcher
+      @negated = negated
+    end
+
+    def negate
+      ParseIso8601Matcher.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 = Time.iso8601(actual)
+
+      if @matcher.is_a?(NeverMatcher)
+        state.errors << state.expected.not.valid_format(:iso8601)
+        return
+      end
+
+      result = yield(@matcher, value)
+
+      return if result.valid?
+
+      time_of = Call.new(Constant.new(Time), :iso8601, [Variable.actual])
+      state.errors[time_of] << result
+    rescue ArgumentError
+      state.errors << state.expected.valid_format(:iso8601) unless @negated
+    end
+
+    def to_s
+      prefix = @negated ? "~" : ""
+
+      return "#{prefix}iso8601_format" if @original_matcher.is_a?(AlwaysMatcher)
+
+      "#{prefix}parse_iso8601(#{@original_matcher})"
+    end
+  end
+end

data/lib/matcher/matchers/parse_json_helper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Matcher
+  autoload :ParseJsonMatcher, "matcher/matchers/parse_json_matcher"
+
+  module MatcherDsl
+    ##
+    # Parses JSON and matches with given matcher
+    # @example
+    #   # matches '{"foo":42}'
+    #   parse_json({ "foo" => Integer })
+    #   # alternatively:
+    #   parse_json ^ { "foo" => Integer }
+    #   # without matcher matches any valid JSON string
+    #   parse_json
+    # @overload parse_json(matcher, **json_options)
+    #   @param matcher [Base]
+    #   @return [ParseJsonMatcher]
+    # @overload parse_json(**json_options)
+    #   @return [OptionalChain<ParseJsonMatcher>]
+    # @see #json_format
+    def parse_json(matcher = UNDEFINED, **)
+      return Chain.new { parse_json(_1, **) }.optional if
+        Matcher.undefined?(matcher)
+
+      matcher = matcher_of(matcher)
+      json_options = {}.merge(**)
+      json_options = Compatibility::NULL_KWARGS if json_options.empty?
+
+      ParseJsonMatcher.new(matcher, json_options:)
+    end
+
+    ##
+    # Matches valid JSON strings
+    # @example
+    #   # matches { payload: '{"foo":42}' }
+    #   { payload: json_format }
+    # @return [ParseJsonMatcher]
+    def json_format
+      @json_format ||= ParseJsonMatcher.new(AlwaysMatcher.instance)
+    end
+  end
+end

data/lib/matcher/matchers/parse_json_matcher.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Matcher
+  class ParseJsonMatcher < Base
+    def initialize(
+      matcher,
+      json_options: Compatibility::NULL_KWARGS,
+      negated: false
+    )
+      super()
+
+      @matcher = negated ? ~matcher : matcher
+      @original_matcher = matcher
+      @json_options = json_options
+      @negated = negated
+    end
+
+    def negate
+      ParseJsonMatcher.new(
+        @original_matcher, json_options: @json_options, 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 = JSON.parse(actual, **@json_options)
+
+      if @matcher.is_a?(NeverMatcher)
+        state.errors << state.expected.not.valid_format(:json)
+        return
+      end
+
+      result = yield(@matcher, value)
+
+      return if result.valid?
+
+      parse_json = Call.new(Constant.new(JSON), :parse, [Variable.actual])
+      state.errors[parse_json] << result
+    rescue JSON::ParserError
+      state.errors << state.expected.valid_format(:json) unless @negated
+    end
+
+    def to_s
+      prefix = @negated ? "~" : ""
+
+      return "#{prefix}json_format" if @original_matcher.is_a?(AlwaysMatcher)
+
+      "#{prefix}parse_json(#{@original_matcher})"
+    end
+  end
+end