Module: ActiveSupport::Dependencies

Extended by:
Dependencies
Included in:
Dependencies
Defined in:
activesupport/lib/active_support/dependencies.rb

Overview

:nodoc:

Defined Under Namespace

Modules: Blamable, Loadable, ModuleConstMissing Classes: LoadingModule, Reference, WatchStack

Instance Method Summary (collapse)

Instance Method Details

- (Object) associate_with(file_name)



310
311
312
# File 'activesupport/lib/active_support/dependencies.rb', line 310

def associate_with(file_name)
  depend_on(file_name, true)
end

- (Object) autoload_module!(into, const_name, qualified_name, path_suffix)

Attempt to autoload the provided module name by searching for a directory matching the expect path suffix. If found, the module is created and assigned to into's constants with the name const_name. Provided that the directory was loaded from a reloadable base path, it is added to the set of constants that are to be unloaded.



431
432
433
434
435
436
437
# File 'activesupport/lib/active_support/dependencies.rb', line 431

def autoload_module!(into, const_name, qualified_name, path_suffix)
  return nil unless base_path = autoloadable_module?(path_suffix)
  mod = Module.new
  into.const_set const_name, mod
  autoloaded_constants << qualified_name unless autoload_once_paths.include?(base_path)
  return mod
end

- (Boolean) autoloadable_module?(path_suffix)

Does the provided path_suffix correspond to an autoloadable module? Instead of returning a boolean, the autoload base for this module is returned.



415
416
417
418
419
420
# File 'activesupport/lib/active_support/dependencies.rb', line 415

def autoloadable_module?(path_suffix)
  autoload_paths.each do |load_path|
    return load_path if File.directory? File.join(load_path, path_suffix)
  end
  nil
end

- (Boolean) autoloaded?(desc)

Determine if the given constant has been automatically loaded.



550
551
552
553
554
555
556
# File 'activesupport/lib/active_support/dependencies.rb', line 550

def autoloaded?(desc)
  # No name => anonymous module.
  return false if desc.is_a?(Module) && desc.anonymous?
  name = to_constant_name desc
  return false unless qualified_const_defined? name
  return autoloaded_constants.include?(name)
end

- (Object) clear



314
315
316
317
318
# File 'activesupport/lib/active_support/dependencies.rb', line 314

def clear
  log_call
  loaded.clear
  remove_unloadable_constants!
end

- (Object) constantize(name)



545
546
547
# File 'activesupport/lib/active_support/dependencies.rb', line 545

def constantize(name)
  ref(name).get
end

- (Object) depend_on(file_name, swallow_load_errors = false, message = "No such file to load -- %s.rb")



298
299
300
301
302
303
304
305
306
307
308
# File 'activesupport/lib/active_support/dependencies.rb', line 298

def depend_on(file_name, swallow_load_errors = false, message = "No such file to load -- %s.rb")
  path = search_for_file(file_name)
  require_or_load(path || file_name)
rescue LoadError => load_error
  unless swallow_load_errors
    if file_name = load_error.message[/ -- (.*?)(\.rb)?$/, 1]
      raise LoadError.new(message % file_name).copy_blame!(load_error)
    end
    raise
  end
end

- (Object) hook!



281
282
283
284
285
286
# File 'activesupport/lib/active_support/dependencies.rb', line 281

def hook!
  Object.class_eval { include Loadable }
  Module.class_eval { include ModuleConstMissing }
  Exception.class_eval { include Blamable }
  true
end

- (Boolean) load?



294
295
296
# File 'activesupport/lib/active_support/dependencies.rb', line 294

def load?
  mechanism == :load
end

- (Object) load_file(path, const_paths = loadable_constants_for_path(path))

Load the file at the provided path. const_paths is a set of qualified constant names. When loading the file, Dependencies will watch for the addition of these constants. Each that is defined will be marked as autoloaded, and will be removed when Dependencies.clear is next called.

If the second parameter is left off, then Dependencies will construct a set of names that the file at path may define. See loadable_constants_for_path for more details.



447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
# File 'activesupport/lib/active_support/dependencies.rb', line 447

def load_file(path, const_paths = loadable_constants_for_path(path))
  log_call path, const_paths
  const_paths = [const_paths].compact unless const_paths.is_a? Array
  parent_paths = const_paths.collect { |const_path| /(.*)::[^:]+\Z/ =~ const_path ? $1 : :Object }

  result = nil
  newly_defined_paths = new_constants_in(*parent_paths) do
    result = Kernel.load path
  end

  autoloaded_constants.concat newly_defined_paths unless load_once_path?(path)
  autoloaded_constants.uniq!
  log "loading #{path} defined #{newly_defined_paths * ', '}" unless newly_defined_paths.empty?
  return result
end

- (Object) load_missing_constant(from_mod, const_name)

Load the constant named const_name which is missing from from_mod. If it is not possible to load the constant into from_mod, try its parent module using const_missing.

Raises:

  • (ArgumentError)


472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
# File 'activesupport/lib/active_support/dependencies.rb', line 472

def load_missing_constant(from_mod, const_name)
  log_call from_mod, const_name

  unless qualified_const_defined?(from_mod.name) && Inflector.constantize(from_mod.name).equal?(from_mod)
    raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
  end

  raise ArgumentError, "#{from_mod} is not missing constant #{const_name}!" if local_const_defined?(from_mod, const_name)

  qualified_name = qualified_name_for from_mod, const_name
  path_suffix = qualified_name.underscore

  trace = caller.reject {|l| l =~ %r{#{Regexp.escape(__FILE__)}}}
  name_error = NameError.new("uninitialized constant #{qualified_name}")
  name_error.set_backtrace(trace)

  file_path = search_for_file(path_suffix)

  if file_path && ! loaded.include?(File.expand_path(file_path)) # We found a matching file to load
    require_or_load file_path
    raise LoadError, "Expected #{file_path} to define #{qualified_name}" unless local_const_defined?(from_mod, const_name)
    return from_mod.const_get(const_name)
  elsif mod = autoload_module!(from_mod, const_name, qualified_name, path_suffix)
    return mod
  elsif (parent = from_mod.parent) && parent != from_mod &&
        ! from_mod.parents.any? { |p| local_const_defined?(p, const_name) }
    # If our parents do not have a constant named +const_name+ then we are free
    # to attempt to load upwards. If they do have such a constant, then this
    # const_missing must be due to from_mod::const_name, which should not
    # return constants from from_mod's parents.
    begin
      return parent.const_missing(const_name)
    rescue NameError => e
      raise unless e.missing_name? qualified_name_for(parent, const_name)
      raise name_error
    end
  else
    raise name_error
  end
end

- (Boolean) load_once_path?(path)



422
423
424
# File 'activesupport/lib/active_support/dependencies.rb', line 422

def load_once_path?(path)
  autoload_once_paths.any? { |base| path.starts_with? base }
end

- (Object) loadable_constants_for_path(path, bases = autoload_paths)

Given path, a filesystem path to a ruby file, return an array of constant paths which would cause Dependencies to attempt to load this file.



382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
# File 'activesupport/lib/active_support/dependencies.rb', line 382

def loadable_constants_for_path(path, bases = autoload_paths)
  path = $1 if path =~ /\A(.*)\.rb\Z/
  expanded_path = File.expand_path(path)
  paths = []

  bases.each do |root|
    expanded_root = File.expand_path(root)
    next unless %r{\A#{Regexp.escape(expanded_root)}(/|\\)} =~ expanded_path

    nesting = expanded_path[(expanded_root.size)..-1]
    nesting = nesting[1..-1] if nesting && nesting[0] == ?/
    next if nesting.blank?

    paths << nesting.camelize
  end

  paths.uniq!
  paths
end

- (Boolean) local_const_defined?(mod, const)

:nodoc:



371
372
373
# File 'activesupport/lib/active_support/dependencies.rb', line 371

def local_const_defined?(mod, const)
  mod.const_defined?(const)
end

- (Object) mark_for_unload(const_desc)

Mark the provided constant name for unloading. This constant will be unloaded on each request, not just the next one.



566
567
568
569
570
571
572
573
574
# File 'activesupport/lib/active_support/dependencies.rb', line 566

def mark_for_unload(const_desc)
  name = to_constant_name const_desc
  if explicitly_unloadable_constants.include? name
    return false
  else
    explicitly_unloadable_constants << name
    return true
  end
end

- (Object) new_constants_in(*descs)

Run the provided block and detect the new constants that were loaded during its execution. Constants may only be regarded as 'new' once – so if the block calls new_constants_in again, then the constants defined within the inner call will not be reported in this one.

If the provided block does not run to completion, and instead raises an exception, any new constants are regarded as being only partially defined and will be removed immediately.



584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
# File 'activesupport/lib/active_support/dependencies.rb', line 584

def new_constants_in(*descs)
  log_call(*descs)

  constant_watch_stack.watch_namespaces(descs)
  aborting = true

  begin
    yield # Now yield to the code that is to define new constants.
    aborting = false
  ensure
    new_constants = constant_watch_stack.new_constants

    log "New constants: #{new_constants * ', '}"
    return new_constants unless aborting

    log "Error during loading, removing partially loaded constants "
    new_constants.each {|c| remove_constant(c) }.clear
  end

  return []
end

- (Boolean) qualified_const_defined?(path)

Is the provided constant path defined?



359
360
361
362
363
364
365
366
# File 'activesupport/lib/active_support/dependencies.rb', line 359

def qualified_const_defined?(path)
  names = path.sub(/^::/, '').to_s.split('::')

  names.inject(Object) do |mod, name|
    return false unless local_const_defined?(mod, name)
    mod.const_get name
  end
end

- (Object) qualified_name_for(mod, name)

Return the constant path for the provided parent and constant name.



464
465
466
467
# File 'activesupport/lib/active_support/dependencies.rb', line 464

def qualified_name_for(mod, name)
  mod_name = to_constant_name mod
  mod_name == "Object" ? name.to_s : "#{mod_name}::#{name}"
end

- (Object) ref(name)



541
542
543
# File 'activesupport/lib/active_support/dependencies.rb', line 541

def ref(name)
  references[name] ||= Reference.new(name)
end

- (Object) remove_constant(const)

:nodoc:



630
631
632
633
634
635
636
637
638
639
640
641
642
# File 'activesupport/lib/active_support/dependencies.rb', line 630

def remove_constant(const) #:nodoc:
  return false unless qualified_const_defined? const

  # Normalize ::Foo, Foo, Object::Foo, and ::Object::Foo to Object::Foo
  names = const.to_s.sub(/^::(Object)?/, 'Object::').split("::")
  to_remove = names.pop
  parent = Inflector.constantize(names * '::')

  log "removing constant #{const}"
  parent.instance_eval { remove_const to_remove }

  return true
end

- (Object) remove_unloadable_constants!

Remove the constants that have been autoloaded, and those that have been marked for unloading.



515
516
517
518
519
520
# File 'activesupport/lib/active_support/dependencies.rb', line 515

def remove_unloadable_constants!
  autoloaded_constants.each { |const| remove_constant const }
  autoloaded_constants.clear
  Reference.clear!
  explicitly_unloadable_constants.each { |const| remove_constant const }
end

- (Object) require_or_load(file_name, const_path = nil)



320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
# File 'activesupport/lib/active_support/dependencies.rb', line 320

def require_or_load(file_name, const_path = nil)
  log_call file_name, const_path
  file_name = $1 if file_name =~ /^(.*)\.rb$/
  expanded = File.expand_path(file_name)
  return if loaded.include?(expanded)

  # Record that we've seen this file *before* loading it to avoid an
  # infinite loop with mutual dependencies.
  loaded << expanded

  begin
    if load?
      log "loading #{file_name}"

      # Enable warnings iff this file has not been loaded before and
      # warnings_on_first_load is set.
      load_args = ["#{file_name}.rb"]
      load_args << const_path unless const_path.nil?

      if !warnings_on_first_load or history.include?(expanded)
        result = load_file(*load_args)
      else
        enable_warnings { result = load_file(*load_args) }
      end
    else
      log "requiring #{file_name}"
      result = require file_name
    end
  rescue Exception
    loaded.delete expanded
    raise
  end

  # Record history *after* loading so first load gets warnings.
  history << expanded
  return result
end

- (Object) search_for_file(path_suffix)

Search for a file in autoload_paths matching the provided suffix.



403
404
405
406
407
408
409
410
411
# File 'activesupport/lib/active_support/dependencies.rb', line 403

def search_for_file(path_suffix)
  path_suffix = path_suffix.sub(/(\.rb)?$/, ".rb")

  autoload_paths.each do |root|
    path = File.join(root, path_suffix)
    return path if File.file? path
  end
  nil # Gee, I sure wish we had first_match ;-)
end

- (Object) to_constant_name(desc)

Convert the provided const desc to a qualified constant name (as a string). A module, class, symbol, or string may be provided.



619
620
621
622
623
624
625
626
627
628
# File 'activesupport/lib/active_support/dependencies.rb', line 619

def to_constant_name(desc) #:nodoc:
  case desc
    when String then desc.sub(/^::/, '')
    when Symbol then desc.to_s
    when Module
      desc.name.presence ||
        raise(ArgumentError, "Anonymous modules have no name to be referenced by")
    else raise TypeError, "Not a valid constant descriptor: #{desc.inspect}"
  end
end

- (Object) unhook!



288
289
290
291
292
# File 'activesupport/lib/active_support/dependencies.rb', line 288

def unhook!
  ModuleConstMissing.exclude_from(Module)
  Loadable.exclude_from(Object)
  true
end

- (Boolean) will_unload?(const_desc)

Will the provided constant descriptor be unloaded?



559
560
561
562
# File 'activesupport/lib/active_support/dependencies.rb', line 559

def will_unload?(const_desc)
  autoloaded?(const_desc) ||
    explicitly_unloadable_constants.include?(to_constant_name(const_desc))
end