tapioca 0.16.9 → 0.17.7

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

@@ -81,12 +81,12 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class ActiveRecordTypedStore < Compiler
         extend T::Sig
 
-        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 +110,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 +121,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 +152,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

@@ -54,12 +54,12 @@ module Tapioca
       #   def year?; end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveResource::Base)]
       class ActiveResource < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveResource::Base) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.schema.blank?
 
@@ -73,7 +73,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 +82,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

@@ -38,19 +38,12 @@ module Tapioca
       #   def photo=(attachable); end
       # end
       # ~~~
+      #: [ConstantType = (Module & ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods)]
       class ActiveStorage < Compiler
         extend T::Sig
 
-        ConstantType = type_member do
-          {
-            fixed: T.all(
-              Module,
-              ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods,
-            ),
-          }
-        end
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.reflect_on_all_attachments.empty?
 
@@ -74,7 +67,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 +78,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

@@ -37,12 +37,12 @@ module Tapioca
       #   mixes_in_class_methods(::Foo::ClassMethods)
       # end
       # ~~~
+      #: [ConstantType = Module]
       class ActiveSupportConcern < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: Module } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           dependencies = linearized_dependencies
 
@@ -64,7 +64,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 +76,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 +87,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)

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

@@ -59,12 +59,12 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveSupport::CurrentAttributes)]
       class ActiveSupportCurrentAttributes < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveSupport::CurrentAttributes) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           dynamic_methods = dynamic_methods_of_constant
           instance_methods = instance_methods_of_constant - dynamic_methods
@@ -96,7 +96,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveSupport::CurrentAttributes)
           end
@@ -104,17 +105,17 @@ module Tapioca
 
         private
 
-        sig { returns(T::Array[Symbol]) }
+        #: -> Array[Symbol]
         def dynamic_methods_of_constant
           constant.instance_variable_get(:@generated_attribute_methods)&.instance_methods(false) || []
         end
 
-        sig { returns(T::Array[Symbol]) }
+        #: -> Array[Symbol]
         def instance_methods_of_constant
           constant.instance_methods(false)
         end
 
-        sig { params(klass: RBI::Scope, method: String, class_method: T::Boolean).void }
+        #: (RBI::Scope klass, String method, class_method: bool) -> void
         def generate_method(klass, method, class_method:)
           method_def = if class_method
             constant.method(method)

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

@@ -34,12 +34,12 @@ module Tapioca
       #   end
       # end
       # ```
+      #: [ConstantType = singleton(::Time)]
       class ActiveSupportTimeExt < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::Time) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return unless constant.respond_to?(:zone)
 
@@ -57,7 +57,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             [::Time]
           end

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

@@ -40,14 +40,14 @@ module Tapioca
       #   def github=(value); end
       # end
       # ```
+      #: [ConstantType = Module]
       class Config < Compiler
         extend T::Sig
 
         CONFIG_OPTIONS_SUFFIX = "ConfigOptions"
 
-        ConstantType = type_member { { fixed: Module } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           # The constant we are given is the specialized config options type
           option_class_name = constant.name
@@ -95,7 +95,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             name = ::Config.const_name
             return [] unless Object.const_defined?(name)

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

@@ -58,12 +58,12 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = (singleton(::FrozenRecord::Base) & Extensions::FrozenRecord)]
       class FrozenRecord < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.all(T.class_of(::FrozenRecord::Base), Extensions::FrozenRecord) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           attributes = constant.attributes
           return if attributes.empty?
@@ -87,7 +87,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::FrozenRecord::Base).reject(&:abstract_class?)
           end
@@ -95,7 +96,7 @@ module Tapioca
 
         private
 
-        sig { params(record: RBI::Scope).void }
+        #: (RBI::Scope record) -> void
         def decorate_scopes(record)
           scopes = constant.__tapioca_scope_names
           return if scopes.nil?
@@ -111,12 +112,7 @@ module Tapioca
           record.create_extend(module_name)
         end
 
-        sig do
-          params(
-            scope_method: String,
-            mod: RBI::Scope,
-          ).void
-        end
+        #: (String scope_method, RBI::Scope mod) -> void
         def generate_scope_method(scope_method, mod)
           mod.create_method(
             scope_method,

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

@@ -34,12 +34,12 @@ module Tapioca
       #   def post_id; end
       # end
       # ~~~
+      #: [ConstantType = singleton(GraphQL::Schema::InputObject)]
       class GraphqlInputObject < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(GraphQL::Schema::InputObject) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           # Skip methods explicitly defined in code
           arguments = constant.all_argument_definitions.select do |argument|
@@ -61,15 +61,13 @@ module Tapioca
 
         private
 
-        sig { returns(T.nilable(String)) }
+        #: -> String?
         def graphql_input_object_argument_source_file
-          @graphql_input_object_argument_source_file ||= T.let(
-            GraphQL::Schema::InputObject.method(:argument).source_location&.first,
-            T.nilable(String),
-          )
+          @graphql_input_object_argument_source_file ||=
+            GraphQL::Schema::InputObject.method(:argument).source_location&.first #: String?
         end
 
-        sig { params(method_name: String).returns(T::Boolean) }
+        #: (String method_name) -> bool
         def method_defined_by_graphql?(method_name)
           method_file = constant.instance_method(method_name).source_location&.first
           !!(method_file && graphql_input_object_argument_source_file == method_file)
@@ -78,7 +76,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_classes.select { |c| GraphQL::Schema::InputObject > c }
           end

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

@@ -35,12 +35,12 @@ module Tapioca
       #   def resolve(body:, post_id:); end
       # end
       # ~~~
+      #: [ConstantType = singleton(GraphQL::Schema::Mutation)]
       class GraphqlMutation < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(GraphQL::Schema::Mutation) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return unless constant.method_defined?(:resolve)
 
@@ -63,12 +63,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            argument: T.nilable(GraphQL::Schema::Argument),
-            constant: T.class_of(GraphQL::Schema::Mutation),
-          ).returns(String)
-        end
+        #: (GraphQL::Schema::Argument? argument, singleton(GraphQL::Schema::Mutation) constant) -> String
         def argument_type(argument, constant)
           return "T.untyped" unless argument
 
@@ -78,7 +73,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             all_classes.select { |c| GraphQL::Schema::Mutation > c && GraphQL::Schema::RelayClassicMutation != c }
           end

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

@@ -55,17 +55,14 @@ module Tapioca
       #   def fetch_by_title_and_review_date(title, review_date, includes: nil); end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class IdentityCache < Compiler
         extend T::Sig
 
-        COLLECTION_TYPE = T.let(
-          ->(type) { "T::Array[::#{type}]" },
-          T.proc.params(type: T.any(Module, String)).returns(String),
-        )
+        COLLECTION_TYPE = ->(type) { "T::Array[::#{type}]" } #: ^((Module | String) type) -> String
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           caches = constant.send(:all_cached_associations)
           cache_indexes = constant.send(:cache_indexes)
@@ -97,7 +94,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|
               ::IdentityCache::WithoutPrimaryIndex > klass
@@ -107,12 +105,7 @@ module Tapioca
 
         private
 
-        sig do
-          params(
-            field: T.untyped,
-            returns_collection: T::Boolean,
-          ).returns(String)
-        end
+        #: (untyped field, returns_collection: bool) -> String
         def type_for_field(field, returns_collection:)
           cache_type = field.reflection.compute_class(field.reflection.class_name)
           if returns_collection
@@ -124,13 +117,7 @@ module Tapioca
           "T.untyped"
         end
 
-        sig do
-          params(
-            field: T.untyped,
-            klass: RBI::Scope,
-            returns_collection: T::Boolean,
-          ).void
-        end
+        #: (untyped field, RBI::Scope klass, returns_collection: bool) -> void
         def create_fetch_field_methods(field, klass, returns_collection:)
           name = field.cached_accessor_name.to_s
           type = type_for_field(field, returns_collection: returns_collection)
@@ -143,12 +130,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            field: T.untyped,
-            klass: RBI::Scope,
-          ).void
-        end
+        #: (untyped field, RBI::Scope klass) -> void
         def create_fetch_by_methods(field, klass)
           is_cache_index = field.instance_variable_defined?(:@attribute_proc)
 
@@ -159,12 +141,7 @@ module Tapioca
           create_index_fetch_by_methods(field, klass) if is_cache_index
         end
 
-        sig do
-          params(
-            field: T.untyped,
-            klass: RBI::Scope,
-          ).void
-        end
+        #: (untyped field, RBI::Scope klass) -> void
         def create_index_fetch_by_methods(field, klass)
           fields_name = field.key_fields.join("_and_")
           name = "fetch_by_#{fields_name}"
@@ -209,12 +186,7 @@ module Tapioca
           )
         end
 
-        sig do
-          params(
-            field: T.untyped,
-            klass: RBI::Scope,
-          ).void
-        end
+        #: (untyped field, RBI::Scope klass) -> void
         def create_aliased_fetch_by_methods(field, klass)
           type, _ = Helpers::ActiveRecordColumnTypeHelper.new(
             constant,

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

@@ -79,12 +79,12 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::JsonApiClient::Resource)]
       class JsonApiClientResource < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::JsonApiClient::Resource) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           schema = resource_schema
           return if schema.nil? && constant.associations.empty?
@@ -108,7 +108,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 |c|
               name_of(c) && ::JsonApiClient::Resource > c
@@ -118,7 +119,7 @@ module Tapioca
 
         private
 
-        sig { returns(T.nilable(::JsonApiClient::Schema)) }
+        #: -> ::JsonApiClient::Schema?
         def resource_schema
           schema = constant.schema
 
@@ -126,12 +127,7 @@ module Tapioca
           schema if schema.size > 0 # rubocop:disable Style/ZeroLengthPredicate
         end
 
-        sig do
-          params(
-            mod: RBI::Scope,
-            property: ::JsonApiClient::Schema::Property,
-          ).void
-        end
+        #: (RBI::Scope mod, ::JsonApiClient::Schema::Property property) -> void
         def generate_methods_for_property(mod, property)
           type = type_for(property)
 
@@ -141,7 +137,7 @@ module Tapioca
           mod.create_method("#{name}=", parameters: [create_param(name, type: type)], return_type: type)
         end
 
-        sig { params(property: ::JsonApiClient::Schema::Property).returns(String) }
+        #: (::JsonApiClient::Schema::Property property) -> String
         def type_for(property)
           type = ::JsonApiClient::Schema::TypeFactory.type_for(property.type)
           return "T.untyped" if type.nil?
@@ -181,12 +177,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            mod: RBI::Scope,
-            association: JsonApiClient::Associations::BaseAssociation,
-          ).void
-        end
+        #: (RBI::Scope mod, JsonApiClient::Associations::BaseAssociation association) -> void
         def generate_methods_for_association(mod, association)
           # If the association is broken, it will raise a NameError when trying to access the association_class
           klass = association.association_class