mocktail 0.0.1

data/lib/mocktail/records_demonstration.rb

@@ -0,0 +1,32 @@
+module Mocktail
+  class RecordsDemonstration
+    def record(demonstration, demo_config)
+      cabinet = Mocktail.cabinet
+      prior_call_count = Mocktail.cabinet.calls.dup.size
+
+      begin
+        cabinet.demonstration_in_progress = true
+        ValidatesArguments.optional(demo_config.ignore_arity) do
+          demonstration.call(Mocktail.matchers)
+        end
+      ensure
+        cabinet.demonstration_in_progress = false
+      end
+
+      if prior_call_count + 1 == cabinet.calls.size
+        cabinet.calls.pop
+      elsif prior_call_count == cabinet.calls.size
+        raise MissingDemonstrationError.new <<~MSG.tr("\n", " ")
+          `stubs` & `verify` expect an invocation of a mocked method by a passed
+          block, but no invocation occurred.
+        MSG
+      else
+        raise AmbiguousDemonstrationError.new <<~MSG.tr("\n", " ")
+          `stubs` & `verify` expect exactly one invocation of a mocked method,
+          but #{cabinet.calls.size - prior_call_count} were detected. As a
+          result, Mocktail doesn't know which invocation to stub or verify.
+        MSG
+      end
+    end
+  end
+end

data/lib/mocktail/registers_matcher.rb

@@ -0,0 +1,52 @@
+module Mocktail
+  class RegistersMatcher
+    def register(matcher_type)
+      if invalid_type?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          Matchers must be Ruby classes
+        MSG
+      elsif invalid_name?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          #{matcher_type.name}.matcher_name must return a valid method name
+        MSG
+      elsif invalid_match?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          #{matcher_type.name}#match? must be defined as a one-argument method
+        MSG
+      elsif invalid_flag?(matcher_type)
+        raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
+          #{matcher_type.name}#is_mocktail_matcher? must be defined
+        MSG
+      else
+        MatcherRegistry.instance.add(matcher_type)
+      end
+    end
+
+    private
+
+    def invalid_type?(matcher_type)
+      !matcher_type.is_a?(Class)
+    end
+
+    def invalid_name?(matcher_type)
+      return true unless matcher_type.respond_to?(:matcher_name)
+      name = matcher_type.matcher_name
+
+      !(name.is_a?(String) || name.is_a?(Symbol)) ||
+        name.to_sym.inspect.start_with?(":\"")
+    end
+
+    def invalid_match?(matcher_type)
+      params = matcher_type.instance_method(:match?).parameters
+      params.size > 1 || ![:req, :opt].include?(params.first[0])
+    rescue NameError
+      true
+    end
+
+    def invalid_flag?(matcher_type)
+      !matcher_type.instance_method(:is_mocktail_matcher?)
+    rescue NameError
+      true
+    end
+  end
+end

data/lib/mocktail/registers_stubbing.rb

@@ -0,0 +1,19 @@
+require_relative "records_demonstration"
+
+module Mocktail
+  class RegistersStubbing
+    def initialize
+      @records_demonstration = RecordsDemonstration.new
+    end
+
+    def register(demonstration, demo_config)
+      Stubbing.new(
+        demonstration: demonstration,
+        demo_config: demo_config,
+        recording: @records_demonstration.record(demonstration, demo_config)
+      ).tap do |stubbing|
+        Mocktail.cabinet.store_stubbing(stubbing)
+      end
+    end
+  end
+end

data/lib/mocktail/replaces_next.rb

@@ -0,0 +1,36 @@
+module Mocktail
+  class ReplacesNext
+    def initialize
+      @top_shelf = TopShelf.instance
+      @redefines_new = RedefinesNew.new
+      @imitates_type = ImitatesType.new
+    end
+
+    def replace(type, count)
+      raise UnsupportedMocktail.new("Mocktail.of_next() only supports classes") unless type.is_a?(Class)
+
+      mocktails = count.times.map { @imitates_type.imitate(type) }
+
+      @top_shelf.register_of_next_replacement!(type)
+      @redefines_new.redefine(type)
+      mocktails.reverse_each do |mocktail|
+        Mocktail.stubs(
+          ignore_extra_args: true,
+          ignore_block: true,
+          ignore_arity: true,
+          times: 1
+        ) {
+          type.new
+        }.with {
+          if mocktail == mocktails.last
+            @top_shelf.unregister_of_next_replacement!(type)
+          end
+
+          mocktail
+        }
+      end
+
+      mocktails.size == 1 ? mocktails.first : mocktails
+    end
+  end
+end

data/lib/mocktail/replaces_type/redefines_new.rb

@@ -0,0 +1,26 @@
+module Mocktail
+  class RedefinesNew
+    def initialize
+      @handles_dry_new_call = HandlesDryNewCall.new
+    end
+
+    def redefine(type)
+      type_replacement = TopShelf.instance.type_replacement_for(type)
+
+      if type_replacement.replacement_new.nil?
+        type_replacement.original_new = type.method(:new)
+        type.singleton_class.send(:undef_method, :new)
+        handles_dry_new_call = @handles_dry_new_call
+        type.define_singleton_method :new, ->(*args, **kwargs, &block) {
+          if TopShelf.instance.new_replaced?(type) ||
+              TopShelf.instance.of_next_registered?(type)
+            handles_dry_new_call.handle(type, args, kwargs, block)
+          else
+            type_replacement.original_new.call(*args, **kwargs, &block)
+          end
+        }
+        type_replacement.replacement_new = type.singleton_method(:new)
+      end
+    end
+  end
+end

data/lib/mocktail/replaces_type/redefines_singleton_methods.rb

@@ -0,0 +1,39 @@
+module Mocktail
+  class RedefinesSingletonMethods
+    def initialize
+      @handles_dry_call = HandlesDryCall.new
+    end
+
+    def redefine(type)
+      type_replacement = TopShelf.instance.type_replacement_for(type)
+      return unless type_replacement.replacement_methods.nil?
+
+      type_replacement.original_methods = type.singleton_methods.map { |name|
+        type.method(name)
+      } - [type_replacement.replacement_new]
+
+      handles_dry_call = @handles_dry_call
+      type_replacement.replacement_methods = type_replacement.original_methods.map { |original_method|
+        type.singleton_class.send(:undef_method, original_method.name)
+        type.define_singleton_method original_method.name, ->(*args, **kwargs, &block) {
+          if TopShelf.instance.singleton_methods_replaced?(type)
+            handles_dry_call.handle(Call.new(
+              singleton: true,
+              double: type,
+              original_type: type,
+              dry_type: type,
+              method: original_method.name,
+              original_method: original_method,
+              args: args,
+              kwargs: kwargs,
+              block: block
+            ))
+          else
+            original_method.call(*args, **kwargs, &block)
+          end
+        }
+        type.singleton_method(original_method.name)
+      }
+    end
+  end
+end

data/lib/mocktail/replaces_type.rb

@@ -0,0 +1,26 @@
+require_relative "replaces_type/redefines_new"
+require_relative "replaces_type/redefines_singleton_methods"
+
+module Mocktail
+  class ReplacesType
+    def initialize
+      @top_shelf = TopShelf.instance
+      @redefines_new = RedefinesNew.new
+      @redefines_singleton_methods = RedefinesSingletonMethods.new
+    end
+
+    def replace(type)
+      unless type.is_a?(Class) || type.is_a?(Module)
+        raise UnsupportedMocktail.new("Mocktail.replace() only supports classes and modules")
+      end
+
+      if type.is_a?(Class)
+        @top_shelf.register_new_replacement!(type)
+        @redefines_new.redefine(type)
+      end
+
+      @top_shelf.register_singleton_method_replacement!(type)
+      @redefines_singleton_methods.redefine(type)
+    end
+  end
+end

data/lib/mocktail/resets_state.rb

@@ -0,0 +1,9 @@
+module Mocktail
+  class ResetsState
+    def reset
+      TopShelf.instance.reset_current_thread!
+      Mocktail.cabinet.reset!
+      ValidatesArguments.enable!
+    end
+  end
+end

data/lib/mocktail/share/determines_matching_calls.rb

@@ -0,0 +1,60 @@
+module Mocktail
+  class DeterminesMatchingCalls
+    def determine(real_call, demo_call, demo_config)
+      real_call.double == demo_call.double &&
+        real_call.method == demo_call.method &&
+
+        # Matcher implementation will replace this:
+        args_match?(real_call.args, demo_call.args, demo_config.ignore_extra_args) &&
+        kwargs_match?(real_call.kwargs, demo_call.kwargs, demo_config.ignore_extra_args) &&
+        blocks_match?(real_call.block, demo_call.block, demo_config.ignore_block)
+    end
+
+    private
+
+    def args_match?(real_args, demo_args, ignore_extra_args)
+      return true if ignore_extra_args && demo_args.empty?
+
+      (
+        real_args.size == demo_args.size ||
+        (ignore_extra_args && real_args.size >= demo_args.size)
+      ) &&
+        demo_args.each.with_index.all? { |demo_arg, i|
+          match?(real_args[i], demo_arg)
+        }
+    end
+
+    def kwargs_match?(real_kwargs, demo_kwargs, ignore_extra_args)
+      return true if ignore_extra_args && demo_kwargs.empty?
+
+      (
+        real_kwargs.size == demo_kwargs.size ||
+        (ignore_extra_args && real_kwargs.size >= demo_kwargs.size)
+      ) &&
+        demo_kwargs.all? { |key, demo_val|
+          real_kwargs.key?(key) && match?(real_kwargs[key], demo_val)
+        }
+    end
+
+    def blocks_match?(real_block, demo_block, ignore_block)
+      ignore_block ||
+        (real_block.nil? && demo_block.nil?) ||
+        (
+          real_block && demo_block &&
+          (
+            demo_block == real_block ||
+            demo_block.call(real_block)
+          )
+        )
+    end
+
+    def match?(real_arg, demo_arg)
+      if demo_arg.respond_to?(:is_mocktail_matcher?) &&
+          demo_arg.is_mocktail_matcher?
+        demo_arg.match?(real_arg)
+      else
+        demo_arg == real_arg
+      end
+    end
+  end
+end

data/lib/mocktail/share/simulates_argument_error.rb

@@ -0,0 +1,28 @@
+module Mocktail
+  class SimulatesArgumentError
+    def simulate(arg_params, args, kwarg_params, kwargs)
+      req_args = arg_params.count { |type, _| type == :req }
+      opt_args = arg_params.count { |type, _| type == :opt }
+      rest_args = arg_params.any? { |type, _| type == :rest }
+      req_kwargs = kwarg_params.select { |type, _| type == :keyreq }
+
+      allowed_args = req_args + opt_args
+      msg = if args.size < req_args || (!rest_args && args.size > allowed_args)
+        expected_desc = if rest_args
+          "#{req_args}+"
+        elsif allowed_args != req_args
+          "#{req_args}..#{allowed_args}"
+        else
+          req_args.to_s
+        end
+
+        "wrong number of arguments (given #{args.size}, expected #{expected_desc}#{"; required keyword#{"s" if req_kwargs.size > 1}: #{req_kwargs.map { |_, name| name }.join(", ")}" unless req_kwargs.empty?})"
+
+      elsif !(missing_kwargs = req_kwargs.reject { |_, name| kwargs.key?(name) }).empty?
+        "missing keyword#{"s" if missing_kwargs.size > 1}: #{missing_kwargs.map { |_, name| name.inspect }.join(", ")}"
+      end
+
+      ArgumentError.new(msg)
+    end
+  end
+end

data/lib/mocktail/value/cabinet.rb

@@ -0,0 +1,41 @@
+# The Cabinet stores all thread-local state, so anything that goes here
+# is guaranteed by Mocktail to be local to the currently-running thread
+module Mocktail
+  class Cabinet
+    attr_writer :demonstration_in_progress
+    attr_reader :calls, :stubbings
+
+    def initialize
+      @doubles = []
+      @calls = []
+      @stubbings = []
+      @demonstration_in_progress = false
+    end
+
+    def reset!
+      @calls = []
+      @stubbings = []
+      # Could cause an exception or prevent pollution—you decide!
+      @demonstration_in_progress = false
+      # note we don't reset doubles as they don't carry any
+      # user-meaningful state on them, and clearing them on reset could result
+      # in valid mocks being broken and stop working
+    end
+
+    def store_double(double)
+      @doubles << double
+    end
+
+    def store_call(call)
+      @calls << call
+    end
+
+    def store_stubbing(stubbing)
+      @stubbings << stubbing
+    end
+
+    def demonstration_in_progress?
+      @demonstration_in_progress
+    end
+  end
+end

data/lib/mocktail/value/call.rb

@@ -0,0 +1,15 @@
+module Mocktail
+  class Call < Struct.new(
+    :singleton,
+    :double,
+    :original_type,
+    :dry_type,
+    :method,
+    :original_method,
+    :args,
+    :kwargs,
+    :block,
+    keyword_init: true
+  )
+  end
+end

data/lib/mocktail/value/demo_config.rb

@@ -0,0 +1,10 @@
+module Mocktail
+  class DemoConfig < Struct.new(
+    :ignore_block,
+    :ignore_extra_args,
+    :ignore_arity,
+    :times,
+    keyword_init: true
+  )
+  end
+end

data/lib/mocktail/value/double.rb

@@ -0,0 +1,11 @@
+module Mocktail
+  class Double
+    attr_reader :original_type, :dry_type, :dry_instance
+
+    def initialize(original_type:, dry_type:, dry_instance:)
+      @original_type = original_type
+      @dry_type = dry_type
+      @dry_instance = dry_instance
+    end
+  end
+end

data/lib/mocktail/value/matcher_registry.rb

@@ -0,0 +1,19 @@
+module Mocktail
+  class MatcherRegistry
+    def self.instance
+      @matcher_registry ||= new
+    end
+
+    def initialize
+      @matchers = {}
+    end
+
+    def add(matcher_type)
+      @matchers[matcher_type.matcher_name] = matcher_type
+    end
+
+    def get(name)
+      @matchers[name]
+    end
+  end
+end

data/lib/mocktail/value/stubbing.rb

@@ -0,0 +1,24 @@
+module Mocktail
+  class Stubbing < Struct.new(
+    :demonstration,
+    :demo_config,
+    :satisfaction_count,
+    :recording,
+    :effect,
+    keyword_init: true
+  )
+
+    def initialize(**kwargs)
+      super
+      self.satisfaction_count ||= 0
+    end
+
+    def satisfied!
+      self.satisfaction_count += 1
+    end
+
+    def with(&block)
+      self.effect = block
+    end
+  end
+end

data/lib/mocktail/value/top_shelf.rb

@@ -0,0 +1,61 @@
+# The top shelf stores all cross-thread & thread-aware state, so anything that
+# goes here is on its own when it comes to ensuring thread safety.
+module Mocktail
+  class TopShelf
+    def self.instance
+      @self ||= new
+    end
+
+    def initialize
+      @type_replacements = {}
+      @new_registrations = {}
+      @of_next_registrations = {}
+      @singleton_method_registrations = {}
+    end
+
+    def type_replacement_for(type)
+      @type_replacements[type] ||= TypeReplacement.new(type: type)
+    end
+
+    def reset_current_thread!
+      @new_registrations[Thread.current] = []
+      @of_next_registrations[Thread.current] = []
+      @singleton_method_registrations[Thread.current] = []
+    end
+
+    def register_new_replacement!(type)
+      @new_registrations[Thread.current] ||= []
+      @new_registrations[Thread.current] |= [type]
+    end
+
+    def new_replaced?(type)
+      @new_registrations[Thread.current] ||= []
+      @new_registrations[Thread.current].include?(type)
+    end
+
+    def register_of_next_replacement!(type)
+      @of_next_registrations[Thread.current] ||= []
+      @of_next_registrations[Thread.current] |= [type]
+    end
+
+    def of_next_registered?(type)
+      @of_next_registrations[Thread.current] ||= []
+      @of_next_registrations[Thread.current].include?(type)
+    end
+
+    def unregister_of_next_replacement!(type)
+      @of_next_registrations[Thread.current] ||= []
+      @of_next_registrations[Thread.current] -= [type]
+    end
+
+    def register_singleton_method_replacement!(type)
+      @singleton_method_registrations[Thread.current] ||= []
+      @singleton_method_registrations[Thread.current] |= [type]
+    end
+
+    def singleton_methods_replaced?(type)
+      @singleton_method_registrations[Thread.current] ||= []
+      @singleton_method_registrations[Thread.current].include?(type)
+    end
+  end
+end

data/lib/mocktail/value/type_replacement.rb

@@ -0,0 +1,11 @@
+module Mocktail
+  class TypeReplacement < Struct.new(
+    :type,
+    :original_methods,
+    :replacement_methods,
+    :original_new,
+    :replacement_new,
+    keyword_init: true
+  )
+  end
+end

data/lib/mocktail/value.rb

@@ -0,0 +1,8 @@
+require_relative "value/cabinet"
+require_relative "value/call"
+require_relative "value/demo_config"
+require_relative "value/double"
+require_relative "value/matcher_registry"
+require_relative "value/stubbing"
+require_relative "value/top_shelf"
+require_relative "value/type_replacement"

data/lib/mocktail/verifies_call/finds_verifiable_calls.rb

@@ -0,0 +1,15 @@
+require_relative "../share/determines_matching_calls"
+
+module Mocktail
+  class FindsVerifiableCalls
+    def initialize
+      @determines_matching_calls = DeterminesMatchingCalls.new
+    end
+
+    def find(recording, demo_config)
+      Mocktail.cabinet.calls.select { |call|
+        @determines_matching_calls.determine(call, recording, demo_config)
+      }
+    end
+  end
+end

data/lib/mocktail/verifies_call/raises_verification_error/gathers_calls_of_method.rb

@@ -0,0 +1,10 @@
+module Mocktail
+  class GathersCallsOfMethod
+    def gather(dry_call)
+      Mocktail.cabinet.calls.select { |call|
+        call.double == dry_call.double &&
+          call.method == dry_call.method
+      }
+    end
+  end
+end

data/lib/mocktail/verifies_call/raises_verification_error/stringifies_call.rb

@@ -0,0 +1,47 @@
+module Mocktail
+  class StringifiesCall
+    def stringify(call)
+      "#{call.method}#{args_to_s(call)}#{blockify(call.block)}"
+    end
+
+    private
+
+    def args_to_s(call)
+      unless (args_lists = [
+        argify(call.args),
+        kwargify(call.kwargs),
+        lambdafy(call.block)
+      ].compact).empty?
+        "(#{args_lists.join(", ")})"
+      end
+    end
+
+    def argify(args)
+      return unless args && !args.empty?
+      args.map(&:inspect).join(", ")
+    end
+
+    def kwargify(kwargs)
+      return unless kwargs && !kwargs.empty?
+      kwargs.map { |key, val| "#{key}: #{val.inspect}" }.join(", ")
+    end
+
+    def lambdafy(block)
+      return unless block&.lambda?
+      "&lambda[#{source_locationify(block)}]"
+    end
+
+    def blockify(block)
+      return unless block && !block.lambda?
+      " { Proc at #{source_locationify(block)} }"
+    end
+
+    def source_locationify(block)
+      "#{strip_pwd(block.source_location[0])}:#{block.source_location[1]}"
+    end
+
+    def strip_pwd(path)
+      path.gsub(Dir.pwd + File::SEPARATOR, "")
+    end
+  end
+end