On Sun, Sep 25, 2011 at 10:48 PM, Perl J. <perljunkie / gmail.com> wrote:
> So I guess the warning to the reader upfront is...  §  
> hack who should have moved to Ruby a decade ago and just couldn't let go
> of Perl.     > (take the time to) figure out how to do in Ruby, so... that's why I'm
> here.
>
> I've got a small framework I wrote in Perl I've been using for years
> that is lightweight and yet powerful. A lot of it centers around the
> use of AUTOLOAD, which some Perlers say is bad -- I say it's extremely
> powerful if used properly, and actually, AUTOLOAD forms a lot of the
> backbone for my framework.        
> in Perl that I see in Ruby.      > a framework to give me some of the power I see in Ruby in Perl. :-)
>
> With all that as a backdrop, here's how I can process command line
> arguments in Perl (*everything* I do in Perl is OO!!) and I want the
> same thing in Ruby.        ɧ> -- not as easy as what I'm used to (or maybe I don't understand
> OptParser, which is likely).
>
> In Perl, I can do this:
>
> options = MyFramework::Options->new(
> sourcePath => 's:'
> destPath => 'd:'
> verbose > 'v'
> );
>
> What ends up happening behind the scenes is a class instance is created
> dynamically that essentially gives me the ability to say:
>
> ## I actually have a puts() I created in Perl as well,
> ## borrowed from Ruby!
> puts(
> "Source path.......: " . $options->sourcePath,
> "Destination path..: " . $options->destPath,
> "Verbose is........: " . ($options->verbose ? 'ON' : 'OFF'),
> );
>
> So I have a getter for sourcePath, a getter for destPath and a getter
> for verbose, automagically created for that instance loaded with the
> values from the command line.  >
> whatever = MyFramework::Options->new(
> foo => 'f:',
> bar => 'b:',
> );
>
> Then I would have an instance of 'whatever' with foo and bar as getters,
> etc. with the values of 'f' and 'b' from the command line loaded
> appropriately.
>
> Now how to do this in Ruby?  > complicated for what I want and am trying to do.   > still are coding some kind of OptParser class for the specific options
> you want -- I don't want to create classes that mirror the command line
> options.          
> (kind of like OpenStruct) what it looks like and it just creates the
> right instance.            > "define" this dynamically on the fly using maybe a hash as initial
> input... I like the flexibility of hashes:
>
> options = Options.new({
> :sPath => 's:',
> :dPath => 'd:',
> :verbose => 'v',
> })
>
> puts "Source path.......: #{options.sPath}"
> puts "Destination path..: #{options.dPath}"
> puts "Verbose is........: #{options.verbose ? 'ON' : 'OFF'}"
>
> What this is saying is "map the value of 's' from the command line into
> @sPath, map the value of 'd' from the command line into @dPath, and map
> whether 'v' exists, true or false, into @verbose."    
> simple can you get??!!
>
> Again, the warning of "trying to do Ruby stuff in a Perl way" comes to
> me, but what I do in Perl is so stinking simple, it's unbelievable, and
> this is one reason I haven't switched over to Ruby yet.   ɧ> trying.
>
> Things I've tried: A lot of different combinations of...
> -- missing_method()
> -- define_method()
> (I don't understand why a lot of d_m() examples use self.class.send()!!)
> -- Struct()
> -- OpenStruct()
>
> So far, requiring "optparse" and doing ARGV.getopts() does some of what
> I want.     ɧ   
>
> require "optparse"
>
> class Options
> attr_reader :cmdline, :options_list
> def initialize( options )
>  ֮ >   >  ֮>   > ## Why do I need to send( :define_method, ... ) here?
> ## Why can't I just say self.define_method?
> ## This seems like it would create proper closure
> ## on params[] elements?!
> self.class.send( :define_method, key ) { params[value] }
>  
> end
> end
>
> options = Options.new({
> :sPath => 's:',
> :dPath => 'd:',
> :verbose => 'v',
> })
>
> If someone can tell me how to do this using OptParser, so be it.  
> from an encapsulation standpoint, I'd like to be able to call it as I do
> above.    
Does this what you need?

11:15:19 Temp$ ./opt.rb -s abc.def -- -x
{:source_path=>"abc.def"}
11:15:22 Temp$ ./opt.rb -s abc.def -- -x
{:source_path=>"abc.def"}
["-x"]
11:15:28 Temp$ ./opt.rb -s abc.def
{:source_path=>"abc.def"}
[]
11:15:31 Temp$ ./opt.rb -s abc.def -d .
{:source_path=>"abc.def", :dest_path=>"."}
[]
11:15:36 Temp$ ./opt.rb -s abc.def -d . -v
{:source_path=>"abc.def", :dest_path=>".", :verbose=>true}
[]
11:15:39 Temp$ ./opt.rb -s abc.def -d . -v a b c
{:source_path=>"abc.def", :dest_path=>".", :verbose=>true}
["a", "b", "c"]

https://gist.github.com/1241917

Kind regards

robert

-- 
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/