matchers 0.1.0.pre.test

data/lib/matcher/matchers/block_matcher.rb

@@ -0,0 +1,59 @@
+# 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 MatcherBuilding
+    ##
+    # 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,35 @@
+# frozen_string_literal: true
+
+module Matcher
+  class BooleanMatcher < Base
+    BOOLEAN = [false, true].freeze
+
+    def initialize(negated: false)
+      @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 MatcherBuilding
+    ##
+    # 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,146 @@
+# 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 MatcherBuilding
+    ##
+    # 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 not { 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,52 @@
+# frozen_string_literal: true
+
+module Matcher
+  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 MatcherBuilding
+    ##
+    # Matches each item with matcher
+    # @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

data/lib/matcher/matchers/each_pair_matcher.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Matcher
+  class EachPairMatcher < Base
+    def initialize(matcher)
+      super()
+
+      @matcher = matcher
+    end
+
+    def negate
+      NegatedEachPairMatcher.new(@matcher)
+    end
+
+    def validate(state)
+      actual = state.actual
+
+      unless actual.respond_to?(:each_pair)
+        state.errors << state.expected.responding_to(:each_pair)
+        return
+      end
+
+      actual.each_pair do |key, value|
+        state.errors[key] << yield(
+          @matcher,
+          [key, value],
+          key: key,
+          value: value,
+          parent: actual
+        )
+      end
+    end
+
+    def to_s
+      "each_pair(#{@matcher})"
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Matches each hash entry
+    # == +matcher+ values
+    # - key
+    # - value
+    # - parent
+    # @example
+    #   # matches { foo: "foo" } but not { foo: "bar" }
+    #   each_pair(k.to_s == v)
+    #   # alternatively:
+    #   each_pair ^ (k.to_s == v)
+    # @overload each_pair(matcher)
+    #   @param matcher [Base]
+    #   @return [EachPairMatcher]
+    # @overload each_pair
+    #   @return [Chain<EachPairMatcher>]
+    # @see #each_key
+    # @see #each_value
+    def each_pair(matcher = UNDEFINED)
+      return Chain.new { each_pair(_1) } if Matcher.undefined?(matcher)
+
+      EachPairMatcher.new(matcher_of(matcher))
+    end
+
+    ##
+    # Matches each hash key
+    # == +matcher+ values
+    # - key
+    # - value
+    # - parent
+    # @example
+    #   # matches { foo: 1, bar: 2 } but not { "foo" => 1, "bar" => 2 }
+    #   each_key(Symbol)
+    #   # alternatively:
+    #   each_key ^ Symbol
+    # @overload each_key(matcher)
+    #   @param matcher [Base]
+    #   @return [EachPairMatcher]
+    # @overload each_key
+    #   @return [Chain<EachPairMatcher>]
+    # @see #each_pair
+    def each_key(matcher = UNDEFINED)
+      return Chain.new { each_key(_1) } if Matcher.undefined?(matcher)
+
+      matcher = matcher_of(matcher)
+
+      EachPairMatcher.new(
+        ProjectMatcher.new(Variable.key, matcher),
+      )
+    end
+
+    ##
+    # Matches each hash value
+    # == +matcher+ values
+    # - key
+    # - value
+    # - parent
+    # @example
+    #   # matches { a: "foo", b: "bar" } but not { a: 1, b: 2 }
+    #   each_value(String)
+    #   # alternatively:
+    #   each_value ^ String
+    # @overload each_value(matcher)
+    #   @param matcher [Base]
+    #   @return [EachPairMatcher]
+    # @overload each_value
+    #   @return [Chain<EachPairMatcher>]
+    # @see #each_pair
+    def each_value(matcher = UNDEFINED)
+      return Chain.new { each_value(_1) } if Matcher.undefined?(matcher)
+
+      assigns = { actual: Variable.value }
+      matcher = matcher_of(matcher)
+
+      EachPairMatcher.new(
+        LetMatcher.new(assigns, matcher),
+      )
+    end
+  end
+end

data/lib/matcher/matchers/equal_matcher.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Matcher
+  class EqualMatcher < Base
+    CACHEABLE_CLASSES = [
+      NilClass,
+      FalseClass,
+      TrueClass,
+      Integer,
+      Float,
+      Symbol,
+      String,
+      Regexp,
+      Module,
+    ].freeze
+
+    def self.cache(value, matcher_cache = MatcherCache.current)
+      return new(value) if !matcher_cache ||
+        !CACHEABLE_CLASSES.include?(value) ||
+        value.is_a?(String) && !value.frozen?
+
+      (matcher_cache.equal_matchers ||= {})[value] ||= new(value)
+    end
+
+    def initialize(value, negated: false)
+      super()
+
+      @value = value
+      @negated = negated
+    end
+
+    def negate
+      EqualMatcher.new(@value, negated: !@negated)
+    end
+
+    def validate(state)
+      value = @value.is_a?(Expression) ? @value.evaluate(state.values) : @value
+
+      if @negated
+        errors = state.errors.or!
+
+        catch(:valid) do
+          validate_negated_helper(state, errors, value, state.actual)
+
+          # prevent clearing errors
+          return
+        end
+
+        # caught :valid
+        errors.clear
+      else
+        validate_helper(state, state.errors, value, state.actual)
+      end
+    end
+
+    IMPLICIT_MATCHER_CLASSES = [Module, Range, Regexp, Hash, Array, Expression].freeze
+
+    def to_s
+      if IMPLICIT_MATCHER_CLASSES.any? { @value.is_a?(_1) }
+        "#{'~' if @negated}equal(#{@value.inspect})"
+      else
+        @negated ? "neg(#{@value.inspect})" : @value.inspect
+      end
+    end
+
+    private
+
+    def validate_helper(state, errors, exp, act)
+      case exp
+      when Array
+        validate_array(state, errors, exp, act)
+      when Hash
+        validate_hash(state, errors, exp, act)
+      when Set
+        validate_set(state, errors, exp, act)
+      else
+        errors << state.expected(act).not_if(@negated).equal(exp) if
+          @negated ^ (act != exp)
+      end
+    end
+
+    def validate_array(state, errors, exp, act)
+      unless act.is_a?(Array)
+        errors << state.expected(act).kind_of(Array)
+        return
+      end
+
+      errors << state.expected(act).length_of(exp.length, act.length) if
+        exp.length != act.length
+
+      [exp.length, act.length].min.times do |i|
+        validate_helper(state, errors[i], exp[i], act[i])
+      end
+    end
+
+    def validate_hash(state, errors, exp, act)
+      unless act.is_a?(Hash)
+        errors << state.expected(act).kind_of(Hash)
+        return
+      end
+
+      (act.keys - exp.keys).each do |key|
+        errors[key] << state.expected(act).not.having_key(key)
+      end
+
+      exp.each do |key, exp_value|
+        act_value = act[key]
+
+        if act_value.nil? && !act.key?(key)
+          errors << state.expected(act).having_key(key)
+        else
+          validate_helper(state, errors[key], exp_value, act_value)
+        end
+      end
+    end
+
+    def validate_set(state, errors, exp, act)
+      unless act.is_a?(Set)
+        errors << state.expected(act).kind_of(Set)
+        return
+      end
+
+      (exp - act).each do |item|
+        errors << state.expected(act).including(item)
+      end
+
+      (act - exp).each do |item|
+        errors << state.expected(act).not.including(item)
+      end
+    end
+
+    def validate_negated_helper(state, errors, exp, act)
+      case exp
+      when Array
+        validate_array_negated(state, errors, exp, act)
+      when Hash
+        validate_hash_negated(state, errors, exp, act)
+      when Set
+        validate_set_negated(state, errors, exp, act)
+      else
+        if act == exp
+          errors << state.expected(act).not.equal(exp)
+        else
+          throw(:valid)
+        end
+      end
+    end
+
+    def validate_array_negated(state, errors, exp, act)
+      throw(:valid) if !act.is_a?(Array) || exp.length != act.length
+
+      exp.length.times do |i|
+        validate_negated_helper(state, errors[i], exp[i], act[i])
+      end
+    end
+
+    def validate_hash_negated(state, errors, exp, act)
+      throw(:valid) unless act.is_a?(Hash)
+
+      exp_keys_set = Set.new(exp.keys)
+      throw(:valid) unless act.keys.all? { exp_keys_set.include?(_1) }
+
+      exp.each do |key, exp_value|
+        act_value = act[key]
+
+        if act_value.nil? && !act.key?(key)
+          throw(:valid)
+        else
+          validate_negated_helper(state, errors[key], exp_value, act_value)
+        end
+      end
+    end
+
+    def validate_set_negated(state, errors, exp, act)
+      throw(:valid) if !act.is_a?(Set) || act != exp
+
+      exp.each do |item|
+        errors << state.expected(act).not.including(item)
+      end
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Matches equal value
+    # @example
+    #   # matches String but not "foo"
+    #   equal(String)
+    # @param value
+    # @return [EqualMatcher]
+    def equal(value)
+      value = expression_or_value(value)
+
+      EqualMatcher.cache(value, @matcher_cache)
+    end
+  end
+end

data/lib/matcher/matchers/equal_set_matcher.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Matcher
+  class EqualSetMatcher < Base
+    def initialize(items, negated: false)
+      super()
+
+      @items = items
+      @negated = negated
+      @includes_expressions = items.any? { _1.is_a?(Expression) }
+    end
+
+    def negate
+      EqualSetMatcher.new(@items, negated: !@negated)
+    end
+
+    def set_for(values)
+      if @includes_expressions
+        @items.to_set do |item|
+          item.is_a?(Expression) ? item.evalute(values) : item
+        end
+      else
+        @set ||= Set.new(@items)
+      end
+    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
+
+      expected_set = set_for(state.values)
+      missing = expected_set.dup
+
+      actual.each_with_index do |act, i|
+        if expected_set.include?(act)
+          unless missing.delete?(act)
+            original_index = index_of(actual, act)
+            state.errors[i] << state.expected(act).not.duplicate(original_index)
+          end
+        else
+          state.errors[i] << state.expected(act).not.in(state.actual)
+        end
+      end
+
+      missing.each do |m|
+        state.errors << state.expected.including(m)
+      end
+    end
+
+    def to_s
+      "#{'~' if @negated}equal_set(#{@items.map(&:to_s).join(', ')})"
+    end
+
+    private
+
+    def validate_negated(state)
+      actual = state.actual
+
+      return unless actual.respond_to?(:each)
+
+      expected_set = set_for(state.values)
+      missing = expected_set.dup
+
+      actual.each do |act|
+        return nil if !expected_set.include?(act) || !missing.delete?(act)
+      end
+
+      state.errors << state.expected.namespace(:set).not.equal(@items) if missing.empty?
+    end
+
+    def index_of(collection, item)
+      collection = collection.enum_for(:each) unless
+        collection.respond_to?(:find_index)
+
+      collection.find_index(item)
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # Matches array elements like a set
+    # @example
+    #   # matches [1, 2, 3] and [3, 2, 1] but neither [0, 1, 2] nor [1, 1, 2, 3]
+    #   equal_set(1, 2, 3)
+    # @param items [Array]
+    # @return [EqualSetMatcher]
+    def equal_set(*items)
+      items.map! { expression_or_value(_1) }
+
+      EqualSetMatcher.new(items)
+    end
+  end
+end