tapioca 0.11.8 → 0.11.10

data/lib/tapioca/commands/todo.rb

@@ -6,6 +6,17 @@ module Tapioca
     class Todo < CommandWithoutTracker
       include SorbetHelper
 
+      DEPRECATION_MESSAGE = T.let(<<~DEPRECATION, String)
+        The `todo` command is deprecated and will be removed in a future release.
+
+        If your project is still missing type definitions for constants, try the following:
+        1. Regenerate gem RBIs by running `bin/tapioca gem --all` and `bin/tapioca annotations`
+        2. Generate RBIs for DSLs by running `bin/tapioca dsl`
+        3. If the missing constants are defined in files that a gem does not load by default,
+           manually require those files in `sorbet/tapioca/require.rb` and regenerate gem RBIs
+        4. Manually create an RBI shim defining the missing constants
+      DEPRECATION
+
       sig do
         params(
           todo_file: String,
@@ -19,6 +30,16 @@ module Tapioca
         super()
       end
 
+      sig { void }
+      def run_with_deprecation
+        say(DEPRECATION_MESSAGE, :red)
+        say("")
+
+        run
+      end
+
+      private
+
       sig { override.void }
       def execute
         say("Finding all unresolved constants, this may take a few seconds... ")
@@ -43,8 +64,6 @@ module Tapioca
         say("Please review changes and commit them.", [:green, :bold])
       end
 
-      private
-
       sig { params(constants: T::Array[String], command: String).returns(RBI::File) }
       def rbi(constants, command:)
         file = RBI::File.new

data/lib/tapioca/commands.rb

@@ -7,9 +7,15 @@ module Tapioca
     autoload :CommandWithoutTracker, "tapioca/commands/command_without_tracker"
     autoload :Annotations, "tapioca/commands/annotations"
     autoload :CheckShims, "tapioca/commands/check_shims"
-    autoload :Dsl, "tapioca/commands/dsl"
+    autoload :AbstractDsl, "tapioca/commands/abstract_dsl"
+    autoload :DslCompilerList, "tapioca/commands/dsl_compiler_list"
+    autoload :DslGenerate, "tapioca/commands/dsl_generate"
+    autoload :DslVerify, "tapioca/commands/dsl_verify"
     autoload :Configure, "tapioca/commands/configure"
-    autoload :Gem, "tapioca/commands/gem"
+    autoload :AbstractGem, "tapioca/commands/abstract_gem"
+    autoload :GemGenerate, "tapioca/commands/gem_generate"
+    autoload :GemSync, "tapioca/commands/gem_sync"
+    autoload :GemVerify, "tapioca/commands/gem_verify"
     autoload :Require, "tapioca/commands/require"
     autoload :Todo, "tapioca/commands/todo"
   end

data/lib/tapioca/dsl/compiler.rb

@@ -45,14 +45,18 @@ module Tapioca
 
         sig { returns(T::Enumerable[T::Class[T.anything]]) }
         def all_classes
-          @all_classes = T.let(@all_classes, T.nilable(T::Enumerable[T::Class[T.anything]]))
-          @all_classes ||= T.cast(ObjectSpace.each_object(Class), T::Enumerable[T::Class[T.anything]]).each
+          @all_classes ||= T.let(
+            T.cast(ObjectSpace.each_object(Class), T::Enumerable[T::Class[T.anything]]).each,
+            T.nilable(T::Enumerable[T::Class[T.anything]]),
+          )
         end
 
         sig { returns(T::Enumerable[Module]) }
         def all_modules
-          @all_modules = T.let(@all_modules, T.nilable(T::Enumerable[Module]))
-          @all_modules ||= T.cast(ObjectSpace.each_object(Module), T::Enumerable[Module]).each
+          @all_modules ||= T.let(
+            T.cast(ObjectSpace.each_object(Module), T::Enumerable[Module]).each,
+            T.nilable(T::Enumerable[Module]),
+          )
         end
       end
 

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

@@ -126,7 +126,9 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            descendants_of(::ActionController::Base).reject(&:abstract?).select(&:name)
+            descendants_of(::ActionController::Base).select(&:name).select do |klass|
+              klass.const_defined?(:HelperMethods, false)
+            end
           end
         end
 

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

@@ -0,0 +1,94 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_model"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveModelValidationsConfirmation` decorates RBI files for all
+      # classes that use [`ActiveModel::Validates::Confirmation`](https://api.rubyonrails.org/classes/ActiveModel/Validations/HelperMethods.html#method-i-validates_confirmation_of).
+      #
+      # For example, with the following class:
+      #
+      # ~~~rb
+      # class User
+      #   include ActiveModel::Validations
+      #
+      #   validates_confirmation_of :password
+      #
+      #   validates :email, confirmation: true
+      # end
+      # ~~~
+      #
+      # this compiler will produce an RBI file with the following content:
+      # ~~~rbi
+      # # typed: true
+      #
+      # class User
+      #
+      #   sig { returns(T.untyped) }
+      #   def email_confirmation; end
+      #
+      #   sig { params(email_confirmation=: T.untyped).returns(T.untyped) }
+      #   def email_confirmation=(email_confirmation); end
+      #
+      #   sig { returns(T.untyped) }
+      #   def password_confirmation; end
+      #
+      #   sig { params(password_confirmation=: T.untyped).returns(T.untyped) }
+      #   def password_confirmation=(password_confirmation); end
+      # end
+      # ~~~
+      class ActiveModelValidationsConfirmation < Compiler
+        extend T::Sig
+
+        ConstantType = type_member do
+          {
+            fixed: T.all(
+              T::Class[ActiveModel::Validations],
+              ActiveModel::Validations::HelperMethods,
+              ActiveModel::Validations::ClassMethods,
+            ),
+          }
+        end
+
+        class << self
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            # Collect all the classes that include ActiveModel::Validations
+            all_classes.select do |c|
+              c < ActiveModel::Validations
+            end
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          confirmation_validators = constant.validators.grep(ActiveModel::Validations::ConfirmationValidator)
+
+          return if confirmation_validators.empty?
+
+          # Create a RBI definition for each class that includes Active::Model::Validations
+          root.create_path(constant) do |klass|
+            # Create RBI definitions for all the attributes that use confirmation validation
+            confirmation_validators.each do |validator|
+              validator.attributes.each do |attr_name|
+                klass.create_method("#{attr_name}_confirmation", return_type: "T.untyped")
+                klass.create_method(
+                  "#{attr_name}_confirmation=",
+                  parameters: [create_param("#{attr_name}_confirmation", type: "T.untyped")],
+                  return_type: "T.untyped",
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -110,8 +110,8 @@ module Tapioca
 
           root.create_path(constant) do |model|
             model.create_module(AttributeMethodsModuleName) do |mod|
-              constant.attribute_names.each do |column_name|
-                add_methods_for_attribute(mod, column_name)
+              (constant.attribute_names + ["id"]).uniq.each do |attribute_name|
+                add_methods_for_attribute(mod, attribute_name)
               end
 
               constant.attribute_aliases.each do |attribute_name, column_name|
@@ -127,7 +127,7 @@ module Tapioca
                 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, column_name, attribute_name, methods_to_add)
+                add_methods_for_attribute(mod, attribute_name, column_name, methods_to_add)
               end
             end
 
@@ -152,13 +152,13 @@ module Tapioca
             name: String,
             methods_to_add: T.nilable(T::Array[String]),
             return_type: String,
-            parameters: T::Array[[String, String]],
+            parameters: T::Array[RBI::TypedParam],
           ).void
         end
         def add_method(klass, name, methods_to_add, return_type: "void", parameters: [])
           klass.create_method(
             name,
-            parameters: parameters.map { |param, type| create_param(param, type: type) },
+            parameters: parameters,
             return_type: return_type,
           ) if methods_to_add.nil? || methods_to_add.include?(name)
         end
@@ -166,13 +166,15 @@ module Tapioca
         sig do
           params(
             klass: RBI::Scope,
-            column_name: String,
             attribute_name: String,
+            column_name: String,
             methods_to_add: T.nilable(T::Array[String]),
           ).void
         end
-        def add_methods_for_attribute(klass, column_name, attribute_name = column_name, methods_to_add = nil)
-          getter_type, setter_type = Helpers::ActiveRecordColumnTypeHelper.new(constant).type_for(column_name)
+        def add_methods_for_attribute(klass, attribute_name, column_name = attribute_name, methods_to_add = nil)
+          getter_type, setter_type = Helpers::ActiveRecordColumnTypeHelper
+            .new(constant)
+            .type_for(attribute_name, column_name)
 
           # Added by ActiveRecord::AttributeMethods::Read
           #
@@ -189,7 +191,7 @@ module Tapioca
             klass,
             "#{attribute_name}=",
             methods_to_add,
-            parameters: [["value", setter_type]],
+            parameters: [create_param("value", type: setter_type)],
             return_type: setter_type,
           )
 
@@ -254,6 +256,10 @@ module Tapioca
             "#{attribute_name}_changed?",
             methods_to_add,
             return_type: "T::Boolean",
+            parameters: [
+              create_kw_opt_param("from", type: setter_type, default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: setter_type, default: "T.unsafe(nil)"),
+            ],
           )
           add_method(
             klass,
@@ -277,6 +283,10 @@ module Tapioca
             "#{attribute_name}_previously_changed?",
             methods_to_add,
             return_type: "T::Boolean",
+            parameters: [
+              create_kw_opt_param("from", type: setter_type, default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: setter_type, default: "T.unsafe(nil)"),
+            ],
           )
           add_method(
             klass,

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

@@ -73,20 +73,17 @@ module Tapioca
         sig { returns(T::Class[ActiveRecord::TestFixtures]) }
         def fixture_loader
           @fixture_loader ||= T.let(
-            T.cast(
-              Class.new do
-                T.unsafe(self).include(ActiveRecord::TestFixtures)
-
-                T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
-                # https://github.com/rails/rails/blob/7c70791470fc517deb7c640bead9f1b47efb5539/activerecord/lib/active_record/test_fixtures.rb#L46
-                singleton_class.define_method(:file_fixture_path) do
-                  Rails.root.join("test", "fixtures", "files")
-                end
-
-                T.unsafe(self).fixtures(:all)
-              end,
-              T::Class[ActiveRecord::TestFixtures],
-            ),
+            Class.new do
+              T.unsafe(self).include(ActiveRecord::TestFixtures)
+
+              T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
+              # https://github.com/rails/rails/blob/7c70791470fc517deb7c640bead9f1b47efb5539/activerecord/lib/active_record/test_fixtures.rb#L46
+              singleton_class.define_method(:file_fixture_path) do
+                Rails.root.join("test", "fixtures", "files")
+              end
+
+              T.unsafe(self).fixtures(:all)
+            end,
             T.nilable(T::Class[ActiveRecord::TestFixtures]),
           )
         end

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

@@ -0,0 +1,149 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_record"
+rescue LoadError
+  return
+end
+
+require "tapioca/dsl/helpers/active_record_constants_helper"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveRecordStore` decorates RBI files for all
+      # classes that use [`ActiveRecord::Store`](https://api.rubyonrails.org/classes/ActiveRecord/Store.html).
+      #
+      # For example, with the following class:
+      #
+      # ~~~rb
+      # class User < ActiveRecord::Base
+      #   store :settings, accessors: :theme
+      #   store_accessor :settings, :power_source, prefix: :prefs
+      # end
+      # ~~~
+      #
+      # this compiler will produce an RBI file with the following content:
+      # ~~~rbi
+      # # typed: true
+      #
+      # class User
+      #   include GeneratedStoredAttributesMethods
+      #
+      #   module GeneratedStoredAttributesMethods
+      #     sig { returns(T.untyped) }
+      #     def prefs_power_source; end
+      #
+      #     sig { params(value: T.untyped).returns(T.untyped) }
+      #     def prefs_power_source=(value); end
+      #
+      #     sig { returns(T.untyped) }
+      #     def prefs_power_source_before_last_save; end
+      #
+      #     sig { returns(T.untyped) }
+      #     def prefs_power_source_change; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def prefs_power_source_changed?; end
+      #
+      #     sig { returns(T.untyped) }
+      #     def prefs_power_source_was; end
+      #
+      #     sig { returns(T.untyped) }
+      #     def saved_change_to_prefs_power_source; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def saved_change_to_prefs_power_source?; end
+      #
+      #     sig { returns(T.untyped) }
+      #     def saved_change_to_theme; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def saved_change_to_theme?; end
+      #
+      #     sig { returns(T.untyped) }
+      #     def theme; end
+      #
+      #     sig { params(value: T.untyped).returns(T.untyped) }
+      #     def theme=(value); end
+      #
+      #     sig { returns(T.untyped) }
+      #     def theme_before_last_save; end
+      #
+      #     sig { returns(T.untyped) }
+      #     def theme_change; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def theme_changed?; end
+      #
+      #     sig { returns(T.untyped) }
+      #     def theme_was; end
+      #   end
+      # end
+      # ~~~
+      class ActiveRecordStore < Compiler
+        extend T::Sig
+        include Helpers::ActiveRecordConstantsHelper
+
+        ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
+
+        sig { override.void }
+        def decorate
+          return if constant.__tapioca_stored_attributes.nil?
+
+          root.create_path(constant) do |klass|
+            klass.create_module(StoredAttributesModuleName) do |mod|
+              constant.__tapioca_stored_attributes.each do |store_attribute, keys, prefix, suffix|
+                accessor_prefix =
+                  case prefix
+                  when String, Symbol
+                    "#{prefix}_"
+                  when TrueClass
+                    "#{store_attribute}_"
+                  else
+                    ""
+                  end
+                accessor_suffix =
+                  case suffix
+                  when String, Symbol
+                    "_#{suffix}"
+                  when TrueClass
+                    "_#{store_attribute}"
+                  else
+                    ""
+                  end
+
+                keys.flatten.map { |key| "#{accessor_prefix}#{key}#{accessor_suffix}" }.each do |accessor_key|
+                  mod.create_method(
+                    "#{accessor_key}=",
+                    parameters: [create_param("value", type: "T.untyped")],
+                    return_type: "T.untyped",
+                  )
+                  mod.create_method(accessor_key, return_type: "T.untyped")
+                  mod.create_method("#{accessor_key}_changed?", return_type: "T::Boolean")
+                  mod.create_method("#{accessor_key}_change", return_type: "T.untyped")
+                  mod.create_method("#{accessor_key}_was", return_type: "T.untyped")
+                  mod.create_method("saved_change_to_#{accessor_key}?", return_type: "T::Boolean")
+                  mod.create_method("saved_change_to_#{accessor_key}", return_type: "T.untyped")
+                  mod.create_method("#{accessor_key}_before_last_save", return_type: "T.untyped")
+                end
+              end
+            end
+
+            klass.create_include(StoredAttributesModuleName)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -98,6 +98,9 @@ module Tapioca
           return if stores.values.all? { |store| store.accessors.empty? }
 
           root.create_path(constant) do |model|
+            store_accessors_module = model.create_module("StoreAccessors")
+            model.create_include("StoreAccessors")
+
             stores.values.each do |store_data|
               store_data.accessors.each do |accessor, name|
                 field = store_data.fields.fetch(accessor)
@@ -105,9 +108,7 @@ module Tapioca
                 type = as_nilable_type(type) if field.null
                 name ||= field.name # support < 1.5.0
 
-                store_accessors_module = model.create_module("StoreAccessors")
                 generate_methods(store_accessors_module, name.to_s, type)
-                model.create_include("StoreAccessors")
               end
             end
           end

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

@@ -85,7 +85,7 @@ module Tapioca
 
           sig { params(concern: Module).returns(T::Array[Module]) }
           def dependencies_of(concern)
-            concern.instance_variable_get(:@_dependencies)
+            concern.instance_variable_get(:@_dependencies) || []
           end
         end
 

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

@@ -55,7 +55,7 @@ module Tapioca
           root.create_path(constant) do |input_object|
             arguments.each do |argument|
               name = argument.keyword.to_s
-              input_object.create_method(name, return_type: Helpers::GraphqlTypeHelper.type_for(argument.type))
+              input_object.create_method(name, return_type: Helpers::GraphqlTypeHelper.type_for(argument))
             end
           end
         end

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

@@ -42,7 +42,7 @@ module Tapioca
       class GraphqlMutation < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(GraphQL::Schema::InputObject) } }
+        ConstantType = type_member { { fixed: T.class_of(GraphQL::Schema::Mutation) } }
 
         sig { override.void }
         def decorate
@@ -59,7 +59,7 @@ module Tapioca
           params = compile_method_parameters_to_rbi(method_def).map do |param|
             name = param.param.name
             argument = arguments_by_name.fetch(name, nil)
-            create_typed_param(param.param, argument ? Helpers::GraphqlTypeHelper.type_for(argument.type) : "T.untyped")
+            create_typed_param(param.param, argument_type(argument))
           end
 
           root.create_path(constant) do |mutation|
@@ -67,6 +67,13 @@ module Tapioca
           end
         end
 
+        sig { params(argument: T.nilable(GraphQL::Schema::Argument)).returns(String) }
+        def argument_type(argument)
+          return "T.untyped" unless argument
+
+          Helpers::GraphqlTypeHelper.type_for(argument)
+        end
+
         class << self
           extend T::Sig