tapioca 0.16.10 → 0.17.0

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

@@ -156,25 +156,23 @@ module Tapioca
         ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
 
         # From ActiveRecord::ConnectionAdapter::Quoting#quote, minus nil
-        ID_TYPES = T.let(
-          [
-            "String",
-            "Symbol",
-            "::ActiveSupport::Multibyte::Chars",
-            "T::Boolean",
-            "BigDecimal",
-            "Numeric",
-            "::ActiveRecord::Type::Binary::Data",
-            "::ActiveRecord::Type::Time::Value",
-            "Date",
-            "Time",
-            "::ActiveSupport::Duration",
-            "T::Class[T.anything]",
-          ].to_set.freeze,
-          T::Set[String],
-        )
-
-        sig { override.void }
+        ID_TYPES = [
+          "String",
+          "Symbol",
+          "::ActiveSupport::Multibyte::Chars",
+          "T::Boolean",
+          "BigDecimal",
+          "Numeric",
+          "::ActiveRecord::Type::Binary::Data",
+          "::ActiveRecord::Type::Time::Value",
+          "Date",
+          "Time",
+          "::ActiveSupport::Duration",
+          "T::Class[T.anything]",
+        ].to_set.freeze #: Set[String]
+
+        # @override
+        #: -> void
         def decorate
           create_classes_and_includes
           create_common_methods
@@ -185,104 +183,86 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             ActiveRecord::Base.descendants.reject(&:abstract_class?)
           end
         end
 
-        ASSOCIATION_METHODS = T.let(
-          ::ActiveRecord::AssociationRelation.instance_methods -
-            ::ActiveRecord::Relation.instance_methods,
-          T::Array[Symbol],
-        )
-        COLLECTION_PROXY_METHODS = T.let(
-          ::ActiveRecord::Associations::CollectionProxy.instance_methods -
-            ::ActiveRecord::AssociationRelation.instance_methods,
-          T::Array[Symbol],
-        )
-
-        QUERY_METHODS = T.let(
-          begin
-            # Grab all Query methods
-            query_methods = ActiveRecord::QueryMethods.instance_methods(false)
-            # Grab all Spawn methods
-            query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
-            # Remove the ones we know are private API
-            query_methods -= [:all, :arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
-            # Remove the methods that ...
-            query_methods
-              .grep_v(/_clause$/) # end with "_clause"
-              .grep_v(/_values?$/) # end with "_value" or "_values"
-              .grep_v(/=$/) # end with "=""
-              .grep_v(/(?<!uniq)!$/) # end with "!" except for "uniq!"
-          end,
-          T::Array[Symbol],
-        )
-        WHERE_CHAIN_QUERY_METHODS = T.let(
-          ActiveRecord::QueryMethods::WhereChain.instance_methods(false),
-          T::Array[Symbol],
-        )
-        FINDER_METHODS = T.let(ActiveRecord::FinderMethods.instance_methods(false), T::Array[Symbol])
-        SIGNED_FINDER_METHODS = T.let(
-          defined?(ActiveRecord::SignedId) ? ActiveRecord::SignedId::ClassMethods.instance_methods(false) : [],
-          T::Array[Symbol],
-        )
-        BATCHES_METHODS = T.let(ActiveRecord::Batches.instance_methods(false), T::Array[Symbol])
-        CALCULATION_METHODS = T.let(ActiveRecord::Calculations.instance_methods(false), T::Array[Symbol])
-        ENUMERABLE_QUERY_METHODS = T.let([:any?, :many?, :none?, :one?], T::Array[Symbol])
-        FIND_OR_CREATE_METHODS = T.let(
-          [:find_or_create_by, :find_or_create_by!, :find_or_initialize_by, :create_or_find_by, :create_or_find_by!],
-          T::Array[Symbol],
-        )
-        BUILDER_METHODS = T.let([:new, :create, :create!, :build], T::Array[Symbol])
-        TO_ARRAY_METHODS = T.let([:to_ary, :to_a], T::Array[Symbol])
+        ASSOCIATION_METHODS = ::ActiveRecord::AssociationRelation.instance_methods -
+          ::ActiveRecord::Relation.instance_methods #: Array[Symbol]
+        COLLECTION_PROXY_METHODS = ::ActiveRecord::Associations::CollectionProxy.instance_methods -
+          ::ActiveRecord::AssociationRelation.instance_methods #: Array[Symbol]
+
+        QUERY_METHODS = begin
+          # Grab all Query methods
+          query_methods = ActiveRecord::QueryMethods.instance_methods(false)
+          # Grab all Spawn methods
+          query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
+          # Remove the ones we know are private API
+          query_methods -= [:all, :arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
+          # Remove the methods that ...
+          query_methods
+            .grep_v(/_clause$/) # end with "_clause"
+            .grep_v(/_values?$/) # end with "_value" or "_values"
+            .grep_v(/=$/) # end with "=""
+            .grep_v(/(?<!uniq)!$/) # end with "!" except for "uniq!"
+        end #: Array[Symbol]
+        WHERE_CHAIN_QUERY_METHODS = ActiveRecord::QueryMethods::WhereChain.instance_methods(false) #: Array[Symbol]
+        FINDER_METHODS = ActiveRecord::FinderMethods.instance_methods(false) #: Array[Symbol]
+        SIGNED_FINDER_METHODS = if defined?(ActiveRecord::SignedId)
+          ActiveRecord::SignedId::ClassMethods.instance_methods(false)
+        else
+          []
+        end #: Array[Symbol]
+        BATCHES_METHODS = ActiveRecord::Batches.instance_methods(false) #: Array[Symbol]
+        CALCULATION_METHODS = ActiveRecord::Calculations.instance_methods(false) #: Array[Symbol]
+        ENUMERABLE_QUERY_METHODS = [:any?, :many?, :none?, :one?] #: Array[Symbol]
+        FIND_OR_CREATE_METHODS = [
+          :find_or_create_by,
+          :find_or_create_by!,
+          :find_or_initialize_by,
+          :create_or_find_by,
+          :create_or_find_by!,
+        ] #: Array[Symbol]
+        BUILDER_METHODS = [:new, :create, :create!, :build] #: Array[Symbol]
+        TO_ARRAY_METHODS = [:to_ary, :to_a] #: Array[Symbol]
 
         private
 
-        sig { returns(RBI::Scope) }
+        #: -> RBI::Scope
         def model
-          @model ||= T.let(
-            root.create_path(constant),
-            T.nilable(RBI::Scope),
-          )
+          @model ||= root.create_path(constant) #: RBI::Scope?
         end
 
-        sig { returns(RBI::Scope) }
+        #: -> RBI::Scope
         def relation_methods_module
-          @relation_methods_module ||= T.let(
-            model.create_module(RelationMethodsModuleName),
-            T.nilable(RBI::Scope),
-          )
+          @relation_methods_module ||= model.create_module(RelationMethodsModuleName) #: RBI::Scope?
         end
 
-        sig { returns(RBI::Scope) }
+        #: -> RBI::Scope
         def association_relation_methods_module
-          @association_relation_methods_module ||= T.let(
-            model.create_module(AssociationRelationMethodsModuleName),
-            T.nilable(RBI::Scope),
-          )
+          @association_relation_methods_module ||=
+            model.create_module(AssociationRelationMethodsModuleName) #: RBI::Scope?
         end
 
-        sig { returns(RBI::Scope) }
+        #: -> RBI::Scope
         def common_relation_methods_module
-          @common_relation_methods_module ||= T.let(
-            model.create_module(CommonRelationMethodsModuleName),
-            T.nilable(RBI::Scope),
-          )
+          @common_relation_methods_module ||= model.create_module(CommonRelationMethodsModuleName) #: RBI::Scope?
         end
 
-        sig { returns(String) }
+        #: -> String
         def constant_name
-          @constant_name ||= T.let(T.must(qualified_name_of(constant)), T.nilable(String))
+          @constant_name ||= T.must(qualified_name_of(constant)) #: String?
         end
 
-        sig { params(method_name: Symbol).returns(T::Boolean) }
+        #: (Symbol method_name) -> bool
         def bang_method?(method_name)
           method_name.to_s.end_with?("!")
         end
 
-        sig { void }
+        #: -> void
         def create_classes_and_includes
           model.create_extend(CommonRelationMethodsModuleName)
           # The model always extends the generated relation module
@@ -297,7 +277,7 @@ module Tapioca
           create_collection_proxy_class
         end
 
-        sig { void }
+        #: -> void
         def create_relation_class
           superclass = "::ActiveRecord::Relation"
 
@@ -316,7 +296,7 @@ module Tapioca
           create_relation_where_chain_class
         end
 
-        sig { void }
+        #: -> void
         def create_association_relation_class
           superclass = "::ActiveRecord::AssociationRelation"
 
@@ -335,7 +315,7 @@ module Tapioca
           create_association_relation_where_chain_class
         end
 
-        sig { void }
+        #: -> void
         def create_relation_group_chain_class
           model.create_class(RelationGroupChainClassName, superclass_name: RelationClassName) do |klass|
             create_group_chain_methods(klass)
@@ -343,7 +323,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_association_relation_group_chain_class
           model.create_class(
             AssociationRelationGroupChainClassName,
@@ -354,7 +334,7 @@ module Tapioca
           end
         end
 
-        sig { params(klass: RBI::Scope).void }
+        #: (RBI::Scope klass) -> void
         def create_group_chain_methods(klass)
           # Calculation methods used with `group` return a hash where the keys cannot be typed
           # but the values can. Technically a `group` anywhere in the query chain produces
@@ -418,7 +398,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_relation_where_chain_class
           model.create_class(RelationWhereChainClassName) do |klass|
             create_where_chain_methods(klass, RelationClassName)
@@ -426,7 +406,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_association_relation_where_chain_class
           model.create_class(AssociationRelationWhereChainClassName) do |klass|
             create_where_chain_methods(klass, AssociationRelationClassName)
@@ -434,7 +414,7 @@ module Tapioca
           end
         end
 
-        sig { params(klass: RBI::Scope, return_type: String).void }
+        #: (RBI::Scope klass, String return_type) -> void
         def create_where_chain_methods(klass, return_type)
           WHERE_CHAIN_QUERY_METHODS.each do |method_name|
             case method_name
@@ -459,7 +439,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_collection_proxy_class
           superclass = "::ActiveRecord::Associations::CollectionProxy"
 
@@ -476,7 +456,7 @@ module Tapioca
           end
         end
 
-        sig { params(klass: RBI::Scope).void }
+        #: (RBI::Scope klass) -> void
         def create_collection_proxy_methods(klass)
           # For these cases, it is valid to pass:
           # - a model instance, thus `Model`
@@ -555,7 +535,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_relation_methods
           create_relation_method("all")
 
@@ -619,7 +599,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_association_relation_methods
           returning_type = "T.nilable(T.any(T::Array[Symbol], FalseClass))"
           unique_by_type = "T.nilable(T.any(T::Array[Symbol], Symbol))"
@@ -664,7 +644,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_common_methods
           create_common_method(
             "destroy_all",
@@ -1049,13 +1029,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            name: T.any(Symbol, String),
-            parameters: T::Array[RBI::TypedParam],
-            return_type: T.nilable(String),
-          ).void
-        end
+        #: ((Symbol | String) name, ?parameters: Array[RBI::TypedParam], ?return_type: String?) -> void
         def create_common_method(name, parameters: [], return_type: nil)
           common_relation_methods_module.create_method(
             name.to_s,
@@ -1064,7 +1038,7 @@ module Tapioca
           )
         end
 
-        sig { void }
+        #: -> void
         def create_where_relation_method
           relation_methods_module.create_method("where") do |method|
             method.add_rest_param("args")
@@ -1093,14 +1067,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            name: T.any(Symbol, String),
-            parameters: T::Array[RBI::TypedParam],
-            relation_return_type: String,
-            association_return_type: String,
-          ).void
-        end
+        #: ((Symbol | String) name, ?parameters: Array[RBI::TypedParam], ?relation_return_type: String, ?association_return_type: String) -> void
         def create_relation_method(
           name,
           parameters: [],

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

@@ -44,7 +44,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           method_names = scope_method_names
 
@@ -77,7 +78,8 @@ module Tapioca
         end
 
         class << self
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
           end
@@ -85,9 +87,9 @@ module Tapioca
 
         private
 
-        sig { returns(T::Array[Symbol]) }
+        #: -> Array[Symbol]
         def scope_method_names
-          scope_methods = T.let([], T::Array[Symbol])
+          scope_methods = [] #: Array[Symbol]
           constant = self.constant
 
           # Keep gathering scope methods until we hit "ActiveRecord::Base"
@@ -104,13 +106,7 @@ module Tapioca
           scope_methods.uniq
         end
 
-        sig do
-          params(
-            mod: RBI::Scope,
-            scope_method: String,
-            return_type: String,
-          ).void
-        end
+        #: (RBI::Scope mod, String scope_method, String return_type) -> void
         def generate_scope_method(mod, scope_method, return_type)
           mod.create_method(
             scope_method,

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

@@ -38,7 +38,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.__tapioca_secure_tokens.nil?
 
@@ -59,7 +60,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
           end

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

@@ -84,7 +84,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.__tapioca_stored_attributes.nil?
 
@@ -134,7 +135,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
           end

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

@@ -86,7 +86,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           stores = constant.typed_stores
           return if stores.values.all? { |store| store.accessors.empty? }
@@ -110,7 +111,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).select do |klass|
               klass.include?(ActiveRecord::TypedStore::Behavior)
@@ -120,22 +122,19 @@ module Tapioca
 
         private
 
-        TYPES = T.let(
-          {
-            boolean: "T::Boolean",
-            integer: "Integer",
-            string: "String",
-            float: "Float",
-            date: "Date",
-            time: "Time",
-            datetime: "DateTime",
-            decimal: "BigDecimal",
-            any: "T.untyped",
-          }.freeze,
-          T::Hash[Symbol, String],
-        )
-
-        sig { params(field: ActiveRecord::TypedStore::Field).returns(String) }
+        TYPES = {
+          boolean: "T::Boolean",
+          integer: "Integer",
+          string: "String",
+          float: "Float",
+          date: "Date",
+          time: "Time",
+          datetime: "DateTime",
+          decimal: "BigDecimal",
+          any: "T.untyped",
+        }.freeze #: Hash[Symbol, String]
+
+        #: (ActiveRecord::TypedStore::Field field) -> String
         def type_for(field)
           type = TYPES.fetch(field.type_sym, "T.untyped")
 
@@ -154,14 +153,7 @@ module Tapioca
           type
         end
 
-        sig do
-          params(
-            klass: RBI::Scope,
-            name: String,
-            type: String,
-          )
-            .void
-        end
+        #: (RBI::Scope klass, String name, String type) -> void
         def generate_methods(klass, name, type)
           klass.create_method(
             "#{name}=",

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

@@ -59,7 +59,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(::ActiveResource::Base) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.schema.blank?
 
@@ -73,7 +74,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveResource::Base)
           end
@@ -81,28 +83,25 @@ module Tapioca
 
         private
 
-        TYPES = T.let(
-          {
-            boolean: "T::Boolean",
-            integer: "Integer",
-            string: "String",
-            float: "Float",
-            date: "Date",
-            time: "Time",
-            datetime: "DateTime",
-            decimal: "BigDecimal",
-            binary: "String",
-            text: "String",
-          }.freeze,
-          T::Hash[Symbol, String],
-        )
+        TYPES = {
+          boolean: "T::Boolean",
+          integer: "Integer",
+          string: "String",
+          float: "Float",
+          date: "Date",
+          time: "Time",
+          datetime: "DateTime",
+          decimal: "BigDecimal",
+          binary: "String",
+          text: "String",
+        }.freeze #: Hash[Symbol, String]
 
-        sig { params(attr_type: Symbol).returns(String) }
+        #: (Symbol attr_type) -> String
         def type_for(attr_type)
           TYPES.fetch(attr_type, "T.untyped")
         end
 
-        sig { params(klass: RBI::Scope, attribute: String, type: String).void }
+        #: (RBI::Scope klass, String attribute, String type) -> void
         def create_schema_methods(klass, attribute, type)
           return_type = type_for(type.to_sym)
 

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

@@ -50,7 +50,8 @@ module Tapioca
           }
         end
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.reflect_on_all_attachments.empty?
 
@@ -74,7 +75,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base)
               .reject(&:abstract_class?)
@@ -84,9 +86,7 @@ module Tapioca
 
         private
 
-        sig do
-          params(reflection: ActiveRecord::Reflection::MacroReflection).returns(String)
-        end
+        #: (ActiveRecord::Reflection::MacroReflection reflection) -> String
         def type_of(reflection)
           case reflection
           when ::ActiveStorage::Reflection::HasOneAttachedReflection

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

@@ -42,7 +42,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: Module } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           dependencies = linearized_dependencies
 
@@ -64,7 +65,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_modules.select do |mod|
               name_of(mod) && # i.e. not anonymous
@@ -75,10 +77,10 @@ module Tapioca
           end
 
           # Returns true when `mod` includes other concerns
-          sig { params(mod: Module).returns(T::Boolean) }
+          #: (Module mod) -> bool
           def has_dependencies?(mod) = dependencies_of(mod).any?
 
-          sig { params(concern: Module).returns(T::Array[Module]) }
+          #: (Module concern) -> Array[Module]
           def dependencies_of(concern)
             concern.instance_variable_get(:@_dependencies) || []
           end
@@ -86,12 +88,12 @@ module Tapioca
 
         private
 
-        sig { params(concern: Module).returns(T::Array[Module]) }
+        #: (Module concern) -> Array[Module]
         def dependencies_of(concern)
           self.class.dependencies_of(concern)
         end
 
-        sig { params(concern: Module).returns(T::Array[Module]) }
+        #: (?Module concern) -> Array[Module]
         def linearized_dependencies(concern = constant)
           # Grab all the dependencies of the concern
           dependencies = dependencies_of(concern)