tapioca 0.6.4 → 0.7.2

data/lib/tapioca/runtime/loader.rb

@@ -0,0 +1,123 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    class Loader
+      extend(T::Sig)
+
+      sig do
+        params(gemfile: Tapioca::Gemfile, initialize_file: T.nilable(String), require_file: T.nilable(String)).void
+      end
+      def load_bundle(gemfile, initialize_file, require_file)
+        require_helper(initialize_file)
+
+        load_rails_application
+
+        gemfile.require_bundle
+
+        require_helper(require_file)
+
+        load_rails_engines
+      end
+
+      sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void }
+      def load_rails_application(environment_load: false, eager_load: false)
+        return unless File.exist?("config/application.rb")
+
+        silence_deprecations
+
+        if environment_load
+          safe_require("./config/environment")
+        else
+          safe_require("./config/application")
+        end
+
+        eager_load_rails_app if eager_load
+      end
+
+      private
+
+      sig { params(file: T.nilable(String)).void }
+      def require_helper(file)
+        return unless file
+        file = File.absolute_path(file)
+        return unless File.exist?(file)
+
+        require(file)
+      end
+
+      sig { returns(T::Array[T.untyped]) }
+      def rails_engines
+        return [] unless Object.const_defined?("Rails::Engine")
+
+        # We can use `Class#descendants` here, since we know Rails is loaded
+        Object.const_get("Rails::Engine").descendants.reject(&:abstract_railtie?)
+      end
+
+      sig { params(path: String).void }
+      def safe_require(path)
+        require path
+      rescue LoadError
+        nil
+      end
+
+      sig { void }
+      def silence_deprecations
+        # Stop any ActiveSupport Deprecations from being reported
+        Object.const_get("ActiveSupport::Deprecation").silenced = true
+      rescue NameError
+        nil
+      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
+          )
+        end
+
+        if Object.const_defined?("Zeitwerk::Loader")
+          zeitwerk_loader = Object.const_get("Zeitwerk::Loader")
+          zeitwerk_loader.eager_load_all
+        end
+
+        if rails.respond_to?(:autoloaders) && rails.autoloaders.zeitwerk_enabled?
+          rails.autoloaders.each(&:eager_load)
+        end
+
+        if application.config.respond_to?(:eager_load_namespaces)
+          application.config.eager_load_namespaces.each(&:eager_load!)
+        end
+      end
+
+      sig { void }
+      def load_rails_engines
+        rails_engines.each do |engine|
+          errored_files = []
+
+          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
+            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
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/runtime/reflection.rb

@@ -0,0 +1,157 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Reflection
+      extend T::Sig
+      extend self
+
+      CLASS_METHOD = T.let(Kernel.instance_method(:class), UnboundMethod)
+      CONSTANTS_METHOD = T.let(Module.instance_method(:constants), UnboundMethod)
+      NAME_METHOD = T.let(Module.instance_method(:name), UnboundMethod)
+      SINGLETON_CLASS_METHOD = T.let(Object.instance_method(:singleton_class), UnboundMethod)
+      ANCESTORS_METHOD = T.let(Module.instance_method(:ancestors), UnboundMethod)
+      SUPERCLASS_METHOD = T.let(Class.instance_method(:superclass), UnboundMethod)
+      OBJECT_ID_METHOD = T.let(BasicObject.instance_method(:__id__), UnboundMethod)
+      EQUAL_METHOD = T.let(BasicObject.instance_method(:equal?), UnboundMethod)
+      PUBLIC_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:public_instance_methods), UnboundMethod)
+      PROTECTED_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:protected_instance_methods), UnboundMethod)
+      PRIVATE_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:private_instance_methods), UnboundMethod)
+      METHOD_METHOD = T.let(Kernel.instance_method(:method), UnboundMethod)
+
+      sig do
+        params(
+          symbol: String,
+          inherit: T::Boolean,
+          namespace: Module
+        ).returns(BasicObject).checked(:never)
+      end
+      def constantize(symbol, inherit: false, namespace: Object)
+        namespace.const_get(symbol, inherit)
+      rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
+        nil
+      end
+
+      sig { params(object: BasicObject).returns(Class).checked(:never) }
+      def class_of(object)
+        CLASS_METHOD.bind(object).call
+      end
+
+      sig { params(constant: Module).returns(T::Array[Symbol]) }
+      def constants_of(constant)
+        CONSTANTS_METHOD.bind(constant).call(false)
+      end
+
+      sig { params(constant: Module).returns(T.nilable(String)) }
+      def name_of(constant)
+        name = NAME_METHOD.bind(constant).call
+        name&.start_with?("#<") ? nil : name
+      end
+
+      sig { params(constant: Module).returns(Class) }
+      def singleton_class_of(constant)
+        SINGLETON_CLASS_METHOD.bind(constant).call
+      end
+
+      sig { params(constant: Module).returns(T::Array[Module]) }
+      def ancestors_of(constant)
+        ANCESTORS_METHOD.bind(constant).call
+      end
+
+      sig { params(constant: Class).returns(T.nilable(Class)) }
+      def superclass_of(constant)
+        SUPERCLASS_METHOD.bind(constant).call
+      end
+
+      sig { params(object: BasicObject).returns(Integer).checked(:never) }
+      def object_id_of(object)
+        OBJECT_ID_METHOD.bind(object).call
+      end
+
+      sig { params(object: BasicObject, other: BasicObject).returns(T::Boolean).checked(:never) }
+      def are_equal?(object, other)
+        EQUAL_METHOD.bind(object).call(other)
+      end
+
+      sig { params(constant: Module).returns(T::Array[Symbol]) }
+      def public_instance_methods_of(constant)
+        PUBLIC_INSTANCE_METHODS_METHOD.bind(constant).call
+      end
+
+      sig { params(constant: Module).returns(T::Array[Symbol]) }
+      def protected_instance_methods_of(constant)
+        PROTECTED_INSTANCE_METHODS_METHOD.bind(constant).call
+      end
+
+      sig { params(constant: Module).returns(T::Array[Symbol]) }
+      def private_instance_methods_of(constant)
+        PRIVATE_INSTANCE_METHODS_METHOD.bind(constant).call
+      end
+
+      sig { params(constant: Module).returns(T::Array[Module]) }
+      def inherited_ancestors_of(constant)
+        if Class === constant
+          ancestors_of(superclass_of(constant) || Object)
+        else
+          Module.ancestors
+        end
+      end
+
+      sig { params(constant: Module).returns(T.nilable(String)) }
+      def qualified_name_of(constant)
+        name = name_of(constant)
+        return if name.nil?
+
+        if name.start_with?("::")
+          name
+        else
+          "::#{name}"
+        end
+      end
+
+      sig { params(method: T.any(UnboundMethod, Method)).returns(T.untyped) }
+      def signature_of(method)
+        T::Utils.signature_for_method(method)
+      rescue LoadError, StandardError
+        nil
+      end
+
+      sig { params(type: T::Types::Base).returns(String) }
+      def name_of_type(type)
+        type.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
+      end
+
+      sig { params(constant: Module, method: Symbol).returns(Method) }
+      def method_of(constant, method)
+        METHOD_METHOD.bind(constant).call(method)
+      end
+
+      # Returns an array with all classes that are < than the supplied class.
+      #
+      #   class C; end
+      #   descendants_of(C) # => []
+      #
+      #   class B < C; end
+      #   descendants_of(C) # => [B]
+      #
+      #   class A < B; end
+      #   descendants_of(C) # => [B, A]
+      #
+      #   class D < C; end
+      #   descendants_of(C) # => [B, A, D]
+      sig do
+        type_parameters(:U)
+          .params(klass: T.all(Class, T.type_parameter(:U)))
+          .returns(T::Array[T.type_parameter(:U)])
+      end
+      def descendants_of(klass)
+        result = ObjectSpace.each_object(klass.singleton_class).reject do |k|
+          T.cast(k, Module).singleton_class? || T.unsafe(k) == klass
+        end
+
+        T.unsafe(result)
+      end
+    end
+  end
+end

data/lib/tapioca/runtime/trackers/autoload.rb

@@ -0,0 +1,72 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Trackers
+      module Autoload
+        extend T::Sig
+
+        NOOP_METHOD = ->(*_args, **_kwargs, &_block) {}
+
+        @constant_names_registered_for_autoload = T.let([], T::Array[String])
+
+        class << self
+          extend T::Sig
+
+          sig { void }
+          def eager_load_all!
+            with_disabled_exits do
+              until @constant_names_registered_for_autoload.empty?
+                # Grab the next constant name
+                constant_name = T.must(@constant_names_registered_for_autoload.shift)
+                # Trigger autoload by constantizing the registered name
+                Reflection.constantize(constant_name, inherit: true)
+              end
+            end
+          end
+
+          sig { params(constant_name: String).void }
+          def register(constant_name)
+            @constant_names_registered_for_autoload << constant_name
+          end
+
+          sig do
+            type_parameters(:Result)
+              .params(block: T.proc.returns(T.type_parameter(:Result)))
+              .returns(T.type_parameter(:Result))
+          end
+          def with_disabled_exits(&block)
+            original_abort = Kernel.instance_method(:abort)
+            original_exit = Kernel.instance_method(:exit)
+
+            begin
+              Kernel.define_method(:abort, NOOP_METHOD)
+              Kernel.define_method(:exit, NOOP_METHOD)
+
+              block.call
+            ensure
+              Kernel.define_method(:exit, original_exit)
+              Kernel.define_method(:abort, original_abort)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# We need to do the alias-method-chain dance since Bootsnap does the same,
+# and prepended modules and alias-method-chain don't play well together.
+#
+# So, why does Bootsnap do alias-method-chain and not prepend? Glad you asked!
+# That's because RubyGems does alias-method-chain for Kernel#require and such,
+# so, if Bootsnap were to do prepend, it might end up breaking RubyGems.
+class Module
+  alias_method(:autoload_without_tapioca, :autoload)
+
+  def autoload(const_name, path)
+    Tapioca::Runtime::Trackers::Autoload.register("#{self}::#{const_name}")
+    autoload_without_tapioca(const_name, path)
+  end
+end

data/lib/tapioca/runtime/trackers/constant_definition.rb

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+require "set"
+
+module Tapioca
+  module Runtime
+    module Trackers
+      # Registers a TracePoint immediately upon load to track points at which
+      # classes and modules are opened for definition. This is used to track
+      # correspondence between classes/modules and files, as this information isn't
+      # available in the ruby runtime without extra accounting.
+      module ConstantDefinition
+        extend Reflection
+
+        @class_files = {}
+
+        # Immediately activated upon load. Observes class/module definition.
+        TracePoint.trace(:class) do |tp|
+          unless tp.self.singleton_class?
+            key = name_of(tp.self)
+            file = tp.path
+            if file == "(eval)"
+              file = T.must(caller_locations)
+                .drop_while { |loc| loc.path == "(eval)" }
+                .first&.path
+            end
+            @class_files[key] ||= Set.new
+            @class_files[key] << file
+          end
+        end
+
+        # Returns the files in which this class or module was opened. Doesn't know
+        # about situations where the class was opened prior to +require+ing,
+        # or where metaprogramming was used via +eval+, etc.
+        def self.files_for(klass)
+          name = String === klass ? klass : name_of(klass)
+          files = @class_files[name]
+          files || Set.new
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/runtime/trackers/mixin.rb

@@ -0,0 +1,80 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Trackers
+      module Mixin
+        extend T::Sig
+
+        @mixin_map = {}.compare_by_identity
+
+        class Type < T::Enum
+          enums do
+            Prepend = new
+            Include = new
+            Extend = new
+          end
+        end
+
+        sig do
+          params(
+            constant: Module,
+            mod: Module,
+            mixin_type: Type,
+            locations: T.nilable(T::Array[Thread::Backtrace::Location])
+          ).void
+        end
+        def self.register(constant, mod, mixin_type, locations)
+          locations ||= []
+          locations.map!(&:absolute_path).uniq!
+          locs = mixin_locations_for(constant)
+          locs.fetch(mixin_type).store(mod, T.cast(locations, T::Array[String]))
+        end
+
+        sig { params(constant: Module).returns(T::Hash[Type, T::Hash[Module, T::Array[String]]]) }
+        def self.mixin_locations_for(constant)
+          @mixin_map[constant] ||= {
+            Type::Prepend => {}.compare_by_identity,
+            Type::Include => {}.compare_by_identity,
+            Type::Extend => {}.compare_by_identity,
+          }
+        end
+      end
+    end
+  end
+end
+
+class Module
+  prepend(Module.new do
+    def prepend_features(constant)
+      Tapioca::Runtime::Trackers::Mixin.register(
+        constant,
+        self,
+        Tapioca::Runtime::Trackers::Mixin::Type::Prepend,
+        caller_locations
+      )
+      super
+    end
+
+    def append_features(constant)
+      Tapioca::Runtime::Trackers::Mixin.register(
+        constant,
+        self,
+        Tapioca::Runtime::Trackers::Mixin::Type::Include,
+        caller_locations
+      )
+      super
+    end
+
+    def extend_object(obj)
+      Tapioca::Runtime::Trackers::Mixin.register(
+        obj,
+        self,
+        Tapioca::Runtime::Trackers::Mixin::Type::Extend,
+        caller_locations
+      ) if Module === obj
+      super
+    end
+  end)
+end

data/lib/tapioca/runtime/trackers/required_ancestor.rb

@@ -0,0 +1,50 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    module Trackers
+      module RequiredAncestor
+        extend T::Sig
+
+        @required_ancestors_map = {}.compare_by_identity
+
+        sig { params(requiring: T::Helpers, block: T.proc.returns(Module)).void }
+        def self.register(requiring, block)
+          ancestors = @required_ancestors_map[requiring] ||= []
+          ancestors << block
+        end
+
+        sig { params(mod: Module).returns(T::Array[T.proc.returns(Module)]) }
+        def self.required_ancestors_blocks_by(mod)
+          @required_ancestors_map[mod] || []
+        end
+
+        sig { params(mod: Module).returns(T::Array[T.nilable(Module)]) }
+        def self.required_ancestors_by(mod)
+          blocks = required_ancestors_blocks_by(mod)
+          blocks.map do |block|
+            block.call
+          rescue NameError
+            # The ancestor required doesn't exist, let's return nil and let the compiler decide what to do.
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+
+module T
+  module Helpers
+    prepend(Module.new do
+      def requires_ancestor(&block)
+        # We can't directly call the block since the ancestor might not be loaded yet.
+        # We save the block in the map and will resolve it later.
+        Tapioca::Runtime::Trackers::RequiredAncestor.register(self, block)
+
+        super
+      end
+    end)
+  end
+end

data/lib/tapioca/{trackers.rb → runtime/trackers.rb}

@@ -9,6 +9,7 @@
 # catch and filter those mixins as coming from Tapioca, we need
 # the mixin tracker to be in place, before any mixin operations
 # are performed.
-require "tapioca/trackers/mixin"
-require "tapioca/trackers/constant_definition"
-require "tapioca/trackers/autoload"
+require "tapioca/runtime/trackers/mixin"
+require "tapioca/runtime/trackers/constant_definition"
+require "tapioca/runtime/trackers/autoload"
+require "tapioca/runtime/trackers/required_ancestor"