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... =A0I'm a bit of a Perl
> hack who should have moved to Ruby a decade ago and just couldn't let go
> of Perl. =A0Perl still does stuff that I use extensively that I can't
> (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. =A0 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. =A0And honestly, it's helped me do some things
> in Perl that I see in Ruby. =A0So there's some irony here in that I wrote
> 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. =A0OptParser in Ruby is WAY more than I'm looking for
> -- 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 =3D MyFramework::Options->new(
> =A0 sourcePath =3D> 's:'
> =A0 destPath =A0 =3D> 'd:'
> =A0 verbose =A0 =A0=3D> '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(
> =A0 "Source path.......: " . $options->sourcePath,
> =A0 "Destination path..: " . $options->destPath,
> =A0 "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. =A0If I said:
>
> whatever =3D MyFramework::Options->new(
> =A0 foo =3D> 'f:',
> =A0 bar =3D> '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? =A0Like I said, the OptParser seems WAY too
> complicated for what I want and am trying to do. =A0It seems like you
> 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. =A0I want to tell the class instance at the time I create it
> (kind of like OpenStruct) what it looks like and it just creates the
> right instance. =A0I want to be able to do this in Ruby, assuming I would
> "define" this dynamically on the fly using maybe a hash as initial
> input... I like the flexibility of hashes:
>
> options =3D Options.new({
> =A0 :sPath =A0 =3D> 's:',
> =A0 :dPath =A0 =3D> 'd:',
> =A0 :verbose =3D> '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." =A0Now how much more
> 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. =A0But now I'm
> 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. =A0This is as close as I've gotten and it's not working:
>
> require "optparse"
>
> class Options
> =A0 attr_reader :cmdline, :options_list
> =A0 def initialize( options )
> =A0 =A0 =A0@cmdline =3D ARGV.join( ' ' )
> =A0 =A0 =A0@options_list =3D options.values.join
> =A0 =A0 =A0params =3D ARGV.getopts( @options_list )
> =A0 =A0 =A0options.each do |key,value|
> =A0 =A0 =A0 =A0 ## Why do I need to send( :define_method, ... ) here?
> =A0 =A0 =A0 =A0 ## Why can't I just say self.define_method?
> =A0 =A0 =A0 =A0 ## This seems like it would create proper closure
> =A0 =A0 =A0 =A0 ## on params[] elements?!
> =A0 =A0 =A0 =A0 self.class.send( :define_method, key ) { params[value] }
> =A0 =A0 =A0end
> =A0 end
> end
>
> options =3D Options.new({
> =A0 :sPath =A0 =3D> 's:',
> =A0 :dPath =A0 =3D> 'd:',
> =A0 :verbose =3D> 'v',
> })
>
> If someone can tell me how to do this using OptParser, so be it. =A0But
> from an encapsulation standpoint, I'd like to be able to call it as I do
> above. =A0If the innards of the Options class use OptParser, fine.

Does this what you need?

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

https://gist.github.com/1241917

Kind regards

robert

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