tapioca 0.10.5 → 0.11.0

data/lib/tapioca/dsl/extensions/active_record.rb

@@ -21,6 +21,15 @@ module Tapioca
             super
           end
 
+          attr_reader :__tapioca_secure_tokens
+
+          def has_secure_token(attribute = :token, length: ::ActiveRecord::SecureToken::MINIMUM_TOKEN_LENGTH)
+            @__tapioca_secure_tokens ||= []
+            @__tapioca_secure_tokens << attribute
+
+            super
+          end
+
           ::ActiveRecord::Base.singleton_class.prepend(self)
         end
       end

data/lib/tapioca/dsl/extensions/kredis.rb

@@ -0,0 +1,114 @@
+# typed: true
+# frozen_string_literal: true
+
+begin
+  require "kredis"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Dsl
+    module Compilers
+      module Extensions
+        module Kredis
+          attr_reader :__tapioca_kredis_types
+
+          def kredis_proxy(name, key: nil, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Proxy")
+            super
+          end
+
+          def kredis_string(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_integer(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_decimal(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_datetime(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_flag(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Flag")
+            super
+          end
+
+          def kredis_float(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_enum(name, key: nil, values:, default:, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Enum", values: values)
+            super
+          end
+
+          def kredis_json(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_list(name, key: nil, typed: :string, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::List")
+            super
+          end
+
+          def kredis_unique_list(name, limit: nil, key: nil, typed: :string, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::UniqueList")
+            super
+          end
+
+          def kredis_set(name, key: nil, typed: :string, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Set")
+            super
+          end
+
+          def kredis_slot(name, key: nil, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Slots")
+            super
+          end
+
+          def kredis_slots(name, available:, key: nil, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Slots")
+            super
+          end
+
+          def kredis_counter(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Counter")
+            super
+          end
+
+          def kredis_hash(name, key: nil, typed: :string, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Hash")
+            super
+          end
+
+          def kredis_boolean(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          private
+
+          def collect_kredis_type(method, type, values: nil)
+            @__tapioca_kredis_types ||= {}
+            @__tapioca_kredis_types[method.to_s] = { type: type, values: values }
+          end
+
+          ::Kredis::Attributes::ClassMethods.prepend(self)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/helpers/active_record_constants_helper.rb

@@ -14,6 +14,7 @@ module Tapioca
         AttributeMethodsModuleName = T.let("GeneratedAttributeMethods", String)
         AssociationMethodsModuleName = T.let("GeneratedAssociationMethods", String)
         DelegatedTypesModuleName = T.let("GeneratedDelegatedTypeMethods", String)
+        SecureTokensModuleName = T.let("GeneratedSecureTokenMethods", String)
 
         RelationMethodsModuleName = T.let("GeneratedRelationMethods", String)
         AssociationRelationMethodsModuleName = T.let("GeneratedAssociationRelationMethods", String)

data/lib/tapioca/dsl/pipeline.rb

@@ -12,6 +12,9 @@ module Tapioca
       sig { returns(T::Array[Module]) }
       attr_reader :requested_constants
 
+      sig { returns(T::Array[Pathname]) }
+      attr_reader :requested_paths
+
       sig { returns(T.proc.params(error: String).void) }
       attr_reader :error_handler
 
@@ -21,6 +24,7 @@ module Tapioca
       sig do
         params(
           requested_constants: T::Array[Module],
+          requested_paths: T::Array[Pathname],
           requested_compilers: T::Array[T.class_of(Compiler)],
           excluded_compilers: T::Array[T.class_of(Compiler)],
           error_handler: T.proc.params(error: String).void,
@@ -29,6 +33,7 @@ module Tapioca
       end
       def initialize(
         requested_constants:,
+        requested_paths: [],
         requested_compilers: [],
         excluded_compilers: [],
         error_handler: $stderr.method(:puts).to_proc,
@@ -39,6 +44,7 @@ module Tapioca
           T::Enumerable[T.class_of(Compiler)],
         )
         @requested_constants = requested_constants
+        @requested_paths = requested_paths
         @error_handler = error_handler
         @number_of_workers = number_of_workers
         @errors = T.let([], T::Array[String])
@@ -50,11 +56,12 @@ module Tapioca
         ).returns(T::Array[T.type_parameter(:T)])
       end
       def run(&blk)
-        constants_to_process = gather_constants(requested_constants)
+        constants_to_process = gather_constants(requested_constants, requested_paths)
           .select { |c| Module === c } # Filter value constants out
           .sort_by! { |c| T.must(Runtime::Reflection.name_of(c)) }
 
-        if constants_to_process.empty?
+        # It's OK if there are no constants to process if we received a valid file/path.
+        if constants_to_process.empty? && requested_paths.select { |p| File.exist?(p) }.empty?
           report_error(<<~ERROR)
             No classes/modules can be matched for RBI generation.
             Please check that the requested classes/modules include processable DSL methods.
@@ -115,12 +122,12 @@ module Tapioca
         active_compilers
       end
 
-      sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
-      def gather_constants(requested_constants)
+      sig { params(requested_constants: T::Array[Module], requested_paths: T::Array[Pathname]).returns(T::Set[Module]) }
+      def gather_constants(requested_constants, requested_paths)
         constants = active_compilers.map(&:processable_constants).reduce(Set.new, :union)
         constants = filter_anonymous_and_reloaded_constants(constants)
 
-        constants &= requested_constants unless requested_constants.empty?
+        constants &= requested_constants unless requested_constants.empty? && requested_paths.empty?
         constants
       end
 

data/lib/tapioca/gem/listeners/sorbet_enums.rb

@@ -12,7 +12,7 @@ module Tapioca
         sig { override.params(event: ScopeNodeAdded).void }
         def on_scope(event)
           constant = event.constant
-          return unless T::Enum > event.constant
+          return unless T::Enum > event.constant # rubocop:disable Style/InvertibleUnlessCondition
 
           enums = T.unsafe(constant).values.map do |enum_type|
             enum_type.instance_variable_get(:@const_name).to_s

data/lib/tapioca/gem/pipeline.rb

@@ -106,6 +106,18 @@ module Tapioca
         @payload_symbols.include?(symbol_name)
       end
 
+      sig { params(name: T.any(String, Symbol)).returns(T::Boolean) }
+      def constant_in_gem?(name)
+        return true unless Object.respond_to?(:const_source_location)
+
+        source_location, _ = Object.const_source_location(name)
+        return true unless source_location
+        # If the source location of the constant is "(eval)", all bets are off.
+        return true if source_location == "(eval)"
+
+        gem.contains_path?(source_location)
+      end
+
       sig { params(method: UnboundMethod).returns(T::Boolean) }
       def method_in_gem?(method)
         source_location = method.source_location&.first
@@ -216,6 +228,7 @@ module Tapioca
         mark_seen(name)
 
         return if symbol_in_payload?(name)
+        return unless constant_in_gem?(name)
 
         target = name_of(constant)
         # If target has no name, let's make it an anonymous class or module with `Class.new` or `Module.new`
@@ -237,6 +250,7 @@ module Tapioca
         mark_seen(name)
 
         return if symbol_in_payload?(name)
+        return unless constant_in_gem?(name)
 
         klass = class_of(value)
 

data/lib/tapioca/loaders/loader.rb

@@ -58,36 +58,102 @@ module Tapioca
 
       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) }
@@ -103,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

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/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.5"
+  VERSION = "0.11.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.10.5
+  version: 0.11.0
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-04 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