tapioca 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4eea2d365ede4ba5398d65a2042c7dc86270ec7309cb0bc9747357f44ea1c675
-  data.tar.gz: 7f7252a0619b138664fe5d30acf0858fb09eb9403d513a06266cc58c464dd3b2
+  metadata.gz: df803cbfcb6a400e88175b21c0bfd3d5c8089853d5ca09cf8f7b7d0076ce201f
+  data.tar.gz: fc580b1ae8202f4d94a45d75665c07a072c7ffde6652aaa3580dd1e8a196288c
 SHA512:
-  metadata.gz: 1ac4530bd50af56e2acee0a630571dbc7452cf10e55ec89088ddb5ed8f9a350fae0b4031602fa13b5b319390172e55bdebe6a3d3b6a722e88fe7902aceb5bb61
-  data.tar.gz: 26a6365606966861c36ffcea2b247a7dfc5395925d04a9d89f35273ce6ae9c3f29ee3d94002c3dd49c46f05acda9e202025a79cf9e4dd0fbebe49ff542d575ae
+  metadata.gz: a36a8f3dc321ce2cf8f5402f3b00aee7ef9e6ea2748ee95371b64dceec217df218fd8dc6ca786cfce90478c9c0db7c14bde1f43276f76a65b4ed2d6fa7093672
+  data.tar.gz: f688b633d7e0ed4627a5929aef8293619641609c143c43082b291330f9fe5fb2c5a72e9e70be0f2d57274908b4f1fc48dd6ff8dcb4d7d815c894af9567a21417

data/Gemfile

@@ -36,4 +36,9 @@ group(:development, :test) do
   gem("aasm", require: false)
   gem("bcrypt", require: false)
   gem("xpath", require: false)
+
+  # net-smtp was removed from default gems in Ruby 3.1, but is used by the `mail` gem.
+  # So we need to add it as a dependency until `mail` is fixed:
+  # https://github.com/rails/rails/blob/0919aa97260ab8240150278d3b07a1547489e3fd/Gemfile#L178-L191
+  gem("net-smtp", "0.3.1", require: false)
 end

data/README.md

@@ -80,8 +80,8 @@ Command: `tapioca init`
 
 This will create the `sorbet/config` and `sorbet/tapioca/require.rb` files for you, if they don't exist. If any of the files already exist, they will not be changed.
 
+<!-- START_HELP_COMMAND_INIT -->
 ```shell
-$ bundle exec tapioca help init
 Usage:
   tapioca init
 
@@ -92,6 +92,7 @@ Options:
 
 initializes folder structure
 ```
+<!-- END_HELP_COMMAND_INIT -->
 
 ### Generate RBI files for gems
 
@@ -99,13 +100,13 @@ Command: `tapioca gem [gems...]`
 
 This will generate RBIs for the specified gems and place them in the RBI directory.
 
+<!-- START_HELP_COMMAND_GEM -->
 ```shell
-$ bundle exec tapioca help gem
 Usage:
   tapioca gem [gem...]
 
 Options:
-  --out, -o, [--outdir=directory]                             # The output directory for generated RBI files
+  --out, -o, [--outdir=directory]                             # The output directory for generated gem RBI files
                                                               # Default: sorbet/rbi/gems
           [--file-header], [--no-file-header]                 # Add a "This file is generated" header on top of each generated RBI file
                                                               # Default: true
@@ -113,10 +114,10 @@ Options:
   --pre, -b, [--prerequire=file]                              # A file to be required before Bundler.require is called
   --post, -a, [--postrequire=file]                            # A file to be required after Bundler.require is called
                                                               # Default: sorbet/tapioca/require.rb
-  -x, [--exclude=gem [gem ...]]                               # Excludes the given gem(s) from RBI generation
-  --typed, -t, [--typed-overrides=gem:level [gem:level ...]]  # Overrides for typed sigils for generated gem RBIs
+  -x, [--exclude=gem [gem ...]]                               # Exclude the given gem(s) from RBI generation
+  --typed, -t, [--typed-overrides=gem:level [gem:level ...]]  # Override for typed sigils for generated gem RBIs
                                                               # Default: {"activesupport"=>"false"}
-          [--verify], [--no-verify]                           # Verifies RBIs are up-to-date
+          [--verify], [--no-verify]                           # Verify RBIs are up-to-date
           [--doc], [--no-doc]                                 # Include YARD documentation from sources when generating RBIs. Warning: this might be slow
           [--exported-gem-rbis], [--no-exported-gem-rbis]     # Include RBIs found in the `rbi/` directory of the gem
                                                               # Default: true
@@ -128,6 +129,7 @@ Options:
 
 generate RBIs from gems
 ```
+<!-- END_HELP_COMMAND_GEM -->
 
 ### Generate the list of all unresolved constants
 
@@ -135,13 +137,13 @@ Command: `tapioca todo`
 
 This will generate the file `sorbet/rbi/todo.rbi` defining all unresolved constants as empty modules.
 
+<!-- START_HELP_COMMAND_TODO -->
 ```shell
-$ bundle exec tapioca help todo
 Usage:
   tapioca todo
 
 Options:
-      [--todo-file=TODO_FILE]
+      [--todo-file=TODO_FILE]              # Path to the generated todo RBI file
                                            # Default: sorbet/rbi/todo.rbi
       [--file-header], [--no-file-header]  # Add a "This file is generated" header on top of each generated RBI file
                                            # Default: true
@@ -151,6 +153,7 @@ Options:
 
 generate the list of unresolved constants
 ```
+<!-- END_HELP_COMMAND_TODO -->
 
 ### Generate DSL RBI files
 
@@ -158,18 +161,18 @@ Command: `tapioca dsl [constant...]`
 
 This will generate DSL RBIs for specified constants (or for all handled constants, if a constant name is not supplied). You can read about DSL RBI generators supplied by `tapioca` in [the manual](manual/generators.md).
 
+<!-- START_HELP_COMMAND_DSL -->
 ```shell
-$ bundle exec tapioca help dsl
 Usage:
   tapioca dsl [constant...]
 
 Options:
-  --out, -o, [--outdir=directory]                # The output directory for generated RBI files
+  --out, -o, [--outdir=directory]                # The output directory for generated DSL RBI files
                                                  # Default: sorbet/rbi/dsl
           [--file-header], [--no-file-header]    # Add a "This file is generated" header on top of each generated RBI file
                                                  # Default: true
-          [--only=generator [generator ...]]     # Only run supplied DSL generators
-          [--exclude=generator [generator ...]]  # Exclude supplied DSL generators
+          [--only=generator [generator ...]]     # Only run supplied DSL generator(s)
+          [--exclude=generator [generator ...]]  # Exclude supplied DSL generator(s)
           [--verify], [--no-verify]              # Verifies RBIs are up-to-date
   -q, [--quiet], [--no-quiet]                    # Supresses file creation output
   -w, [--workers=N]                              # EXPERIMENTAL: Number of parallel workers to use when generating RBIs
@@ -180,6 +183,8 @@ Options:
 
 generate RBIs for dynamic methods
 ```
+<!-- END_HELP_COMMAND_DSL -->
+
 ## Configuration
 
 Tapioca supports loading command defaults from a configuration file. The default configuration
@@ -192,20 +197,57 @@ For example, if you always want to generate gem RBIs with inline documentation,
 
 ```yaml
 gem:
-  docs: true
+  doc: true
 ```
 
 Additionally, if you always want to exclude the `AASM` and `ActiveRecordFixtures` DSL compilers in your DSL RBI generation runs, your config file would then look like this:
 
 ```yaml
 gem:
-  docs: true
+  doc: true
 dsl:
   exclude:
   - UrlHelpers
   - ActiveRecordFixtures
 ```
 
+The full configuration file, with each option and its default value, would look something like this:
+<!-- START_CONFIG_TEMPLATE -->
+```yaml
+---
+require:
+  postrequire: sorbet/tapioca/require.rb
+todo:
+  todo_file: sorbet/rbi/todo.rbi
+  file_header: true
+dsl:
+  outdir: sorbet/rbi/dsl
+  file_header: true
+  only: []
+  exclude: []
+  verify: false
+  quiet: false
+  workers: 1
+gem:
+  outdir: sorbet/rbi/gems
+  file_header: true
+  all: false
+  prerequire: ''
+  postrequire: sorbet/tapioca/require.rb
+  exclude: []
+  typed_overrides:
+    activesupport: 'false'
+  verify: false
+  doc: false
+  exported_gem_rbis: true
+  workers: 1
+clean_shims:
+  gem_rbi_dir: sorbet/rbi/gems
+  dsl_rbi_dir: sorbet/rbi/dsl
+  shim_rbi_dir: sorbet/rbi/shims
+```
+<!-- END_CONFIG_TEMPLATE -->
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/tapioca. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](https://github.com/Shopify/tapioca/blob/main/CODE_OF_CONDUCT.md) code of conduct.

data/lib/tapioca/cli.rb

@@ -47,6 +47,7 @@ module Tapioca
     desc "todo", "generate the list of unresolved constants"
     option :todo_file,
       type: :string,
+      desc: "Path to the generated todo RBI file",
       default: DEFAULT_TODO_FILE
     option :file_header,
       type: :boolean,

data/lib/tapioca/compilers/dsl/active_record_columns.rb

@@ -296,7 +296,7 @@ module Tapioca
 
         sig { params(type: String).returns(String) }
         def as_nilable_type(type)
-          return type if type.start_with?("T.nilable(")
+          return type if type.start_with?("T.nilable(") || type == "T.untyped"
           "T.nilable(#{type})"
         end
       end

data/lib/tapioca/compilers/dsl/base.rb

@@ -136,11 +136,13 @@ module Tapioca
           method_def = signature.nil? ? method_def : signature.method
           method_types = parameters_types_from_signature(method_def, signature)
 
-          method_def.parameters.each_with_index.map do |(type, name), index|
+          parameters = T.let(method_def.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
+
+          parameters.each_with_index.map do |(type, name), index|
             fallback_arg_name = "_arg#{index}"
 
-            name ||= fallback_arg_name
-            name = name.to_s.gsub(/&|\*/, fallback_arg_name) # avoid incorrect names from `delegate`
+            name = name ? name.to_s : fallback_arg_name
+            name = fallback_arg_name unless valid_parameter_name?(name)
             method_type = T.must(method_types[index])
 
             case type
@@ -173,6 +175,11 @@ module Tapioca
           return_type = "T.untyped" if return_type == "<NOT-TYPED>"
           return_type
         end
+
+        sig { params(name: String).returns(T::Boolean) }
+        def valid_parameter_name?(name)
+          name.match?(/^[[[:alnum:]]_]+$/)
+        end
       end
     end
   end

data/lib/tapioca/compilers/dynamic_mixin_compiler.rb

@@ -174,20 +174,31 @@ class DynamicMixinCompiler
 
   sig { params(tree: RBI::Tree).returns([T::Array[Module], T::Array[Module]]) }
   def compile_mixes_in_class_methods(tree)
-    includes = dynamic_includes.select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
-    includes.each do |mod|
+    includes = dynamic_includes.map do |mod|
       qname = qualified_name_of(mod)
-      tree << RBI::Include.new(T.must(qname))
-    end
+
+      next if qname.nil? || qname.empty?
+      next if filtered_mixin?(qname)
+
+      tree << RBI::Include.new(qname)
+
+      mod
+    end.compact
 
     # If we can generate multiple mixes_in_class_methods, then we want to use all dynamic extends that are not the
     # constant itself
-    mixed_in_class_methods = dynamic_extends.select { |mod| mod != @constant }
+    mixed_in_class_methods = dynamic_extends.select do |mod|
+      mod != @constant && !module_included_by_another_dynamic_extend?(mod, dynamic_extends)
+    end
+
     return [[], []] if mixed_in_class_methods.empty?
 
     mixed_in_class_methods.each do |mod|
       qualified_name = qualified_name_of(mod)
+
       next if qualified_name.nil? || qualified_name.empty?
+      next if filtered_mixin?(qualified_name)
+
       tree << RBI::MixesInClassMethods.new(qualified_name)
     end
 
@@ -195,4 +206,18 @@ class DynamicMixinCompiler
   rescue
     [[], []] # silence errors
   end
+
+  sig { params(mod: Module, dynamic_extends: T::Array[Module]).returns(T::Boolean) }
+  def module_included_by_another_dynamic_extend?(mod, dynamic_extends)
+    dynamic_extends.any? do |dynamic_extend|
+      mod != dynamic_extend && ancestors_of(dynamic_extend).include?(mod)
+    end
+  end
+
+  sig { params(qualified_mixin_name: String).returns(T::Boolean) }
+  def filtered_mixin?(qualified_mixin_name)
+    # filter T:: namespace mixins that aren't T::Props
+    # T::Props and subconstants have semantic value
+    qualified_mixin_name.start_with?("::T::") && !qualified_mixin_name.start_with?("::T::Props")
+  end
 end

data/lib/tapioca/compilers/requires_compiler.rb

@@ -17,10 +17,9 @@ module Tapioca
       def compile
         config = Spoom::Sorbet::Config.parse_file(@sorbet_path)
         files = collect_files(config)
+        names_in_project = files.map { |file| [File.basename(file, ".rb"), true] }.to_h
         files.flat_map do |file|
-          collect_requires(file).reject do |req|
-            name_in_project?(files, req)
-          end
+          collect_requires(file).reject { |req| names_in_project[req] }
         end.sort.uniq.map do |name|
           "require \"#{name}\"\n"
         end.join
@@ -45,9 +44,10 @@ module Tapioca
 
       sig { params(file_path: String).returns(T::Enumerable[String]) }
       def collect_requires(file_path)
-        File.read(file_path).lines.map do |line|
+        File.binread(file_path).lines.map do |line|
           /^\s*require\s*(\(\s*)?['"](?<name>[^'"]+)['"](\s*\))?/.match(line) { |m| m["name"] }
         end.compact
+          .reject { |require| require.include?('#{') } # ignore interpolation
       end
 
       sig { params(config: Spoom::Sorbet::Config, file_path: Pathname).returns(T::Boolean) }
@@ -83,13 +83,6 @@ module Tapioca
       def path_parts(path)
         T.unsafe(path).descend.map { |part| part.basename.to_s }
       end
-
-      sig { params(files: T::Enumerable[String], name: String).returns(T::Boolean) }
-      def name_in_project?(files, name)
-        files.any? do |file|
-          File.basename(file, ".rb") == name
-        end
-      end
     end
   end
 end

data/lib/tapioca/compilers/symbol_table/symbol_generator.rb

@@ -141,7 +141,6 @@ module Tapioca
           return if symbol_ignored?(name)
 
           klass = class_of(value)
-          return if klass == TypeMember || klass == TypeTemplate
 
           klass_name = if klass == ObjectSpace::WeakMap
             # WeakMap is an implicit generic with one type variable
@@ -172,6 +171,7 @@ module Tapioca
         sig { params(tree: RBI::Tree, name: String, constant: Module).void }
         def compile_module(tree, name, constant)
           return unless defined_in_gem?(constant, strict: false)
+          return if Tapioca::TypeVariableModule === constant
 
           comments = documentation_comments(name)
           scope =
@@ -282,30 +282,16 @@ module Tapioca
           type_variables = GenericTypeRegistry.lookup_type_variables(constant)
           return unless type_variables
 
-          # Create a map of subconstants (via their object ids) to their names.
-          # We need this later when we want to lookup the name of the registered type
-          # variable via the value of the type variable constant.
-          subconstant_to_name_lookup = constants_of(constant)
-            .each_with_object({}.compare_by_identity) do |constant_name, table|
-            table[constantize(constant_name.to_s, namespace: constant)] = constant_name.to_s
-          end
-
           # Map each type variable to its string representation.
           #
-          # Each entry of `type_variables` maps an object_id to a String,
+          # Each entry of `type_variables` maps a Module to a String,
           # and the order they are inserted into the hash is the order they should be
           # defined in the source code.
-          #
-          # By looping over these entries and then getting the actual constant name
-          # from the `subconstant_to_name_lookup` we defined above, gives us all the
-          # information we need to serialize type variable definitions.
-          type_variable_declarations = type_variables.map do |type_variable, serialized_type_variable|
-            constant_name = subconstant_to_name_lookup[type_variable]
-            type_variable.name = constant_name
-            # Here, we know that constant_value will be an instance of
-            # T::Types::CustomTypeVariable, which knows how to serialize
-            # itself to a type_member/type_template
-            tree << RBI::TypeMember.new(constant_name, serialized_type_variable)
+          type_variable_declarations = type_variables.map do |type_variable|
+            type_variable_name = type_variable.name
+            next unless type_variable_name
+
+            tree << RBI::TypeMember.new(type_variable_name, type_variable.serialize)
           end
 
           return if type_variable_declarations.empty?
@@ -392,7 +378,7 @@ module Tapioca
             .select do |mod|
               name = name_of(mod)
 
-              name && !name.start_with?("T::")
+              name && !filtered_mixin?(name)
             end
             .map do |mod|
               add_to_symbol_queue(name_of(mod))
@@ -496,7 +482,9 @@ module Tapioca
           sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
             fallback_arg_name = "_arg#{index}"
 
-            unless name
+            name = if name
+              name.to_s
+            else
               # For attr_writer methods, Sorbet signatures have the name
               # of the method (without the trailing = sign) as the name of
               # the only parameter. So, if the parameter does not have a name
@@ -512,15 +500,15 @@ module Tapioca
                 method_name[-1] == "="
               )
 
-              name = if writer_method_with_sig
-                T.must(method_name[0...-1]).to_sym
+              if writer_method_with_sig
+                method_name.delete_suffix("=")
               else
                 fallback_arg_name
               end
             end
 
             # Sanitize param names
-            name = name.to_s.gsub(/[^a-zA-Z0-9_]/, fallback_arg_name)
+            name = fallback_arg_name unless valid_parameter_name?(name)
 
             [type, name]
           end
@@ -613,6 +601,13 @@ module Tapioca
           SymbolLoader.ignore_symbol?(symbol_name)
         end
 
+        sig { params(mixin_name: String).returns(T::Boolean) }
+        def filtered_mixin?(mixin_name)
+          # filter T:: namespace mixins that aren't T::Props
+          # T::Props and subconstants have semantic value
+          mixin_name.start_with?("T::") && !mixin_name.start_with?("T::Props")
+        end
+
         SPECIAL_METHOD_NAMES = T.let([
           "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
           "<", "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`"
@@ -624,6 +619,11 @@ module Tapioca
           !!name.match(/^[[:word:]]+[?!=]?$/)
         end
 
+        sig { params(name: String).returns(T::Boolean) }
+        def valid_parameter_name?(name)
+          name.match?(/^[[[:alnum:]]_]+$/)
+        end
+
         sig { params(method: UnboundMethod).returns(T::Boolean) }
         def method_in_gem?(method)
           source_location = method.source_location&.first

data/lib/tapioca/gemfile.rb

@@ -99,6 +99,9 @@ module Tapioca
       sig { returns(String) }
       attr_reader :full_gem_path, :version
 
+      sig { returns(T::Array[Pathname]) }
+      attr_reader :files
+
       sig { params(spec: Spec).void }
       def initialize(spec)
         @spec = T.let(spec, Tapioca::Gemfile::Spec)
@@ -106,6 +109,7 @@ module Tapioca
         @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])
       end
 
       sig { params(gemfile_dir: String).returns(T::Boolean) }
@@ -113,21 +117,6 @@ module Tapioca
         gem_ignored? || gem_in_app_dir?(gemfile_dir)
       end
 
-      sig { returns(T::Array[Pathname]) }
-      def files
-        if default_gem?
-          # `Bundler::RemoteSpecification` delegates missing methods to
-          # `Gem::Specification`, so `files` actually always exists on spec.
-          T.unsafe(@spec).files.map do |file|
-            ruby_lib_dir.join(file)
-          end
-        else
-          @spec.full_require_paths.flat_map do |path|
-            Pathname.glob((Pathname.new(path) / "**/*.rb").to_s)
-          end
-        end
-      end
-
       sig { returns(String) }
       def name
         @spec.name
@@ -154,7 +143,7 @@ module Tapioca
 
       sig { returns(T::Array[String]) }
       def exported_rbi_files
-        @exported_rbi_files ||= Dir.glob("#{full_gem_path}/rbi/**/*.rbi")
+        @exported_rbi_files ||= Dir.glob("#{full_gem_path}/rbi/**/*.rbi").sort
       end
 
       sig { returns(T::Boolean) }
@@ -176,14 +165,49 @@ module Tapioca
 
       private
 
-      sig { returns(T::Boolean) }
+      sig { returns(T::Array[Pathname]) }
+      def collect_files
+        if default_gem?
+          # `Bundler::RemoteSpecification` delegates missing methods to
+          # `Gem::Specification`, so `files` actually always exists on spec.
+          T.unsafe(@spec).files.map do |file|
+            resolve_to_ruby_lib_dir(file)
+          end
+        else
+          @spec.full_require_paths.flat_map do |path|
+            Pathname.glob((Pathname.new(path) / "**/*.rb").to_s)
+          end
+        end
+      end
+
+      sig { returns(T.nilable(T::Boolean)) }
       def default_gem?
         @spec.respond_to?(:default_gem?) && @spec.default_gem?
       end
 
-      sig { returns(Pathname) }
-      def ruby_lib_dir
-        Pathname.new(RbConfig::CONFIG["rubylibdir"])
+      sig { returns(Regexp) }
+      def require_paths_prefix_matcher
+        @require_paths_prefix_matcher = T.let(@require_paths_prefix_matcher, 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
+      end
+
+      sig { params(file: String).returns(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
+        # we can always replace the match with the Ruby lib directory and
+        # we would have properly resolved the file under the Ruby lib dir.
+        prefix_matcher = Regexp.union(require_paths_prefix_matcher, //)
+
+        ruby_lib_dir = RbConfig::CONFIG["rubylibdir"]
+        file = file.sub(prefix_matcher, "#{ruby_lib_dir}/")
+
+        Pathname.new(file).expand_path
       end
 
       sig { returns(String) }

data/lib/tapioca/generators/base.rb

@@ -11,8 +11,8 @@ module Tapioca
         include Thor::Actions
       end
 
-      include CliHelper
       include Thor::Base
+      include CliHelper
 
       abstract!
 

data/lib/tapioca/generic_type_registry.rb

@@ -20,7 +20,6 @@ module Tapioca
   # variable to type variable serializers. This allows us to associate type variables
   # to the constant names that represent them, easily.
   module GenericTypeRegistry
-    TypeVariable = T.type_alias { T.any(TypeMember, TypeTemplate) }
     @generic_instances = T.let(
       {},
       T::Hash[String, Module]
@@ -28,7 +27,7 @@ module Tapioca
 
     @type_variables = T.let(
       {}.compare_by_identity,
-      T::Hash[Module, T::Hash[TypeVariable, String]]
+      T::Hash[Module, T::Array[TypeVariableModule]]
     )
 
     class << self
@@ -60,7 +59,12 @@ module Tapioca
         @generic_instances[name] ||= create_generic_type(constant, name)
       end
 
-      sig { params(constant: Module).returns(T.nilable(T::Hash[TypeVariable, String])) }
+      sig { params(instance: Object).returns(T::Boolean) }
+      def generic_type_instance?(instance)
+        @generic_instances.values.any? { |generic_type| generic_type === instance }
+      end
+
+      sig { params(constant: Module).returns(T.nilable(T::Array[TypeVariableModule])) }
       def lookup_type_variables(constant)
         @type_variables[constant]
       end
@@ -77,13 +81,13 @@ module Tapioca
       sig do
         params(
           constant: T.untyped,
-          type_variable: TypeVariable,
+          type_variable: TypeVariableModule,
         ).void
       end
       def register_type_variable(constant, type_variable)
         type_variables = lookup_or_initialize_type_variables(constant)
 
-        type_variables[type_variable] = type_variable.serialize
+        type_variables << type_variable
       end
 
       private
@@ -109,6 +113,17 @@ module Tapioca
         # Let's set the `name` method to return the proper generic name
         generic_type.define_singleton_method(:name) { name }
 
+        # We need to define a `<=` method on the cloned constant, so that Sorbet
+        # can do covariance/contravariance checks on the type variables.
+        #
+        # Normally, we would be doing proper covariance/contravariance checks here, but
+        # that is not necessary, since we are not implementing a runtime type checker
+        # here. It is just enough for the checks to pass, so that we can serialize the
+        # signatures, assuming the sigs were well-formed.
+        #
+        # So we act like all subtype checks pass.
+        generic_type.define_singleton_method(:<=) { |_| true }
+
         # Return the generic type we created
         generic_type
       end
@@ -140,9 +155,9 @@ module Tapioca
         end
       end
 
-      sig { params(constant: Module).returns(T::Hash[TypeVariable, String]) }
+      sig { params(constant: Module).returns(T::Array[TypeVariableModule]) }
       def lookup_or_initialize_type_variables(constant)
-        @type_variables[constant] ||= {}.compare_by_identity
+        @type_variables[constant] ||= []
       end
     end
   end

data/lib/tapioca/helpers/active_record_column_type_helper.rb

@@ -43,13 +43,13 @@ class ActiveRecordColumnTypeHelper
     setter_type = getter_type
 
     if column&.null
-      return ["T.nilable(#{getter_type})", "T.nilable(#{setter_type})"]
+      return [as_nilable_type(getter_type), as_nilable_type(setter_type)]
     end
 
     if column_name == @constant.primary_key ||
         column_name == "created_at" ||
         column_name == "updated_at"
-      getter_type = "T.nilable(#{getter_type})"
+      getter_type = as_nilable_type(getter_type)
     end
 
     [getter_type, setter_type]
@@ -63,9 +63,19 @@ class ActiveRecordColumnTypeHelper
         !(constant.singleton_class < Object.const_get(:StrongTypeGeneration))
   end
 
+  sig { params(type: String).returns(String) }
+  def as_nilable_type(type)
+    if type.start_with?("T.nilable(") || type == "T.untyped"
+      type
+    else
+      "T.nilable(#{type})"
+    end
+  end
+
   sig { params(column_type: Object).returns(String) }
   def handle_unknown_type(column_type)
     return "T.untyped" unless ActiveModel::Type::Value === column_type
+    return "T.untyped" if Tapioca::GenericTypeRegistry.generic_type_instance?(column_type)
 
     lookup_return_type_of_method(column_type, :deserialize) ||
       lookup_return_type_of_method(column_type, :cast) ||

data/lib/tapioca/helpers/cli_helper.rb

@@ -12,15 +12,16 @@ module Tapioca
 
     sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
     def say_error(message = "", *color)
-      force_new_line = (message.to_s !~ /( |\t)\Z/)
-      # NOTE: This is a hack. We're no longer subclassing from Thor::Shell::Color
-      # so we no longer have access to the prepare_message call.
-      # We should update this to remove this.
-      buffer = shell.send(:prepare_message, *T.unsafe([message, *T.unsafe(color)]))
-      buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")
-
-      $stderr.print(buffer)
-      $stderr.flush
+      # 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
+      #    the same line, and
+      # 2. it accepts a last parameter which breaks the ability to pass color values
+      #    as splats.
+      #
+      # So we implement our own version here to work around those problems.
+      shell.indent(-shell.padding) do
+        super(message, color)
+      end
     end
   end
 end

data/lib/tapioca/helpers/config_helper.rb

@@ -6,6 +6,9 @@ require "yaml"
 module Tapioca
   module ConfigHelper
     extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Thor }
 
     sig { returns(String) }
     attr_reader :command_name
@@ -60,9 +63,122 @@ module Tapioca
         config = YAML.load_file(config_file, fallback: {})
       end
 
+      validate_config!(config_file, config)
+
       Thor::CoreExt::HashWithIndifferentAccess.new(config[command_name] || {})
     end
 
+    sig { params(config_file: String, config: T::Hash[T.untyped, T.untyped]).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))
+
+      commands = T.cast(self, Thor).class.commands
+
+      errors = config.flat_map do |config_key, config_options|
+        command = commands[config_key.to_s]
+
+        unless command
+          next build_error("unknown key `#{config_key}`")
+        end
+
+        validate_config_options(command.options, config_key, config_options || {})
+      end.compact
+
+      unless errors.empty?
+        print_errors(config_file, errors)
+        exit(1)
+      end
+    ensure
+      @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
+    def validate_config_options(command_options, config_key, config_options)
+      config_options.map do |config_option_key, config_option_value|
+        command_option = command_options[config_option_key.to_sym]
+
+        unless command_option
+          next build_error("unknown option `#{config_option_key}` for key `#{config_key}`")
+        end
+
+        config_option_value_type = case config_option_value
+        when FalseClass, TrueClass
+          :boolean
+        when Numeric
+          :numeric
+        when Hash
+          :hash
+        when Array
+          :array
+        when String
+          :string
+        else
+          :object
+        end
+
+        unless config_option_value_type == command_option.type
+          next build_error("invalid value for option `#{config_option_key}` for key `#{config_key}` " \
+            "- expected `#{command_option.type.capitalize}` but found #{config_option_value_type.capitalize}")
+        end
+      end.compact
+    end
+
+    class ConfigErrorMessagePart < T::Struct
+      const :message, String
+      const :colors, T::Array[Symbol]
+    end
+
+    class ConfigError < T::Struct
+      const :message_parts, T::Array[ConfigErrorMessagePart]
+    end
+
+    sig { params(msg: String).returns(ConfigError) }
+    def build_error(msg)
+      parts = msg.split(/(`[^`]+` ?)/)
+
+      message_parts = parts.map do |part|
+        match = part.match(/`([^`]+)`( ?)/)
+
+        if match
+          ConfigErrorMessagePart.new(
+            message: "#{match[1]}#{match[2]}",
+            colors: [:bold, :blue]
+          )
+        else
+          ConfigErrorMessagePart.new(
+            message: part,
+            colors: [:yellow]
+          )
+        end
+      end
+
+      ConfigError.new(
+        message_parts: message_parts
+      )
+    end
+
+    sig { params(config_file: String, errors: T::Array[ConfigError]).void }
+    def print_errors(config_file, errors)
+      say_error("\nConfiguration file ", :red)
+      say_error("#{config_file} ", :blue, :bold)
+      say_error("has the following errors:\n\n", :red)
+
+      errors.each do |error|
+        say_error("- ")
+        error.message_parts.each do |part|
+          T.unsafe(self).say_error(part.message, *part.colors)
+        end
+      end
+    end
+
     sig do
       params(options: T.nilable(Thor::CoreExt::HashWithIndifferentAccess))
         .returns(Thor::CoreExt::HashWithIndifferentAccess)

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -23,17 +23,31 @@ module T
       def type_member(variance = :invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
         # `T::Generic#type_member` just instantiates a `T::Type::TypeMember` instance and returns it.
         # We use that when registering the type member and then later return it from this method.
-        type_member = Tapioca::TypeMember.new(variance, fixed, lower, upper)
-        Tapioca::GenericTypeRegistry.register_type_variable(self, type_member)
-        type_member
+        Tapioca::TypeVariableModule.new(
+          T.cast(self, Module),
+          Tapioca::TypeVariableModule::Type::Member,
+          variance,
+          fixed,
+          lower,
+          upper
+        ).tap do |type_variable|
+          Tapioca::GenericTypeRegistry.register_type_variable(self, type_variable)
+        end
       end
 
       def type_template(variance = :invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
         # `T::Generic#type_template` just instantiates a `T::Type::TypeTemplate` instance and returns it.
         # We use that when registering the type template and then later return it from this method.
-        type_template = Tapioca::TypeTemplate.new(variance, fixed, lower, upper)
-        Tapioca::GenericTypeRegistry.register_type_variable(self, type_template)
-        type_template
+        Tapioca::TypeVariableModule.new(
+          T.cast(self, Module),
+          Tapioca::TypeVariableModule::Type::Template,
+          variance,
+          fixed,
+          lower,
+          upper
+        ).tap do |type_variable|
+          Tapioca::GenericTypeRegistry.register_type_variable(self, type_variable)
+        end
       end
     end
 
@@ -42,15 +56,26 @@ module T
 
   module Types
     class Simple
-      # This module intercepts calls to the `name` method for
-      # simple types, so that it can ask the name to the type if
-      # the type is generic, since, by this point, we've created
-      # a clone of that type with the `name` method returning the
-      # appropriate name for that specific concrete type.
-      module GenericNamePatch
+      module GenericPatch
+        def valid?(obj)
+          # Since `Tapioca::TypeVariable` is a `Module`, it will be wrapped by a
+          # `Simple` type. We want to always make type variable types valid, so we
+          # need to explicitly check that `raw_type` is a `Tapioca::TypeVariable`
+          # and return `true`
+          if defined?(Tapioca::TypeVariableModule) && Tapioca::TypeVariableModule === @raw_type
+            return true
+          end
+
+          obj.is_a?(@raw_type)
+        end
+
+        # This method intercepts calls to the `name` method for simple types, so that
+        # it can ask the name to the type if the type is generic, since, by this point,
+        # we've created a clone of that type with the `name` method returning the
+        # appropriate name for that specific concrete type.
         def name
-          if T::Generic === @raw_type
-            # for types that are generic, use the name
+          if T::Generic === @raw_type || Tapioca::TypeVariableModule === @raw_type
+            # for types that are generic or are type variables, use the name
             # returned by the "name" method of this instance
             @name ||= T.unsafe(@raw_type).name.freeze
           else
@@ -60,60 +85,57 @@ module T
         end
       end
 
-      prepend GenericNamePatch
+      prepend GenericPatch
     end
   end
 end
 
 module Tapioca
-  class TypeMember < T::Types::TypeMember
+  # This is subclassing from `Module` so that instances of this type will be modules.
+  # The reason why we want that is because that means those instances will automatically
+  # get bound to the constant names they are assigned to by Ruby. As a result, we don't
+  # need to do any matching of constants to type variables to bind their names, Ruby will
+  # do that automatically for us and we get the `name` method for free from `Module`.
+  class TypeVariableModule < Module
     extend T::Sig
 
-    sig { returns(T.nilable(String)) }
-    attr_accessor :name
-
-    sig { returns(T.untyped) }
-    attr_reader :fixed, :lower, :upper
+    class Type < T::Enum
+      enums do
+        Member = new("type_member")
+        Template = new("type_template")
+      end
+    end
 
-    sig { params(variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
-    def initialize(variance, fixed, lower, upper)
-      super(variance)
+    sig do
+      params(context: Module, type: Type, variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void
+    end
+    def initialize(context, type, variance, fixed, lower, upper) # rubocop:disable Metrics/ParameterLists
+      @context = context
+      @type = type
+      @variance = variance
       @fixed = fixed
       @lower = lower
       @upper = upper
+      super()
     end
 
-    sig { returns(String) }
-    def serialize
-      parts = []
-      parts << ":#{@variance}" unless @variance == :invariant
-      parts << "fixed: #{@fixed}" if @fixed
-      parts << "lower: #{@lower}" unless @lower == T.untyped
-      parts << "upper: #{@upper}" unless @upper == BasicObject
-
-      parameters = parts.join(", ")
-
-      serialized = +"type_member"
-      serialized << "(#{parameters})" unless parameters.empty?
-      serialized
-    end
-  end
-
-  class TypeTemplate < T::Types::TypeTemplate
-    extend T::Sig
-
     sig { returns(T.nilable(String)) }
-    attr_accessor :name
-
-    sig { returns(T.untyped) }
-    attr_reader :fixed, :lower, :upper
+    def name
+      constant_name = super
+
+      # This is a hack to work around modules under anonymous modules not having
+      # names in 2.6 and 2.7: https://bugs.ruby-lang.org/issues/14895
+      #
+      # This happens when a type variable is declared under `class << self`, for
+      # example.
+      #
+      # The workaround is to give the parent context a name, at which point, our
+      # module gets bound to a name under that name, as well.
+      unless constant_name
+        constant_name = with_bound_name_pre_3_0 { super }
+      end
 
-    sig { params(variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
-    def initialize(variance, fixed, lower, upper)
-      super(variance)
-      @fixed = fixed
-      @lower = lower
-      @upper = upper
+      constant_name&.split("::")&.last
     end
 
     sig { returns(String) }
@@ -126,9 +148,25 @@ module Tapioca
 
       parameters = parts.join(", ")
 
-      serialized = +"type_template"
+      serialized = @type.serialize.dup
       serialized << "(#{parameters})" unless parameters.empty?
       serialized
     end
+
+    private
+
+    sig do
+      type_parameters(:Result)
+        .params(block: T.proc.returns(T.type_parameter(:Result)))
+        .returns(T.type_parameter(:Result))
+    end
+    def with_bound_name_pre_3_0(&block)
+      require "securerandom"
+      temp_name = "TYPE_VARIABLE_TRACKING_#{SecureRandom.hex}"
+      self.class.const_set(temp_name, @context)
+      block.call
+    ensure
+      self.class.send(:remove_const, temp_name) if temp_name
+    end
   end
 end

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.6.1"
+  VERSION = "0.6.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-26 00:00:00.000000000 Z
+date: 2022-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler