tapioca 0.4.27 → 0.5.3

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

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "rails"
+  require "active_record"
+  require "active_record/fixtures"
+  require "active_support/test_case"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveRecordFixtures` decorates RBIs for test fixture methods
+      # that are created dynamically by Rails.
+      #
+      # For example, given an application with a posts table, we can have a fixture file
+      #
+      # ~~~yaml
+      # first_post:
+      #   author: John
+      #   title: My post
+      # ~~~
+      #
+      # Rails will allow us to invoke `posts(:first_post)` in tests to get the fixture record.
+      # The generated RBI by this generator will produce the following
+      #
+      # ~~~rbi
+      # # test_case.rbi
+      # # typed: true
+      # class ActiveSupport::TestCase
+      #   sig { params(fixture_names: Symbol).returns(T.untyped) }
+      #   def posts(*fixture_names); end
+      # end
+      # ~~~
+      class ActiveRecordFixtures < Base
+        extend T::Sig
+
+        sig { override.params(root: RBI::Tree, constant: T.class_of(ActiveSupport::TestCase)).void }
+        def decorate(root, constant)
+          method_names = fixture_loader.ancestors # get all ancestors from class that includes AR fixtures
+            .drop(1) # drop the anonymous class itself from the array
+            .reject(&:name) # only collect anonymous ancestors because fixture methods are always on an anonymous module
+            .map! do |mod|
+              [mod.private_instance_methods(false), mod.instance_methods(false)]
+            end
+            .flatten # merge methods into a single list
+          return if method_names.empty?
+
+          root.create_path(constant) do |mod|
+            method_names.each do |name|
+              create_fixture_method(mod, name.to_s)
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          [ActiveSupport::TestCase]
+        end
+
+        private
+
+        sig { returns(Class) }
+        def fixture_loader
+          Class.new do
+            T.unsafe(self).include(ActiveRecord::TestFixtures)
+            T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
+            T.unsafe(self).fixtures(:all)
+          end
+        end
+
+        sig { params(mod: RBI::Scope, name: String).void }
+        def create_fixture_method(mod, name)
+          mod.create_method(
+            name,
+            parameters: [create_rest_param("fixture_names", type: "Symbol")],
+            return_type: "T.untyped"
+          )
+        end
+      end
+    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

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

@@ -0,0 +1,106 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tapioca/compilers/sorbet"
+
+begin
+  require "active_support"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveSupportConcern` generates RBI files for classes that both `extend`
+      # `ActiveSupport::Concern` and `include` another class that extends `ActiveSupport::Concern`
+      #
+      # For example for the following hierarchy:
+      #
+      # ~~~rb
+      # # concern.rb
+      # module Foo
+      #  extend ActiveSupport::Concern
+      #  module ClassMethods; end
+      # end
+      #
+      # module Bar
+      #  extend ActiveSupport::Concern
+      #  module ClassMethods; end
+      #  include Foo
+      # end
+      #
+      # class Baz
+      #  include Bar
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `concern.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # typed: true
+      # module Bar
+      #   mixes_in_class_methods(::Foo::ClassMethods)
+      # end
+      # ~~~
+      class ActiveSupportConcern < Base
+        extend T::Sig
+
+        sig { override.params(root: RBI::Tree, constant: Module).void }
+        def decorate(root, constant)
+          dependencies = linearized_dependencies_of(constant)
+
+          mixed_in_class_methods = dependencies
+            .uniq # Deduplicate
+            .map do |concern| # Map to class methods module name, if exists
+              "#{qualified_name_of(concern)}::ClassMethods" if concern.const_defined?(:ClassMethods)
+            end
+            .compact # Remove non-existent records
+
+          return if mixed_in_class_methods.empty?
+
+          root.create_path(constant) do |mod|
+            mixed_in_class_methods.each do |mix|
+              mod.create_mixes_in_class_methods(mix)
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          # Find all Modules that are:
+          all_modules.select do |mod|
+            # named (i.e. not anonymous)
+            name_of(mod) &&
+              # not singleton classes
+              !mod.singleton_class? &&
+              # extend ActiveSupport::Concern, and
+              mod.singleton_class < ActiveSupport::Concern &&
+              # have dependencies (i.e. include another concern)
+              !dependencies_of(mod).empty?
+          end
+        end
+
+        private
+
+        sig { params(concern: Module).returns(T::Array[Module]) }
+        def dependencies_of(concern)
+          concern.instance_variable_get(:@_dependencies)
+        end
+
+        sig { params(concern: Module).returns(T::Array[Module]) }
+        def linearized_dependencies_of(concern)
+          # Grab all the dependencies of the concern
+          dependencies = dependencies_of(concern)
+
+          # Flatten this concern's dependencies and all of their dependencies
+          dependencies.flat_map do |dependency|
+            # Linearize dependencies of the current dependency,
+            # which, itself, is a concern
+            linearized_dependencies_of(dependency) << dependency
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,10 +1,10 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_support"
+  # The following is needed due to https://github.com/rails/rails/pull/41610
+  require "active_support/core_ext/module/delegation"
 rescue LoadError
   return
 end
@@ -65,7 +65,7 @@ module Tapioca
         sig do
           override
             .params(
-              root: Parlour::RbiGenerator::Namespace,
+              root: RBI::Tree,
               constant: T.class_of(::ActiveSupport::CurrentAttributes)
             )
             .void
@@ -75,7 +75,7 @@ module Tapioca
           instance_methods = instance_methods_for(constant) - dynamic_methods
           return if dynamic_methods.empty? && instance_methods.empty?
 
-          root.path(constant) do |current_attributes|
+          root.create_path(constant) do |current_attributes|
             dynamic_methods.each do |method|
               method = method.to_s
               # We want to generate each method both on the class
@@ -95,7 +95,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveSupport::CurrentAttributes.descendants
+          descendants_of(::ActiveSupport::CurrentAttributes)
         end
 
         private
@@ -110,11 +110,16 @@ module Tapioca
           constant.instance_methods(false)
         end
 
-        sig { params(klass: Parlour::RbiGenerator::Namespace, method: String, class_method: T::Boolean).void }
+        sig { params(klass: RBI::Scope, method: String, class_method: T::Boolean).void }
         def generate_method(klass, method, class_method:)
           if method.end_with?("=")
-            parameter = Parlour::RbiGenerator::Parameter.new("value", type: "T.untyped")
-            klass.create_method(method, class_method: class_method, parameters: [parameter], return_type: "T.untyped")
+            parameter = create_param("value", type: "T.untyped")
+            klass.create_method(
+              method,
+              class_method: class_method,
+              parameters: [parameter],
+              return_type: "T.untyped"
+            )
           else
             klass.create_method(method, class_method: class_method, return_type: "T.untyped")
           end