im 0.1.6 → 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.6"
+  VERSION = "0.2.0"
 end

data/lib/im.rb

@@ -1,193 +1,26 @@
 # frozen_string_literal: true
 
 module Im
-  load $:.resolve_feature_path("im/ruby_version_check")[1], true
-
-  @toplevel_constants = Object.constants.reject { |c| Object.autoload?(c) }
-  @autoloads = {}
-  @registry = {}
-  @current_imports = []
-
-  require "im/version"
-  require "im/kernel"
-
-  class << self
-    attr_reader :current_imports, :registry, :autoloads, :toplevel_constants
-
-    def with_import(import)
-      @current_imports.push(import || current_import)
-
-      unless tracer_originally_enabled = @tracer.enabled?
-        @tracer.enable
-      end
-
-      yield
-    ensure
-      @current_imports.pop
-      @tracer.disable unless tracer_originally_enabled
-    end
-
-    def current_import
-      current_imports.last
-    end
-
-    def importing?
-      !!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(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(resolved_path)
-        end
-      end
-
-      loaded = yield # super
-
-      if required = registry[resolved_path]
-        if loaded && registry.key?(caller_path)
-          registry[caller_path].requires << required
-        end
-
-        imports = importing? ? current_imports : [Object]
-        import_constants(required, imports)
-      end
-
-      loaded
-    end
-
-    def handle_autoload(path)
-      if importing? && (resolved_path = resolve_path(path))
-        autoloads[resolved_path] = current_import
-      end
-      yield
-    end
-
-    def resolve_path(path)
-      (resolved = $:.resolve_feature_path(path)) && resolved[1]
-    end
-
-    def import_constants(required, imports)
-      return if imports.empty? || required.nil?
-
-      required.requires.each { |r| require r.path }
-
-      imports.each do |import|
-        required.defined_constants.each do |name, mod|
-          # Do not assign constants that are aliased to root namespace
-          root = name.to_s.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, mod) unless import.const_defined?(name, false)
-          rescue NameError
-          end
-        end
-      end
-    end
-  end
-
-  class Import < Module
-    def initialize(root)
-      @root = root
-      super()
-      Im.with_import(self) do
-        Im.toplevel_constants.each do |const|
-          self.const_set(const, Object.const_get(const))
-        end
-      end
-    end
-
-    def inspect
-      @inspect ||= "<#Im::Import root: #{@root}>"
-    end
-
-    def const_added(name)
-      path = const_source_location(name)[0]
-      value = const_get(name, false)
-      Im.registry[path] ||= Require.new(path, self)
-      Im.registry[path].defined_constants[name] ||= value
-      super
-    end
-  end
-
-  Require = Struct.new(:path, :import, :defined_constants, :requires) do
-    def initialize(path, import, defined_constants = {}, requires = [])
-      super
-    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 = $:.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
-
-    required = 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
-
-    Im.import_constants(required, Im.current_imports)
-
-    required&.import
+    _, feature_path = $:.resolve_feature_path(path)
+    Registry.loader_for(feature_path) if feature_path
   end
 
-  @tracer = TracePoint.new(:class) do |event|
-    next unless (name = event.self.name&.to_sym)
-    next if Im.toplevel_constants.include?(name)
-
-    # We don't want to track classes defined under singleton classes, like
-    # this:
-    #
-    #   class Foo
-    #     class << self
-    #       class Bar
-    #       end
-    #     end
-    #   end
-    #
-    # Here, `class Bar` will trigger a TracePoint event, and because of the
-    # Ruby patch `name` will return "Bar", but this is not actually a class we
-    # need to alias in imports, so we can safely skip it. The only way I've
-    # found to do that though is to evaluate `Module.nesting` from the event's
-    # binding. This is weird, but it works!
-    #
-    next if event.binding.eval("Module.nesting").any?(&:singleton_class?)
-
-    if resolved = $:.resolve_feature_path(event.path)
-      resolved_path = resolved[1]
-      Im.registry[resolved_path] ||= Require.new(resolved_path, Im.current_import)
-      Im.registry[resolved_path].defined_constants[name] = event.self
-    end
-  end
-
-  require "im/module"
-
   extend self
 end

metadata

@@ -1,84 +1,48 @@
 --- !ruby/object:Gem::Specification
 name: im
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Salzberg
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2022-10-03 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,15 +51,15 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.0.dev
 signing_key:
 specification_version: 4
-summary: Module import system.
+summary: Multiverse autoloader
 test_files: []

data/CHANGELOG.md

@@ -1,31 +0,0 @@
-## [Unreleased]
-
-## [0.1.6] - 2022-10-03
-- Remove `Object.const_missing` patch (Ruby patch now handles dynamic toplevel
-  references)
-
-## [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,8 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in im.gemspec
-gemspec
-
-gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -1,37 +0,0 @@
-PATH
-  remote: .
-  specs:
-    im (0.1.6)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    diff-lcs (1.5.0)
-    rake (13.0.6)
-    rake-compiler (1.2.0)
-      rake
-    rspec (3.11.0)
-      rspec-core (~> 3.11.0)
-      rspec-expectations (~> 3.11.0)
-      rspec-mocks (~> 3.11.0)
-    rspec-core (3.11.0)
-      rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-mocks (3.11.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-support (3.11.0)
-
-PLATFORMS
-  x86_64-linux
-
-DEPENDENCIES
-  im!
-  rake (~> 13.0)
-  rake-compiler
-  rspec (~> 3.0)
-
-BUNDLED WITH
-   2.3.18

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2022 Chris Salzberg
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/Rakefile

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec

data/lib/im/module.rb

@@ -1,9 +0,0 @@
-class Module
-  alias_method :im_original_autoload, :autoload
-
-  def autoload(name, path)
-    Im.handle_autoload(path) do
-      im_original_autoload(name, path)
-    end
-  end
-end