CLI::Arguments

CLI::Arguments provides a very simple means of parsing command line arguments.

Unlike other more complex libs this provides only the most basic and standard parsing functionality. In many cases that‘s all one really needs.

Usage is straight foward. Simply instantiate the class and query it for the particular "views" of the command line you want.

  cargs = CLI::Arguments.new("-a foo -b=2")

  cargs.parameters    #=> [['foo'],{'a'=>true,'b'=>'2'}]
  cargs.flags         #=> ['a']
  cargs.preoptions    #=> {'a'=>true}
  cargs.preflags      #=> ['a']
  cargs.subcommand    #=> ['foo',{'b'=>'2'}]
Methods
arguments flags new operands options parameters parameters parameters_without_duplicates preflags preoptions subcommand subcommand_with_arguments subcommand_with_parameters subcommand_with_preoptions
Attributes
[R] argv
[R] arity
[R] line
Public Class methods
new(line=nil, arity=nil)

Takes the command line string (or array) and options. Options have flags and end with a hash of option arity.

# File lib/more/facets/arguments.rb, line 85
    def initialize(line=nil, arity=nil)
      @line, @argv  = parse_line(line)
      @arity = parse_arity(arity||{})
      parse
    end
parameters(*args)
# File lib/more/facets/arguments.rb, line 71
    def self.parameters(*args)
      new.parameters(*args)
    end
Public Instance methods
arguments()

Alias for operands

flags()

Return flags, which are true options.

# File lib/more/facets/arguments.rb, line 117
    def flags
      f = []
      @options.each do |k, v|
        if TrueClass===v or FalseClass===v  # not that it's ever false
          f << k
        end
      end
      return f
    end
operands()

Returns operand array.

This method is also aliased as arguments
# File lib/more/facets/arguments.rb, line 95
    def operands
      @operands
    end
options()

Returns options hash.

# File lib/more/facets/arguments.rb, line 104
    def options
      @options
    end
parameters()

Returns [operands, options], which is good for plugging directly into a method.

# File lib/more/facets/arguments.rb, line 111
    def parameters
      return @operands, @options
    end
parameters_without_duplicates()

Like parameters but without allowing for duplicate options.

# File lib/more/facets/arguments.rb, line 192
    def parameters_without_duplicates
      opts = {}
      @options.each do |k,v|
        if Array===v
          opts[k] = v[0]
        else
          opts[k] =  v
        end
      end
      return @operands, opts
    end
preflags()

Same as flags but only returns flags in the preoptions.

# File lib/more/facets/arguments.rb, line 179
    def preflags
      preopts, remainder = *parse_preoptions(argv)
      f = []
      preopts.each do |k, v|
        if TrueClass===v or FalseClass===v  # not that it's ever false
          f << k
        end
      end
      return f
    end
preoptions()

Returns a hash of options that occur before the first operand. This works well with subcommand to get the main command‘s options.

  line = "--trace stamp --file VERSION"
  cargs = CLI::Arguments.new(line)
  opts = cargs.preoptions
  opts #=> {"trace"=>true}
# File lib/more/facets/arguments.rb, line 171
    def preoptions
      preopts, remainder = *parse_preoptions(argv)
      return preopts
    end
subcommand()
subcommand_with_arguments()

Assumes the first operand is a "subcommand" and returns it and the argments following it as another Arguments object.

TODO: This probably should be called ‘subcommand’.

# File lib/more/facets/arguments.rb, line 155
    def subcommand_with_arguments
      opts, args = *parse_preoptions(argv)
      cmd = args.shift
      subargs = self.class.new(args, @arity)
      return cmd, subargs
    end
subcommand_with_parameters()

Assumes the first operand is a "subcommand" and returns it and the argments following it as parameters.

This method is also aliased as subcommand
# File lib/more/facets/arguments.rb, line 131
    def subcommand_with_parameters
      opts, args = *parse_preoptions(argv)
      cmd = args.shift
      subargs = self.class.new(args, @arity)
      return [cmd, *subargs.parameters]
    end
subcommand_with_preoptions()
# File lib/more/facets/arguments.rb, line 141
    def subcommand_with_preoptions
      pre, args = *parse_preoptions(argv)
      cmd = args.shift
      subargs = self.class.new(args, @arity)
      args, opts = *subargs.parameters
      return [cmd, args, pre.merge(opts)]
    end