tapioca 0.4.10 → 0.4.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db90e001ad45dbd8edd11b2288405dd406588e1bb46120c7cd5f0cb560647ea6
-  data.tar.gz: 1eab20c32a1785046f814ca2fc54866bbc0c9d083bf682a8b1ea15bf92c9cc1e
+  metadata.gz: 41fd25f2497122191c01ef7e9376d6d56e070e9ec5e7626fd1ace153a1b01fd5
+  data.tar.gz: 390bdd0023f086be720f722d530c00cee4eafd603052259331a353c4fa0d3a9b
 SHA512:
-  metadata.gz: 77d4598557fc72b8a76dea56b626d05a3f91dd88d53cb0e96156ed92419534a32beeed17cd0f4791e37c972f2da86c07bb6a386a0dbb5813a5b4f998438e3127
-  data.tar.gz: 102c5591a319f1846506d0e1e439f52613bc9f5d6110eab98ee857d7a943921584e12b56733ec7b4f6e95824396ea1052ffc691eed0505bf2b00a7438ceabbe0
+  metadata.gz: 1f25290fb6e4544329b79b7eb20191126cddf1e9707f1aeb98b60d1dd24ea1f9c7df525ccfb5fd2b50fb12929b773b9adf9143b98da859903c29cdf3125484f6
+  data.tar.gz: 8c7adbe3d3881118487945b46638d5b0bdd29d732424f071c7efb39048db80c7cdd9601bc51e306742aaeae02b002661204e5c18eeb8162c138507269a794c01

data/Gemfile

@@ -10,12 +10,10 @@ group(:deployment, :development) do
   gem("rake")
 end
 
-gem("bundler", "~> 1.17")
 gem("yard", "~> 0.9.25")
 gem("pry-byebug")
 gem("minitest")
 gem("minitest-hooks")
-gem("minitest-fork_executor")
 gem("minitest-reporters")
 gem("sorbet")
 
@@ -33,6 +31,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/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:
@@ -24,6 +24,8 @@ module Tapioca
       #   belongs_to :category
       #   has_many :comments
       #   has_one :author, class_name: "User"
+      #
+      #   accepts_nested_attributes_for :category, :comments, :author
       # end
       # ~~~
       #
@@ -36,56 +38,65 @@ 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(attributes: T.untyped).returns(T.untyped) }
+      #     def author_attributes=(attributes); end
+      #
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+      #     def build_author(*args, &blk); end
       #
-      #   sig { params(value: T.nilable(::User)).void }
-      #   def author=(value); 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(::User) }
-      #   def build_author(*args, &blk); end
+      #     sig { returns(T.nilable(::Category)) }
+      #     def category; end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
-      #   def build_category(*args, &blk); end
+      #     sig { params(value: T.nilable(::Category)).void }
+      #     def category=(value); end
       #
-      #   sig { returns(T.nilable(::Category)) }
-      #   def category; end
+      #     sig { params(attributes: T.untyped).returns(T.untyped) }
+      #     def category_attributes=(attributes); 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(attributes: T.untyped).returns(T.untyped) }
+      #     def comments_attributes=(attributes); 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 +110,15 @@ 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)
-              end
+          root.path(constant) do |model|
+            module_name = "GeneratedAssociationMethods"
+
+            model.create_module(module_name) do |mod|
+              populate_nested_attribute_writers(mod, constant)
+              populate_associations(mod, constant)
             end
-          end
 
-          root.path(constant) do |klass|
-            klass.create_include(module_name)
+            model.create_include(module_name)
           end
         end
 
@@ -122,6 +129,31 @@ module Tapioca
 
         private
 
+        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(ActiveRecord::Base)).void }
+        def populate_nested_attribute_writers(mod, constant)
+          constant.nested_attributes_options.keys.each do |association_name|
+            create_method(
+              mod,
+              "#{association_name}_attributes=",
+              parameters: [
+                Parlour::RbiGenerator::Parameter.new("attributes", type: "T.untyped"),
+              ],
+              return_type: "T.untyped"
+            )
+          end
+        end
+
+        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(ActiveRecord::Base)).void }
+        def populate_associations(mod, constant)
+          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
+
         sig do
           params(
             klass: Parlour::RbiGenerator::Namespace,

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