Module: Zeitwerk::Loader::Callbacks

Includes:
RealModName
Included in:
Zeitwerk::Loader
Defined in:
lib/zeitwerk/loader/callbacks.rb

Instance Method Summary collapse

Methods included from RealModName

#real_mod_name

Instance Method Details

#on_dir_autoloaded(dir) ⇒ Object

Invoked from our decorated Kernel#require when a managed directory is autoloaded.



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/zeitwerk/loader/callbacks.rb', line 34

def on_dir_autoloaded(dir)
  # Module#autoload does not serialize concurrent requires, and we handle
  # directories ourselves, so the callback needs to account for concurrency.
  #
  # Multi-threading would introduce a race condition here in which thread t1
  # autovivifies the module, and while autoloads for its children are being
  # set, thread t2 autoloads the same namespace.
  #
  # Without the mutex and subsequent delete call, t2 would reset the module.
  # That not only would reassign the constant (undesirable per se) but, worse,
  # the module object created by t2 wouldn't have any of the autoloads for its
  # children, since t1 would have correctly deleted its lazy_subdirs entry.
  mutex2.synchronize do
    if cref = autoloads.delete(dir)
      autovivified_module = cref[0].const_set(cref[1], Module.new)
      cpath = autovivified_module.name
      log("module #{cpath} autovivified from directory #{dir}") if logger

      to_unload[cpath] = [dir, cref] if reloading_enabled?

      # We don't unregister `dir` in the registry because concurrent threads
      # wouldn't find a loader associated to it in Kernel#require and would
      # try to require the directory. Instead, we are going to keep track of
      # these to be able to unregister later if eager loading.
      autoloaded_dirs << dir

      on_namespace_loaded(autovivified_module)

      run_on_load_callbacks(cpath, autovivified_module, dir) unless on_load_callbacks.empty?
    end
  end
end

#on_file_autoloaded(file) ⇒ Object

Invoked from our decorated Kernel#require when a managed file is autoloaded.



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/zeitwerk/loader/callbacks.rb', line 10

def on_file_autoloaded(file)
  cref  = autoloads.delete(file)
  cpath = cpath(*cref)

  # If reloading is enabled, we need to put this constant for unloading
  # regardless of what cdef? says. In Ruby < 3.1 the internal state is not
  # fully cleared. Module#constants still includes it, and you need to
  # remove_const. See https://github.com/ruby/ruby/pull/4715.
  to_unload[cpath] = [file, cref] if reloading_enabled?
  Zeitwerk::Registry.unregister_autoload(file)

  if cdef?(*cref)
    log("constant #{cpath} loaded from file #{file}") if logger
    run_on_load_callbacks(cpath, cget(*cref), file) unless on_load_callbacks.empty?
  else
    raise Zeitwerk::NameError.new("expected file #{file} to define constant #{cpath}, but didn't", cref.last)
  end
end

#on_namespace_loaded(namespace) ⇒ Object

Invoked when a class or module is created or reopened, either from the tracer or from module autovivification. If the namespace has matching subdirectories, we descend into them now.



73
74
75
76
77
78
79
 
# File 'lib/zeitwerk/loader/callbacks.rb', line 73

def on_namespace_loaded(namespace)
  if subdirs = lazy_subdirs.delete(real_mod_name(namespace))
    subdirs.each do |subdir|
      set_autoloads_in_dir(subdir, namespace)
    end
  end
end