tapioca 0.4.8 → 0.4.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f225f517eb2bb6e6d7aa6910bb42a35280b57ad8223dbd8bc255ce92377c6eb3
-  data.tar.gz: f3672f181cbcd71b9c8056c815e77313d75fcb2a78d2be5dbad3d2e51e35de39
+  metadata.gz: ce4d47f5c9b44a027ecd554533420b2a567ba3353cc073b85498fb86522a56ba
+  data.tar.gz: abee7797626806d015d410423a4f929875076f58f5e4859a2567a3f2921424bd
 SHA512:
-  metadata.gz: dcd0b9ebf36c2a467bb2e88cb91b1f0634cb772a3a5cf29f7dd3b716ddc3c4fd2ea4dd84b671df243255cc15651deb157d149578dde07f3f7eb26f0a8814a297
-  data.tar.gz: df7355fe19f05210797993286ead0f653a0f5b5f89263f469e8afece16d39026bde0cec1a0b266256ab236f43c27e95bd2912be3a9be74877ca6ca28037e09d7
+  metadata.gz: 1370fc47539d7f9504796faddcc71f08c0ecccd8b9af8623ab2a4496eef8e94f535aeb4e7266149a0e759e9115dfa0a062a57ea77db412e366ac07436912ae82
+  data.tar.gz: 9761bc6237bb0702e33cbca95e6f896c6ee07dc0efbec8a99d09493b551e162b28c63439320afeed56c6efec07b00621c54f245ab3b88011fe988dab1e2ac5c8

data/Gemfile

@@ -15,7 +15,6 @@ gem("yard", "~> 0.9.25")
 gem("pry-byebug")
 gem("minitest")
 gem("minitest-hooks")
-gem("minitest-fork_executor")
 gem("minitest-reporters")
 gem("sorbet")
 
@@ -33,6 +32,9 @@ group(:development, :test) do
   gem("activemodel-serializers-xml", "~> 1.0", require: false)
   gem("activeresource", "~> 5.1", require: false)
   gem("google-protobuf", "~>3.12.0", require: false)
+  # Fix version to 0.14.1 since it is the last version to support Ruby 2.4
+  gem("shopify-money", "= 0.14.1", require: false)
+  gem("sidekiq", "~>5.0", require: false) # Version 6 dropped support for Ruby 2.4
 end
 
 gem "rubocop-sorbet", ">= 0.4.1"

data/README.md

@@ -55,6 +55,8 @@ and do not forget to execute `tapioca` using `bundler`:
 ```shell
 $ bundle exec tapioca
 Commands:
+  tapioca --version, -v      # show version
+  tapioca dsl [constant...]  # generate RBIs for dynamic methods
   tapioca generate [gem...]  # generate RBIs from gems
   tapioca help [COMMAND]     # Describe available commands or one specific command
   tapioca init               # initializes folder structure
@@ -63,12 +65,12 @@ Commands:
   tapioca todo               # generate the list of unresolved constants
 
 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
-  --out, -o, [--outdir=directory]             # The output directory for generated RBI files
-                                              # Default: sorbet/rbi/gems
-  --cmd, -c, [--generate-command=command]     # The command to run to regenerate RBI files
-  --typed, -t, [--typed-overrides=gem:level]  # Overrides for typed sigils for generated gem RBIs
+  --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
+  --out, -o, [--outdir=directory]                             # The output directory for generated RBI files
+  --cmd, -c, [--generate-command=command]                     # The command to run to regenerate RBI files
+  -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
 ```
 
 ## Usage

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

@@ -13,8 +13,7 @@ module Tapioca
   module Compilers
     module Dsl
       # `Tapioca::Compilers::Dsl::ActionControllerHelpers` decorates RBI files for all
-      # subclasses of `::ActionController::Base`
-      # to add helper methods (see https://api.rubyonrails.org/classes/ActionController/Helpers.html).
+      # subclasses of [`ActionController::Base`](https://api.rubyonrails.org/classes/ActionController/Helpers.html).
       #
       # For example, with the following `MyHelper` module:
       #
@@ -50,22 +49,22 @@ module Tapioca
       # # user_controller.rbi
       # # typed: strong
       # class UserController
-      #   sig { returns(UserController::HelperProxy) }
-      #   def helpers; end
-      # end
+      #   module HelperMethods
+      #     include MyHelper
       #
-      # module UserController::HelperMethods
-      #    include MyHelper
+      #     sig { params(user: T.untyped).returns(T.untyped) }
+      #     def age(user); end
       #
-      #    sig { params(user: T.untyped).returns(T.untyped) }
-      #    def age(user); end
+      #     sig { returns(T.untyped) }
+      #     def current_user_name; end
+      #   end
       #
-      #    sig { returns(T.untyped) }
-      #    def current_user_name; end
-      #  end
+      #   class HelperProxy < ::ActionView::Base
+      #     include HelperMethods
+      #   end
       #
-      # class UserController::HelperProxy < ::ActionView::Base
-      #   include UserController::HelperMethods
+      #   sig { returns(HelperProxy) }
+      #   def helpers; end
       # end
       # ~~~
       class ActionControllerHelpers < Base
@@ -77,42 +76,42 @@ module Tapioca
             .void
         end
         def decorate(root, constant)
-          helper_proxy_name = "#{constant}::HelperProxy"
-          helper_methods_name = "#{constant}::HelperMethods"
+          helper_proxy_name = "HelperProxy"
+          helper_methods_name = "HelperMethods"
           proxied_helper_methods = constant._helper_methods.map(&:to_s).map(&:to_sym)
 
-          # Create helper method module
-          root.create_module(helper_methods_name) do |helper_methods|
-            helpers_module = constant._helpers
+          # Define the helpers method
+          root.path(constant) do |controller|
+            create_method(controller, 'helpers', return_type: helper_proxy_name)
 
-            gather_includes(helpers_module).each do |ancestor|
-              helper_methods.create_include(ancestor)
-            end
+            # Create helper method module
+            controller.create_module(helper_methods_name) do |helper_methods|
+              helpers_module = constant._helpers
 
-            helpers_module.instance_methods(false).each do |method_name|
-              method = if proxied_helper_methods.include?(method_name)
-                constant.instance_method(method_name)
-              else
-                helpers_module.instance_method(method_name)
+              gather_includes(helpers_module).each do |ancestor|
+                helper_methods.create_include(ancestor)
               end
-              create_method_from_def(helper_methods, method)
-            end
-          end
 
-          # Create helper proxy class
-          root.create_class(helper_proxy_name, superclass: "::ActionView::Base") do |proxy|
-            proxy.create_include(helper_methods_name)
-          end
+              helpers_module.instance_methods(false).each do |method_name|
+                method = if proxied_helper_methods.include?(method_name)
+                  constant.instance_method(method_name)
+                else
+                  helpers_module.instance_method(method_name)
+                end
+                create_method_from_def(helper_methods, method)
+              end
+            end
 
-          # Define the helpers method
-          root.path(constant) do |controller|
-            create_method(controller, 'helpers', return_type: helper_proxy_name)
+            # Create helper proxy class
+            controller.create_class(helper_proxy_name, superclass: "::ActionView::Base") do |proxy|
+              proxy.create_include(helper_methods_name)
+            end
           end
         end
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActionController::Base.descendants.reject(&:abstract?)
+          ::ActionController::Base.descendants.reject(&:abstract?).select(&:name)
         end
 
         private
@@ -121,7 +120,7 @@ module Tapioca
         def gather_includes(mod)
           mod.ancestors
             .reject { |ancestor| ancestor.is_a?(Class) || ancestor == mod || ancestor.name.nil? }
-            .map { |ancestor| T.must(ancestor.name) }
+            .map { |ancestor| "::#{ancestor.name}" }
             .reverse
         end
       end

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

@@ -12,8 +12,8 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `Tapioca::Compilers::Dsl::ActionMailer` generates RBI files for subclasses of `ActionMailer::Base`
-      # (see https://api.rubyonrails.org/classes/ActionMailer/Base.html).
+      # `Tapioca::Compilers::Dsl::ActionMailer` generates RBI files for subclasses of
+      # [`ActionMailer::Base`](https://api.rubyonrails.org/classes/ActionMailer/Base.html).
       #
       # For example, with the following `ActionMailer` subclass:
       #
@@ -40,12 +40,12 @@ module Tapioca
 
         sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActionMailer::Base)).void }
         def decorate(root, constant)
-          root.path(constant) do |k|
+          root.path(constant) do |mailer|
             constant.action_methods.to_a.each do |mailer_method|
               method_def = constant.instance_method(mailer_method)
               parameters = compile_method_parameters_to_parlour(method_def)
               create_method(
-                k,
+                mailer,
                 mailer_method,
                 parameters: parameters,
                 return_type: '::ActionMailer::MessageDelivery',

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

@@ -12,9 +12,9 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveRecordAssociations` refines RBI files for subclasses of `ActiveRecord::Base`
-      # (see https://api.rubyonrails.org/classes/ActiveRecord/Base.html). This generator is only
-      # responsible for defining the methods that would be created for the association that
+      # `Tapioca::Compilers::Dsl::ActiveRecordAssociations` refines RBI files for subclasses of
+      # [`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html).
+      # This generator is only responsible for defining the methods that would be created for the associations that
       # are defined in the Active Record model.
       #
       # For example, with the following model class:
@@ -36,56 +36,56 @@ module Tapioca
       #
       # class Post
       #   include Post::GeneratedAssociationMethods
-      # end
       #
-      # module Post::GeneratedAssociationMethods
-      #   sig { returns(T.nilable(::User)) }
-      #   def author; end
+      #   module Post::GeneratedAssociationMethods
+      #     sig { returns(T.nilable(::User)) }
+      #     def author; end
       #
-      #   sig { params(value: T.nilable(::User)).void }
-      #   def author=(value); end
+      #     sig { params(value: T.nilable(::User)).void }
+      #     def author=(value); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
-      #   def build_author(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+      #     def build_author(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
-      #   def build_category(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+      #     def build_category(*args, &blk); end
       #
-      #   sig { returns(T.nilable(::Category)) }
-      #   def category; end
+      #     sig { returns(T.nilable(::Category)) }
+      #     def category; end
       #
-      #   sig { params(value: T.nilable(::Category)).void }
-      #   def category=(value); end
+      #     sig { params(value: T.nilable(::Category)).void }
+      #     def category=(value); end
       #
-      #   sig { returns(T::Array[T.untyped]) }
-      #   def comment_ids; end
+      #     sig { returns(T::Array[T.untyped]) }
+      #     def comment_ids; end
       #
-      #   sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
-      #   def comment_ids=(ids); end
+      #     sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+      #     def comment_ids=(ids); end
       #
-      #   sig { returns(::ActiveRecord::Associations::CollectionProxy[Comment]) }
-      #   def comments; end
+      #     sig { returns(::ActiveRecord::Associations::CollectionProxy[Comment]) }
+      #     def comments; end
       #
-      #   sig { params(value: T::Enumerable[::Comment]).void }
-      #   def comments=(value); end
+      #     sig { params(value: T::Enumerable[::Comment]).void }
+      #     def comments=(value); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
-      #   def create_author(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+      #     def create_author(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
-      #   def create_author!(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+      #     def create_author!(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
-      #   def create_category(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+      #     def create_category(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
-      #   def create_category!(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+      #     def create_category!(*args, &blk); end
       #
-      #   sig { returns(T.nilable(::User)) }
-      #   def reload_author; end
+      #     sig { returns(T.nilable(::User)) }
+      #     def reload_author; end
       #
-      #   sig { returns(T.nilable(::Category)) }
-      #   def reload_category; end
+      #     sig { returns(T.nilable(::Category)) }
+      #     def reload_category; end
+      #   end
       # end
       # ~~~
       class ActiveRecordAssociations < Base
@@ -99,19 +99,20 @@ module Tapioca
         def decorate(root, constant)
           return if constant.reflections.empty?
 
-          module_name = "#{constant}::GeneratedAssociationMethods"
-          root.create_module(module_name) do |mod|
-            constant.reflections.each do |association_name, reflection|
-              if reflection.collection?
-                populate_collection_assoc_getter_setter(mod, constant, association_name, reflection)
-              else
-                populate_single_assoc_getter_setter(mod, constant, association_name, reflection)
+          root.path(constant) do |model|
+            module_name = "GeneratedAssociationMethods"
+
+            model.create_module(module_name) do |mod|
+              constant.reflections.each do |association_name, reflection|
+                if reflection.collection?
+                  populate_collection_assoc_getter_setter(mod, constant, association_name, reflection)
+                else
+                  populate_single_assoc_getter_setter(mod, constant, association_name, reflection)
+                end
               end
             end
-          end
 
-          root.path(constant) do |klass|
-            klass.create_include(module_name)
+            model.create_include(module_name)
           end
         end
 
@@ -152,7 +153,7 @@ module Tapioca
             "reload_#{association_name}",
             return_type: association_type,
           )
-          if reflection.constructable?
+          unless reflection.polymorphic?
             create_method(
               klass,
               "build_#{association_name}",

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

@@ -12,24 +12,12 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveRecordColumns` refines RBI files for subclasses of `ActiveRecord::Base`
-      # (see https://api.rubyonrails.org/classes/ActiveRecord/Base.html). This generator is only
-      # responsible for defining the attribute methods that would be created for the columns that
-      # are defined in the Active Record model.
-      #
-      # **Note:** This generator, by default, generates weak signatures for column methods and treats each
-      # column to be `T.untyped`. This is done on purpose to ensure that the nilability of Active Record
-      # columns do not make it hard for existing code to adopt gradual typing. It is possible, however, to
-      # generate stricter type signatures for your ActiveRecord column types. If your ActiveRecord model extends
-      # a module with name `StrongTypeGeneration`, this generator will generate stricter signatures that follow
-      # closely with the types defined in the schema.
-      #
-      # The `StrongTypeGeneration` module you define in your application should add an `after_initialize` callback
-      # to the model and ensure that all the non-nilable attributes of the model are actually initialized with non-`nil`
-      # values.
+      # `Tapioca::Compilers::Dsl::ActiveRecordColumns` refines RBI files for subclasses of
+      # [`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html).
+      # This generator is only responsible for defining the attribute methods that would be
+      # created for the columns that are defined in the Active Record model.
       #
       # For example, with the following model class:
-      #
       # ~~~rb
       # class Post < ActiveRecord::Base
       # end
@@ -54,54 +42,58 @@ module Tapioca
       # # post.rbi
       # # typed: true
       # class Post
-      #   sig { returns(T.nilable(::String)) }
-      #   def body; end
+      #   include GeneratedAttributeMethods
+      #
+      #   module GeneratedAttributeMethods
+      #     sig { returns(T.nilable(::String)) }
+      #     def body; end
       #
-      #   sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
-      #   def body=; end
+      #     sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def body=; end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def body?; end
+      #     sig { returns(T::Boolean) }
+      #     def body?; end
       #
-      #   sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
-      #   def created_at; end
+      #     sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
+      #     def created_at; end
       #
-      #   sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) }
-      #   def created_at=; end
+      #     sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) }
+      #     def created_at=; end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def created_at?; end
+      #     sig { returns(T::Boolean) }
+      #     def created_at?; end
       #
-      #   sig { returns(T.nilable(T::Boolean)) }
-      #   def published; end
+      #     sig { returns(T.nilable(T::Boolean)) }
+      #     def published; end
       #
-      #   sig { params(value: T::Boolean).returns(T::Boolean) }
-      #   def published=; end
+      #     sig { params(value: T::Boolean).returns(T::Boolean) }
+      #     def published=; end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def published?; end
+      #     sig { returns(T::Boolean) }
+      #     def published?; end
       #
-      #   sig { returns(::String) }
-      #   def title; end
+      #     sig { returns(::String) }
+      #     def title; end
       #
-      #   sig { params(value: ::String).returns(::String) }
-      #   def title=(value); end
+      #     sig { params(value: ::String).returns(::String) }
+      #     def title=(value); end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def title?(*args); end
+      #     sig { returns(T::Boolean) }
+      #     def title?; end
       #
-      #   sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
-      #   def updated_at; end
+      #     sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
+      #     def updated_at; end
       #
-      #   sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) }
-      #   def updated_at=; end
+      #     sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) }
+      #     def updated_at=; end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def updated_at?; end
+      #     sig { returns(T::Boolean) }
+      #     def updated_at?; end
       #
-      #   ## Also the methods added by https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Dirty.html
-      #   ## Also the methods added by https://api.rubyonrails.org/classes/ActiveModel/Dirty.html
-      #   ## Also the methods added by https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/BeforeTypeCast.html
+      #     ## Also the methods added by https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Dirty.html
+      #     ## Also the methods added by https://api.rubyonrails.org/classes/ActiveModel/Dirty.html
+      #     ## Also the methods added by https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/BeforeTypeCast.html
+      #   end
       # end
       # ~~~
       class ActiveRecordColumns < Base
@@ -111,26 +103,27 @@ module Tapioca
         def decorate(root, constant)
           return unless constant.table_exists?
 
-          module_name = "#{constant}::GeneratedAttributeMethods"
-          root.create_module(module_name) do |mod|
-            constant.columns_hash.each_key do |column_name|
-              column_name = column_name.to_s
-              add_methods_for_attribute(mod, constant, column_name)
-            end
+          root.path(constant) do |model|
+            module_name = "GeneratedAttributeMethods"
+
+            model.create_module(module_name) do |mod|
+              constant.columns_hash.each_key do |column_name|
+                column_name = column_name.to_s
+                add_methods_for_attribute(mod, constant, column_name)
+              end
 
-            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) }
-              methods_to_add = new_method_names - old_method_names
+              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) }
+                methods_to_add = new_method_names - old_method_names
 
-              add_methods_for_attribute(mod, constant, column_name, attribute_name, methods_to_add)
+                add_methods_for_attribute(mod, constant, column_name, attribute_name, methods_to_add)
+              end
             end
-          end
 
-          root.path(constant) do |klass|
-            klass.create_include(module_name)
+            model.create_include(module_name)
           end
         end
 
@@ -318,6 +311,8 @@ module Tapioca
 
           getter_type =
             case column_type
+            when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
+              "::Money"
             when ActiveRecord::Type::Integer
               "::Integer"
             when ActiveRecord::Type::String