From: "trans (Thomas Sawyer)" <transfire@...>
Date: 2012-12-14T00:43:03+09:00
Subject: [ruby-core:50876] [ruby-trunk - Feature #7548] Load and Require Callbacks


Issue #7548 has been updated by trans (Thomas Sawyer).


=begin
There are have been times when I wanted to see what libraries were being loaded and in what order. Usually because of some esoteric bug, and trying to isolate what libraries are involved. In such a case I've had to manually override load and require, something like:

  class << Kernel
    alias :_require, :require
    def require(*args)
      $stderr.puts "require: %s" % [args.inspect]
      _require(*args)
    end

    alias :_load, :load
    def load(*args)
      $stderr.puts "load: %s" % [args.inspect]
      _load(*args)
    end
  end

  module Kernel
    def require(*args)
      Kernel.require(*args)
    end
    def load(*args)
      Kernel.load(*args)
    end
  end
=end

Notice we have to do both Kernel instance and singleton methods to be sure we catch all of them. These days we might also need to add (({#require_relative})) to that.

So the thought then is, if there were callbacks, it would be easier to do, simply:

  def required(*args)
    $stderr.puts "require: %s" % [args.inspect]
  end

  def loaded(*args)
    $stderr.puts "load: %s" % [args.inspect]
  end

Actually considering this a bit more, it would probably be even better just to have one callback method that passed options to designate which kind of loading took place. e.g. 

  def loaded(file, opts)
    opts[:load] => true means #load was used/
                   false means #require was used

    opts[:relative] => true means #require_relative was used

    opts[:wrap] => the wrap argument for #load.
  end


----------------------------------------
Feature #7548: Load and Require Callbacks
https://bugs.ruby-lang.org/issues/7548#change-34709

Author: trans (Thomas Sawyer)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: next minor


=begin
Should #load and #require have callbacks? e.g.

  def required(path)
    ...
  end

  def loaded(path, wrap)
    ...
  end

On occasion I have wanted to do load monitoring to track down a bug. This would have made it easier.

Are there any other good use cases?
=end



-- 
http://bugs.ruby-lang.org/