I’m having a little debate with myself. On my current project I have a
bunch of little reusable task scripts that a command line tool runs.
The scripts are written as the top-level (although I actually simulate
the top-level when running them). So for example a script would just be
puts “This is an example!”
Then on the command line I would do:
% mytool example
This is an example!
That’s all well and good, but many of the scripts have generally useful
routines and I would like them to be accessible by other programs too,
not just my command line tool. So I thoght maybe it would be better if
a module were required to wrap the defs.
puts "This is another!"
That works, of course, but it adds an additonal layer of essentially
redundant code, which IMHO is ugly.
Then I got to thinking. Why don’t we write resuable lib in this fashion
anyway and just create our own containers on the fly when loading them?
MyToolExample = load_as_module “example.rb”
What intersting about that is then we could determine in what capacity
it is to be used. For example:
MyToolExample = load_as_function_module “example.rb”
adds self extend
MyToolExample = load_as_self_extended_module “example.rb”
MyToolExample = load_as_class “example.rb”
We could even have include and extend take a lib path.
Of course this effectively puts encapsulation, at least at the top
level, on a per-file basis. But in many respects that seems kind of
nice. It increases flexability and reduces configuration complexity.
So what do your think? Is this technique worth promoting? Or am I being
silly and should just wrap all my scripts in modules?