tapioca 0.8.3 → 0.9.0

data/lib/tapioca/cli.rb

@@ -5,8 +5,7 @@ module Tapioca
   class Cli < Thor
     include CliHelper
     include ConfigHelper
-    include SorbetHelper
-    include ShimsHelper
+    include EnvHelper
 
     FILE_HEADER_OPTION_DESC = "Add a \"This file is generated\" header on top of each generated RBI file"
 
@@ -22,12 +21,23 @@ module Tapioca
       desc: "Verbose output for debugging purposes",
       default: false
 
-    desc "init", "initializes folder structure"
+    desc "init", "get project ready for type checking"
     def init
-      command = Commands::Init.new(
+      invoke(:configure)
+      invoke(:annotations)
+      invoke(:gem)
+      invoke(:todo)
+
+      print_init_next_steps
+    end
+
+    desc "configure", "initialize folder structure and type checking configuration"
+    option :postrequire, type: :string, default: DEFAULT_POSTREQUIRE_FILE
+    def configure
+      command = Commands::Configure.new(
         sorbet_config: SORBET_CONFIG_FILE,
-        tapioca_config: TAPIOCA_CONFIG_FILE,
-        default_postrequire: DEFAULT_POSTREQUIRE_FILE
+        tapioca_config: options[:config],
+        default_postrequire: options[:postrequire]
       )
       command.execute
     end
@@ -100,8 +110,15 @@ module Tapioca
     option :rbi_max_line_length,
       type: :numeric,
       desc: "Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped",
-      default: 120
+      default: DEFAULT_RBI_MAX_LINE_LENGTH
+    option :environment,
+      aliases: ["-e"],
+      type: :string,
+      desc: "The Rack/Rails environment to use when generating RBIs",
+      default: DEFAULT_ENVIRONMENT
     def dsl(*constants)
+      set_environment(options)
+
       command = Commands::Dsl.new(
         requested_constants: constants,
         outpath: Pathname.new(options[:outdir]),
@@ -194,9 +211,16 @@ module Tapioca
     option :rbi_max_line_length,
       type: :numeric,
       desc: "Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped",
-      default: 120
+      default: DEFAULT_RBI_MAX_LINE_LENGTH
+    option :environment,
+      aliases: ["-e"],
+      type: :string,
+      desc: "The Rack/Rails environment to use when generating RBIs",
+      default: DEFAULT_ENVIRONMENT
     def gem(*gems)
       Tapioca.silence_warnings do
+        set_environment(options)
+
         all = options[:all]
         verify = options[:verify]
 
@@ -208,7 +232,7 @@ module Tapioca
           typed_overrides: options[:typed_overrides],
           outpath: Pathname.new(options[:outdir]),
           file_header: options[:file_header],
-          doc: options[:doc],
+          include_doc: options[:doc],
           include_exported_rbis: options[:exported_gem_rbis],
           number_of_workers: options[:workers],
           auto_strictness: options[:auto_strictness],
@@ -243,68 +267,45 @@ module Tapioca
     option :gem_rbi_dir, type: :string, desc: "Path to gem RBIs", default: DEFAULT_GEM_DIR
     option :dsl_rbi_dir, type: :string, desc: "Path to DSL RBIs", default: DEFAULT_DSL_DIR
     option :shim_rbi_dir, type: :string, desc: "Path to shim RBIs", default: DEFAULT_SHIM_DIR
+    option :annotations_rbi_dir, type: :string, desc: "Path to annotations RBIs", default: DEFAULT_ANNOTATIONS_DIR
+    option :todo_rbi_file, type: :string, desc: "Path to the generated todo RBI file", default: DEFAULT_TODO_FILE
     option :payload, type: :boolean, desc: "Check shims against Sorbet's payload", default: true
     def check_shims
-      index = RBI::Index.new
-
-      shim_rbi_dir = options[:shim_rbi_dir]
-      if !Dir.exist?(shim_rbi_dir) || Dir.empty?(shim_rbi_dir)
-        say("No shim RBIs to check", :green)
-        exit(0)
-      end
-
-      payload_path = T.let(nil, T.nilable(String))
-
-      if options[:payload]
-        if sorbet_supports?(:print_payload_sources)
-          Dir.mktmpdir do |dir|
-            payload_path = dir
-            result = sorbet("--no-config --print=payload-sources:#{payload_path}")
-
-            unless result.status
-              say_error("Sorbet failed to dump payload")
-              say_error(result.err)
-              exit(1)
-            end
-
-            index_payload(index, payload_path)
-          end
-        else
-          say_error("The version of Sorbet used in your Gemfile.lock does not support `--print=payload-sources`")
-          say_error("Current: v#{SORBET_GEM_SPEC.version}")
-          say_error("Required: #{FEATURE_REQUIREMENTS[:print_payload_sources]}")
-          exit(1)
-        end
-      end
+      command = Commands::CheckShims.new(
+        gem_rbi_dir: options[:gem_rbi_dir],
+        dsl_rbi_dir: options[:dsl_rbi_dir],
+        shim_rbi_dir: options[:shim_rbi_dir],
+        annotations_rbi_dir: options[:annotations_rbi_dir],
+        todo_rbi_file: options[:todo_rbi_file],
+        payload: options[:payload]
+      )
+      command.execute
+    end
 
-      index_rbis(index, "shim", shim_rbi_dir)
-      index_rbis(index, "gem", options[:gem_rbi_dir])
-      index_rbis(index, "dsl", options[:dsl_rbi_dir])
-
-      duplicates = duplicated_nodes_from_index(index, shim_rbi_dir)
-      unless duplicates.empty?
-        duplicates.each do |key, nodes|
-          say_error("\nDuplicated RBI for #{key}:", :red)
-          nodes.each do |node|
-            node_loc = node.loc
-            next unless node_loc
-
-            loc_string = location_to_payload_url(node_loc, path_prefix: payload_path)
-            say_error(" * #{loc_string}", :red)
-          end
-        end
-        say_error("\nPlease remove the duplicated definitions from the #{shim_rbi_dir} directory.", :red)
+    desc "annotations", "Pull gem RBI annotations from remote sources"
+    option :sources, type: :array, default: [CENTRAL_REPO_ROOT_URI],
+      desc: "URIs of the sources to pull gem RBI annotations from"
+    option :netrc, type: :boolean, default: true, desc: "Use .netrc to authenticate to private sources"
+    option :netrc_file, type: :string, desc: "Path to .netrc file"
+    option :auth, type: :string, default: nil, desc: "HTTP authorization header for private sources"
+    option :typed_overrides,
+      aliases: ["--typed", "-t"],
+      type: :hash,
+      banner: "gem:level [gem:level ...]",
+      desc: "Override for typed sigils for pulled annotations",
+      default: {}
+    def annotations
+      if !options[:netrc] && options[:netrc_file]
+        say_error("Options `--no-netrc` and `--netrc-file` can't be used together", :bold, :red)
         exit(1)
       end
 
-      say("\nNo duplicates found in shim RBIs", :green)
-      exit(0)
-    end
-
-    desc "annotations", "Pull gem annotations from a central RBI repository"
-    option :repo_uri, type: :string, desc: "Repository URI to pull annotations from", default: CENTRAL_REPO_ROOT_URI
-    def annotations
-      command = Commands::Annotations.new(central_repo_root_uri: options[:repo_uri])
+      command = Commands::Annotations.new(
+        central_repo_root_uris: options[:sources],
+        auth: options[:auth],
+        netrc_file: netrc_file(options),
+        typed_overrides: options[:typed_overrides]
+      )
       command.execute
     end
 
@@ -320,5 +321,61 @@ module Tapioca
         true
       end
     end
+
+    private
+
+    def print_init_next_steps
+      say(<<~OUTPUT)
+        #{set_color("This project is now set up for use with Sorbet and Tapioca", :bold)}
+
+        The sorbet/ folder should exist and look something like this:
+
+        ├── config             # Default options to be passed to Sorbet on every run
+        └── rbi/
+          ├── annotations/     # Type definitions pulled from the rbi-central repository
+          ├── gems/            # Autogenerated type definitions for your gems
+          └── todo.rbi         # Constants which were still missing after RBI generation
+        └── tapioca/
+          ├── config.yml       # Default options to be passed to Tapioca
+          └── require.rb       # A file where you can make requires from gems that might be needed for gem RBI generation
+
+        Please check this folder into version control.
+
+        #{set_color("🤔 What's next", :bold)}
+
+        1. Many Ruby applications use metaprogramming DSLs to dynamically generate constants and methods.
+          To generate type definitions for any DSLs in your application, run:
+
+          #{set_color("bin/tapioca dsl", :cyan)}
+
+        2. Check whether the constants in the #{set_color("sorbet/rbi/todo.rbi", :cyan)} file actually exist in your project.
+          It is possible that some of these constants are typos, and leaving them in #{set_color("todo.rbi", :cyan)} will
+          hide errors in your application. Ideally, you should be able to remove all definitions
+          from this file and delete it.
+
+        3. Typecheck your project:
+
+          #{set_color("bundle exec srb tc", :cyan)}
+
+          There should not be any typechecking errors.
+
+        4. Upgrade a file marked "#{set_color("# typed: false", :cyan)}" to "#{set_color("# typed: true", :cyan)}".
+          Then, run: #{set_color("bundle exec srb tc", :cyan)} and try to fix any errors.
+
+          You can use Spoom to bump files for you:
+
+          #{set_color("spoom bump --from false --to true", :cyan)}
+
+          To learn more about Spoom, visit: #{set_color("https://github.com/Shopify/spoom", :cyan)}
+
+        5. Add signatures to your methods with #{set_color("sig", :cyan)}. To learn how, read: #{set_color("https://sorbet.org/docs/sigs", :cyan)}
+
+        #{set_color("Documentation", :bold)}
+        We recommend skimming these docs to get a feel for how to use Sorbet:
+        - Gradual Type Checking: #{set_color("https://sorbet.org/docs/gradual", :cyan)}
+        - Enabling Static Checks: #{set_color("https://sorbet.org/docs/static", :cyan)}
+        - RBI Files: #{set_color("https://sorbet.org/docs/rbi", :cyan)}
+      OUTPUT
+    end
   end
 end

data/lib/tapioca/commands/annotations.rb

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "net/http"
-
 module Tapioca
   module Commands
     class Annotations < Command
@@ -10,18 +8,33 @@ module Tapioca
 
       sig do
         params(
-          central_repo_root_uri: String,
-          central_repo_index_path: String
+          central_repo_root_uris: T::Array[String],
+          auth: T.nilable(String),
+          netrc_file: T.nilable(String),
+          central_repo_index_path: String,
+          typed_overrides: T::Hash[String, String]
         ).void
       end
-      def initialize(central_repo_root_uri:, central_repo_index_path: CENTRAL_REPO_INDEX_PATH)
+      def initialize(
+        central_repo_root_uris:,
+        auth: nil,
+        netrc_file: nil,
+        central_repo_index_path: CENTRAL_REPO_INDEX_PATH,
+        typed_overrides: {}
+      )
         super()
-        @central_repo_root_uri = central_repo_root_uri
-        @index = T.let(fetch_index, RepoIndex)
+        @central_repo_root_uris = central_repo_root_uris
+        @auth = auth
+        @netrc_file = netrc_file
+        @netrc_info = T.let(nil, T.nilable(Netrc))
+        @tokens = T.let(repo_tokens, T::Hash[String, T.nilable(String)])
+        @indexes = T.let({}, T::Hash[String, RepoIndex])
+        @typed_overrides = typed_overrides
       end
 
       sig { override.void }
       def execute
+        @indexes = fetch_indexes
         project_gems = list_gemfile_gems
         remove_expired_annotations(project_gems)
         fetch_annotations(project_gems)
@@ -60,11 +73,33 @@ module Tapioca
         say("\nDone\n\n", :green)
       end
 
-      sig { returns(RepoIndex) }
-      def fetch_index
-        say("Retrieving index from central repository... ", [:blue, :bold])
-        content = fetch_file(CENTRAL_REPO_INDEX_PATH)
-        exit(1) unless content
+      sig { returns(T::Hash[String, RepoIndex]) }
+      def fetch_indexes
+        multiple_repos = @central_repo_root_uris.size > 1
+        repo_number = 1
+        indexes = T.let({}, T::Hash[String, RepoIndex])
+
+        @central_repo_root_uris.each do |uri|
+          index = fetch_index(uri, repo_number: multiple_repos ? repo_number : nil)
+          next unless index
+
+          indexes[uri] = index
+          repo_number += 1
+        end
+
+        if indexes.empty?
+          say_error("\nCan't fetch annotations without sources (no index fetched)", :bold, :red)
+          exit(1)
+        end
+
+        indexes
+      end
+
+      sig { params(repo_uri: String, repo_number: T.nilable(Integer)).returns(T.nilable(RepoIndex)) }
+      def fetch_index(repo_uri, repo_number:)
+        say("Retrieving index from central repository#{repo_number ? " ##{repo_number}" : ""}... ", [:blue, :bold])
+        content = fetch_file(repo_uri, CENTRAL_REPO_INDEX_PATH)
+        return nil unless content
 
         index = RepoIndex.from_json(content)
         say("Done", :green)
@@ -74,7 +109,11 @@ module Tapioca
       sig { params(gem_names: T::Array[String]).returns(T::Array[String]) }
       def fetch_annotations(gem_names)
         say("Fetching gem annotations from central repository... ", [:blue, :bold])
-        fetchable_gems = gem_names.select { |gem_name| @index.has_gem?(gem_name) }
+        fetchable_gems = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[String, T::Array[String]])
+
+        gem_names.each_with_object(fetchable_gems) do |gem_name, hash|
+          @indexes.each { |uri, index| hash[gem_name] << uri if index.has_gem?(gem_name) }
+        end
 
         if fetchable_gems.empty?
           say(" Nothing to do")
@@ -82,16 +121,21 @@ module Tapioca
         end
 
         say("\n")
-        fetched_gems = fetchable_gems.select { |name| fetch_annotation(name) }
+        fetched_gems = fetchable_gems.select { |gem_name, repo_uris| fetch_annotation(repo_uris, gem_name) }
         say("\nDone", :green)
-        fetched_gems
+        fetched_gems.keys.sort
       end
 
-      sig { params(gem_name: String).void }
-      def fetch_annotation(gem_name)
-        content = fetch_file("#{CENTRAL_REPO_ANNOTATIONS_DIR}/#{gem_name}.rbi")
+      sig { params(repo_uris: T::Array[String], gem_name: String).void }
+      def fetch_annotation(repo_uris, gem_name)
+        contents = repo_uris.map do |repo_uri|
+          fetch_file(repo_uri, "#{CENTRAL_REPO_ANNOTATIONS_DIR}/#{gem_name}.rbi")
+        end
+
+        content = merge_files(gem_name, contents.compact)
         return unless content
 
+        content = apply_typed_override(gem_name, content)
         content = add_header(gem_name, content)
 
         dir = DEFAULT_ANNOTATIONS_DIR
@@ -100,36 +144,44 @@ module Tapioca
         create_file("#{dir}/#{gem_name}.rbi", content)
       end
 
-      sig { params(path: String).returns(T.nilable(String)) }
-      def fetch_file(path)
-        if @central_repo_root_uri.start_with?(%r{https?://})
-          fetch_http_file(path)
+      sig { params(repo_uri: String, path: String).returns(T.nilable(String)) }
+      def fetch_file(repo_uri, path)
+        if repo_uri.start_with?(%r{https?://})
+          fetch_http_file(repo_uri, path)
         else
-          fetch_local_file(path)
+          fetch_local_file(repo_uri, path)
         end
       end
 
-      sig { params(path: String).returns(T.nilable(String)) }
-      def fetch_local_file(path)
-        File.read("#{@central_repo_root_uri}/#{path}")
+      sig { params(repo_uri: String, path: String).returns(T.nilable(String)) }
+      def fetch_local_file(repo_uri, path)
+        File.read("#{repo_uri}/#{path}")
       rescue => e
         say_error("\nCan't fetch file `#{path}` (#{e.message})", :bold, :red)
         nil
       end
 
-      sig { params(path: String).returns(T.nilable(String)) }
-      def fetch_http_file(path)
-        uri = URI("#{@central_repo_root_uri}/#{path}")
-        response = Net::HTTP.get_response(uri)
+      sig { params(repo_uri: String, path: String).returns(T.nilable(String)) }
+      def fetch_http_file(repo_uri, path)
+        auth = @tokens[repo_uri]
+        uri = URI("#{repo_uri}/#{path}")
+
+        request = Net::HTTP::Get.new(uri)
+        request["Authorization"] = auth if auth
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(request)
+        end
+
         case response
         when Net::HTTPSuccess
           response.body
         else
-          say_error("\nCan't fetch file `#{path}` from #{@central_repo_root_uri} (#{response.class})", :bold, :red)
+          say_http_error(path, repo_uri, message: response.class)
           nil
         end
       rescue SocketError, Errno::ECONNREFUSED => e
-        say_error("\nCan't fetch file `#{path}` from #{@central_repo_root_uri} (#{e.message})", :bold, :red)
+        say_http_error(path, repo_uri, message: e.message)
         nil
       end
 
@@ -137,7 +189,7 @@ module Tapioca
       def add_header(name, content)
         header = <<~COMMENT
           # DO NOT EDIT MANUALLY
-          # This file was pulled from #{@central_repo_root_uri}.
+          # This file was pulled from a central RBI files repository.
           # Please run `#{default_command(:annotations)}` to update it.
         COMMENT
 
@@ -149,6 +201,86 @@ module Tapioca
           content
         end
       end
+
+      sig { params(name: String, content: String).returns(String) }
+      def apply_typed_override(name, content)
+        strictness = @typed_overrides[name]
+        return content unless strictness
+
+        unless Spoom::Sorbet::Sigils.strictness_in_content(content)
+          return "# typed: #{strictness}\n\n#{content}"
+        end
+
+        Spoom::Sorbet::Sigils.update_sigil(content, strictness)
+      end
+
+      sig { params(gem_name: String, contents: T::Array[String]).returns(T.nilable(String)) }
+      def merge_files(gem_name, contents)
+        return nil if contents.empty?
+
+        rewriter = RBI::Rewriters::Merge.new(keep: RBI::Rewriters::Merge::Keep::NONE)
+
+        contents.each do |content|
+          rbi = RBI::Parser.parse_string(content)
+          rewriter.merge(rbi)
+        end
+
+        tree = rewriter.tree
+        return tree.string if tree.conflicts.empty?
+
+        say_error("\n\n  Can't import RBI file for `#{gem_name}` as it contains conflicts:", :yellow)
+
+        tree.conflicts.each do |conflict|
+          say_error("    #{conflict}", :yellow)
+        end
+
+        nil
+      rescue RBI::ParseError => e
+        say_error("\n\n  Can't import RBI file for `#{gem_name}` as it contains errors:", :yellow)
+        say_error("    Error: #{e.message} (#{e.location})")
+        nil
+      end
+
+      sig { returns(T::Hash[String, T.nilable(String)]) }
+      def repo_tokens
+        @netrc_info = Netrc.read(@netrc_file) if @netrc_file
+        @central_repo_root_uris.map do |uri|
+          if @auth
+            [uri, @auth]
+          else
+            [uri, token_for(uri)]
+          end
+        end.compact.to_h
+      end
+
+      sig { params(repo_uri: String).returns(T.nilable(String)) }
+      def token_for(repo_uri)
+        return nil unless @netrc_info
+
+        host = URI(repo_uri).host
+        return nil unless host
+
+        creds = @netrc_info[host]
+        return nil unless creds
+
+        token = creds.to_a.last
+        return nil unless token
+
+        "token #{token}"
+      end
+
+      sig { params(path: String, repo_uri: String, message: String).void }
+      def say_http_error(path, repo_uri, message:)
+        say_error("\nCan't fetch file `#{path}` from #{repo_uri} (#{message})\n\n", :bold, :red)
+        say_error(<<~ERROR)
+          Tapioca can't access the annotations at #{repo_uri}.
+
+          Are you trying to access a private repository?
+          If so, please specify your Github credentials in your ~/.netrc file or by specifying the --auth option.
+
+          See https://github.com/Shopify/tapioca#using-a-netrc-file for more details.
+        ERROR
+      end
     end
   end
 end

data/lib/tapioca/commands/check_shims.rb

@@ -0,0 +1,91 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Commands
+    class CheckShims < Command
+      extend T::Sig
+      include SorbetHelper
+      include RBIFilesHelper
+
+      sig do
+        params(
+          gem_rbi_dir: String,
+          dsl_rbi_dir: String,
+          annotations_rbi_dir: String,
+          shim_rbi_dir: String,
+          todo_rbi_file: String,
+          payload: T::Boolean
+        ).void
+      end
+      def initialize(gem_rbi_dir:, dsl_rbi_dir:, annotations_rbi_dir:, shim_rbi_dir:, todo_rbi_file:, payload:)
+        super()
+        @gem_rbi_dir = gem_rbi_dir
+        @dsl_rbi_dir = dsl_rbi_dir
+        @annotations_rbi_dir = annotations_rbi_dir
+        @shim_rbi_dir = shim_rbi_dir
+        @todo_rbi_file = todo_rbi_file
+        @payload = payload
+      end
+
+      sig { override.void }
+      def execute
+        index = RBI::Index.new
+
+        if (!Dir.exist?(@shim_rbi_dir) || Dir.empty?(@shim_rbi_dir)) && !File.exist?(@todo_rbi_file)
+          say("No shim RBIs to check", :green)
+          exit(0)
+        end
+
+        payload_path = T.let(nil, T.nilable(String))
+
+        if @payload
+          if sorbet_supports?(:print_payload_sources)
+            Dir.mktmpdir do |dir|
+              payload_path = dir
+              result = sorbet("--no-config --print=payload-sources:#{payload_path}")
+
+              unless result.status
+                say_error("Sorbet failed to dump payload")
+                say_error(result.err)
+                exit(1)
+              end
+
+              index_payload(index, payload_path)
+            end
+          else
+            say_error("The version of Sorbet used in your Gemfile.lock does not support `--print=payload-sources`")
+            say_error("Current: v#{SORBET_GEM_SPEC.version}")
+            say_error("Required: #{FEATURE_REQUIREMENTS[:print_payload_sources]}")
+            exit(1)
+          end
+        end
+
+        index_rbi(index, "todo", @todo_rbi_file)
+        index_rbis(index, "shim", @shim_rbi_dir)
+        index_rbis(index, "gem", @gem_rbi_dir)
+        index_rbis(index, "dsl", @dsl_rbi_dir)
+        index_rbis(index, "annotation", @annotations_rbi_dir)
+
+        duplicates = duplicated_nodes_from_index(index, shim_rbi_dir: @shim_rbi_dir, todo_rbi_file: @todo_rbi_file)
+        unless duplicates.empty?
+          duplicates.each do |key, nodes|
+            say_error("\nDuplicated RBI for #{key}:", :red)
+            nodes.each do |node|
+              node_loc = node.loc
+              next unless node_loc
+
+              loc_string = location_to_payload_url(node_loc, path_prefix: payload_path)
+              say_error(" * #{loc_string}", :red)
+            end
+          end
+          say_error("\nPlease remove the duplicated definitions from #{@shim_rbi_dir} and #{@todo_rbi_file}", :red)
+          exit(1)
+        end
+
+        say("\nNo duplicates found in shim RBIs", :green)
+        exit(0)
+      end
+    end
+  end
+end

data/lib/tapioca/commands/{init.rb → configure.rb}

@@ -3,7 +3,7 @@
 
 module Tapioca
   module Commands
-    class Init < Command
+    class Configure < Command
       sig do
         params(
           sorbet_config: String,

data/lib/tapioca/commands/dsl.rb

@@ -5,7 +5,7 @@ module Tapioca
   module Commands
     class Dsl < Command
       include SorbetHelper
-      include RBIHelper
+      include RBIFilesHelper
 
       sig do
         params(

data/lib/tapioca/commands/gem.rb

@@ -5,7 +5,7 @@ module Tapioca
   module Commands
     class Gem < Command
       include SorbetHelper
-      include RBIHelper
+      include RBIFilesHelper
 
       sig do
         params(
@@ -16,7 +16,7 @@ module Tapioca
           typed_overrides: T::Hash[String, String],
           outpath: Pathname,
           file_header: T::Boolean,
-          doc: T::Boolean,
+          include_doc: T::Boolean,
           include_exported_rbis: T::Boolean,
           number_of_workers: T.nilable(Integer),
           auto_strictness: T::Boolean,
@@ -32,7 +32,7 @@ module Tapioca
         typed_overrides:,
         outpath:,
         file_header:,
-        doc:,
+        include_doc:,
         include_exported_rbis:,
         number_of_workers: nil,
         auto_strictness: true,
@@ -57,7 +57,7 @@ module Tapioca
         @bundle = T.let(nil, T.nilable(Gemfile))
         @existing_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
         @expected_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
-        @doc = T.let(doc, T::Boolean)
+        @include_doc = T.let(include_doc, T::Boolean)
         @include_exported_rbis = include_exported_rbis
       end
 
@@ -182,7 +182,7 @@ module Tapioca
           default_command(:gem, gem.name),
           reason: "types exported from the `#{gem.name}` gem",) if @file_header
 
-        rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @doc).compile
+        rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @include_doc).compile
 
         merge_with_exported_rbi(gem, rbi) if @include_exported_rbis