tapioca 0.10.4 → 0.11.0

data/lib/tapioca/loaders/loader.rb

@@ -47,44 +47,113 @@ module Tapioca
 
         eager_load_rails_app if eager_load
       rescue LoadError, StandardError => e
-        say("Tapioca attempted to load the Rails application after encountering a `config/application.rb` file, " \
-          "but it failed. If your application uses Rails please ensure it can be loaded correctly before generating " \
-          "RBIs.\n#{e}", :yellow)
+        say(
+          "Tapioca attempted to load the Rails application after encountering a `config/application.rb` file, " \
+            "but it failed. If your application uses Rails please ensure it can be loaded correctly before " \
+            "generating RBIs.\n#{e}",
+          :yellow,
+        )
         say("Continuing RBI generation without loading the Rails application.")
       end
 
       sig { void }
       def load_rails_engines
-        rails_engines.each do |engine|
-          errored_files = []
+        return if engines.empty?
 
+        with_rails_application do
+          run_initializers
+
+          if zeitwerk_mode?
+            load_engines_in_zeitwerk_mode
+          else
+            load_engines_in_classic_mode
+          end
+        end
+      end
+
+      def run_initializers
+        engines.each do |engine|
+          engine.instance.initializers.tsort_each do |initializer|
+            initializer.run(Rails.application)
+          rescue ScriptError, StandardError
+            nil
+          end
+        end
+      end
+
+      sig { void }
+      def load_engines_in_zeitwerk_mode
+        # Collect all the directories that are already managed by all existing Zeitwerk loaders.
+        managed_dirs = Zeitwerk::Registry.loaders.flat_map(&:dirs).to_set
+        # We use a fresh loader to load the engine directories, so that we don't interfere with
+        # any of the existing loaders.
+        autoloader = Zeitwerk::Loader.new
+
+        engines.each do |engine|
+          engine.config.eager_load_paths.each do |path|
+            # Zeitwerk only accepts existing directories in `push_dir`.
+            next unless File.directory?(path)
+            # We should not add directories that are already managed by a Zeitwerk loader.
+            next if managed_dirs.member?(path)
+
+            autoloader.push_dir(path)
+          end
+        end
+
+        autoloader.setup
+      end
+
+      sig { void }
+      def load_engines_in_classic_mode
+        # This is code adapted from `Rails::Engine#eager_load!` in
+        # https://github.com/rails/rails/blob/d9e188dbab81b412f73dfb7763318d52f360af49/railties/lib/rails/engine.rb#L489-L495
+        #
+        # We can't use `Rails::Engine#eager_load!` directly because it will raise as soon as it encounters
+        # an error, which is not what we want. We want to try to load as much as we can.
+        engines.each do |engine|
           engine.config.eager_load_paths.each do |load_path|
             Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
-              require(file)
-            rescue LoadError, StandardError
-              errored_files << file
+              require_dependency file
             end
-          end
-
-          # Try files that have errored one more time
-          # It might have been a load order problem
-          errored_files.each do |file|
-            require(file)
-          rescue LoadError, StandardError
+          rescue ScriptError, StandardError
             nil
           end
         end
       end
 
-      sig { returns(T::Array[T.untyped]) }
-      def rails_engines
-        return [] unless Object.const_defined?("Rails::Engine")
+      sig { returns(T::Boolean) }
+      def zeitwerk_mode?
+        Rails.respond_to?(:autoloaders) &&
+          Rails.autoloaders.respond_to?(:zeitwerk_enabled?) &&
+          Rails.autoloaders.zeitwerk_enabled?
+      end
+
+      sig { params(blk: T.proc.void).void }
+      def with_rails_application(&blk)
+        # Store the current Rails.application object so that we can restore it
+        rails_application = T.unsafe(Rails.application)
+
+        # Create a new Rails::Application object, so that we can load the engines.
+        # Some engines and the `Rails.autoloaders` call might expect `Rails.application`
+        # to be set, so we need to create one here.
+        unless rails_application
+          Rails.application = Class.new(Rails::Application)
+        end
+
+        blk.call
+      ensure
+        Rails.app_class = Rails.application = rails_application
+      end
+
+      T::Sig::WithoutRuntime.sig { returns(T::Array[T.class_of(Rails::Engine)]) }
+      def engines
+        return [] unless defined?(Rails::Engine)
 
         safe_require("active_support/core_ext/class/subclasses")
 
         project_path = Bundler.default_gemfile.parent.expand_path
         # We can use `Class#descendants` here, since we know Rails is loaded
-        Object.const_get("Rails::Engine")
+        Rails::Engine
           .descendants
           .reject(&:abstract_railtie?)
           .reject { |engine| gem_in_app_dir?(project_path, engine.config.root.to_path) }
@@ -100,30 +169,25 @@ module Tapioca
       sig { void }
       def silence_deprecations
         # Stop any ActiveSupport Deprecations from being reported
-        Object.const_get("ActiveSupport::Deprecation").silenced = true
-      rescue NameError
-        nil
+        if defined?(ActiveSupport::Deprecation)
+          ActiveSupport::Deprecation.silenced = true
+        end
       end
 
       sig { void }
       def eager_load_rails_app
-        rails = Object.const_get("Rails")
-        application = rails.application
-
-        if Object.const_defined?("ActiveSupport")
-          Object.const_get("ActiveSupport").run_load_hooks(
-            :before_eager_load,
-            application,
-          )
+        application = Rails.application
+
+        if defined?(ActiveSupport)
+          ActiveSupport.run_load_hooks(:before_eager_load, application)
         end
 
-        if Object.const_defined?("Zeitwerk::Loader")
-          zeitwerk_loader = Object.const_get("Zeitwerk::Loader")
-          zeitwerk_loader.eager_load_all
+        if defined?(Zeitwerk::Loader)
+          Zeitwerk::Loader.eager_load_all
         end
 
-        if rails.respond_to?(:autoloaders) && rails.autoloaders.zeitwerk_enabled?
-          rails.autoloaders.each(&:eager_load)
+        if Rails.respond_to?(:autoloaders)
+          Rails.autoloaders.each(&:eager_load)
         end
 
         if application.config.respond_to?(:eager_load_namespaces)

data/lib/tapioca/rbi_ext/model.rb

@@ -5,7 +5,7 @@ module RBI
   class Tree
     extend T::Sig
 
-    sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: Scope).void)).void }
+    sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: Scope).void)).returns(Scope) }
     def create_path(constant, &block)
       constant_name = Tapioca::Runtime::Reflection.name_of(constant)
       raise "given constant does not have a name" unless constant_name
@@ -91,8 +91,13 @@ module RBI
       return unless Tapioca::RBIHelper.valid_method_name?(name)
 
       sig = RBI::Sig.new(return_type: return_type)
-      method = RBI::Method.new(name, sigs: [sig], is_singleton: class_method, visibility: visibility,
-        comments: comments)
+      method = RBI::Method.new(
+        name,
+        sigs: [sig],
+        is_singleton: class_method,
+        visibility: visibility,
+        comments: comments,
+      )
       parameters.each do |param|
         method << param.param
         sig << RBI::SigParam.new(param.param.name, param.type)

data/lib/tapioca/rbi_formatter.rb

@@ -26,12 +26,15 @@ module Tapioca
     end
   end
 
-  DEFAULT_RBI_FORMATTER = T.let(RBIFormatter.new(
-    add_sig_templates: false,
-    group_nodes: true,
-    max_line_length: nil,
-    nest_singleton_methods: true,
-    nest_non_public_methods: true,
-    sort_nodes: true,
-  ), RBIFormatter)
+  DEFAULT_RBI_FORMATTER = T.let(
+    RBIFormatter.new(
+      add_sig_templates: false,
+      group_nodes: true,
+      max_line_length: nil,
+      nest_singleton_methods: true,
+      nest_non_public_methods: true,
+      sort_nodes: true,
+    ),
+    RBIFormatter,
+  )
 end

data/lib/tapioca/runtime/attached_class_of_32.rb

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    # This module should only be included when running Ruby version 3.2
+    # or newer. It relies on the Class#attached_object method, which was
+    # added in Ruby 3.2 and fetches the attached object of a singleton
+    # class without having to iterate through all of ObjectSpace.
+    module AttachedClassOf
+      extend T::Sig
+
+      sig { params(singleton_class: Class).returns(T.nilable(Module)) }
+      def attached_class_of(singleton_class)
+        result = singleton_class.attached_object
+        Module === result ? result : nil
+      end
+    end
+  end
+end

data/lib/tapioca/runtime/attached_class_of_legacy.rb

@@ -0,0 +1,27 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    # This module should only be included when running versions of Ruby
+    # older than 3.2. Because the Class#attached_object method is not
+    # available, it implements finding the attached class of a singleton
+    # class by iterating through ObjectSpace.
+    module AttachedClassOf
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { Tapioca::Runtime::Reflection }
+
+      sig { params(singleton_class: Class).returns(T.nilable(Module)) }
+      def attached_class_of(singleton_class)
+        # https://stackoverflow.com/a/36622320/98634
+        result = ObjectSpace.each_object(singleton_class).find do |klass|
+          singleton_class_of(T.cast(klass, Module)) == singleton_class
+        end
+
+        T.cast(result, T.nilable(Module))
+      end
+    end
+  end
+end

data/lib/tapioca/runtime/reflection.rb

@@ -1,9 +1,20 @@
 # typed: strict
 # frozen_string_literal: true
 
+# On Ruby 3.2 or newer, Class defines an attached_object method that returns the
+# attached class of a singleton class without iterating ObjectSpace. On older
+# versions of Ruby, we fall back to iterating ObjectSpace.
+if Class.method_defined?(:attached_object)
+  require "tapioca/runtime/attached_class_of_32"
+else
+  require "tapioca/runtime/attached_class_of_legacy"
+end
+
 module Tapioca
   module Runtime
     module Reflection
+      include AttachedClassOf
+
       extend T::Sig
       extend self
 
@@ -174,16 +185,6 @@ module Tapioca
         resolved_loc.absolute_path || ""
       end
 
-      sig { params(singleton_class: Module).returns(T.nilable(Module)) }
-      def attached_class_of(singleton_class)
-        # https://stackoverflow.com/a/36622320/98634
-        result = ObjectSpace.each_object(singleton_class).find do |klass|
-          singleton_class_of(T.cast(klass, Module)) == singleton_class
-        end
-
-        T.cast(result, Module)
-      end
-
       sig { params(constant: Module).returns(T::Set[String]) }
       def file_candidates_for(constant)
         relevant_methods_for(constant).filter_map do |method|

data/lib/tapioca/runtime/trackers.rb

@@ -13,6 +13,23 @@ module Tapioca
       class << self
         extend T::Sig
 
+        sig do
+          type_parameters(:Return)
+            .params(blk: T.proc.returns(T.type_parameter(:Return)))
+            .returns(T.type_parameter(:Return))
+        end
+        def with_trackers_enabled(&blk)
+          # Currently this is a dirty hack to ensure disabling trackers
+          # doesn't work while in the block passed to this method.
+          disable_all_method = method(:disable_all!)
+          define_singleton_method(:disable_all!) {}
+          blk.call
+        ensure
+          if disable_all_method
+            define_singleton_method(:disable_all!, disable_all_method)
+          end
+        end
+
         sig { void }
         def disable_all!
           @trackers.each(&:disable!)

data/lib/tapioca/static/symbol_loader.rb

@@ -41,6 +41,20 @@ module Tapioca
           symbols_from_paths(gem.files)
         end
 
+        sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
+        def symbols_from_paths(paths)
+          output = Tempfile.create("sorbet") do |file|
+            file.write(Array(paths).join("\n"))
+            file.flush
+
+            symbol_table_json_from("@#{file.path.shellescape}")
+          end
+
+          return Set.new if output.empty?
+
+          SymbolTableParser.parse_json(output)
+        end
+
         private
 
         sig { returns(T::Array[T.class_of(Rails::Engine)]) }
@@ -59,20 +73,6 @@ module Tapioca
         def symbol_table_json_from(input, table_type: "symbol-table-json")
           sorbet("--no-config", "--quiet", "--print=#{table_type}", input).out
         end
-
-        sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
-        def symbols_from_paths(paths)
-          output = Tempfile.create("sorbet") do |file|
-            file.write(Array(paths).join("\n"))
-            file.flush
-
-            symbol_table_json_from("@#{file.path.shellescape}")
-          end
-
-          return Set.new if output.empty?
-
-          SymbolTableParser.parse_json(output)
-        end
       end
     end
   end

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.10.4"
+  VERSION = "0.11.0"
 end

data/lib/tapioca.rb

@@ -43,11 +43,14 @@ module Tapioca
   DEFAULT_TODO_FILE = T.let("#{DEFAULT_RBI_DIR}/todo.rbi", String)
   DEFAULT_ANNOTATIONS_DIR = T.let("#{DEFAULT_RBI_DIR}/annotations", String)
 
-  DEFAULT_OVERRIDES = T.let({
-    # ActiveSupport overrides some core methods with different signatures
-    # so we generate a typed: false RBI for it to suppress errors
-    "activesupport" => "false",
-  }.freeze, T::Hash[String, String])
+  DEFAULT_OVERRIDES = T.let(
+    {
+      # ActiveSupport overrides some core methods with different signatures
+      # so we generate a typed: false RBI for it to suppress errors
+      "activesupport" => "false",
+    }.freeze,
+    T::Hash[String, String],
+  )
 
   DEFAULT_RBI_MAX_LINE_LENGTH = 120
   DEFAULT_ENVIRONMENT = "development"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.11.0
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-12-19 00:00:00.000000000 Z
+date: 2023-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -176,6 +176,7 @@ files:
 - lib/tapioca/dsl/compilers/active_record_fixtures.rb
 - lib/tapioca/dsl/compilers/active_record_relations.rb
 - lib/tapioca/dsl/compilers/active_record_scope.rb
+- lib/tapioca/dsl/compilers/active_record_secure_token.rb
 - lib/tapioca/dsl/compilers/active_record_typed_store.rb
 - lib/tapioca/dsl/compilers/active_resource.rb
 - lib/tapioca/dsl/compilers/active_storage.rb
@@ -186,6 +187,7 @@ files:
 - lib/tapioca/dsl/compilers/graphql_input_object.rb
 - lib/tapioca/dsl/compilers/graphql_mutation.rb
 - lib/tapioca/dsl/compilers/identity_cache.rb
+- lib/tapioca/dsl/compilers/kredis.rb
 - lib/tapioca/dsl/compilers/mixed_in_class_attributes.rb
 - lib/tapioca/dsl/compilers/protobuf.rb
 - lib/tapioca/dsl/compilers/rails_generators.rb
@@ -195,6 +197,7 @@ files:
 - lib/tapioca/dsl/compilers/url_helpers.rb
 - lib/tapioca/dsl/extensions/active_record.rb
 - lib/tapioca/dsl/extensions/frozen_record.rb
+- lib/tapioca/dsl/extensions/kredis.rb
 - lib/tapioca/dsl/helpers/active_record_column_type_helper.rb
 - lib/tapioca/dsl/helpers/active_record_constants_helper.rb
 - lib/tapioca/dsl/helpers/graphql_type_helper.rb
@@ -239,6 +242,8 @@ files:
 - lib/tapioca/rbi_ext/model.rb
 - lib/tapioca/rbi_formatter.rb
 - lib/tapioca/repo_index.rb
+- lib/tapioca/runtime/attached_class_of_32.rb
+- lib/tapioca/runtime/attached_class_of_legacy.rb
 - lib/tapioca/runtime/dynamic_mixin_compiler.rb
 - lib/tapioca/runtime/generic_type_registry.rb
 - lib/tapioca/runtime/reflection.rb