I've got some code that looks like the following. First, there's a simple Parser class for parsing command-line arguments with options.
class Parser
def initialize(&b); ...; end # Create new parser.
def parse(args = ARGV); ...; end # Consume command-line args.
def opt(...); ...; end # Declare supported option.
def die(...); ...; end # Validation handler.
end
Then I have my own Parsers module which holds some metadata about parsers that I want to track.
module Parsers
ParserMap = {}
def self.make_parser(kind, desc, &b)
b ||= lambda {}
module_eval {
ParserMap[kind] = {:desc => "", :validation => lambda {} }
ParserMap[kind][:desc] = desc
# Create new parser identified by `<Kind>Parser`. Making a Parser is very
# expensive, so we defer its creation until it's actually needed later
# by wrapping it in a lambda and calling it when we actually need it.
const_set(name_for_parser(kind), lambda { Parser.new(&b) })
}
end
# ...
end
Now when you want to add a new parser, you can call make_parser like so:
make_parser :db, "login to database" do
# Options that this parser knows how to parse.
opt :verbose, "be verbose with output messages"
opt :uid, "user id"
opt :pwd, "password"
end
Cool. But there's a problem. We want to optionally associate validation with each parser, so that we can write something like:
validation = lambda { |parser, opts|
parser.die unless opts[:uid] && opts[:pwd] # Must provide login.
}
The interface contract with Parser says that we can't do any validation until after Parser#parse has been called. So, we want to do the following:
Associate an optional block with every Parser we make with make_parser.
We also want to be able to run this block, ideally as a new method called Parser#validate. But any on-demand method is equally suitable.
How do we do that?
