im 0.1.5 → 0.2.0

data/lib/im/module_const_added.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Im::ModuleConstAdded
+  UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
+  private_constant :UNBOUND_METHOD_MODULE_NAME
+
+  # We patch Module#const_added to track every time a constant is added to a
+  # permanently-named module pointing to an Im-autoloaded constant. This is
+  # important because the moment that an Im-autoloaded constant is attached to
+  # a permanently named module, its name changes permanently. Although Im
+  # internally avoids the use of absolute cpaths, ExplicitNamespace must use
+  # them and thus we need to update its internal registry accordingly.
+  #
+  # @sig (Symbol) -> void
+  def const_added(const_name)
+    # If we are called from an autoload, no need to track.
+    return super if autoload?(const_name)
+
+    # Get the name of this module and only continue if it is a permanent name.
+    return unless cpath = Im.permanent_cpath(self)
+
+    # We know this is not an autoloaded constant, so it is safe to fetch the
+    # value. We fetch the value, get it's object_id, and check the registry to
+    # see if it is an Im-autoloaded module.
+    relative_cpath, loader, references = Im::Registry.autoloaded_modules[const_get(const_name).object_id]
+    return super unless loader
+
+    # Update the context for this const add. This is important for reloading so
+    # we can reset inbound references when the autoloaded module is unloaded.
+    references << [self, const_name]
+
+    # Update all absolute cpath references to this module by replacing all
+    # references to the original cpath with the new, permanently-named cpath.
+    #
+    # For example, if we had a module loader::Foo::Bar, and loader::Foo was
+    # assigned to Baz like this:
+    #
+    #   Baz = loader::Foo
+    #
+    # then we must update cpaths from a string like
+    #
+    #   "#<Im::Loader ...>::Foo::Bar"
+    #
+    # to
+    #
+    #   "Baz::Bar"
+    #
+    # To do this, we take the loader's module_prefix ("#<Im::Loader ...>::"),
+    # append to it the relative cpath of the constant ("Foo") and replace that by the new
+    # name ("Baz"), roughly like this:
+    #
+    #   "#<Im::Loader ...>::Foo::Bar".gsub(/^#{"#<Im::Loader ...>::Foo"}/, "Baz")
+    #
+    prefix = relative_cpath ? "#{loader.module_prefix}#{relative_cpath}" : loader.module_prefix.delete_suffix("::")
+    ::Im::ExplicitNamespace.__update_cpaths(prefix, "#{cpath}::#{const_name}")
+
+    super
+  rescue NameError
+    super
+  end
+end
+
+::Module.prepend(Im::ModuleConstAdded)

data/lib/im/registry.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Im
+  module Registry # :nodoc: all
+    class << self
+      # Keeps track of all loaders. Useful to broadcast messages and to prevent
+      # them from being garbage collected.
+      #
+      # @private
+      # @sig Array[Im::Loader]
+      attr_reader :loaders
+
+      # Registers gem loaders to let `for_gem` be idempotent in case of reload.
+      #
+      # @private
+      # @sig Hash[String, Im::Loader]
+      attr_reader :gem_loaders_by_root_file
+
+      # Maps absolute paths to the loaders responsible for them.
+      #
+      # This information is used by our decorated `Kernel#require` to be able to
+      # invoke callbacks and autovivify modules.
+      #
+      # @private
+      # @sig Hash[String, Im::Loader]
+      attr_reader :autoloads
+
+      # @private
+      # @sig Hash[String, Im::Loader]
+      attr_reader :paths
+
+      # This hash table addresses an edge case in which an autoload is ignored.
+      #
+      # For example, let's suppose we want to autoload in a gem like this:
+      #
+      #   # lib/my_gem.rb
+      #   loader = Im::Loader.new
+      #   loader.push_dir(__dir__)
+      #   loader.setup
+      #
+      #   module loader::MyGem
+      #   end
+      #
+      # if you require "my_gem", as Bundler would do, this happens while setting
+      # up autoloads:
+      #
+      #   1. Object.autoload?(:MyGem) returns `nil` because the autoload for
+      #      the constant is issued by Im while the same file is being
+      #      required.
+      #   2. The constant `MyGem` is undefined while setup runs.
+      #
+      # Therefore, a directory `lib/my_gem` would autovivify a module according to
+      # the existing information. But that would be wrong.
+      #
+      # To overcome this fundamental limitation, we keep track of the constant
+      # paths that are in this situation ---in the example above, "MyGem"--- and
+      # take this collection into account for the autovivification logic.
+      #
+      # Note that you cannot generally address this by moving the setup code
+      # below the constant definition, because we want libraries to be able to
+      # use managed constants in the module body:
+      #
+      #   module loader::MyGem
+      #     include MyConcern
+      #   end
+      #
+      # @private
+      # @sig Hash[String, [String, Im::Loader]]
+      attr_reader :inceptions
+
+      # @private
+      # @sig Hash[Integer, [Im::Loader, String, Array]]
+      attr_reader :autoloaded_modules
+
+      # Registers a loader.
+      #
+      # @private
+      # @sig (Im::Loader) -> void
+      def register_loader(loader)
+        loaders << loader
+      end
+
+      # @private
+      # @sig (Im::Loader) -> void
+      def unregister_loader(loader)
+        loaders.delete(loader)
+        gem_loaders_by_root_file.delete_if { |_, l| l == loader }
+        autoloads.delete_if { |_, l| l == loader }
+        paths.delete_if { |_, l| l == loader }
+        inceptions.delete_if { |_, (_, l)| l == loader }
+        autoloaded_modules.delete_if { |_, (_, l, _)| l == loader }
+      end
+
+      # This method returns always a loader, the same instance for the same root
+      # file. That is how Im::Loader.for_gem is idempotent.
+      #
+      # @private
+      # @sig (String) -> Im::Loader
+      def loader_for_gem(root_file, warn_on_extra_files:)
+        gem_loaders_by_root_file[root_file] ||= GemLoader._new(root_file, warn_on_extra_files: warn_on_extra_files)
+      end
+
+      # @private
+      # @sig (Im::Loader, String) -> String
+      def register_autoload(loader, abspath)
+        paths[abspath] = autoloads[abspath] = loader
+      end
+
+      # @private
+      # @sig (String) -> void
+      def unregister_autoload(abspath)
+        autoloads.delete(abspath)
+      end
+
+      # @private
+      # @sig (Im::Loader, String) -> String
+      def register_path(loader, abspath)
+        paths[abspath] = loader
+      end
+
+      # @private
+      # @sig (String) -> void
+      def unregister_path(abspath)
+        paths.delete(abspath)
+      end
+
+      # @private
+      # @sig (String, String, Im::Loader) -> void
+      def register_inception(cpath, abspath, loader)
+        inceptions[cpath] = [abspath, loader]
+      end
+
+      # @private
+      # @sig (String) -> String?
+      def inception?(cpath)
+        if pair = inceptions[cpath]
+          pair.first
+        end
+      end
+
+      def register_autoloaded_module(mod, module_name, loader)
+        autoloaded_modules[mod.object_id] = [module_name, loader, []]
+      end
+
+      # @private
+      # @sig (String) -> Im::Loader?
+      def loader_for(path)
+        paths[path]
+      end
+
+      # @private
+      # @sig (Im::Loader) -> void
+      def on_unload(loader)
+        autoloads.delete_if { |_path, object| object == loader }
+        inceptions.delete_if { |_cpath, (_path, object)| object == loader }
+      end
+    end
+
+    @loaders                  = []
+    @gem_loaders_by_root_file = {}
+    @autoloads                = {}
+    @paths                    = {}
+    @inceptions               = {}
+    @autoloaded_modules       = {}
+  end
+end

data/lib/im/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Im
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

data/lib/im.rb

@@ -1,180 +1,26 @@
 # frozen_string_literal: true
 
 module Im
-  load $LOAD_PATH.resolve_feature_path("im/ruby_version_check")[1], true
-
-  @constants = Object.constants.reject { |c| Kernel.autoload?(c) }.dup
-  @autoloads = {}
-  @registry = {}
-
-  require "im/version"
-  require "im/kernel"
-
-  class << self
-    attr_reader :current_import, :registry, :autoloads, :constants
-
-    def with_import(import)
-      original_import = current_import
-      @current_import = import || Im.current_import
-
-      unless tracer_originally_enabled = @tracer.enabled?
-        @tracer.enable
-      end
-
-      yield(import)
-
-    ensure
-      @current_import = original_import
-      @tracer.disable unless tracer_originally_enabled
-    end
-
-    def importing?
-      !!Im.current_import
-    end
-
-    def handle_require(path, caller_path)
-      resolved_path = resolve_path(path)
-
-      return yield unless resolved_path
-
-      if autoloaded = autoloads.delete(resolved_path)
-        return with_import(autoloaded) do |_import|
-          !!import(path)
-        end
-      end
-
-      if importing?
-        registry[resolved_path] ||= Require.new(resolved_path, current_import)
-      elsif registry.key?(caller_path)
-        return with_import(registry[caller_path].import) do |_import|
-          !!import(resolved_path)
-        end
-      end
-
-      loaded = yield # super
-
-      if required = registry[resolved_path]
-        if loaded && registry.key?(caller_path)
-          registry[caller_path].requires << required
-        end
-
-        required.requires.each { |r| require r.path }
-        import = current_import || Object
-
-        required.modules.each do |m|
-          name = m.name
-
-          # Do not assign constants that are aliased to root namespace
-          root = name.split("::", 2)[0]
-          next if Object.const_defined?(root) &&
-            import.const_defined?(root, false) &&
-            Object.const_get(root) == import.const_get(root)
-
-          begin
-            import.const_set(name, m) unless import.const_defined?(name, false)
-          rescue NameError
-          end
-        end
-      end
-
-      loaded
-    end
-
-    def handle_autoload(path)
-      if resolved_path = resolve_path(path)
-        Im.autoloads[resolved_path] = Im.current_import
-      end
-      yield
-    end
-
-    def resolve_path(path)
-      (resolved = $LOAD_PATH.resolve_feature_path(path)) && resolved[1]
-    end
-  end
-
-  class Import < Module
-    def initialize(root)
-      @root = root
-      super()
-      Im.with_import(self) do
-        Im.constants.each do |const|
-          self.const_set(const, Object.const_get(const))
-        end
-      end
-    end
-
-    def inspect
-      @inspect ||= "<#Im::Import root: #{@root}>"
-    end
-  end
-
-  Require = Struct.new(:path, :import, :modules, :requires) do
-    def initialize(path, import, modules = [], requires = [])
-      super(path, import, modules, requires)
-    end
-  end
-
+  require_relative "im/const_path"
+  require_relative "im/internal"
+  require_relative "im/loader"
+  require_relative "im/gem_loader"
+  require_relative "im/registry"
+  require_relative "im/explicit_namespace"
+  require_relative "im/module_const_added"
+  require_relative "im/inflector"
+  require_relative "im/gem_inflector"
+  require_relative "im/kernel"
+  require_relative "im/error"
+  require_relative "im/version"
+
+  extend Im::ConstPath
+
+  # @sig (String) -> Im::Loader?
   def import(path)
-    if resolved = $LOAD_PATH.resolve_feature_path(path)
-      resolved_path = resolved[1]
-      raise LoadError, "import can only import ruby files" unless resolved[0] == :rb
-    else
-      raise LoadError, "cannot load such file -- #{path}"
-    end
-
-    Im.registry.fetch(resolved_path) do
-      # handle autoload within import
-      return nil if $LOADED_FEATURES.include?(resolved_path)
-
-      $LOADED_FEATURES << resolved_path
-
-      import = Im.current_import || Import.new(path)
-      (Im.registry[resolved_path] ||= Require.new(resolved_path, import)).tap do
-        Im.with_import(import) do
-          load resolved_path, import
-        end
-      end
-    end&.import
+    _, feature_path = $:.resolve_feature_path(path)
+    Registry.loader_for(feature_path) if feature_path
   end
 
-  # This is a hack to catch references to top-level constants (`::Foo`) and, if
-  # the calling line is a key in the Im registry, replace the toplevel constant
-  # reference with its corresponding constant under the import namespace.
-  #
-  # By doing this, a reference to `::Foo` in an imported file will resolve to
-  # `mod::Foo`, where `mod` is the import module. Ideally this should
-  # ultimately happen at the Ruby implementation level.
-  module RootNamespaceRedirect
-    def const_missing(name)
-
-      # Take top five locations to allow for other `const_missing` overrides
-      # in the backtrace. If there are more than five, then this will no longer
-      # work. This is currently very inefficient.
-      if location = caller_locations(1, 5).find { |l| Im.registry.key?(l.path) }
-        Im.registry[location.path].import.const_get(name)
-      else
-        super
-      end
-    end
-  end
-
-  @tracer = TracePoint.new(:class) do |event|
-    next unless (name = event.self.name)
-    next if Im.constants.include?(name.to_sym)
-
-    if resolved = $LOAD_PATH.resolve_feature_path(event.path)
-      resolved_path = resolved[1]
-      if Im.registry.key?(resolved_path)
-        (Im.registry[resolved_path].modules << event.self).uniq!
-      else
-        Im.registry[resolved_path] = Require.new(resolved_path, Im.current_import, [event.self])
-      end
-    end
-  end
-
-  require "im/module"
-
   extend self
 end
-
-Object.extend Im::RootNamespaceRedirect

metadata

@@ -1,84 +1,48 @@
 --- !ruby/object:Gem::Specification
 name: im
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Salzberg
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2022-09-22 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-description: Import code without side-effects.
-email:
-- chris@dejimata.com
+date: 2023-01-28 00:00:00.000000000 Z
+dependencies: []
+description: "    Im is a thread-safe code loader for anonymous-rooted namespaces.\n"
+email: chris@dejimata.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
-- Gemfile
-- Gemfile.lock
-- LICENSE.txt
+- MIT-LICENSE
 - README.md
-- Rakefile
 - lib/im.rb
+- lib/im/const_path.rb
+- lib/im/error.rb
+- lib/im/explicit_namespace.rb
+- lib/im/gem_inflector.rb
+- lib/im/gem_loader.rb
+- lib/im/inflector.rb
+- lib/im/internal.rb
 - lib/im/kernel.rb
-- lib/im/module.rb
-- lib/im/ruby_version_check.rb
+- lib/im/loader.rb
+- lib/im/loader/callbacks.rb
+- lib/im/loader/config.rb
+- lib/im/loader/eager_load.rb
+- lib/im/loader/helpers.rb
+- lib/im/module_const_added.rb
+- lib/im/registry.rb
 - lib/im/version.rb
 homepage: https://github.com/shioyama/im
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/shioyama/im
+  changelog_uri: https://github.com/shioyama/im/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/shioyama/im
   bug_tracker_uri: https://github.com/shioyama/im/issues
-  changelog_uri: https://github.com/shioyama/im/CHANGELOG.md
-  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -87,7 +51,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -97,5 +61,5 @@ requirements: []
 rubygems_version: 3.4.0.dev
 signing_key:
 specification_version: 4
-summary: Module import system.
+summary: Multiverse autoloader
 test_files: []

data/CHANGELOG.md

@@ -1,28 +0,0 @@
-## [Unreleased]
-
-## [0.1.5] - 2022-09-22
-- Rename Im::Dependency -> Im::Require
-- Handle dynamic requires (require called from method body after file has been imported)
-- Refactor: move require/autoload patch logic to Im handler methods
-
-
-## [0.1.4] - 2022-09-19
-- Correctly assign constants imported via recursive requires
-
-## [0.1.3] - 2022-09-16
-- Fix gemspec
-
-## [0.1.1] - 2022-09-16
-
-- Fix TracePoint event
-- Simplify import inspect
-- Remove unnecessary Kernel#autoload patch
-- Encode comprehensive list of top-level constants
-
-## [0.1.0] - 2022-09-15
-
-- Initial release, requires patched version of Ruby.
-
-## [0.0.1] - 2022-07-13
-
-- Stub

data/Gemfile

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in im.gemspec
-gemspec
-
-gem "rspec", "~> 3.0"
-gem "rails"
-gem "sqlite3"