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.
def another puts "This is another!" end
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?