matchers 0.1.0.pre.test

data/lib/matcher/expressions/string_expression.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Matcher
+  class StringExpression < Expression
+    def initialize(parts)
+      super()
+
+      @parts = parts
+    end
+
+    attr_reader :parts
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(StringExpression) &&
+        @parts.eql?(other.parts)
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [self.class, @parts].hash
+    end
+
+    def variables
+      @variables ||= @parts.flat_map(&:variables).uniq
+    end
+
+    def evaluate(values)
+      @parts.map { _1.evaluate(values) }.join
+    end
+
+    def substitute(replacements)
+      return self unless replacements.keys.intersect?(variables)
+
+      substituted_parts = @parts.map { _1.substitute(replacements) }
+
+      StringExpression.new(substituted_parts)
+    end
+
+    def to_s
+      parts = @parts.map do |part|
+        if part.is_a?(Constant) && part.value.is_a?(String)
+          part.value
+        else
+          "\#{#{part}}"
+        end
+      end
+
+      "\"#{parts.join}\""
+    end
+  end
+end

data/lib/matcher/expressions/symbol_proc.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Matcher
+  class SymbolProc
+    def initialize(proc_or_symbol)
+      case proc_or_symbol
+      when Symbol
+        @symbol = proc_or_symbol
+        @proc = proc_or_symbol.to_proc
+      when Proc
+        @proc = proc_or_symbol
+        @symbol = get_symbol(proc_or_symbol)
+      else
+        raise "Expected Proc or Symbol, got #{proc_or_symbol.inspect}"
+      end
+    end
+
+    attr_reader :symbol
+
+    def ==(other)
+      equal?(other) || other.instance_of?(SymbolProc) && @symbol == other.symbol
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @symbol].hash
+    end
+
+    def variables
+      []
+    end
+
+    def to_proc
+      @proc
+    end
+
+    def to_s
+      "&#{@symbol.inspect}"
+    end
+    alias inspect to_s
+
+    private
+
+    def get_symbol(proc)
+      receiver = Variable.actual # could be any
+      recorder = Recorder.new(receiver)
+      result = proc.call(recorder)
+      expression = Recorder.to_expression(result)
+
+      expression.method
+    end
+  end
+end

data/lib/matcher/expressions/variable.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Variable < Expression
+    WELL_KNOWN = %i[actual key value index parent original].freeze
+
+    WELL_KNOWN.each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{method}                                                      # def self.actual
+          @#{method} ||= Variable.new(:#{method})                               #   @actual ||= Variable.actual
+        end                                                                     # end
+      RUBY
+    end
+
+    def self.well_known?(symbol)
+      WELL_KNOWN.include?(symbol)
+    end
+
+    def self.cache(symbol, expression_cache: true)
+      return send(symbol) if well_known?(symbol)
+
+      expression_cache = ExpressionCache.current if expression_cache == true
+
+      if expression_cache
+        expression_cache.less_known_variable_for(symbol)
+      else
+        new(symbol)
+      end
+    end
+
+    def self.substitutions
+      Thread.current[:matcher_variable_substitution_stack]
+    end
+
+    def self.with_substitutions(**substitutions)
+      stack = (Thread.current[:matcher_variable_substitution_stack] ||= HashStack.new)
+      stack.push(substitutions)
+
+      begin
+        yield
+      ensure
+        stack.pop(substitutions)
+        Thread.current[:matcher_variable_substitution_stack] = nil if stack.empty?
+      end
+    end
+
+    attr_reader :symbol
+
+    def initialize(symbol)
+      super()
+
+      @symbol = symbol
+    end
+
+    def variables
+      [@symbol]
+    end
+
+    def evaluate(values)
+      value = values[@symbol]
+
+      raise "no value for #{@symbol.inspect}" if value.nil? && !values.key?(@symbol)
+
+      value
+    end
+
+    def ==(other)
+      other.instance_of?(Variable) && other.symbol == @symbol
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @symbol].hash
+    end
+
+    def substitute(replacements)
+      symbol = replacements[@symbol]
+      symbol ? Variable.new(symbol) : self
+    end
+
+    def to_s
+      Variable.substitutions&.[](@symbol) || @symbol.to_s
+    end
+  end
+end

data/lib/matcher/hash_stack.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Matcher
+  class HashStack
+    extend Forwardable
+
+    def initialize
+      @stacks = {}
+    end
+
+    def_delegators :@stacks, :empty?, :key?, :keys
+    def_delegators :to_h, :merge
+
+    def [](key)
+      @stacks[key]&.last
+    end
+
+    def push(hash)
+      hash.each do |k, v|
+        (@stacks[k] ||= []) << v
+      end
+    end
+
+    def pop(hash)
+      hash.each_key do |k|
+        array = @stacks[k]
+        array.pop
+
+        @stacks.delete(k) if array.empty?
+      end
+    end
+
+    def slice(*keys)
+      keys.each_with_object({}) do |k, h|
+        pair = @stacks.assoc(k)
+
+        next unless pair
+
+        h[k] = pair[1].last
+      end
+    end
+
+    def merge(hash)
+      hash.default_proc = ->(h, k) { h[k] = self[k] }
+      hash
+    end
+
+    def to_h
+      @stacks.transform_values(&:last)
+    end
+    alias to_hash to_h
+  end
+end

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/optional.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Optional
+    include NoExpression
+
+    CACHEABLE_CLASSES = [
+      NilClass,
+      FalseClass,
+      TrueClass,
+      Integer,
+      Float,
+      Symbol,
+      String,
+      Regexp,
+      Module,
+      Base,
+    ].freeze
+
+    def self.cache(value, matcher_cache = MatcherCache.current)
+      return new(value) if !matcher_cache ||
+        !CACHEABLE_CLASSES.include?(value.class) ||
+        value.is_a?(String) && !value.frozen?
+
+      (matcher_cache.optionals ||= {})[value] ||= new(value)
+    end
+
+    def self.value_of(obj)
+      obj.is_a?(Optional) ? obj.value : obj
+    end
+
+    def initialize(value)
+      @value = value
+    end
+
+    attr_reader :value
+
+    def ~
+      ~Matcher.cache(self)
+    end
+
+    def ==(other)
+      return true if equal?(other)
+
+      other.instance_of?(self.class) && other.value == @value
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @value].hash
+    end
+
+    def to_s
+      "optional(#{@value.inspect})"
+    end
+    alias inspect to_s
+  end
+
+  module MatcherBuilding
+    ##
+    # Marks a hash key as optional or wraps a matcher to also accept +nil+
+    # @example
+    #   # optional hash key
+    #   { optional(:foo) => 1 }
+    #   # match nil or String
+    #   optional(String)
+    # @overload optional(value)
+    #   @param value
+    #   @return [Optional]
+    # @overload optional
+    #   @return [Chain]
+    def optional(value = UNDEFINED)
+      return Chain.new { optional(_1) } if Matcher.undefined?(value)
+
+      value = Expression.try_recorder(value)
+
+      Optional.new(value)
+    end
+  end
+end

data/lib/matcher/markers/others.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Matcher
+  class Others
+    include Singleton
+    include NoMatcher
+    include NoExpression
+
+    def to_s
+      'others'
+    end
+    alias inspect to_s
+  end
+
+  module MatcherBuilding
+    ##
+    # Hash key that matches remaining entries
+    # @example
+    #   {
+    #     id: Integer,
+    #     others => each_value(String),
+    #   }
+    # @return [Others]
+    def others
+      Others.instance
+    end
+  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 *(matcher)
+      matcher = Matcher.cache(matcher)
+
+      if matcher.is_a?(AllMatcher)
+        AllMatcher.new(@matchers + matcher.matchers)
+      else
+        AllMatcher.new(@matchers + [matcher])
+      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.map(&:to_s).join(', ')})"
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # 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,28 @@
+# 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 MatcherBuilding
+    ##
+    # Matches always
+    # @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 +(matcher)
+      matcher = Matcher.cache(matcher)
+
+      if matcher.is_a?(AnyMatcher)
+        AnyMatcher.new(@matchers + matcher.matchers)
+      else
+        AnyMatcher.new(@matchers + [matcher])
+      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 if sub_error.valid?
+
+        sub_error
+      end
+
+      state.errors << OrError.from(sub_errors)
+    end
+
+    def to_s
+      "any(#{@matchers.map(&:to_s).join(', ')})"
+    end
+  end
+
+  module MatcherBuilding
+    ##
+    # 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,35 @@
+# frozen_string_literal: true
+
+module Matcher
+  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
+
+      errors << state.expected.length_of(@array.length, actual.length) if @array.length != actual.length
+
+      [@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