Skip to content
Build ruby command line apps with a very comfortable options and parameter pre processing.
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.



Building command line apps like:

Defaults = { :verbose => false }

Applix.main(ARGV, Defaults) do 
    handle(:one) do |*args, opts|
        if opts[:verbose]
            puts "arguments: #{args.inspect}"
            puts "options: #{opts.inspect}"

    handle(:two) do |*args, opts|
        if opts[:verbose]
            puts "arguments: #{args.inspect}"
            puts "options: #{opts.inspect}"

can be called like:

$ app --verbose one 1234 x y z
arguments: ["1234", "x", "y", "z"]
options: {:verbose => true}

Command line options will be processed with Hash#from_argv. Hash#from_argv builds a hash from ARGV like argument vector according to following examples:

'-f'                  --> { :f      => true }
'--flag'              --> { :flag   => true }
'--flag:false'        --> { :flag   => false }
'--flag=false'        --> { :flag   => 'false' }
'--option=value'      --> { :option => "value" }
'--int=1'             --> { :int    => "1" }
'--float=2.3'         --> { :float  => "2.3" }
'--float:2.3'         --> { :float  => 2.3 }
'--txt="foo bar"'     --> { :txt    => "foo bar" }
'--txt:\'"foo bar"\'' --> { :txt    => "foo bar" }
'--txt:%w{foo bar}'   --> { :txt    => ["foo", "bar"] }
''      --> { :now    => #<Date: 3588595/2,0,2299161> }

Remaining arguments(non flag/options) are inserted as [:args], eg:

Hash.from_argv %w(--foo --bar=loo 123 now)


{ :foo => true, :bar => 'loo', :args => ["123", "now"] }

Command line micro DSLs with @argsloop@

Imagine you have an app which could perform multiple operations on a excel sheet. Like reading, validating and reporting. You could put all variations in a single command which to call directly from a command line. A better is to break down such a procedure into single steps which can be performed independently and combined freely on the command line. Example procedure:

load select validate print

Now you can make this an applix command line DSL like this:

Applix.main(ARGV) do any(argsloop: end

and calling it like:

$ my_app load select validate print

Now to make applix call your app with the right commands and parameters the commands just have to take its parameters off the arg vector like this:

app.load(args) filename = args.shift ... args end sheetname = args.shift ... args end

app.validate(args) ... args end

app.print(args) ... args end

Adding new steps now is easy, like instead of print you could make an upload to another database for example without the need touch existing code.

Note on Patches/Pull Requests

  • Fork the project.
  • Make your feature addition or bug fix.
  • Add tests for it. This is important so I don't break it in a future version unintentionally.
  • Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
  • Send me a pull request. Bonus points for topic branches.


Copyright (c) 2009/11 dirk luesebrink. See LICENSE for details.

You can’t perform that action at this time.