Implement a thing

Author: LTe

README.md

@@ -173,6 +173,7 @@ Options:
   --post, -a,  [--postrequire=file]                                   # A file to be required after Bundler.require is called
                                                                       # Default: sorbet/tapioca/require.rb
   -x,          [--exclude=gem [gem ...]]                              # Exclude the given gem(s) from RBI generation
+               [--include-dependencies], [--no-include-dependencies]  # Generate RBI files for dependencies of the given gem(s)
   --typed, -t, [--typed-overrides=gem:level [gem:level ...]]          # Override for typed sigils for generated gem RBIs
                                                                       # Default: {"activesupport"=>"false"}
                [--verify], [--no-verify]                              # Verify RBIs are up-to-date
@@ -201,7 +202,7 @@ generate RBIs from gems
 ```
 <!-- END_HELP_COMMAND_GEM -->
 
-By default, running `tapioca gem` will only generate the RBI files for gems that have been added to or removed from the project's `Gemfile` this means that Tapioca will not regenerate the RBI files for untouched gems. However, when changing Tapioca configuration or bumping its version, it may be useful to force the regeneration of the RBI files previously generated. This can be done with the `--all` option:
+By default, running `tapioca gem` will only generate the RBI files for gems that have been added to or removed from the project's `Gemfile` this means that Tapioca will not regenerate the RBI files for untouched gems. When supplying gem names if you want to generate RBI files for their dependencies as well, you can use the `--include-dependencies` option. However, when changing Tapioca configuration or bumping its version, it may be useful to force the regeneration of the RBI files previously generated. This can be done with the `--all` option:
 
 ```shell
 bin/tapioca gems --all
@@ -944,6 +945,7 @@ gem:
   prerequire: ''
   postrequire: sorbet/tapioca/require.rb
   exclude: []
+  include_dependencies: false
   typed_overrides:
     activesupport: 'false'
   verify: false

lib/tapioca/cli.rb

@@ -193,6 +193,10 @@ def dsl(*constant_or_paths)
       banner: "gem [gem ...]",
       desc: "Exclude the given gem(s) from RBI generation",
       default: []
+    option :include_dependencies,
+      type: :boolean,
+      desc: "Generate RBI files for dependencies of the given gem(s)",
+      default: false
     option :typed_overrides,
       aliases: ["--typed", "-t"],
       type: :hash,
@@ -246,17 +250,22 @@ def gem(*gems)
 
       all = options[:all]
       verify = options[:verify]
+      include_dependencies = options[:include_dependencies]
 
       raise MalformattedArgumentError, "Options '--all' and '--verify' are mutually exclusive" if all && verify
 
-      unless gems.empty?
+      if gems.empty?
+        raise MalformattedArgumentError,
+          "Option '--include-dependencies' must be provided with gems" if include_dependencies
+      else
         raise MalformattedArgumentError, "Option '--all' must be provided without any other arguments" if all
         raise MalformattedArgumentError, "Option '--verify' must be provided without any other arguments" if verify
       end
 
       command_args = {
         gem_names: all ? [] : gems,
         exclude: options[:exclude],
+        include_dependencies: options[:include_dependencies],
         prerequire: options[:prerequire],
         postrequire: options[:postrequire],
         typed_overrides: options[:typed_overrides],

lib/tapioca/commands/abstract_gem.rb

@@ -13,6 +13,7 @@ class AbstractGem < Command
         params(
           gem_names: T::Array[String],
           exclude: T::Array[String],
+          include_dependencies: T::Boolean,
           prerequire: T.nilable(String),
           postrequire: String,
           typed_overrides: T::Hash[String, String],
@@ -31,6 +32,7 @@ class AbstractGem < Command
       def initialize(
         gem_names:,
         exclude:,
+        include_dependencies:,
         prerequire:,
         postrequire:,
         typed_overrides:,
@@ -47,6 +49,7 @@ def initialize(
       )
         @gem_names = gem_names
         @exclude = exclude
+        @include_dependencies = include_dependencies
         @prerequire = prerequire
         @postrequire = postrequire
         @typed_overrides = typed_overrides
@@ -74,6 +77,7 @@ def initialize(
       def gems_to_generate(gem_names)
         return @bundle.dependencies if gem_names.empty?
 
+        gem_names = gems_and_their_dependencies(gem_names) if @include_dependencies
         gem_names.map do |gem_name|
           gem = @bundle.gem(gem_name)
 
@@ -82,7 +86,12 @@ def gems_to_generate(gem_names)
           end
 
           gem
-        end
+        end.flatten.compact
+      end
+
+      sig { params(gem_names: T::Array[String]).returns(T::Array[String]) }
+      def gems_and_their_dependencies(gem_names)
+        gem_names.map { |gem_name| gem_with_dependencies(gem_name) }.flatten
       end
 
       sig { params(gem: Gemfile::GemSpec).void }
@@ -252,6 +261,26 @@ def expected_rbis
           .to_h { |gem| [gem.name, gem.version.to_s] }
       end
 
+      sig do
+        params(
+          gem_name: String,
+          gem_names: T::Array[String],
+        ).returns(T::Array[String])
+      end
+      def gem_with_dependencies(gem_name, gem_names = [])
+        gem = @bundle.gem(gem_name)
+        return [gem_name] if gem.nil?
+
+        direct_dependencies = gem.dependencies.map { |gem_spec| @bundle.gem(gem_spec.name) }.compact.map(&:name)
+        gem_names = [gem.name, gem_names, direct_dependencies].flatten.uniq.compact
+
+        return gem_names if direct_dependencies.empty?
+
+        direct_dependencies.reduce(gem_names) do |result, name|
+          gem_with_dependencies(name, result)
+        end
+      end
+
       sig { params(gem_name: String, version: String).returns(Pathname) }
       def gem_rbi_filename(gem_name, version)
         @outpath / "#{gem_name}@#{version}.rbi"

lib/tapioca/gemfile.rb

@@ -156,6 +156,11 @@ def name
         @spec.name
       end
 
+      sig { returns(T::Array[::Gem::Dependency]) }
+      def dependencies
+        @spec.dependencies
+      end
+
       sig { returns(String) }
       def rbi_file_name
         "#{name}@#{version}.rbi"

spec/tapioca/cli/gem_spec.rb

@@ -198,6 +198,17 @@ class << self
           assert_empty_stdout(result)
           refute_success_status(result)
         end
+
+        it "must show an error if --include-dependencies is supplied without gem" do
+          result = @project.tapioca("gem --include-dependencies")
+
+          assert_equal(<<~ERR, result.err)
+            Option '--include-dependencies' must be provided with gems
+          ERR
+
+          assert_empty_stdout(result)
+          refute_success_status(result)
+        end
       end
 
       describe "generate" do
@@ -744,6 +755,32 @@ class Secret; end
           assert_success_status(result)
         end
 
+        it "must respect include-dependencies option" do
+          @project.require_real_gem("actionpack", "7.0.6")
+          @project.require_mock_gem(mock_gem("foo", "0.0.1"))
+          @project.require_mock_gem(mock_gem("bar", "0.3.0", dependencies: ["bundler", "actionpack"]))
+          @project.require_mock_gem(mock_gem("baz", "0.0.2"))
+          @project.bundle_install
+
+          result = @project.tapioca("gem foo bar --include-dependencies")
+
+          assert_stdout_includes(result, "Compiled foo")
+          assert_stdout_includes(result, "Compiled bar")
+          assert_stdout_includes(result, "Compiled actionpack")
+          assert_stdout_includes(result, "Compiled rack")
+          refute_includes(result.out, "Compiled baz")
+          refute_includes(result.out, "Compiled bundler")
+
+          assert_project_file_exist("sorbet/rbi/gems/foo@0.0.1.rbi")
+          assert_project_file_exist("sorbet/rbi/gems/bar@0.3.0.rbi")
+          assert_project_file_exist("sorbet/rbi/gems/actionpack@7.0.6.rbi")
+          assert_project_file_exist("sorbet/rbi/gems/rack@2.2.8.rbi")
+          refute_project_file_exist("sorbet/rbi/gems/baz@0.0.2.rbi")
+
+          assert_empty_stderr(result)
+          assert_success_status(result)
+        end
+
         it "does not crash when the extras gem is loaded" do
           foo = mock_gem("foo", "0.0.1") do
             write("lib/foo.rb", FOO_RB)