tapioca 0.16.10 → 0.17.0

data/lib/tapioca/gem_info.rb

@@ -9,7 +9,7 @@ module Tapioca
     class << self
       extend(T::Sig)
 
-      sig { params(spec: Bundler::LazySpecification).returns(GemInfo) }
+      #: (Bundler::LazySpecification spec) -> GemInfo
       def from_spec(spec)
         new(name: spec.name, version: spec.version)
       end

data/lib/tapioca/gemfile.rb

@@ -14,34 +14,34 @@ module Tapioca
       )
     end
 
-    sig { returns(Bundler::Definition) }
+    #: Bundler::Definition
     attr_reader(:definition)
 
-    sig { returns(T::Array[GemSpec]) }
+    #: Array[GemSpec]
     attr_reader(:dependencies)
 
-    sig { returns(T::Array[String]) }
+    #: Array[String]
     attr_reader(:missing_specs)
 
-    sig { params(excluded_gems: T::Array[String]).void }
+    #: (Array[String] excluded_gems) -> void
     def initialize(excluded_gems)
-      @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)
+      @gemfile = File.new(Bundler.default_gemfile) #: File
+      @lockfile = File.new(Bundler.default_lockfile) #: File
+      @definition = Bundler::Dsl.evaluate(gemfile, lockfile, {}) #: Bundler::Definition
       @excluded_gems = excluded_gems
 
       dependencies, missing_specs = load_dependencies
 
-      @dependencies = T.let(dependencies, T::Array[GemSpec])
-      @missing_specs = T.let(missing_specs, T::Array[String])
+      @dependencies = dependencies #: Array[GemSpec]
+      @missing_specs = missing_specs #: Array[String]
     end
 
-    sig { params(gem_name: String).returns(T.nilable(GemSpec)) }
+    #: (String gem_name) -> GemSpec?
     def gem(gem_name)
       dependencies.detect { |dep| dep.name == gem_name }
     end
 
-    sig { void }
+    #: -> void
     def require_bundle
       BundlerExt::AutoRequireHook.override_require_false(exclude: @excluded_gems) do
         T.unsafe(runtime).require(*groups)
@@ -50,10 +50,10 @@ module Tapioca
 
     private
 
-    sig { returns(File) }
+    #: File
     attr_reader(:gemfile, :lockfile)
 
-    sig { returns([T::Array[GemSpec], T::Array[String]]) }
+    #: -> [Array[GemSpec], Array[String]]
     def load_dependencies
       materialized_dependencies, missing_specs = materialize_deps
       dependencies = materialized_dependencies
@@ -64,7 +64,7 @@ module Tapioca
       [dependencies, missing_specs]
     end
 
-    sig { returns([T::Enumerable[Spec], T::Array[String]]) }
+    #: -> [T::Enumerable[Spec], Array[String]]
     def materialize_deps
       deps = definition.locked_gems.dependencies.except(*@excluded_gems).values
       resolve = definition.resolve
@@ -87,17 +87,17 @@ module Tapioca
       [materialized_dependencies, missing_specs]
     end
 
-    sig { returns(Bundler::Runtime) }
+    #: -> Bundler::Runtime
     def runtime
       Bundler::Runtime.new(File.dirname(gemfile.path), definition)
     end
 
-    sig { returns(T::Array[Symbol]) }
+    #: -> Array[Symbol]
     def groups
       definition.groups
     end
 
-    sig { returns(String) }
+    #: -> String
     def dir
       File.expand_path(gemfile.path + "/..")
     end
@@ -109,74 +109,68 @@ module Tapioca
       class << self
         extend T::Sig
 
-        sig { returns(T::Hash[String, Gemfile::GemSpec]) }
+        #: -> Hash[String, Gemfile::GemSpec]
         def spec_lookup_by_file_path
-          @lookup ||= T.let(
-            [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs]
-              .map! { |spec| new(spec.to_spec) }
-              .flat_map do |spec|
-                spec.files.filter_map { |file| [file.realpath.to_s, spec] if file.exist? }
-              end.to_h,
-            T.nilable(T::Hash[String, Gemfile::GemSpec]),
-          )
+          @lookup ||= [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs]
+            .map! { |spec| new(spec.to_spec) }
+            .flat_map do |spec|
+              spec.files.filter_map { |file| [file.realpath.to_s, spec] if file.exist? }
+            end.to_h #: Hash[String, Gemfile::GemSpec]?
         end
       end
 
-      IGNORED_GEMS = T.let(
-        [
-          "sorbet",
-          "sorbet-static",
-          "sorbet-runtime",
-          "sorbet-static-and-runtime",
-          "debug",
-          "irb",
-          "fakefs",
-        ].freeze,
-        T::Array[String],
-      )
-
-      sig { returns(String) }
+      IGNORED_GEMS = [
+        "sorbet",
+        "sorbet-static",
+        "sorbet-runtime",
+        "sorbet-static-and-runtime",
+        "debug",
+        "irb",
+        "fakefs",
+      ].freeze #: Array[String]
+
+      #: String
       attr_reader :full_gem_path, :version
 
-      sig { returns(T::Array[Pathname]) }
+      #: Array[Pathname]
       attr_reader :files
 
-      sig { params(spec: Spec).void }
+      #: (Spec spec) -> void
       def initialize(spec)
-        @spec = T.let(spec, Tapioca::Gemfile::Spec)
+        @spec = spec #: Tapioca::Gemfile::Spec
         real_gem_path = to_realpath(@spec.full_gem_path)
-        @full_gem_path = T.let(real_gem_path, String)
-        @version = T.let(version_string, String)
-        @exported_rbi_files = T.let(nil, T.nilable(T::Array[String]))
-        @files = T.let(collect_files, T::Array[Pathname])
+        @full_gem_path = real_gem_path #: String
+        @version = version_string #: String
+        @exported_rbi_files = nil #: Array[String]?
+        @files = collect_files #: Array[Pathname]
       end
 
-      sig { params(other: BasicObject).returns(T::Boolean) }
+      #: (BasicObject other) -> bool
       def ==(other)
         GemSpec === other && other.name == name && other.version == version
       end
 
-      sig { params(gemfile_dir: String).returns(T::Boolean) }
+      #: (String gemfile_dir) -> bool
       def ignore?(gemfile_dir)
         gem_ignored? || gem_in_app_dir?(gemfile_dir, full_gem_path)
       end
 
-      sig { returns(String) }
+      #: -> String
       def name
         @spec.name
       end
 
-      sig { returns(T::Array[::Gem::Dependency]) }
+      #: -> Array[::Gem::Dependency]
       def dependencies
         @spec.dependencies
       end
 
-      sig { returns(String) }
+      #: -> String
       def rbi_file_name
         "#{name}@#{version}.rbi"
       end
 
-      sig { params(path: String).returns(T::Boolean) }
+      #: (String path) -> bool
       def contains_path?(path)
         if default_gem?
           files.any? { |file| file.to_s == to_realpath(path) }
@@ -185,7 +179,7 @@ module Tapioca
         end
       end
 
-      sig { void }
+      #: -> void
       def parse_yard_docs
         files.each do |path|
           YARD.parse(path.to_s, [], Logger::Severity::FATAL)
@@ -201,17 +195,17 @@ module Tapioca
         end
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def exported_rbi_files
         @exported_rbi_files ||= Dir.glob("#{full_gem_path}/rbi/**/*.rbi").sort
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def export_rbi_files?
         exported_rbi_files.any?
       end
 
-      sig { returns(RBI::MergeTree) }
+      #: -> RBI::MergeTree
       def exported_rbi_tree
         rewriter = RBI::Rewriters::Merge.new(keep: RBI::Rewriters::Merge::Keep::NONE)
 
@@ -223,7 +217,7 @@ module Tapioca
         rewriter.tree
       end
 
-      sig { params(file: Pathname).returns(Pathname) }
+      #: (Pathname file) -> Pathname
       def relative_path_for(file)
         if default_gem?
           file.realpath.relative_path_from(RbConfig::CONFIG["rubylibdir"])
@@ -234,7 +228,7 @@ module Tapioca
 
       private
 
-      sig { returns(T::Array[Pathname]) }
+      #: -> Array[Pathname]
       def collect_files
         if default_gem?
           # `Bundler::RemoteSpecification` delegates missing methods to
@@ -249,24 +243,21 @@ module Tapioca
         end
       end
 
-      sig { returns(T.nilable(T::Boolean)) }
+      #: -> bool?
       def default_gem?
         @spec.respond_to?(:default_gem?) && @spec.default_gem?
       end
 
-      sig { returns(Regexp) }
+      #: -> Regexp
       def require_paths_prefix_matcher
-        @require_paths_prefix_matcher ||= T.let(
-          begin
-            require_paths = T.unsafe(@spec).require_paths
-            prefix_matchers = require_paths.map { |rp| Regexp.new("^#{rp}/") }
-            Regexp.union(prefix_matchers)
-          end,
-          T.nilable(Regexp),
-        )
+        @require_paths_prefix_matcher ||= begin
+          require_paths = T.unsafe(@spec).require_paths
+          prefix_matchers = require_paths.map { |rp| Regexp.new("^#{rp}/") }
+          Regexp.union(prefix_matchers)
+        end #: Regexp?
       end
 
-      sig { params(file: String).returns(Pathname) }
+      #: (String file) -> Pathname
       def resolve_to_ruby_lib_dir(file)
         # We want to match require prefixes but fallback to an empty match
         # if none of the require prefixes actually match. This is so that
@@ -280,14 +271,14 @@ module Tapioca
         Pathname.new(file).expand_path
       end
 
-      sig { returns(String) }
+      #: -> String
       def version_string
         version = @spec.version.to_s
         version += "-#{@spec.source.revision}" if Bundler::Source::Git === @spec.source
         version
       end
 
-      sig { params(path: String).returns(T::Boolean) }
+      #: (String path) -> bool
       def has_parent_gemspec?(path)
         # For some Git installed gems the location of the loaded file can
         # be different from the gem path as indicated by the spec file
@@ -308,7 +299,7 @@ module Tapioca
         false
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def gem_ignored?
         IGNORED_GEMS.include?(name)
       end

data/lib/tapioca/helpers/cli_helper.rb

@@ -8,7 +8,7 @@ module Tapioca
 
     requires_ancestor { Thor::Shell }
 
-    sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
+    #: (?String message, *(Symbol | Array[Symbol]) color) -> void
     def say_error(message = "", *color)
       # Thor has its own `say_error` now, but it has two problems:
       # 1. it adds the padding around all the messages, even if they continue on
@@ -22,14 +22,14 @@ module Tapioca
       end
     end
 
-    sig { params(options: T::Hash[Symbol, T.untyped]).returns(RBIFormatter) }
+    #: (Hash[Symbol, untyped] options) -> RBIFormatter
     def rbi_formatter(options)
       rbi_formatter = DEFAULT_RBI_FORMATTER
       rbi_formatter.max_line_length = options[:rbi_max_line_length]
       rbi_formatter
     end
 
-    sig { params(options: T::Hash[Symbol, T.untyped]).returns(T.nilable(String)) }
+    #: (Hash[Symbol, untyped] options) -> String?
     def netrc_file(options)
       return if options[:auth]
       return unless options[:netrc]

data/lib/tapioca/helpers/config_helper.rb

@@ -8,20 +8,20 @@ module Tapioca
 
     requires_ancestor { Thor }
 
-    sig { returns(String) }
+    #: String
     attr_reader :command_name
 
-    sig { returns(Thor::CoreExt::HashWithIndifferentAccess) }
+    #: Thor::CoreExt::HashWithIndifferentAccess
     attr_reader :defaults
 
-    sig { params(args: T.untyped, local_options: T.untyped, config: T.untyped).void }
+    #: (?untyped args, ?untyped local_options, ?untyped config) -> void
     def initialize(args = [], local_options = {}, config = {})
       # Store current command
       command = config[:current_command]
       command_options = config[:command_options]
-      @command_name = T.let(command.name, String)
-      @merged_options = T.let(nil, T.nilable(Thor::CoreExt::HashWithIndifferentAccess))
-      @defaults = T.let(Thor::CoreExt::HashWithIndifferentAccess.new, Thor::CoreExt::HashWithIndifferentAccess)
+      @command_name = command.name #: String
+      @merged_options = nil #: Thor::CoreExt::HashWithIndifferentAccess?
+      @defaults = Thor::CoreExt::HashWithIndifferentAccess.new #: Thor::CoreExt::HashWithIndifferentAccess
 
       # Filter command options unless we are handling the help command.
       # This is so that the defaults are printed
@@ -30,7 +30,7 @@ module Tapioca
       super
     end
 
-    sig { returns(Thor::CoreExt::HashWithIndifferentAccess) }
+    #: -> Thor::CoreExt::HashWithIndifferentAccess
     def options
       @merged_options ||= begin
         original_options = super
@@ -42,7 +42,7 @@ module Tapioca
 
     private
 
-    sig { params(options: T::Hash[Symbol, Thor::Option]).void }
+    #: (Hash[Symbol, Thor::Option] options) -> void
     def filter_defaults(options)
       options.each do |key, option|
         # Store the value of the current default in our defaults hash
@@ -52,7 +52,7 @@ module Tapioca
       end
     end
 
-    sig { params(options: Thor::CoreExt::HashWithIndifferentAccess).returns(Thor::CoreExt::HashWithIndifferentAccess) }
+    #: (Thor::CoreExt::HashWithIndifferentAccess options) -> Thor::CoreExt::HashWithIndifferentAccess
     def config_options(options)
       config_file = options[:config]
       config = {}
@@ -66,12 +66,12 @@ module Tapioca
       Thor::CoreExt::HashWithIndifferentAccess.new(config[command_name] || {})
     end
 
-    sig { params(config_file: String, config: T::Hash[T.untyped, T.untyped]).void }
+    #: (String config_file, Hash[untyped, untyped] config) -> void
     def validate_config!(config_file, config)
       # To ensure that this is not re-entered, we mark during validation
       return if @validating_config
 
-      @validating_config = T.let(true, T.nilable(T::Boolean))
+      @validating_config = true #: bool?
 
       commands = T.cast(self, Thor).class.commands
 
@@ -92,13 +92,7 @@ module Tapioca
       @validating_config = false
     end
 
-    sig do
-      params(
-        command_options: T::Hash[Symbol, Thor::Option],
-        config_key: String,
-        config_options: T::Hash[T.untyped, T.untyped],
-      ).returns(T::Array[ConfigError])
-    end
+    #: (Hash[Symbol, Thor::Option] command_options, String config_key, Hash[untyped, untyped] config_options) -> Array[ConfigError]
     def validate_config_options(command_options, config_key, config_options)
       config_options.filter_map do |config_option_key, config_option_value|
         command_option = command_options[config_option_key.to_sym]
@@ -149,7 +143,7 @@ module Tapioca
       const :message_parts, T::Array[ConfigErrorMessagePart]
     end
 
-    sig { params(msg: String).returns(ConfigError) }
+    #: (String msg) -> ConfigError
     def build_error(msg)
       parts = msg.split(/(`[^`]+` ?)/)
 
@@ -174,7 +168,7 @@ module Tapioca
       )
     end
 
-    sig { params(config_file: String, errors: T::Array[ConfigError]).returns(String) }
+    #: (String config_file, Array[ConfigError] errors) -> String
     def build_error_message(config_file, errors)
       error_messages = errors.map do |error|
         "- " + error.message_parts.map do |part|
@@ -189,10 +183,7 @@ module Tapioca
       ERROR
     end
 
-    sig do
-      params(options: T.nilable(Thor::CoreExt::HashWithIndifferentAccess))
-        .returns(Thor::CoreExt::HashWithIndifferentAccess)
-    end
+    #: (*Thor::CoreExt::HashWithIndifferentAccess? options) -> Thor::CoreExt::HashWithIndifferentAccess
     def merge_options(*options)
       merged = options.each_with_object({}) do |option, result|
         result.merge!(option || {}) do |_, this_val, other_val|

data/lib/tapioca/helpers/env_helper.rb

@@ -8,7 +8,7 @@ module Tapioca
 
     requires_ancestor { Thor }
 
-    sig { params(options: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] options) -> void
     def set_environment(options) # rubocop:disable Naming/AccessorMethodName
       ENV["RAILS_ENV"] = ENV["RACK_ENV"] = options[:environment]
       ENV["RUBY_DEBUG_LAZY"] = "1"

data/lib/tapioca/helpers/gem_helper.rb

@@ -5,7 +5,7 @@ module Tapioca
   module GemHelper
     extend T::Sig
 
-    sig { params(app_dir: T.any(String, Pathname), full_gem_path: String).returns(T::Boolean) }
+    #: ((String | Pathname) app_dir, String full_gem_path) -> bool
     def gem_in_app_dir?(app_dir, full_gem_path)
       app_dir = to_realpath(app_dir)
       full_gem_path = to_realpath(full_gem_path)
@@ -13,17 +13,17 @@ module Tapioca
       !gem_in_bundle_path?(full_gem_path) && !gem_in_ruby_path?(full_gem_path) && path_in_dir?(full_gem_path, app_dir)
     end
 
-    sig { params(full_gem_path: String).returns(T::Boolean) }
+    #: (String full_gem_path) -> bool
     def gem_in_bundle_path?(full_gem_path)
       path_in_dir?(full_gem_path, Bundler.bundle_path) || path_in_dir?(full_gem_path, Bundler.app_cache)
     end
 
-    sig { params(full_gem_path: String).returns(T::Boolean) }
+    #: (String full_gem_path) -> bool
     def gem_in_ruby_path?(full_gem_path)
       path_in_dir?(full_gem_path, RbConfig::CONFIG["rubylibprefix"])
     end
 
-    sig { params(path: T.any(String, Pathname)).returns(String) }
+    #: ((String | Pathname) path) -> String
     def to_realpath(path)
       path_string = path.to_s
       path_string = File.realpath(path_string) if File.exist?(path_string)
@@ -32,7 +32,7 @@ module Tapioca
 
     private
 
-    sig { params(path: T.any(Pathname, String), dir: T.any(Pathname, String)).returns(T::Boolean) }
+    #: ((Pathname | String) path, (Pathname | String) dir) -> bool
     def path_in_dir?(path, dir)
       dir = Pathname.new(dir)
       path = Pathname.new(path)

data/lib/tapioca/helpers/git_attributes.rb

@@ -5,14 +5,14 @@ class GitAttributes
   class << self
     extend T::Sig
 
-    sig { params(path: Pathname).void }
+    #: (Pathname path) -> void
     def create_generated_attribute_file(path)
       create_gitattributes_file(path, <<~CONTENT)
         **/*.rbi linguist-generated=true
       CONTENT
     end
 
-    sig { params(path: Pathname).void }
+    #: (Pathname path) -> void
     def create_vendored_attribute_file(path)
       create_gitattributes_file(path, <<~CONTENT)
         **/*.rbi linguist-vendored=true
@@ -21,7 +21,7 @@ class GitAttributes
 
     private
 
-    sig { params(path: Pathname, content: String).void }
+    #: (Pathname path, String content) -> void
     def create_gitattributes_file(path, content)
       # We don't want to start creating folders, just to write
       # the `.gitattributes` file. So, if the folder doesn't