mocktail 1.2.3 → 3.0.0

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

data/lib/mocktail/matchers/not.rb

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

data/lib/mocktail/matchers/numeric.rb

@@ -1,16 +1,17 @@
 module Mocktail::Matchers
   class Numeric < Base
+    extend T::Sig
+
     def self.matcher_name
       :numeric
     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)
-      [Integer, Float, (BigDecimal if defined?(BigDecimal))].include?(actual.class)
+      actual.is_a?(::Numeric)
     end
 
     def inspect

data/lib/mocktail/matchers/that.rb

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

data/lib/mocktail/matchers.rb

@@ -7,6 +7,9 @@ require_relative "matchers/base"
 require_relative "matchers/any"
 require_relative "matchers/captor"
 require_relative "matchers/includes"
+require_relative "matchers/includes_string"
+require_relative "matchers/includes_hash"
+require_relative "matchers/includes_key"
 require_relative "matchers/is_a"
 require_relative "matchers/matches"
 require_relative "matchers/not"

data/lib/mocktail/raises_neato_no_method_error.rb

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

data/lib/mocktail/records_demonstration.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class RecordsDemonstration
+    extend T::Sig
+
     def record(demonstration, demo_config)
       cabinet = Mocktail.cabinet
       prior_call_count = Mocktail.cabinet.calls.dup.size

data/lib/mocktail/registers_matcher.rb

@@ -1,5 +1,11 @@
 module Mocktail
   class RegistersMatcher
+    extend T::Sig
+
+    def initialize
+      @grabs_original_method_parameters = GrabsOriginalMethodParameters.new
+    end
+
     def register(matcher_type)
       if invalid_type?(matcher_type)
         raise InvalidMatcherError.new <<~MSG.tr("\n", " ")
@@ -32,12 +38,11 @@ module Mocktail
       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?(":\"")
+      !name.respond_to?(:to_sym) || name.to_sym.inspect.start_with?(":\"")
     end
 
     def invalid_match?(matcher_type)
-      params = matcher_type.instance_method(:match?).parameters
+      params = @grabs_original_method_parameters.grab(matcher_type.instance_method(:match?))
       params.size > 1 || ![:req, :opt].include?(params.first[0])
     rescue NameError
       true

data/lib/mocktail/registers_stubbing.rb

@@ -2,6 +2,8 @@ require_relative "records_demonstration"
 
 module Mocktail
   class RegistersStubbing
+    extend T::Sig
+
     def initialize
       @records_demonstration = RecordsDemonstration.new
     end

data/lib/mocktail/replaces_next.rb

@@ -1,11 +1,17 @@
 module Mocktail
   class ReplacesNext
+    extend T::Sig
+
     def initialize
       @top_shelf = TopShelf.instance
       @redefines_new = RedefinesNew.new
       @imitates_type = ImitatesType.new
     end
 
+    def replace_once(type)
+      replace(type, 1).fetch(0)
+    end
+
     def replace(type, count)
       raise UnsupportedMocktail.new("Mocktail.of_next() only supports classes") unless type.is_a?(Class)
 
@@ -30,7 +36,7 @@ module Mocktail
         }
       end
 
-      (mocktails.size == 1) ? mocktails.first : mocktails
+      mocktails
     end
   end
 end

data/lib/mocktail/replaces_type/redefines_new.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class RedefinesNew
+    extend T::Sig
+
     def initialize
       @handles_dry_new_call = HandlesDryNewCall.new
     end
@@ -13,7 +15,7 @@ module Mocktail
         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)
+              (type.is_a?(Class) && TopShelf.instance.of_next_registered?(type))
             handles_dry_new_call.handle(type, args, kwargs, block)
           else
             type_replacement.original_new.call(*args, **kwargs, &block)

data/lib/mocktail/replaces_type/redefines_singleton_methods.rb

@@ -1,5 +1,7 @@
 module Mocktail
   class RedefinesSingletonMethods
+    extend T::Sig
+
     def initialize
       @handles_dry_call = HandlesDryCall.new
     end
@@ -10,11 +12,11 @@ module Mocktail
 
       type_replacement.original_methods = type.singleton_methods.map { |name|
         type.method(name)
-      } - [type_replacement.replacement_new]
+      }.reject { |method| sorbet_method_hook?(method) } - [type_replacement.replacement_new]
 
       declare_singleton_method_missing_errors!(type)
       handles_dry_call = @handles_dry_call
-      type_replacement.replacement_methods = type_replacement.original_methods.map { |original_method|
+      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)
@@ -58,5 +60,15 @@ module Mocktail
           )
         }
     end
+
+    private
+
+    def sorbet_method_hook?(method)
+      [
+        T::Sig,
+        T::Private::Methods::MethodHooks,
+        T::Private::Methods::SingletonMethodHooks
+      ].include?(method.owner)
+    end
   end
 end

data/lib/mocktail/replaces_type/runs_sorbet_sig_blocks_before_replacement.rb

@@ -0,0 +1,37 @@
+module Mocktail
+  class RunsSorbetSigBlocksBeforeReplacement
+    extend T::Sig
+
+    # This is necessary because when Sorbet runs a sig block of a singleton
+    # method, it has the net effect of unwrapping/redefining the method. If
+    # we try to use Mocktail.replace(Foo) and Foo.bar has a Sorbet sig block,
+    # then we'll end up with three "versions" of the same method and no way
+    # to keep straight which one == which:
+    #
+    #  A - Foo.bar, as defined in the original class
+    #  B - Foo.bar, as redefined by RedefinesSingletonMethods
+    #  C - Foo.bar, as wrapped by sorbet-runtime
+    #
+    # Initially, Foo.method(:bar) would == C, but after the type
+    # replacement, it would == B (with a reference back to C as the original),
+    # but after handling a single dry call, our invocation of
+    # GrabsOriginalMethodParameters.grab(Foo.method(:bar)) would invoke the
+    # Sorbet `sig` block, which has the net effect of redefining the method back
+    # to A.
+    #
+    # It's very fun and confusing and a great time.
+
+    def run(type)
+      return unless defined?(T::Private::Methods)
+
+      type.singleton_methods.each do |method_name|
+        method = type.method(method_name)
+
+        # Again: calling this for the side effect of running the sig block
+        #
+        # https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/private/methods/_methods.rb#L111
+        T::Private::Methods.signature_for_method(method)
+      end
+    end
+  end
+end

data/lib/mocktail/replaces_type.rb

@@ -1,10 +1,14 @@
 require_relative "replaces_type/redefines_new"
 require_relative "replaces_type/redefines_singleton_methods"
+require_relative "replaces_type/runs_sorbet_sig_blocks_before_replacement"
 
 module Mocktail
   class ReplacesType
+    extend T::Sig
+
     def initialize
       @top_shelf = TopShelf.instance
+      @runs_sorbet_sig_blocks_before_replacement = RunsSorbetSigBlocksBeforeReplacement.new
       @redefines_new = RedefinesNew.new
       @redefines_singleton_methods = RedefinesSingletonMethods.new
     end
@@ -14,6 +18,8 @@ module Mocktail
         raise UnsupportedMocktail.new("Mocktail.replace() only supports classes and modules")
       end
 
+      @runs_sorbet_sig_blocks_before_replacement.run(type)
+
       if type.is_a?(Class)
         @top_shelf.register_new_replacement!(type)
         @redefines_new.redefine(type)