Need less entries in require.rb

lib/tapioca/commands/gem.rb

@@ -124,7 +124,7 @@ def loader
 
       sig { returns(Gemfile) }
       def bundle
-        @bundle ||= Gemfile.new
+        @bundle ||= Gemfile.new(@exclude)
       end
 
       sig { void }

lib/tapioca/gemfile.rb

@@ -16,6 +16,50 @@ class Gemfile
       )
     end
 
+    # This is a module that gets prepended to `Bundler::Dependency` and
+    # makes sure even gems marked as `require: false` are required during
+    # `Bundler.require`.
+    module AutoRequireHook
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { ::Bundler::Dependency }
+
+      @exclude = T.let([], T::Array[String])
+
+      class << self
+        extend T::Sig
+
+        sig { params(exclude: T::Array[String]).returns(T::Array[String]) }
+        attr_writer :exclude
+
+        sig { params(name: T.untyped).returns(T::Boolean) }
+        def excluded?(name)
+          @exclude.include?(name)
+        end
+      end
+
+      sig { returns(T.untyped).checked(:never) }
+      def autorequire
+        value = super
+
+        # If the gem is excluded, we don't want to force require it, in case
+        # it has side-effects users don't want. For example, `fakefs` gem, if
+        # loaded, takes over filesystem operations.
+        return value if AutoRequireHook.excluded?(name)
+
+        # If a gem is marked as `require: false`, then its `autorequire`
+        # value will be `[]`. But, we want those gems to be loaded for our
+        # purposes as well, so we return `nil` in those cases, instead, which
+        # means `require: true`.
+        return nil if value == []
+
+        value
+      end
+
+      ::Bundler::Dependency.prepend(self)
+    end
+
     sig { returns(Bundler::Definition) }
     attr_reader(:definition)
 
@@ -25,8 +69,9 @@ class Gemfile
     sig { returns(T::Array[String]) }
     attr_reader(:missing_specs)
 
-    sig { void }
-    def initialize
+    sig { params(exclude: T::Array[String]).void }
+    def initialize(exclude)
+      AutoRequireHook.exclude = exclude
       @gemfile = T.let(File.new(Bundler.default_gemfile), File)
       @lockfile = T.let(File.new(Bundler.default_lockfile), File)
       @definition = T.let(Bundler::Dsl.evaluate(gemfile, lockfile, {}), Bundler::Definition)