Unique Object for Each source file

[Joel VanderWerf]

This is a silly little bit of code, but it's sort of an answer to
http://ruby-talk.org/99775, "RCR: Unique Object for Each source file".

Also, I had been thinking about proposing an RCR to let Kernel#load
return the last value in the file it loads, so it would be easy to
construct an object in a script file and hand it back to the main
program. But after reading back to the thread at
http://ruby-talk.org/62660, that didn't seem like the best way to go.
So, based on Nobu's suggestion in http://ruby-talk.org/62727, here is a
Script class which does the following:

- program.rb:

require 'script'
script = Script.load("script.rb")
p script::VALUE
script.run

- script.rb:

VALUE = [1,2,3]
def run
puts "#{self} running."
end

- output:

$ ruby program.rb
[1, 2, 3]
#<Script:/tmp/script.rb> running.

The value returned by Script.load is a module, and you can access its
constants and module methods, as expected. You can, of course, define
any number of constants or methods in the scope of the script file.
Defining things at the top level in your script file behaves as you
expect, like definitions at the top level of ruby itself, but in the
scope of the script. More precisely, every "def foo" results in
'module_function "foo"' getting invoked, so you can call foo on the
script object itself, back in the main program. This also means that
instance variables defined at the top level of your script are
accessible from the module functions that you define at the top level.

Script has implementations of #load and #require that, called from
within a "script", try to find files locally (relative to the script
file) and then fall back to the Kernel versions of #load and #require,
which look in $LOAD_PATH. If a local file is found, its definitions go
into the same scope as the original script. The intent is that if you
have main script file that loads some others, and everything works
nicely with "ruby script.rb", then it should also work with
Script.load("script.rb"), except that all of your definitions will be
wrapped in the module returned by Script.load. (And it will not break if
you Dir.chdir.)

Also, it is possible to pass "arguments" to a script by attaching a
block to Script.load and using it to define constants in the script's scope.

The implementation of Script is very simple and is included below. A
complete package with documentation and examples is at
http://redshift.sourceforge.net/script.

It's seems like too trivial a thing to put on RAA, especially with a
grand name like "script", so I'll just leave where it is for now, unless
someone has a better suggestion.

-- script.rb
class Script < Module
attr_reader :main_file
attr_reader :dir
attr_reader :loaded_features

class << self
alias load new
end

def initialize(main_file)
@main_file = File.expand_path(main_file)
@dir = File.dirname(@main_file)
@loaded_features = {}

yield self if block_given?
load_in_module(main_file)
end

def load(file, wrap = false)
load_in_module(File.join(@dir, file))
true
rescue MissingFile
super
end

def require(feature)
unless @loaded_features[feature]
@loaded_features[feature] = true
file = File.join(@dir, feature)
file += ".rb" unless /\.rb$/ =~ file
load_in_module(file)
end
rescue MissingFile
@loaded_features[feature] = false
super
end

class MissingFile < LoadError; end

def load_in_module(file)
module_eval(IO.read(file), file)
rescue Errno::ENOENT => e
if /#{file}$/ =~ e.message
raise MissingFile, e.message
else
raise
end
end

def method_added(name)
module_function(name)
end

def to_s
"#<#{self.class}:#{File.join(dir, File.basename(main_file))}>"
end
end