mocktail 1.2.3 → 2.0.0

data/Rakefile

@@ -4,7 +4,6 @@ require "standard/rake"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
-  t.libs << "lib"
   t.test_files = FileList["test/**/*_test.rb"]
 end
 

data/bin/console

@@ -77,5 +77,4 @@ Shop.open!(42)
 
 Shop.close!(42)
 
-require "pry"
-Pry.start
+binding.irb

data/bin/tapioca

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'tapioca' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("tapioca", "tapioca")

data/lib/mocktail/collects_calls.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class CollectsCalls
+    extend T::Sig
+
     def collect(double, method_name)
       calls = ExplainsThing.new.explain(double).reference.calls
 

data/lib/mocktail/debug.rb

@@ -1,5 +1,7 @@
 module Mocktail
   module Debug
+    extend T::Sig
+
     # It would be easy and bad for the mocktail lib to call something like
     #
     #   double == other_double
@@ -12,26 +14,27 @@ module Mocktail
     # happens unintentionally. This works in conjunction with the test
     # MockingMethodfulClassesTest, because it mocks every defined method on the
     # mocked BasicObject
+
     def self.guard_against_mocktail_accidentally_calling_mocks_if_debugging!
       return unless ENV["MOCKTAIL_DEBUG_ACCIDENTAL_INTERNAL_MOCK_CALLS"]
-      raise
-    rescue => e
+      raise Mocktail::Error
+    rescue Mocktail::Error => e
       base_path = Pathname.new(__FILE__).dirname.to_s
-      backtrace_minus_this_and_whoever_called_this = e.backtrace[2..]
-      internal_call_sites = backtrace_minus_this_and_whoever_called_this.take_while { |call_site|
+      backtrace_minus_this_and_whoever_called_this = e.backtrace&.[](2..)
+      internal_call_sites = backtrace_minus_this_and_whoever_called_this&.take_while { |call_site|
         # the "in `block" is very confusing but necessary to include lines after
         # a stubs { blah.foo }.with { … } call, since that's when most of the
         # good stuff happens
         call_site.start_with?(base_path) || call_site.include?("in `block")
-      }.reject { |call_site| call_site.include?("in `block") }
+      }&.reject { |call_site| call_site.include?("in `block") } || []
 
       approved_call_sites = [
-        "fulfills_stubbing.rb:14",
-        "validates_arguments.rb:16",
-        "validates_arguments.rb:19"
+        /fulfills_stubbing.rb:(16|20)/,
+        /validates_arguments.rb:(18|23)/,
+        /validates_arguments.rb:(21|26)/
       ]
       if internal_call_sites.any? && approved_call_sites.none? { |approved_call_site|
-        internal_call_sites.first.include?(approved_call_site)
+        internal_call_sites.first&.match?(approved_call_site)
       }
         raise Error.new <<~MSG
           Unauthorized internal call of a mock internally by Mocktail itself:
@@ -40,7 +43,7 @@ module Mocktail
 
           Offending call's complete stack trace:
 
-          #{backtrace_minus_this_and_whoever_called_this.join("\n")}
+          #{backtrace_minus_this_and_whoever_called_this&.join("\n")}
           ==END OFFENDING TRACE==
         MSG
       end

data/lib/mocktail/dsl.rb

@@ -1,5 +1,7 @@
 module Mocktail
   module DSL
+    extend T::Sig
+
     def stubs(ignore_block: false, ignore_extra_args: false, ignore_arity: false, times: nil, &demo)
       RegistersStubbing.new.register(demo, DemoConfig.new(
         ignore_block: ignore_block,

data/lib/mocktail/errors.rb

@@ -12,4 +12,6 @@ module Mocktail
   class InvalidMatcherError < Error; end
 
   class VerificationError < Error; end
+
+  class TypeCheckingError < Error; end
 end

data/lib/mocktail/explains_nils.rb

@@ -3,6 +3,8 @@ require_relative "share/stringifies_call"
 
 module Mocktail
   class ExplainsNils
+    extend T::Sig
+
     def initialize
       @stringifies_method_name = StringifiesMethodName.new
       @stringifies_call = StringifiesCall.new

data/lib/mocktail/explains_thing.rb

@@ -3,6 +3,8 @@ require_relative "share/stringifies_call"
 
 module Mocktail
   class ExplainsThing
+    extend T::Sig
+
     def initialize
       @stringifies_method_name = StringifiesMethodName.new
       @stringifies_call = StringifiesCall.new
@@ -11,7 +13,8 @@ module Mocktail
     def explain(thing)
       if (double = Mocktail.cabinet.double_for_instance(thing))
         double_explanation(double)
-      elsif (type_replacement = TopShelf.instance.type_replacement_if_exists_for(thing))
+      elsif (thing.is_a?(Module) || thing.is_a?(Class)) &&
+          (type_replacement = TopShelf.instance.type_replacement_if_exists_for(thing))
         replaced_type_explanation(type_replacement)
       elsif (fake_method_explanation = fake_method_explanation_for(thing))
         fake_method_explanation
@@ -67,7 +70,7 @@ module Mocktail
     def data_for_type_replacement(type_replacement)
       TypeReplacementData.new(
         type: type_replacement.type,
-        replaced_method_names: type_replacement.replacement_methods.map(&:name).sort,
+        replaced_method_names: type_replacement.replacement_methods&.map(&:name)&.sort || [],
         calls: Mocktail.cabinet.calls.select { |call|
           call.double == type_replacement.type
         },
@@ -81,7 +84,7 @@ module Mocktail
       type_replacement_data = data_for_type_replacement(type_replacement)
 
       ReplacedTypeExplanation.new(type_replacement_data, <<~MSG)
-        `#{type_replacement.type}' is a #{type_replacement.type.class.to_s.downcase} that has had its singleton methods faked.
+        `#{type_replacement.type}' is a #{type_replacement.type.class.to_s.downcase} that has had its methods faked.
 
         It has these mocked methods:
         #{type_replacement_data.replaced_method_names.map { |method| "  - #{method}" }.join("\n")}
@@ -116,7 +119,7 @@ module Mocktail
     end
 
     def no_explanation(thing)
-      NoExplanation.new(thing,
+      NoExplanation.new(NoExplanationData.new(thing: thing),
         "Unfortunately, Mocktail doesn't know what this thing is: #{thing.inspect}")
     end
   end

data/lib/mocktail/grabs_original_method_parameters.rb

@@ -0,0 +1,30 @@
+module Mocktail
+  class GrabsOriginalMethodParameters
+    extend T::Sig
+
+    # Sorbet wraps the original method in a sig wrapper, so we need to unwrap it.
+    # The value returned from `owner.instance_method(method_name)` does not have
+    # the real parameters values available, as they'll have been erased
+    #
+    # If the method isn't wrapped by Sorbet, this will return the #instance_method,
+    # per usual
+
+    def grab(method)
+      return [] unless method
+
+      if (wrapped_method = sorbet_wrapped_method(method))
+        wrapped_method.parameters
+      else
+        method.parameters
+      end
+    end
+
+    private
+
+    def sorbet_wrapped_method(method)
+      return unless defined?(::T::Private::Methods)
+
+      T::Private::Methods.signature_for_method(method)
+    end
+  end
+end

data/lib/mocktail/handles_dry_call/fulfills_stubbing/describes_unsatisfied_stubbing.rb

@@ -3,6 +3,8 @@ require_relative "../../share/bind"
 
 module Mocktail
   class DescribesUnsatisfiedStubbing
+    extend T::Sig
+
     def initialize
       @cleans_backtrace = CleansBacktrace.new
     end
@@ -14,7 +16,7 @@ module Mocktail
           Bind.call(dry_call.double, :==, stubbing.recording.double) &&
             dry_call.method == stubbing.recording.method
         },
-        backtrace: @cleans_backtrace.clean(Error.new).backtrace
+        backtrace: @cleans_backtrace.clean(Error.new).backtrace || []
       )
     end
   end

data/lib/mocktail/handles_dry_call/fulfills_stubbing/finds_satisfaction.rb

@@ -2,14 +2,18 @@ require_relative "../../share/determines_matching_calls"
 
 module Mocktail
   class FindsSatisfaction
+    extend T::Sig
+
     def initialize
       @determines_matching_calls = DeterminesMatchingCalls.new
     end
 
     def find(dry_call)
       Mocktail.cabinet.stubbings.reverse.find { |stubbing|
+        demo_config_times = stubbing.demo_config.times
+
         @determines_matching_calls.determine(dry_call, stubbing.recording, stubbing.demo_config) &&
-          (stubbing.demo_config.times.nil? || stubbing.demo_config.times > stubbing.satisfaction_count)
+          (demo_config_times.nil? || demo_config_times > stubbing.satisfaction_count)
       }
     end
   end

data/lib/mocktail/handles_dry_call/fulfills_stubbing.rb

@@ -3,6 +3,8 @@ require_relative "fulfills_stubbing/describes_unsatisfied_stubbing"
 
 module Mocktail
   class FulfillsStubbing
+    extend T::Sig
+
     def initialize
       @finds_satisfaction = FindsSatisfaction.new
       @describes_unsatisfied_stubbing = DescribesUnsatisfiedStubbing.new

data/lib/mocktail/handles_dry_call/logs_call.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class LogsCall
+    extend T::Sig
+
     def log(dry_call)
       Mocktail.cabinet.store_call(dry_call)
     end

data/lib/mocktail/handles_dry_call/validates_arguments.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class ValidatesArguments
+    extend T::Sig
+
     def self.disable!
       Thread.current[:mocktail_arity_validation_disabled] = true
     end
@@ -9,16 +11,16 @@ module Mocktail
     end
 
     def self.disabled?
-      Thread.current[:mocktail_arity_validation_disabled]
+      !!Thread.current[:mocktail_arity_validation_disabled]
     end
 
     def self.optional(disable, &blk)
       return blk.call unless disable
 
       disable!
-      blk.call.tap do
-        enable!
-      end
+      ret = blk.call
+      enable!
+      ret
     end
 
     def initialize

data/lib/mocktail/handles_dry_call.rb

@@ -4,6 +4,8 @@ require_relative "handles_dry_call/validates_arguments"
 
 module Mocktail
   class HandlesDryCall
+    extend T::Sig
+
     def initialize
       @validates_arguments = ValidatesArguments.new
       @logs_call = LogsCall.new

data/lib/mocktail/handles_dry_new_call.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class HandlesDryNewCall
+    extend T::Sig
+
     def initialize
       @validates_arguments = ValidatesArguments.new
       @logs_call = LogsCall.new

data/lib/mocktail/imitates_type/ensures_imitation_support.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class EnsuresImitationSupport
+    extend T::Sig
+
     def ensure(type)
       unless type.is_a?(Class) || type.is_a?(Module)
         raise UnsupportedMocktail.new <<~MSG.tr("\n", " ")

data/lib/mocktail/imitates_type/makes_double/declares_dry_class/reconstructs_call.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class ReconstructsCall
+    extend T::Sig
+
     def reconstruct(double:, call_binding:, default_args:, dry_class:, type:, method:, original_method:, signature:)
       Call.new(
         singleton: false,
@@ -37,7 +39,8 @@ module Mocktail
     def non_default_args(params, default_args)
       named_args = params.allowed
         .reject { |p| default_args&.key?(p) }
-      rest_arg = if params.rest && !default_args&.key?(params.rest)
+      rest_param = params.rest
+      rest_arg = if rest_param && !default_args&.key?(rest_param)
         params.rest
       end
 

data/lib/mocktail/imitates_type/makes_double/declares_dry_class.rb

@@ -2,60 +2,72 @@ require_relative "declares_dry_class/reconstructs_call"
 
 module Mocktail
   class DeclaresDryClass
+    extend T::Sig
+
+    DEFAULT_ANCESTORS = Class.new(Object).ancestors[1..]
+
     def initialize
       @raises_neato_no_method_error = RaisesNeatoNoMethodError.new
       @transforms_params = TransformsParams.new
       @stringifies_method_signature = StringifiesMethodSignature.new
+      @grabs_original_method_parameters = GrabsOriginalMethodParameters.new
     end
 
     def declare(type, instance_methods)
       dry_class = Class.new(Object) {
-        include type if type.instance_of?(Module)
+        include type if type.is_a?(Module) && !type.is_a?(Class)
 
-        def initialize(*args, **kwargs, &blk)
+        define_method :initialize do |*args, **kwargs, &blk|
         end
 
-        define_method :is_a?, ->(thing) {
-          type.ancestors.include?(thing)
-        }
-        alias_method :kind_of?, :is_a?
+        [:is_a?, :kind_of?].each do |method_name|
+          define_method method_name, ->(thing) {
+            # Mocktails extend from Object, so share the same ancestors, plus the passed type
+            [type, *DEFAULT_ANCESTORS].include?(thing)
+          }
+        end
 
-        if type.instance_of?(Class)
+        if type.is_a?(Class)
           define_method :instance_of?, ->(thing) {
             type == thing
           }
         end
       }
 
-      # These have special implementations, but if the user defines
-      # any of them on the object itself, then they'll be replaced with normal
-      # mocked methods. YMMV
+      add_more_methods!(dry_class, type, instance_methods)
+
+      dry_class  # This is all fake! That's the whole point—it's not a real Foo, it's just some new class that quacks like a Foo
+    end
+
+    private
+
+    # These have special implementations, but if the user defines
+    # any of them on the object itself, then they'll be replaced with normal
+    # mocked methods. YMMV
+
+    def add_more_methods!(dry_class, type, instance_methods)
       add_stringify_methods!(dry_class, :to_s, type, instance_methods)
       add_stringify_methods!(dry_class, :inspect, type, instance_methods)
       define_method_missing_errors!(dry_class, type, instance_methods)
 
       define_double_methods!(dry_class, type, instance_methods)
-
-      dry_class
     end
 
-    private
-
     def define_double_methods!(dry_class, type, instance_methods)
-      instance_methods.each do |method|
-        dry_class.undef_method(method) if dry_class.method_defined?(method)
-        parameters = type.instance_method(method).parameters
+      instance_methods.each do |method_name|
+        dry_class.undef_method(method_name) if dry_class.method_defined?(method_name)
+        parameters = @grabs_original_method_parameters.grab(type.instance_method(method_name))
         signature = @transforms_params.transform(Call.new, params: parameters)
         method_signature = @stringifies_method_signature.stringify(signature)
         __mocktail_closure = {
           dry_class: dry_class,
           type: type,
-          method: method,
-          original_method: type.instance_method(method),
+          method: method_name,
+          original_method: type.instance_method(method_name),
           signature: signature
         }
 
-        dry_class.define_method method,
+        dry_class.define_method method_name,
           eval(<<-RUBBY, binding, __FILE__, __LINE__ + 1) # standard:disable Security/Eval
             ->#{method_signature} do
               ::Mocktail::Debug.guard_against_mocktail_accidentally_calling_mocks_if_debugging!

data/lib/mocktail/imitates_type/makes_double/gathers_fakeable_instance_methods.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class GathersFakeableInstanceMethods
+    extend T::Sig
+
     def gather(type)
       methods = type.instance_methods + [
         (:respond_to_missing? if type.private_method_defined?(:respond_to_missing?))

data/lib/mocktail/imitates_type/makes_double.rb

@@ -3,6 +3,8 @@ require_relative "makes_double/gathers_fakeable_instance_methods"
 
 module Mocktail
   class MakesDouble
+    extend T::Sig
+
     def initialize
       @declares_dry_class = DeclaresDryClass.new
       @gathers_fakeable_instance_methods = GathersFakeableInstanceMethods.new
@@ -11,6 +13,7 @@ module Mocktail
     def make(type)
       dry_methods = @gathers_fakeable_instance_methods.gather(type)
       dry_type = @declares_dry_class.declare(type, dry_methods)
+
       Double.new(
         original_type: type,
         dry_type: dry_type,

data/lib/mocktail/imitates_type.rb

@@ -3,8 +3,10 @@ require_relative "imitates_type/makes_double"
 
 module Mocktail
   class ImitatesType
+    extend T::Sig
+    extend T::Generic
+
     def initialize
-      @top_shelf = TopShelf.instance
       @ensures_imitation_support = EnsuresImitationSupport.new
       @makes_double = MakesDouble.new
     end

data/lib/mocktail/initialize_based_on_type_system_mode_switching.rb

@@ -0,0 +1,9 @@
+require_relative "typed"
+
+# Constant boolean, so won't statically type-check, but `T.unsafe` can't be used
+# because we haven't required sorbet-runtime yet
+if eval("Mocktail::TYPED", binding, __FILE__, __LINE__)
+  require "sorbet-runtime"
+else
+  require "#{Gem.loaded_specs["sorbet-eraser"].gem_dir}/lib/t"
+end

data/lib/mocktail/initializes_mocktail.rb

@@ -1,9 +1,14 @@
 module Mocktail
   class InitializesMocktail
+    extend T::Sig
+
     def init
       [
         Mocktail::Matchers::Any,
         Mocktail::Matchers::Includes,
+        Mocktail::Matchers::IncludesString,
+        Mocktail::Matchers::IncludesKey,
+        Mocktail::Matchers::IncludesHash,
         Mocktail::Matchers::IsA,
         Mocktail::Matchers::Matches,
         Mocktail::Matchers::Not,

data/lib/mocktail/matcher_presentation.rb

@@ -1,12 +1,14 @@
 module Mocktail
   class MatcherPresentation
+    extend T::Sig
+
     def respond_to_missing?(name, include_private = false)
       !!MatcherRegistry.instance.get(name) || super
     end
 
-    def method_missing(name, *args, **kwargs, &blk)
+    def method_missing(name, *args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
       if (matcher = MatcherRegistry.instance.get(name))
-        matcher.new(*args, **kwargs, &blk)
+        matcher.new(*args, **kwargs, &blk) # standard:disable Style/ArgumentsForwarding
       else
         super
       end

data/lib/mocktail/matchers/any.rb

@@ -1,12 +1,13 @@
 module Mocktail::Matchers
   class Any < Base
+    extend T::Sig
+
     def self.matcher_name
       :any
     end
 
-    # Change this comment to a descriptive one once this is merged:
-    # https://github.com/rubocop/rubocop/pull/10551
-    def initialize # standard:disable Style/RedundantInitialize
+    def initialize
+      # Empty initialize is necessary b/c Base default expects an argument
     end
 
     def match?(actual)

data/lib/mocktail/matchers/base.rb

@@ -1,17 +1,25 @@
 module Mocktail::Matchers
   class Base
+    extend T::Sig
+    extend T::Helpers
+
+    if Mocktail::TYPED && T::Private::RuntimeLevels.default_checked_level != :never
+
+    end
+
     # Custom matchers can receive any args, kwargs, or block they want. Usually
     # single-argument, though, so that's defaulted here and in #insepct
+
     def initialize(expected)
       @expected = expected
     end
 
     def self.matcher_name
-      raise Mocktail::Error.new("The `matcher_name` class method must return a valid method name")
+      raise Mocktail::InvalidMatcherError.new("The `matcher_name` class method must return a valid method name")
     end
 
     def match?(actual)
-      raise Mocktail::Error.new("Matchers must implement `match?(argument)`")
+      raise Mocktail::InvalidMatcherError.new("Matchers must implement `match?(argument)`")
     end
 
     def inspect

data/lib/mocktail/matchers/captor.rb

@@ -13,7 +13,11 @@ module Mocktail::Matchers
   # See Mockito, which is the earliest implementation I know of:
   # https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Captor.html
   class Captor
+    extend T::Sig
+
     class Capture < Mocktail::Matchers::Base
+      extend T::Sig
+
       def self.matcher_name
         :capture
       end
@@ -40,7 +44,12 @@ module Mocktail::Matchers
       end
     end
 
+    # This T.untyped is intentional. Even though a Capture is surely returned,
+    # in order for a verification demonstration to pass its own type check,
+    # it needs to think it's being returned whatever parameter is expected
+
     attr_reader :capture
+
     def initialize
       @capture = Capture.new
     end

data/lib/mocktail/matchers/includes.rb

@@ -1,5 +1,7 @@
 module Mocktail::Matchers
   class Includes < Base
+    extend T::Sig
+
     def self.matcher_name
       :includes
     end

data/lib/mocktail/matchers/includes_hash.rb

@@ -0,0 +1,9 @@
+module Mocktail::Matchers
+  class IncludesHash < Includes
+    extend T::Sig
+
+    def self.matcher_name
+      :includes_hash
+    end
+  end
+end

data/lib/mocktail/matchers/includes_key.rb

@@ -0,0 +1,9 @@
+module Mocktail::Matchers
+  class IncludesKey < Includes
+    extend T::Sig
+
+    def self.matcher_name
+      :includes_key
+    end
+  end
+end

data/lib/mocktail/matchers/includes_string.rb

@@ -0,0 +1,9 @@
+module Mocktail::Matchers
+  class IncludesString < Includes
+    extend T::Sig
+
+    def self.matcher_name
+      :includes_string
+    end
+  end
+end

data/lib/mocktail/matchers/is_a.rb

@@ -1,5 +1,7 @@
 module Mocktail::Matchers
   class IsA < Base
+    extend T::Sig
+
     def self.matcher_name
       :is_a
     end

data/lib/mocktail/matchers/matches.rb

@@ -1,5 +1,7 @@
 module Mocktail::Matchers
   class Matches < Base
+    extend T::Sig
+
     def self.matcher_name
       :matches
     end