mocktail 2.0.0 → 3.0.1

data/lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb

@@ -1,5 +1,7 @@
 # typed: strict
 
+require_relative "../share/folds_keywords_into_options_hash"
+
 module Mocktail
   class RedefinesSingletonMethods
     extend T::Sig
@@ -7,6 +9,7 @@ module Mocktail
     sig { void }
     def initialize
       @handles_dry_call = T.let(HandlesDryCall.new, HandlesDryCall)
+      @folds_keywords_into_options_hash = T.let(FoldsKeywordsIntoOptionsHash.new, FoldsKeywordsIntoOptionsHash)
     end
 
     sig { params(type: T.any(T::Class[T.anything], Module)).void }
@@ -20,10 +23,12 @@ module Mocktail
 
       declare_singleton_method_missing_errors!(type)
       handles_dry_call = @handles_dry_call
+      folds_keywords_into_options_hash = @folds_keywords_into_options_hash
       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)
+            args, kwargs = folds_keywords_into_options_hash.fold(original_method, args, kwargs)
             handles_dry_call.handle(Call.new(
               singleton: true,
               double: type,

data/lib/mocktail/sorbet/mocktail/share/folds_keywords_into_options_hash.rb

@@ -0,0 +1,25 @@
+# typed: strict
+
+module Mocktail
+  class FoldsKeywordsIntoOptionsHash
+    extend T::Sig
+
+    KEYWORD_PARAM_TYPES = T.let([:key, :keyreq, :keyrest, :nokey].freeze, T::Array[Symbol])
+
+    sig { void }
+    def initialize
+      @grabs_original_method_parameters = T.let(GrabsOriginalMethodParameters.new, GrabsOriginalMethodParameters)
+    end
+
+    # Ruby 3 passes keywords to a method with no keyword params as a trailing
+    # positional hash, but our generic (*args, **kwargs) lambdas always split
+    # them out, so fold them back in to match what the real method would see
+    sig { params(original_method: T.nilable(T.any(UnboundMethod, Method)), args: T::Array[T.anything], kwargs: T::Hash[Symbol, T.anything]).returns([T::Array[T.anything], T::Hash[Symbol, T.anything]]) }
+    def fold(original_method, args, kwargs)
+      return [args, kwargs] if kwargs.empty? || original_method.nil?
+      return [args, kwargs] if @grabs_original_method_parameters.grab(original_method).any? { |type, _| KEYWORD_PARAM_TYPES.include?(type) }
+
+      [[*args, kwargs], {}]
+    end
+  end
+end

data/lib/mocktail/sorbet/mocktail/share/stringifies_call.rb

@@ -12,7 +12,6 @@ module Mocktail
     sig { params(calls: T::Array[Call], nonzero_message: String, zero_message: String, anonymous_blocks: T::Boolean, always_parens: T::Boolean).returns(String) }
     def stringify_multiple(calls, nonzero_message:, zero_message:,
       anonymous_blocks: false, always_parens: false)
-
       if calls.empty?
         "#{zero_message}.\n"
       else

data/lib/mocktail/sorbet/mocktail/simulates_argument_error/transforms_params.rb

@@ -28,7 +28,7 @@ module Mocktail
         positional_args: dry_call.args,
 
         keyword_params: Params.new(
-          all: params.select { |type, _|
+          all: params.select { |type, _| # standard:disable Style/HashSlice
             [:keyreq, :key, :keyrest].include?(type)
           }.map { |pair| pair.fetch(1) },
           required: params.select { |t, _| Bind.call(t, :==, :keyreq) }.map { |pair| pair.fetch(1) },
@@ -48,7 +48,7 @@ module Mocktail
     def name_unnamed_params(params)
       params.map.with_index { |param, i|
         if param.size == 1
-          param + ["unnamed_arg_#{i + 1}".to_sym]
+          param + [:"unnamed_arg_#{i + 1}"]
         else
           param
         end

data/lib/mocktail/sorbet/mocktail/value/call.rb

@@ -36,7 +36,7 @@ module Mocktail
           :singleton, :double, :original_type, :dry_type,
           :method, :original_method, :args, :kwargs, :block
         ].all? { |attr|
-          instance_variable_get("@#{attr}") == other.send(attr)
+          instance_variable_get(:"@#{attr}") == other.send(attr)
         }
       else
         false

data/lib/mocktail/sorbet/mocktail/version.rb

@@ -8,5 +8,5 @@ module Mocktail
     Mocktail.send(:remove_const, :VERSION)
   end
 
-  VERSION = "2.0.0"
+  VERSION = "3.0.1"
 end

data/lib/mocktail/value/call.rb

@@ -32,7 +32,7 @@ module Mocktail
           :singleton, :double, :original_type, :dry_type,
           :method, :original_method, :args, :kwargs, :block
         ].all? { |attr|
-          instance_variable_get("@#{attr}") == other.send(attr)
+          instance_variable_get(:"@#{attr}") == other.send(attr)
         }
       else
         false

data/lib/mocktail/version.rb

@@ -6,5 +6,5 @@ module Mocktail
     Mocktail.send(:remove_const, :VERSION)
   end
 
-  VERSION = "2.0.0"
+  VERSION = "3.0.1"
 end

data/mocktail.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
 
   spec.summary = "Take your objects, and make them a double"
   spec.homepage = "https://github.com/testdouble/mocktail"
-  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.1.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features|src|sub_projects|spoom_data|sorbet|script|docs)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
   end
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }

data/rbi/mocktail-pregenerated.rbi

@@ -4,17 +4,13 @@
 # This is an autogenerated file for types exported from the `mocktail` gem.
 # Please instead update this file by running `bin/tapioca gem mocktail`.
 
-# typed: true
 
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `mocktail` gem.
-# Please instead update this file by running `bin/tapioca gem mocktail`.
+# typed: true
 
 # The Cabinet stores all thread-local state, so anything that goes here
 # is guaranteed by Mocktail to be local to the currently-running thread
 #
 # source://mocktail//lib/mocktail/sorbet/mocktail/typed.rb#3
-# The Cabinet stores all thread-local state, so anything that goes here
 module Mocktail
   extend ::Mocktail::DSL
 
@@ -212,7 +208,7 @@ class Mocktail::Call < ::T::Struct
   def hash; end
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -372,7 +368,7 @@ class Mocktail::DemoConfig < ::T::Struct
   const :times, T.nilable(::Integer), default: T.unsafe(nil)
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -445,7 +441,7 @@ class Mocktail::Double < ::T::Struct
   const :dry_methods, T::Array[::Symbol]
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -460,7 +456,7 @@ class Mocktail::DoubleData < ::T::Struct
   const :stubbings, T::Array[Mocktail::Stubbing[T.anything]]
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -592,7 +588,7 @@ class Mocktail::FakeMethodData < ::T::Struct
   const :stubbings, T::Array[Mocktail::Stubbing[T.anything]]
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -630,6 +626,30 @@ class Mocktail::FindsVerifiableCalls
   def find(recording, demo_config); end
 end
 
+# source://mocktail//lib/mocktail/sorbet/mocktail/share/folds_keywords_into_options_hash.rb#4
+class Mocktail::FoldsKeywordsIntoOptionsHash
+  # source://mocktail//lib/mocktail/sorbet/mocktail/share/folds_keywords_into_options_hash.rb#10
+  sig { void }
+  def initialize; end
+
+  # Ruby 3 passes keywords to a method with no keyword params as a trailing
+  # positional hash, but our generic (*args, **kwargs) lambdas always split
+  # them out, so fold them back in to match what the real method would see
+  #
+  # source://mocktail//lib/mocktail/sorbet/mocktail/share/folds_keywords_into_options_hash.rb#18
+  sig do
+    params(
+      original_method: T.nilable(T.any(::Method, ::UnboundMethod)),
+      args: T::Array[T.anything],
+      kwargs: T::Hash[::Symbol, T.anything]
+    ).returns([T::Array[T.anything], T::Hash[::Symbol, T.anything]])
+  end
+  def fold(original_method, args, kwargs); end
+end
+
+# source://mocktail//lib/mocktail/sorbet/mocktail/share/folds_keywords_into_options_hash.rb#7
+Mocktail::FoldsKeywordsIntoOptionsHash::KEYWORD_PARAM_TYPES = T.let(T.unsafe(nil), Array)
+
 # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_call/fulfills_stubbing.rb#7
 class Mocktail::FulfillsStubbing
   # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_call/fulfills_stubbing.rb#11
@@ -704,13 +724,13 @@ class Mocktail::HandlesDryCall
   def handle(dry_call); end
 end
 
-# source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_new_call.rb#4
+# source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_new_call.rb#6
 class Mocktail::HandlesDryNewCall
-  # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_new_call.rb#8
+  # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_new_call.rb#10
   sig { void }
   def initialize; end
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_new_call.rb#16
+  # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_new_call.rb#19
   sig do
     params(
       type: T::Class[T.all(::Object, ::T)],
@@ -915,15 +935,6 @@ end
 # https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Captor.html
 #
 # source://mocktail//lib/mocktail/sorbet/mocktail/matchers/captor.rb#17
-# Captors are conceptually complex implementations, but with a simple usage/purpose:
-# They are values the user can create and hold onto that will return a matcher
-# and then "capture" the value made by the real call, for later analysis & assertion.
-# Unlike other matchers, these don't make any useful sense for stubbing, but are
-# very useful when asserting complication call verifications
-# The fact the user will need the reference outside the verification call is
-# why this is a top-level method on Mocktail, and not included in the |m| block
-# arg to stubs/verify
-# See Mockito, which is the earliest implementation I know of:
 class Mocktail::Matchers::Captor
   # source://mocktail//lib/mocktail/sorbet/mocktail/matchers/captor.rb#62
   sig { void }
@@ -1139,7 +1150,7 @@ class Mocktail::NoExplanationData < ::T::Struct
   def stubbings; end
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -1160,7 +1171,7 @@ class Mocktail::Params < ::T::Struct
   def rest?; end
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -1338,23 +1349,23 @@ class Mocktail::RedefinesNew
   def redefine(type); end
 end
 
-# source://mocktail//lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb#4
+# source://mocktail//lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb#6
 class Mocktail::RedefinesSingletonMethods
-  # source://mocktail//lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb#8
+  # source://mocktail//lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb#10
   sig { void }
   def initialize; end
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb#47
+  # source://mocktail//lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb#52
   sig { params(type: T.any(::Module, T::Class[T.anything])).void }
   def declare_singleton_method_missing_errors!(type); end
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb#13
+  # source://mocktail//lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb#16
   sig { params(type: T.any(::Module, T::Class[T.anything])).void }
   def redefine(type); end
 
   private
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb#72
+  # source://mocktail//lib/mocktail/sorbet/mocktail/replaces_type/redefines_singleton_methods.rb#77
   sig { params(method: ::Method).returns(T::Boolean) }
   def sorbet_method_hook?(method); end
 end
@@ -1498,7 +1509,7 @@ class Mocktail::Signature < ::T::Struct
   const :block_arg, T.nilable(::Proc), default: T.unsafe(nil)
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -1543,31 +1554,31 @@ class Mocktail::StringifiesCall
 
   private
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#47
+  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#46
   sig { params(args: T::Array[::Object]).returns(T.nilable(::String)) }
   def argify(args); end
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#30
+  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#29
   sig { params(call: ::Mocktail::Call, parens: T::Boolean).returns(T.nilable(::String)) }
   def args_to_s(call, parens: T.unsafe(nil)); end
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#65
+  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#64
   sig { params(block: T.nilable(::Proc), anonymous: T::Boolean).returns(T.nilable(::String)) }
   def blockify(block, anonymous:); end
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#53
+  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#52
   sig { params(kwargs: T::Hash[::Symbol, ::Object]).returns(T.nilable(::String)) }
   def kwargify(kwargs); end
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#59
+  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#58
   sig { params(block: T.nilable(::Proc)).returns(T.nilable(::String)) }
   def lambdafy(block); end
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#76
+  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#75
   sig { params(block: ::Proc).returns(::String) }
   def source_locationify(block); end
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#81
+  # source://mocktail//lib/mocktail/sorbet/mocktail/share/stringifies_call.rb#80
   sig { params(path: ::String).returns(::String) }
   def strip_pwd(path); end
 end
@@ -1621,7 +1632,7 @@ class Mocktail::Stubbing < ::T::Struct
   def with(&block); end
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -1634,8 +1645,6 @@ Mocktail::TYPED = T.let(T.unsafe(nil), TrueClass)
 # method replacements carried out with Mocktail.replace(ClassOrModule)
 #
 # source://mocktail//lib/mocktail/sorbet/mocktail/value/top_shelf.rb#7
-# The TopShelf is where we keep all the more global, dangerous state.
-# In particular, this is where Mocktail manages state related to singleton
 class Mocktail::TopShelf
   # source://mocktail//lib/mocktail/sorbet/mocktail/value/top_shelf.rb#19
   sig { void }
@@ -1722,7 +1731,7 @@ class Mocktail::TypeReplacement < ::T::Struct
   prop :replacement_new, T.nilable(::Method)
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -1741,7 +1750,7 @@ class Mocktail::TypeReplacementData < ::T::Struct
   def double; end
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -1756,7 +1765,7 @@ class Mocktail::UnsatisfyingCall < ::T::Struct
   const :backtrace, T::Array[::String]
 
   class << self
-    # source://sorbet-runtime/0.5.10983/lib/types/struct.rb#13
+    # source://sorbet-runtime/0.5.11971/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -1788,11 +1797,11 @@ Mocktail::VERSION = T.let(T.unsafe(nil), String)
 
 # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_call/validates_arguments.rb#4
 class Mocktail::ValidatesArguments
-  # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_call/validates_arguments.rb#32
+  # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_call/validates_arguments.rb#35
   sig { void }
   def initialize; end
 
-  # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_call/validates_arguments.rb#37
+  # source://mocktail//lib/mocktail/sorbet/mocktail/handles_dry_call/validates_arguments.rb#40
   sig { params(dry_call: ::Mocktail::Call).returns(::NilClass) }
   def validate(dry_call); end
 

data/script/build

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+echo "-----> Deleting lib/ and copying src/ to lib/"
+rm -rf lib
+cp -r src/ lib
+
+echo "-----> Erasing sorbet sigs from lib/ (for non-Sorbet users)"
+bundle exec sorbet-eraser "lib/**/*.rb"
+echo "-----> Overwriting Mocktail::TYPED constant for lib/"
+cat << RUBY > lib/mocktail/typed.rb
+module Mocktail
+  TYPED = false
+end
+RUBY
+
+echo "-----> Erasing sorbet 'typed: ' sigils from lib/mocktail"
+./script/strip_sigils
+
+echo "-----> Copying src/ to lib/mocktail/sorbet/ (for Sorbet users)"
+cp -r src/ lib/mocktail/sorbet
+
+echo "-----> Running Standard against all code"
+bundle exec rake standard:fix
+
+echo "-----> Generating RBIs to publish with the gems"
+
+echo "----------> ❶ Faking out mocktail.rb and pointing it to mocktail/sorbet"
+mv lib/mocktail.rb lib/mocktail.rb.nope
+cat << RUBY > lib/mocktail.rb
+require_relative "mocktail/sorbet"
+RUBY
+
+echo "----------> ❷ Generating sorbet sigs via tapioca in sub_projects/rbi_generator"
+rm -f rbi/mocktail-pregenerated.rbi
+cd sub_projects/rbi_generator
+rm -f sorbet/rbi/gems/mocktail@*.rbi
+bundle
+bundle exec tapioca gem --all --exclude=tapioca ast diff-lcs erubi netrc parser prettier_print racc rbi spoom syntax_tree thor unparser sorbet yard parallel yard-sorbet
+cd ../..
+
+echo "----------> ❸ Moving the generated RBI to rbi/mocktail-pregenerated.rbi"
+cp sub_projects/rbi_generator/sorbet/rbi/gems/mocktail@*.rbi rbi/mocktail-pregenerated.rbi
+mv lib/mocktail.rb.nope lib/mocktail.rb
+
+

data/script/setup

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+bundle
+
+cd sub_projects/rbi_generator/
+bundle
+cd ../..
+
+cd sub_projects/sorbet_user/
+bundle
+cd ../..
+
+cd sub_projects/untyped_user/
+bundle
+cd ../..

data/script/spoom_me

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+bundle exec spoom coverage --save
+bundle exec spoom coverage report
+bundle exec spoom coverage open

data/script/strip_sigils

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# Removes all the sigil comments from the top of our sorbet-free code
+
+# Find all files that start with "# typed" in the first line
+files=$(grep -rl '^# typed' --exclude-dir=lib/mocktail/sorbet lib/*)
+
+# Loop through each file and delete the first line
+for file in $files
+do
+    # Check if we're on a Mac
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        sed -i '' '1d' $file
+    else
+        sed -i '1d' $file
+    fi
+done

data/script/test

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+echo "-----> Running Mocktail's test against src"
+COVER=true bundle exec rake
+
+echo "-----> Type-checking Mocktail source"
+bundle exec srb tc
+
+echo "-----> Building src/mocktail into lib/mocktail and lib/mocktail/sorbet"
+./script/build
+
+echo "-----> Running Mocktail's test against lib"
+MOCKTAIL_TEST_SRC_DIRECTORY="lib" bundle exec rake
+
+echo "-----> Running Mocktail's test against lib/mocktail/sorbet"
+MOCKTAIL_TEST_SRC_DIRECTORY="lib/mocktail/sorbet" bundle exec rake
+
+echo "-----> Ensuring that double-requiring Mocktail produces the right warning and bails out of redefining constants"
+script/test_double_require_warnings
+
+echo "-----> Type-checking the copy of Mocktail in lib/mocktail/sorbet"
+bundle exec srb tc --ignore src/ --dir lib/mocktail/sorbet
+
+echo "-----> Running sample project tests"
+cd sub_projects/sorbet_user
+./script/test
+cd ../..
+
+cd sub_projects/untyped_user
+./script/test
+cd ../..

data/script/test_double_require_warnings

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require "open3"
+
+def assert_warning(command:, warning:)
+  stdout, stderr, status = Open3.capture3(command)
+  # Ignore incidental Ruby/RubyGems/Bundler runtime warnings (e.g. from a
+  # Ruby version shipping a newer RubyGems than an older pinned Bundler
+  # expects) -- they always follow Ruby's "path:line: warning: message"
+  # format, unlike Mocktail's own warning below.
+  relevant_stderr = stderr.lines.reject { |line| line.match?(/\A\S+:\d+: warning: /) }.join
+  if relevant_stderr != warning
+    fail <<~MSG
+      Expected the correct error message on STDERR but it was wrong"
+
+      Expected:
+      #{warning}
+
+      Actual:
+      #{stderr}
+    MSG
+
+  end
+  fail "Expected empty STDOUT, but was #{stdout.inspect}" unless stdout.empty?
+  fail "Expected command to exit 0, but was #{status.exitstatus}" unless status.success?
+end
+
+puts "Test requiring 'mocktail' and then 'mocktail/sorbet' gives the right warning"
+assert_warning(
+  command: <<~CMD,
+    bundle exec ruby -e 'require "#{Dir.pwd}/lib/mocktail/sorbet"; require "#{Dir.pwd}/lib/mocktail"'
+  CMD
+  warning: <<~WARN
+    `require "mocktail"' was called, but Mocktail was already required as `require "mocktail/sorbet"', so we're NOT going to load it to avoid constants from being redefined. If you want to use Mocktail WITHOUT sorbet runtime checks, remove whatever is requiring `mocktail/sorbet'.
+  WARN
+)
+
+puts "Test requiring 'mocktail/sorbet' and then 'mocktail' gives the right warning"
+assert_warning(
+  command: <<~CMD,
+    bundle exec ruby -e 'require "#{Dir.pwd}/lib/mocktail"; require "#{Dir.pwd}/lib/mocktail/sorbet"'
+  CMD
+  warning: <<~WARN
+    `require "mocktail/sorbet"' was called, but Mocktail was already required as `require "mocktail"', so we're NOT going to load it to avoid constants from being redefined. If you want to use Mocktail WITH sorbet runtime checks, remove whatever is requiring `mocktail'.
+  WARN
+)

data/script/update

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+echo "-----> Updating root gems"
+bundle update
+
+echo "-----> Updating 'sub_projects/rbi_generator' gems"
+cd sub_projects/rbi_generator
+bundle update
+cd ../..
+
+echo "-----> Updating 'sub_projects/sorbet_user' gems"
+cd sub_projects/sorbet_user
+bundle update
+cd ../..
+
+echo "-----> Updating 'sub_projects/untyped_user' gems"
+cd sub_projects/untyped_user
+bundle update
+cd ../..

data/sorbet/config

@@ -0,0 +1,12 @@
+--dir
+.
+--ignore=tmp/
+--ignore=Rakefile
+--ignore=vendor/
+--ignore=sub_projects/sorbet_user/
+--ignore=sub_projects/rbi_generator/
+--ignore=lib/
+# Ignore b/c these stubs will confuse the typechecker and generate a bunch of errors, even tho #typed: false
+--ignore=test/support/sorbet_stubs.rb
+# Ignore b/c this pregenerated rbi is for consumers of the gem, not the gem itself
+--ignore=rbi/mocktail-pregenerated.rbi