tapioca 0.4.26 → 0.5.0

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_record"
 rescue LoadError
@@ -99,11 +97,11 @@ module Tapioca
       class ActiveRecordColumns < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(ActiveRecord::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(ActiveRecord::Base)).void }
         def decorate(root, constant)
           return unless constant.table_exists?
 
-          root.path(constant) do |model|
+          root.create_path(constant) do |model|
             module_name = "GeneratedAttributeMethods"
 
             model.create_module(module_name) do |mod|
@@ -129,34 +127,31 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ActiveRecord::Base.descendants.reject(&:abstract_class?)
+          descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
         end
 
         private
 
         sig do
           params(
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             name: String,
             methods_to_add: T.nilable(T::Array[String]),
-            return_type: T.nilable(String),
+            return_type: String,
             parameters: T::Array[[String, String]]
           ).void
         end
-        def add_method(klass, name, methods_to_add, return_type: nil, parameters: [])
-          create_method(
-            klass,
+        def add_method(klass, name, methods_to_add, return_type: "void", parameters: [])
+          klass.create_method(
             name,
-            parameters: parameters.map do |param, type|
-              Parlour::RbiGenerator::Parameter.new(param, type: type)
-            end,
+            parameters: parameters.map { |param, type| create_param(param, type: type) },
             return_type: return_type
           ) if methods_to_add.nil? || methods_to_add.include?(name)
         end
 
         sig do
           params(
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             constant: T.class_of(ActiveRecord::Base),
             column_name: String,
             attribute_name: String,
@@ -164,7 +159,7 @@ module Tapioca
           ).void
         end
         def add_methods_for_attribute(klass, constant, column_name, attribute_name = column_name, methods_to_add = nil)
-          getter_type, setter_type = type_for(constant, column_name)
+          getter_type, setter_type = ActiveRecordColumnTypeHelper.new(constant).type_for(column_name)
 
           # Added by ActiveRecord::AttributeMethods::Read
           #
@@ -298,96 +293,6 @@ module Tapioca
           )
         end
 
-        sig do
-          params(
-            constant: T.class_of(ActiveRecord::Base),
-            column_name: String
-          ).returns([String, String])
-        end
-        def type_for(constant, column_name)
-          return ["T.untyped", "T.untyped"] if do_not_generate_strong_types?(constant)
-
-          column_type = constant.attribute_types[column_name]
-
-          getter_type =
-            case column_type
-            when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
-              "::Money"
-            when ActiveRecord::Type::Integer
-              "::Integer"
-            when ActiveRecord::Type::String
-              "::String"
-            when ActiveRecord::Type::Date
-              "::Date"
-            when ActiveRecord::Type::Decimal
-              "::BigDecimal"
-            when ActiveRecord::Type::Float
-              "::Float"
-            when ActiveRecord::Type::Boolean
-              "T::Boolean"
-            when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
-              "::DateTime"
-            when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
-              "::ActiveSupport::TimeWithZone"
-            else
-              handle_unknown_type(column_type)
-            end
-
-          column = constant.columns_hash[column_name]
-          setter_type = getter_type
-
-          if column&.null
-            return ["T.nilable(#{getter_type})", "T.nilable(#{setter_type})"]
-          end
-
-          if column_name == constant.primary_key ||
-              column_name == "created_at" ||
-              column_name == "updated_at"
-            getter_type = "T.nilable(#{getter_type})"
-          end
-
-          [getter_type, setter_type]
-        end
-
-        sig { params(constant: Module).returns(T::Boolean) }
-        def do_not_generate_strong_types?(constant)
-          Object.const_defined?(:StrongTypeGeneration) &&
-              !(constant.singleton_class < Object.const_get(:StrongTypeGeneration))
-        end
-
-        sig { params(column_type: Object).returns(String) }
-        def handle_unknown_type(column_type)
-          return "T.untyped" unless ActiveModel::Type::Value === column_type
-
-          lookup_return_type_of_method(column_type, :deserialize) ||
-            lookup_return_type_of_method(column_type, :cast) ||
-            lookup_arg_type_of_method(column_type, :serialize) ||
-            "T.untyped"
-        end
-
-        sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
-        def lookup_return_type_of_method(column_type, method)
-          signature = T::Private::Methods.signature_for_method(column_type.method(method))
-          return unless signature
-
-          return_type = signature.return_type
-          return if return_type == T::Private::Types::Void || return_type == T::Private::Types::NotTyped
-
-          return_type.to_s
-        end
-
-        sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
-        def lookup_arg_type_of_method(column_type, method)
-          signature = T::Private::Methods.signature_for_method(column_type.method(method))
-          return unless signature
-
-          # Arg types is an array [name, type] entries, so we desctructure the type of
-          # first argument to get the first argument type
-          _, first_argument_type = signature.arg_types.first
-
-          first_argument_type.to_s
-        end
-
         sig { params(type: String).returns(String) }
         def as_nilable_type(type)
           return type if type.start_with?("T.nilable(")

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_record"
 rescue LoadError
@@ -60,11 +58,11 @@ module Tapioca
       class ActiveRecordEnum < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActiveRecord::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActiveRecord::Base)).void }
         def decorate(root, constant)
           return if constant.defined_enums.empty?
 
-          root.path(constant) do |model|
+          root.create_path(constant) do |model|
             module_name = "EnumMethodsModule"
 
             model.create_module(module_name) do |mod|
@@ -75,14 +73,14 @@ module Tapioca
 
             constant.defined_enums.each do |name, enum_map|
               type = type_for_enum(enum_map)
-              create_method(model, name.pluralize, class_method: true, return_type: type)
+              model.create_method(name.pluralize, class_method: true, return_type: type)
             end
           end
         end
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveRecord::Base.descendants.reject(&:abstract_class?)
+          descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
         end
 
         private
@@ -93,21 +91,21 @@ module Tapioca
           value_type = if value_type.length == 1
             value_type.first
           else
-            "T.any(#{value_type.join(', ')})"
+            "T.any(#{value_type.join(", ")})"
           end
 
           "T::Hash[T.any(String, Symbol), #{value_type}]"
         end
 
-        sig { params(constant: T.class_of(::ActiveRecord::Base), klass: Parlour::RbiGenerator::Namespace).void }
+        sig { params(constant: T.class_of(::ActiveRecord::Base), klass: RBI::Scope).void }
         def generate_instance_methods(constant, klass)
           methods = constant.send(:_enum_methods_module).instance_methods
 
           methods.each do |method|
             method = method.to_s
-            return_type = "T::Boolean" if method.end_with?("?")
+            return_type = method.end_with?("?") ? "T::Boolean" : "void"
 
-            create_method(klass, method, return_type: return_type)
+            klass.create_method(method, return_type: return_type)
           end
         end
       end

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_record"
 rescue LoadError
@@ -47,7 +45,7 @@ module Tapioca
 
         sig do
           override.params(
-            root: Parlour::RbiGenerator::Namespace,
+            root: RBI::Tree,
             constant: T.class_of(::ActiveRecord::Base)
           ).void
         end
@@ -55,7 +53,7 @@ module Tapioca
           scope_method_names = constant.send(:generated_relation_methods).instance_methods(false)
           return if scope_method_names.empty?
 
-          root.path(constant) do |model|
+          root.create_path(constant) do |model|
             module_name = "GeneratedRelationMethods"
 
             model.create_module(module_name) do |mod|
@@ -70,7 +68,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveRecord::Base.descendants.reject(&:abstract_class?)
+          descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
         end
 
         private
@@ -78,19 +76,18 @@ module Tapioca
         sig do
           params(
             scope_method: String,
-            mod: Parlour::RbiGenerator::Namespace,
+            mod: RBI::Scope,
           ).void
         end
         def generate_scope_method(scope_method, mod)
           # This return type should actually be Model::ActiveRecord_Relation
           return_type = "T.untyped"
 
-          create_method(
-            mod,
+          mod.create_method(
             scope_method,
             parameters: [
-              Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
-              Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
+              create_rest_param("args", type: "T.untyped"),
+              create_block_param("blk", type: "T.untyped"),
             ],
             return_type: return_type,
           )

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

@@ -1,9 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-require "tapioca/core_ext/class"
-
 begin
   require "activerecord-typedstore"
 rescue LoadError
@@ -92,7 +89,7 @@ module Tapioca
         sig do
           override
             .params(
-              root: Parlour::RbiGenerator::Namespace,
+              root: RBI::Tree,
               constant: T.class_of(::ActiveRecord::Base)
             )
             .void
@@ -101,7 +98,7 @@ module Tapioca
           stores = constant.typed_stores
           return if stores.values.flat_map(&:accessors).empty?
 
-          root.path(constant) do |model|
+          root.create_path(constant) do |model|
             stores.values.each do |store_data|
               store_data.accessors.each do |accessor|
                 field = store_data.fields[accessor]
@@ -116,7 +113,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveRecord::Base.descendants.select do |klass|
+          descendants_of(::ActiveRecord::Base).select do |klass|
             klass.include?(ActiveRecord::TypedStore::Behavior)
           end
         end
@@ -142,7 +139,7 @@ module Tapioca
 
         sig do
           params(
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             name: String,
             type: String
           )
@@ -151,7 +148,7 @@ module Tapioca
         def generate_methods(klass, name, type)
           klass.create_method(
             "#{name}=",
-            parameters: [Parlour::RbiGenerator::Parameter.new(name, type: type)],
+            parameters: [create_param(name, type: type)],
             return_type: type
           )
           klass.create_method(name, return_type: type)

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_resource"
 rescue LoadError
@@ -63,16 +61,11 @@ module Tapioca
       class ActiveResource < Base
         extend T::Sig
 
-        sig do
-          override.params(
-            root: Parlour::RbiGenerator::Namespace,
-            constant: T.class_of(::ActiveResource::Base)
-          ).void
-        end
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActiveResource::Base)).void }
         def decorate(root, constant)
           return if constant.schema.blank?
 
-          root.path(constant) do |resource|
+          root.create_path(constant) do |resource|
             constant.schema.each do |attribute, type|
               create_schema_methods(resource, attribute, type)
             end
@@ -81,7 +74,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveResource::Base.descendants
+          descendants_of(::ActiveResource::Base)
         end
 
         private
@@ -104,36 +97,15 @@ module Tapioca
           TYPES.fetch(attr_type, "T.untyped")
         end
 
-        sig do
-          params(
-            klass: Parlour::RbiGenerator::Namespace,
-            attribute: String,
-            type: String
-          ).void
-        end
+        sig { params(klass: RBI::Scope, attribute: String, type: String).void }
         def create_schema_methods(klass, attribute, type)
           return_type = type_for(type.to_sym)
 
-          create_method(
-            klass,
-            attribute,
-            return_type: return_type
-          )
-
-          create_method(
-            klass,
-            "#{attribute}?",
-            return_type: "T::Boolean"
-          )
-
-          create_method(
-            klass,
-            "#{attribute}=",
-            parameters: [
-              Parlour::RbiGenerator::Parameter.new("value", type: return_type),
-            ],
-            return_type: return_type
-          )
+          klass.create_method(attribute, return_type: return_type)
+          klass.create_method("#{attribute}?", return_type: "T::Boolean")
+          klass.create_method("#{attribute}=", parameters: [
+            create_param("value", type: return_type),
+          ], return_type: return_type)
         end
       end
     end

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

@@ -0,0 +1,98 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_storage"
+  require "active_storage/reflection"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveStorage` decorates RBI files for subclasses of
+      # `ActiveRecord::Base` that declare [one](https://edgeguides.rubyonrails.org/active_storage_overview.html#has-one-attached)
+      # or [many](https://edgeguides.rubyonrails.org/active_storage_overview.html#has-many-attached) attachments.
+      #
+      # For example, with the following `ActiveRecord::Base` subclass:
+      #
+      # ~~~rb
+      # class Post < ApplicationRecord
+      #  has_one_attached :photo
+      #  has_many_attached :blogs
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `post.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # typed: strong
+      #
+      # class Post
+      #   sig { returns(ActiveStorage::Attached::Many) }
+      #   def blogs; end
+      #
+      #   sig { params(attachable: T.untyped).returns(T.untyped) }
+      #   def blogs=(attachable); end
+      #
+      #   sig { returns(ActiveStorage::Attached::One) }
+      #   def photo; end
+      #
+      #   sig { params(attachable: T.untyped).returns(T.untyped) }
+      #   def photo=(attachable); end
+      # end
+      # ~~~
+      class ActiveStorage < Base
+        extend T::Sig
+
+        sig do
+          override.params(root: RBI::Tree,
+            constant: T.all(Module, ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods)).void
+        end
+        def decorate(root, constant)
+          return if constant.reflect_on_all_attachments.empty?
+
+          root.create_path(constant) do |scope|
+            constant.reflect_on_all_attachments.each do |reflection|
+              type = type_of(reflection)
+              name = reflection.name.to_s
+              scope.create_method(
+                name,
+                return_type: type
+              )
+              scope.create_method(
+                "#{name}=",
+                parameters: [create_param("attachable", type: "T.untyped")],
+                return_type: "T.untyped"
+              )
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          descendants_of(::ActiveRecord::Base)
+            .reject(&:abstract_class?)
+            .grep(::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods)
+        end
+
+        private
+
+        sig do
+          params(reflection: ActiveRecord::Reflection::MacroReflection).returns(String)
+        end
+        def type_of(reflection)
+          case reflection
+          when ::ActiveStorage::Reflection::HasOneAttachedReflection
+            "ActiveStorage::Attached::One"
+          when ::ActiveStorage::Reflection::HasManyAttachedReflection
+            "ActiveStorage::Attached::Many"
+          else
+            "T.untyped"
+          end
+        end
+      end
+    end
+  end
+end