matchers 0.1.0.pre.1

data/lib/matcher/list.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Matcher
+  class List
+    include Enumerable
+
+    def self.empty
+      EmptyList.instance
+    end
+
+    def self.one(item)
+      NonEmptyList.new(item)
+    end
+
+    def to_s
+      to_a.to_s
+    end
+    alias inspect to_s
+  end
+
+  class EmptyList < List
+    include Singleton
+
+    def add(item)
+      NonEmptyList.new(item)
+    end
+    alias << add
+
+    def empty?
+      true
+    end
+
+    def last
+      nil
+    end
+
+    def each
+      self
+    end
+
+    def reverse_each
+      return to_enum(:reverse_each) unless block_given?
+
+      self
+    end
+
+    def to_a
+      []
+    end
+  end
+
+  class NonEmptyList < List
+    attr_reader :head, :tail
+
+    def initialize(head, tail = nil)
+      super()
+
+      @head = head
+      @tail = tail
+    end
+
+    def empty?
+      false
+    end
+
+    def add(item)
+      NonEmptyList.new(item, self)
+    end
+    alias << add
+
+    def last
+      @tail&.last || @head
+    end
+
+    def hash
+      @hash ||= [self.class, @head, @tail].hash
+    end
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(NonEmptyList) &&
+        @head.eql?(other.head) &&
+        @tail.eql?(other.tail)
+    end
+    alias eql? ==
+
+    def each
+      c = self
+
+      while c
+        yield c.head
+        c = c.tail
+      end
+    end
+
+    def reverse_each(&)
+      @tail&.reverse_each(&)
+      yield @head
+    end
+  end
+end

data/lib/matcher/markers.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Matcher
+  module NoMatcher end
+  module NoExpression end
+  module NoKey end
+end

data/lib/matcher/matcher_cache.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Matcher
+  MatcherCache = Struct.new(
+    :negated_matchers,
+    :equal_matchers,
+    :expression_matchers,
+    :kind_of_matchers,
+    :optionals,
+    :optional_matchers,
+    :range_matchers,
+    :regexp_matchers,
+  ) do
+    def self.current(build_session = Matcher.build_session)
+      build_session[:_matcher_cache] ||= new if build_session
+    end
+  end
+end

data/lib/matcher/matchers/all_matcher.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Matcher
+  class AllMatcher < Base
+    def initialize(matchers)
+      super()
+
+      @matchers = matchers
+    end
+
+    attr_reader :matchers
+
+    def *(other)
+      other = Matcher.cache(other)
+
+      if other.is_a?(AllMatcher)
+        AllMatcher.new(@matchers + other.matchers)
+      else
+        AllMatcher.new(@matchers + [other])
+      end
+    end
+
+    def negate
+      AnyMatcher.new(@matchers.map(&:~))
+    end
+
+    def validate(state)
+      @matchers.each do |matcher|
+        state.errors << yield(matcher)
+      end
+    end
+
+    def to_s
+      "all(#{@matchers.join(', ')})"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches all matchers
+    # @example
+    #   # matches 12 but not 9 or 13
+    #   all(_ > 10, _.even?)
+    #   # alternatively:
+    #   of(_ > 10) * of(_.even?)
+    # @param matchers [Array<Base>]
+    # @return [AllMatcher]
+    # @see Base#*
+    def all(*matchers)
+      case matchers.length
+      when 0
+        AlwaysMatcher.instance
+      when 1
+        matcher_of(matchers[0])
+      else
+        AllMatcher.new(matchers.map { matcher_of(_1) })
+      end
+    end
+  end
+end

data/lib/matcher/matchers/always_matcher.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Matcher
+  class AlwaysMatcher < Base
+    include Singleton
+
+    def ~
+      NeverMatcher.instance
+    end
+
+    def validate(_state) end
+
+    def to_s
+      "always"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches always
+    #
+    # Many matchers accept child matchers, for instance the HashMatcher. But
+    # before they invoke a child matcher they often perform implicit checks. And
+    # sometimes, we are only interested in those implicit checks and don't care
+    # about having a child matcher.
+    #
+    # @example
+    #   { foo: always }
+    # @return [AlwaysMatcher]
+    def always
+      AlwaysMatcher.instance
+    end
+  end
+end

data/lib/matcher/matchers/any_matcher.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Matcher
+  class AnyMatcher < Base
+    def initialize(matchers)
+      super()
+
+      @matchers = matchers
+    end
+
+    attr_reader :matchers
+
+    def +(other)
+      other = Matcher.cache(other)
+
+      if other.is_a?(AnyMatcher)
+        AnyMatcher.new(@matchers + other.matchers)
+      else
+        AnyMatcher.new(@matchers + [other])
+      end
+    end
+
+    def negate
+      AllMatcher.new(@matchers.map(&:~))
+    end
+
+    def validate(state)
+      if @matchers.empty?
+        state.errors << state.report.exist
+        return
+      end
+
+      sub_errors = @matchers.map do |matcher|
+        sub_error = yield matcher
+
+        return nil if sub_error.valid?
+
+        sub_error
+      end
+
+      state.errors << OrError.from(sub_errors)
+    end
+
+    def to_s
+      "any(#{@matchers.join(', ')})"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches any matcher
+    # @example
+    #   # matches "foo" and 1 but not 1.5
+    #   any(String, Integer)
+    #   # alternatively:
+    #   of(String) + of(Integer)
+    # @param matchers [Array<Base>]
+    # @return [AnyMatcher]
+    def any(*matchers)
+      case matchers.length
+      when 0
+        NeverMatcher.instance
+      when 1
+        matcher_of(matchers[0])
+      else
+        AnyMatcher.new(matchers.map { matcher_of(_1) })
+      end
+    end
+  end
+end

data/lib/matcher/matchers/array_matcher.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Matcher
+  ##
+  # == Basic array matching
+  #
+  #   m = Matcher.build { [1, 2, 3] }
+  #
+  #   m.match?([1, 2, 3])   # => true
+  #   m.match([1, 2])       # > root: expected length of 3 but was 2
+  #   m.match([1, 2, 3, 4]) # > root: expected length of 3 but was 4
+  #
+  #   m.match([3, 2, 1])
+  #   # > root[0]: expected 1 but got 3
+  #   # > root[2]: expected 3 but got 1
+  #
+  #   m = Match.build { [Integer, String] }
+  #   m.match?([1, "foo"]) # => true
+  #
+  # == Values passed to element matchers
+  # +ArrayMatcher+ passes +index+ and +parent+ to its element matchers.
+  #
+  #   # index or i
+  #   m = Matcher.build { [_ == i] }
+  #   m.match?([0]) # => true
+  #   m.match([1])  # > root[0]: expected actual == index but got 1 == 0
+  #
+  #   # parent
+  #   m = Matcher.build do
+  #     in_order = imply(i > 0, parent[i - 1] <= _)
+  #     [in_order, in_order, in_order]
+  #   end
+  #
+  #   m.match?([1, 2, 3])
+  #   # => true
+  #   m.match([1, 2, 0])
+  #   # > root[2]: expected actual >= parent[index - 1] but got 0 >= 2, where
+  #   #   parent = [1, 2, 0], index = 2
+  class ArrayMatcher < Base
+    def initialize(array)
+      super()
+
+      @array = array
+    end
+
+    def negate
+      NegatedArrayMatcher.new(@array)
+    end
+
+    def validate(state)
+      actual = state.actual
+      errors = state.errors
+
+      unless actual.is_a?(Array)
+        errors << state.expected.kind_of(Array)
+        return
+      end
+
+      if @array.length != actual.length
+        errors << state.expected.length_of(@array.length, actual.length)
+      end
+
+      [@array.length, actual.length].min.times do |i|
+        errors[i] << yield(@array[i], actual[i], index: i, parent: actual)
+      end
+    end
+
+    def to_s
+      @array.to_s
+    end
+  end
+end

data/lib/matcher/matchers/block_matcher.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Matcher
+  class BlockMatcher < Base
+    def initialize(block, description = nil, negated: false)
+      super()
+
+      @block = block
+      @description = description
+      @negated = negated
+    end
+
+    def negate
+      BlockMatcher.new(@block, @description, negated: !@negated)
+    end
+
+    def validate(state)
+      result = Utils.call_block(@block, state.values)
+
+      state.errors << build_message(state) if @negated ^ !result
+    end
+
+    def to_s
+      string = @description || "-> { #{block_location} }"
+
+      if @negated
+        "neg(#{string})"
+      else
+        string
+      end
+    end
+
+    private
+
+    def build_message(state)
+      if @description
+        state.expected.not_if(@negated)
+          .described_by(@description)
+      else
+        state.expected.namespace(:block).not_if(@negated)
+          .satisfied(block_location)
+      end
+    end
+
+    def block_location
+      Utils.block_location(@block)
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches when block returns truthy
+    # @example
+    #   satisfy('an even number') { |actual:| actual.even? }
+    # @param message [String, nil] optional description for error reporting
+    # @return [BlockMatcher]
+    def satisfy(message = nil, &block)
+      BlockMatcher.new(block, message)
+    end
+  end
+end

data/lib/matcher/matchers/boolean_matcher.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Matcher
+  class BooleanMatcher < Base
+    BOOLEAN = [false, true].freeze
+
+    def initialize(negated: false)
+      super()
+
+      @negated = negated
+    end
+
+    def negate
+      BooleanMatcher.new(negated: !@negated)
+    end
+
+    def validate(state)
+      state.errors << state.expected.not_if(@negated).in(BOOLEAN) if
+        @negated == BOOLEAN.include?(state.actual)
+    end
+
+    def to_s
+      "#{'~' if @negated}boolean"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches +true+ and +false+
+    # @example
+    #   { available: boolean }
+    # @return [BooleanMatcher]
+    def boolean
+      @boolean ||= BooleanMatcher.new
+    end
+  end
+end

data/lib/matcher/matchers/dig_matcher.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Matcher
+  class DigMatcher < Base
+    def initialize(keys, matcher, optional: false, negated: false)
+      super()
+
+      @keys = keys
+      @matcher = negated ? ~matcher : matcher
+      @original_matcher = matcher
+      @optional = optional
+      @negated = negated
+    end
+
+    def negate
+      DigMatcher.new(
+        @keys, @original_matcher, optional: @optional, negated: !@negated
+      )
+    end
+
+    def validate(state, &)
+      return validate_negated(state, &) if @negated
+
+      cur = state.actual
+      errors = state.errors
+
+      @keys.each do |key|
+        key = key.evaluate(state.values) if key.is_a?(Expression)
+        is_array = cur.is_a?(Array)
+
+        if is_array
+          unless key.is_a?(Integer)
+            errors << state.expected(cur).kind_of(Hash)
+            return nil
+          end
+        elsif !cur.is_a?(Hash)
+          or_error = state.new_collector.or!
+          or_error << state.expected(cur).kind_of(Hash)
+          or_error << state.expected(cur).kind_of(Array)
+          errors << or_error.error
+
+          return nil
+        end
+
+        prev = cur
+        cur = cur[key]
+
+        if cur.nil?
+          if @optional
+            return nil unless is_array ? index?(prev, key) : prev.key?(key)
+          elsif is_array
+            unless index?(prev, key)
+              errors << state.expected(prev).having_index(key)
+              return nil
+            end
+          else
+            unless prev.key?(key)
+              errors << state.expected(prev).having_key(key)
+              return nil
+            end
+          end
+        end
+
+        errors = errors[key]
+      end
+
+      errors << yield(@matcher, cur)
+    end
+
+    def to_s
+      helper = "#{'optional_' if @optional}dig"
+      keys = @keys.map(&:inspect).join(", ")
+      matcher = Matcher.parenthesize(@original_matcher)
+
+      "#{'~' if @negated}#{helper}(#{keys}) ^ #{matcher}"
+    end
+
+    private
+
+    def index?(array, index)
+      index.between?(-array.length, array.length - 1)
+    end
+
+    def validate_negated(state)
+      cur = state.actual
+      errors = state.errors
+
+      @keys.each do |key|
+        key = key.evaluate(state.values) if key.is_a?(Expression)
+        is_array = cur.is_a?(Array)
+
+        return nil if is_array ? !key.is_a?(Integer) : !cur.is_a?(Hash)
+
+        prev = cur
+        cur = cur[key]
+
+        if cur.nil?
+          if is_array
+            unless index?(prev, key)
+              errors << state.expected(prev).having_index(key) if @optional
+              return nil
+            end
+          else
+            unless prev.key?(key)
+              errors << state.expected(prev).having_key(key) if @optional
+              return nil
+            end
+          end
+        end
+
+        errors = errors[key]
+      end
+
+      errors << yield(@matcher, cur)
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches deeply nested values
+    # @example
+    #   # matches [0, { a: { "B" => 42 } }] where b: "B", but not []
+    #   dig(1, :a, vars[:b]) ^ Integer
+    # @param path [Array<Expression>]
+    # @param optional [true, false] matches if path doesn't exist when +true+
+    # @return [Chain<DigMatcher>]
+    def dig(*path, optional: false)
+      path.each_with_index do |key, i|
+        path[i] = expression_or_value(key)
+      end
+
+      Chain.new do |matcher|
+        DigMatcher.new(path, matcher, optional:)
+      end
+    end
+
+    ##
+    # Matches deeply nested value only if path exists
+    # @example
+    #   # matches { a: { b: 1 } } and { a: {} } but
+    #   # neither { a: { b: nil } } nor { a: nil }
+    #   optional_dig(:a, :b) ^ 1
+    # @param path [Array<Expression>]
+    # @return [Chain<DigMatcher>]
+    def optional_dig(*path)
+      dig(*path, optional: true)
+    end
+  end
+end

data/lib/matcher/matchers/each_matcher.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Matcher
+  ##
+  # Match each item.
+  # @example
+  #   m = Matcher.build { each(Integer) }
+  #
+  #   m.match?([1, 2, 3])
+  #   # => true
+  #   m.match([1, "foo"])
+  #   # > root[1]: expected a kind of Integer but got "foo"
+  #
+  #   # "each" passes index and parent to its item matcher:
+  #   m = Matcher.build { each(_ == i) }
+  #   m.match?([0, 1]) # => true
+  #   m.match?([0, 2]) # => false
+  #
+  #   m = Matcher.build { each(_ < parent.length) }
+  #   m.match?([1, 0, 2]) # => true
+  #   m.match?([1, 2, 3]) # => false
+  class EachMatcher < Base
+    def initialize(matcher)
+      super()
+
+      @matcher = matcher
+    end
+
+    def negate
+      NegatedEachMatcher.new(@matcher)
+    end
+
+    def validate(state)
+      unless state.actual.respond_to?(:each)
+        state.errors << state.expected.responding_to(:each)
+        return
+      end
+
+      i = 0
+      state.actual.each do |item|
+        state.errors[i] << yield(@matcher, item, index: i, parent: state.actual)
+        i += 1
+      end
+    end
+
+    def to_s
+      "each(#{@matcher})"
+    end
+  end
+
+  module MatcherDsl
+    ##
+    # Matches each item with matcher
+    #
+    # == +matcher+ values
+    #
+    # Passes +index+
+    #
+    #   m = Matcher.build { each(_ == i) }
+    #   m.match?([0, 1]) # => true
+    #   m.match?([0, 2]) # => false
+    #
+    # Passes +parent+
+    #
+    #   m = Matcher.build { each(_ < parent.length) }
+    #   m.match?([1, 0, 2]) # => true
+    #   m.match?([1, 2, 3]) # => false
+    #
+    # @example
+    #   # matches [1, 2] but not [1, "foo"]
+    #   each(Integer)
+    #   # alternatively:
+    #   each ^ Integer
+    # @overload each(matcher)
+    #   @param matcher [Base]
+    #   @return [EachMatcher]
+    # @overload each
+    #   @return [Chain<EachMatcher>]
+    def each(matcher = UNDEFINED)
+      return Chain.new { each(_1) } if Matcher.undefined?(matcher)
+
+      EachMatcher.new(matcher_of(matcher))
+    end
+  end
+end