tapioca 0.6.1 → 0.7.0

data/lib/tapioca/reflection.rb

@@ -1,151 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  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::Private::Methods.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 { type_parameters(:U).params(klass: T.type_parameter(:U)).returns(T::Array[T.type_parameter(:U)]) }
-    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

data/lib/tapioca/trackers/autoload.rb

@@ -1,70 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Tapioca
-  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
-
-# 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::Trackers::Autoload.register("#{self}::#{const_name}")
-    autoload_without_tapioca(const_name, path)
-  end
-end

data/lib/tapioca/trackers/constant_definition.rb

@@ -1,42 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "set"
-
-module Tapioca
-  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

data/lib/tapioca/trackers/mixin.rb

@@ -1,78 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Tapioca
-  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
-
-class Module
-  prepend(Module.new do
-    def prepend_features(constant)
-      Tapioca::Trackers::Mixin.register(
-        constant,
-        self,
-        Tapioca::Trackers::Mixin::Type::Prepend,
-        caller_locations
-      )
-      super
-    end
-
-    def append_features(constant)
-      Tapioca::Trackers::Mixin.register(
-        constant,
-        self,
-        Tapioca::Trackers::Mixin::Type::Include,
-        caller_locations
-      )
-      super
-    end
-
-    def extend_object(obj)
-      Tapioca::Trackers::Mixin.register(
-        obj,
-        self,
-        Tapioca::Trackers::Mixin::Type::Extend,
-        caller_locations
-      ) if Module === obj
-      super
-    end
-  end)
-end