tapioca 0.6.0 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a99e7a4475e2991e305c461774e45e128d430632e96581fc541680b61275e4e1
-  data.tar.gz: 8ee7b9b225dd752edf606a98aee1b8490687f351dae642b24060549740d2ab5a
+  metadata.gz: 6ea7bddec4d5d00918ca3236afee754f7f8dd9481d78bf8e26819c0140b154ff
+  data.tar.gz: 681d5ed15d27c20833aa4df86dc1a61d721e0d5993a43073873f2406a254d806
 SHA512:
-  metadata.gz: 3ab85b1422fba3aa79de02fad9e164b2013cef3a388ad196e4c11f0c2c6dc142b6a540a430f4a4ace9f3ebe92da2f29fbe733e13ceb481277e7d7e2691db9f0c
-  data.tar.gz: b9f2c2cca77916e08fcbb1ca021818b51bc5edd8d899b2f5e89dae3bfddd38dd8e403b16bacd8c8db37dc630448458d7d6f52e6445cb9ecb96c6bba16c4c20e7
+  metadata.gz: a2e885fa0010d90899b1f167e3a68c1d65f7cec21d7386a321a51d753fdf6e4deaf97d5c0866b7969cf90f42a5aa68af858e173237f8fc0a7c31bc08c3931185
+  data.tar.gz: a48f142ad8402b07c2b4724801b2dee912f1b95975bb9951feb97aef433a46c248e458527827be3a450336f2c62195714a5f5b476ed7704dad4ccefdb93aca98

data/Gemfile

@@ -35,4 +35,10 @@ group(:development, :test) do
   gem("config", require: false)
   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_model_attributes.rb

@@ -62,26 +62,32 @@ module Tapioca
 
         sig { params(constant: ::ActiveModel::Attributes::ClassMethods).returns(T::Array[[::String, ::String]]) }
         def attribute_methods_for(constant)
-          constant.attribute_method_matchers.flat_map do |matcher|
+          patterns = if constant.respond_to?(:attribute_method_patterns)
+            # https://github.com/rails/rails/pull/44367
+            T.unsafe(constant).attribute_method_patterns
+          else
+            constant.attribute_method_matchers
+          end
+          patterns.flat_map do |pattern|
             constant.attribute_types.map do |name, value|
-              next unless handle_method_matcher?(matcher)
+              next unless handle_method_pattern?(pattern)
 
-              [matcher.method_name(name), type_for(value)]
+              [pattern.method_name(name), type_for(value)]
             end.compact
           end
         end
 
-        sig do
-          params(matcher: ::ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher)
-            .returns(T::Boolean)
-        end
-        def handle_method_matcher?(matcher)
-          target = if matcher.respond_to?(:method_missing_target)
+        sig { params(pattern: T.untyped).returns(T::Boolean) }
+        def handle_method_pattern?(pattern)
+          target = if pattern.respond_to?(:method_missing_target)
             # Pre-Rails 6.0, the field is named "method_missing_target"
-            T.unsafe(matcher).method_missing_target
-          else
+            T.unsafe(pattern).method_missing_target
+          elsif pattern.respond_to?(:target)
             # Rails 6.0+ has renamed the field to "target"
-            matcher.target
+            pattern.target
+          else
+            # https://github.com/rails/rails/pull/44367/files
+            T.unsafe(pattern).proxy_target
           end
 
           HANDLED_METHOD_TARGETS.include?(target.to_s)
@@ -109,7 +115,7 @@ module Tapioca
             return "T.untyped"
           end
 
-          "T.nilable(#{type})"
+          as_nilable_type(type)
         end
 
         sig { params(klass: RBI::Scope, method: String, type: String).void }

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

@@ -184,7 +184,7 @@ module Tapioca
         end
         def populate_single_assoc_getter_setter(klass, constant, association_name, reflection)
           association_class = type_for(constant, reflection)
-          association_type = "T.nilable(#{association_class})"
+          association_type = as_nilable_type(association_class)
 
           klass.create_method(
             association_name.to_s,

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

@@ -114,8 +114,14 @@ module Tapioca
               constant.attribute_aliases.each do |attribute_name, column_name|
                 attribute_name = attribute_name.to_s
                 column_name = column_name.to_s
-                new_method_names = constant.attribute_method_matchers.map { |m| m.method_name(attribute_name) }
-                old_method_names = constant.attribute_method_matchers.map { |m| m.method_name(column_name) }
+                patterns = if constant.respond_to?(:attribute_method_patterns)
+                  # https://github.com/rails/rails/pull/44367
+                  T.unsafe(constant).attribute_method_patterns
+                else
+                  constant.attribute_method_matchers
+                end
+                new_method_names = patterns.map { |m| m.method_name(attribute_name) }
+                old_method_names = patterns.map { |m| m.method_name(column_name) }
                 methods_to_add = new_method_names - old_method_names
 
                 add_methods_for_attribute(mod, constant, column_name, attribute_name, methods_to_add)
@@ -293,12 +299,6 @@ module Tapioca
             return_type: "T::Boolean"
           )
         end
-
-        sig { params(type: String).returns(String) }
-        def as_nilable_type(type)
-          return type if type.start_with?("T.nilable(")
-          "T.nilable(#{type})"
-        end
       end
     end
   end

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

@@ -250,6 +250,15 @@ module Tapioca
           sig { returns(String) }
           attr_reader :constant_name
 
+          sig { params(type: String).returns(String) }
+          def as_nilable_type(type)
+            if type.start_with?("T.nilable(", "::T.nilable(") || type == "T.untyped" || type == "::T.untyped"
+              type
+            else
+              "T.nilable(#{type})"
+            end
+          end
+
           sig { void }
           def create_classes_and_includes
             model.create_extend(CommonRelationMethodsModuleName)
@@ -532,7 +541,7 @@ module Tapioca
                   ],
                   return_type: "T::Boolean"
                 )
-              when :find, :find_by!
+              when :find
                 create_common_method(
                   "find",
                   parameters: [
@@ -546,7 +555,15 @@ module Tapioca
                   parameters: [
                     create_rest_param("args", type: "T.untyped"),
                   ],
-                  return_type: "T.nilable(#{constant_name})"
+                  return_type: as_nilable_type(constant_name)
+                )
+              when :find_by!
+                create_common_method(
+                  "find_by!",
+                  parameters: [
+                    create_rest_param("args", type: "T.untyped"),
+                  ],
+                  return_type: constant_name
                 )
               when :first, :last, :take
                 create_common_method(
@@ -562,7 +579,7 @@ module Tapioca
                 return_type = if method_name.end_with?("!")
                   constant_name
                 else
-                  "T.nilable(#{constant_name})"
+                  as_nilable_type(constant_name)
                 end
 
                 create_common_method(

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

@@ -107,7 +107,7 @@ module Tapioca
               store_data.accessors.each do |accessor|
                 field = store_data.fields[accessor]
                 type = type_for(field.type_sym)
-                type = "T.nilable(#{type})" if field.null && type != "T.untyped"
+                type = as_nilable_type(type) if field.null
 
                 store_accessors_module = model.create_module("StoreAccessors")
                 generate_methods(store_accessors_module, field.name.to_s, type)

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,20 @@ module Tapioca
           return_type = "T.untyped" if return_type == "<NOT-TYPED>"
           return_type
         end
+
+        sig { params(type: String).returns(String) }
+        def as_nilable_type(type)
+          if type.start_with?("T.nilable(", "::T.nilable(") || type == "T.untyped" || type == "::T.untyped"
+            type
+          else
+            "T.nilable(#{type})"
+          end
+        end
+
+        sig { params(name: String).returns(T::Boolean) }
+        def valid_parameter_name?(name)
+          name.match?(/^[[[:alnum:]]_]+$/)
+        end
       end
     end
   end

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

@@ -116,7 +116,7 @@ module Tapioca
           if returns_collection
             COLLECTION_TYPE.call(cache_type)
           else
-            "T.nilable(::#{cache_type})"
+            as_nilable_type(T.must(qualified_name_of(cache_type)))
           end
         rescue ArgumentError
           "T.untyped"
@@ -175,18 +175,20 @@ module Tapioca
           parameters << create_kw_opt_param("includes", default: "nil", type: "T.untyped")
 
           if field.unique
+            type = T.must(qualified_name_of(constant))
+
             klass.create_method(
               "#{name}!",
               class_method: true,
               parameters: parameters,
-              return_type: "::#{constant}"
+              return_type: type
             )
 
             klass.create_method(
               name,
               class_method: true,
               parameters: parameters,
-              return_type: "T.nilable(::#{constant})"
+              return_type: as_nilable_type(type)
             )
           else
             klass.create_method(

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

@@ -64,12 +64,12 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          all_modules.select do |const|
+          all_classes.select do |const|
             name = qualified_name_of(const)
 
             name &&
               !name.match?(BUILT_IN_MATCHER) &&
-              const < ::Rails::Generators::Base
+              ::Rails::Generators::Base > const
           end
         end
 
@@ -111,7 +111,7 @@ module Tapioca
           if arg.required || arg.default
             type
           else
-            "T.nilable(#{type})"
+            as_nilable_type(type)
           end
         end
       end

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

@@ -71,14 +71,15 @@ module Tapioca
           )
           return if properties.keys.empty?
 
-          instance_methods = constant.instance_methods(false).map(&:to_s).to_set
-
           root.create_path(constant) do |k|
-            properties.values.each do |property|
-              generate_methods_for_property(k, property) do |method_name|
-                !instance_methods.include?(method_name.to_sym)
+            smart_properties_methods_name = "SmartPropertiesGeneratedMethods"
+            k.create_module(smart_properties_methods_name) do |mod|
+              properties.values.each do |property|
+                generate_methods_for_property(mod, property)
               end
             end
+
+            k.create_include(smart_properties_methods_name)
           end
         end
 
@@ -95,26 +96,21 @@ module Tapioca
 
         sig do
           params(
-            klass: RBI::Scope,
-            property: ::SmartProperties::Property,
-            block: T.proc.params(arg: String).returns(T::Boolean)
+            mod: RBI::Scope,
+            property: ::SmartProperties::Property
           ).void
         end
-        def generate_methods_for_property(klass, property, &block)
+        def generate_methods_for_property(mod, property)
           type = type_for(property)
 
           if property.writable?
             name = property.name.to_s
             method_name = "#{name}="
 
-            klass.create_method(
-              method_name,
-              parameters: [create_param(name, type: type)],
-              return_type: type
-            ) if block.call(method_name)
+            mod.create_method(method_name, parameters: [create_param(name, type: type)], return_type: type)
           end
 
-          klass.create_method(property.reader.to_s, return_type: type) if block.call(property.reader.to_s)
+          mod.create_method(property.reader.to_s, return_type: type)
         end
 
         BOOLEANS = T.let([
@@ -147,11 +143,8 @@ module Tapioca
             "T.untyped"
           end
 
-          # Early return for "T.untyped", nothing more to do.
-          return type if type == "T.untyped"
-
           might_be_optional = Proc === required || !required
-          type = "T.nilable(#{type})" if might_be_optional
+          type = as_nilable_type(type) if might_be_optional
 
           type
         end

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

@@ -151,9 +151,14 @@ module Tapioca
 
         sig { params(mod: Module, helper: Module).returns(T::Boolean) }
         def includes_helper?(mod, helper)
-          superclass_ancestors = mod.superclass&.ancestors if Class === mod
-          superclass_ancestors ||= []
-          (mod.ancestors - superclass_ancestors).include?(helper)
+          superclass_ancestors = []
+
+          if Class === mod
+            superclass = superclass_of(mod)
+            superclass_ancestors = ancestors_of(superclass) if superclass
+          end
+
+          (ancestors_of(mod) - superclass_ancestors).any? { |ancestor| helper == ancestor }
         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