cri 2.0b1 → 2.0rc1

data/README.md

@@ -1,7 +1,121 @@
 Cri
 ===
 
-Cri is a library for building easy-to-use commandline tools.
+Cri is a library for building easy-to-use commandline tools with support for
+nested commands.
+
+Usage
+-----
+
+The central concept in Cri is the _command_, which has option definitions as
+well as code for actually executing itself. In Cri, the commandline tool
+itself is a command as well.
+
+Here’s a sample command definition:
+
+	command = Cri::Command.define do
+	  name        'dostuff'
+	  usage       'dostuff [options]'
+	  aliases     :ds, :stuff
+	  summary     'does stuff'
+	  description 'This command does a lot of stuff. I really mean a lot.'
+
+	  flag   :h, :help,  'show help for this command' do |value, cmd|
+	    puts cmd.help
+	    exit 0
+	  end
+	  flag   :m, :more,  'do even more stuff'
+	  option :s, :stuff, 'specify stuff to do', :argument => :required
+
+	  run do |opts, args, cmd|
+	    stuff = opts[:stuff] || 'generic stuff'
+	    puts "Doing #{stuff}!"
+
+	    if opts[:more]
+	      puts 'Doing it even more!'
+	    end
+	  end
+	end
+
+To run this command, invoke the `#run` method with the raw arguments. For
+example, for a root command (the commandline tool itself), the command could
+be called like this:
+
+	command.run(ARGS)
+
+Each command has automatically generated help. This help can be printed using
+{Cri::Command#help}; something like this will be shown:
+
+	usage: dostuff [options]
+
+	does stuff
+
+	    This command does a lot of stuff. I really mean a lot.
+
+	options:
+
+	    -h --help      show help for this command
+	    -m --more      do even more stuff
+	    -s --stuff     specify stuff to do
+
+Let’s disect the command definition and start with the first five lines:
+
+	name        'dostuff'
+	usage       'dostuff [options]'
+	aliases     :ds, :stuff
+	summary     'does stuff'
+	description 'This command does a lot of stuff. I really mean a lot.'
+
+These lines of the command definition specify the name of the command (or the
+commandline tool, if the command is the root command), the usage, a list of
+aliases that can be used to call this command, a one-line summary and a (long)
+description. The usage should not include a “usage:” prefix nor the name of
+the supercommand, because the latter will be automatically prepended.
+
+Aliases don’t make sense for root commands, but for subcommands they do.
+
+The next few lines contain the command’s option definitions:
+
+	flag   :h, :help,  'show help for this command' do |value, cmd|
+	  puts cmd.help
+	  exit 0
+	end
+	flag   :m, :more,  'do even more stuff'
+	option :s, :stuff, 'specify stuff to do', :argument => :required
+
+Options can be defined using the following methods:
+
+* {Cri::CommandDSL#option} or {Cri::CommandDSL#opt}
+* {Cri::CommandDSL#flag} (implies forbidden argument)
+* {Cri::CommandDSL#required} (implies required argument)
+* {Cri::CommandDSL#optional} (implies optional argument)
+
+Each of the above methods also take a block, which will be executed when the
+option is found. The argument to the block are the option value (`true` in
+case the option does not have an argument) and the command.
+
+The last part of the command defines the execution itself:
+
+	run do |opts, args, cmd|
+	  stuff = opts[:stuff] || 'generic stuff'
+	  puts "Doing #{stuff}!"
+
+	  if opts[:more]
+	    puts 'Doing it even more!'
+	  end
+	end
+
+The {Cri::CommandDSL#run} method takes a block with the actual code to
+execute. This block takes three arguments: the options, any arguments passed
+to the command, and the command itself.
+
+Commands can have subcommands. For example, the `git` commandline tool would be represented by a command that has subcommands named `commit`, `add`, and so on. Commands with subcommands do not use a run block; execution will always be dispatched to a subcommand (or none, if no subcommand is found).
+
+To add a command as a subcommand to another command, use the {Cri::Command#add_command} method, like this:
+
+	root_cmd.add_command cmd_add
+	root_cmd.add_command cmd_commit
+	root.cmd.add_command cmd_init
 
 Contributors
 ------------

data/lib/cri.rb

@@ -2,20 +2,22 @@
 
 module Cri
 
-  # @todo Document
+  # A generic error class for all Cri-specific errors.
   class Error < ::StandardError
   end
 
-  # @todo Document
+  # Error that will be raised when an implementation for a method or command
+  # is missing. For commands, this may mean that a run block is missing.
   class NotImplementedError < Error
   end
 
-  # @todo Document
+  # Error that will be raised when no help is available because the help
+  # command has no supercommand for which to show help.
   class NoHelpAvailableError < Error
   end
 
   # The current Cri version.
-  VERSION = '2.0b1'
+  VERSION = '2.0rc1'
 
   autoload 'Command',           'cri/command'
   autoload 'CommandDSL',        'cri/command_dsl'

data/lib/cri/command.rb

@@ -45,35 +45,49 @@ module Cri
 
     end
 
-    # @todo Document
+    # @return [Cri::Command, nil] This command’s supercommand, or nil if the
+    #   command has no supercommand
     attr_accessor :supercommand
 
-    # @todo document
+    # @return [Set<Cri::Command>] This command’s subcommands
     attr_accessor :commands
     alias_method :subcommands, :commands
 
-    # @todo Document
+    # @return [String] The name
     attr_accessor :name
 
-    # @todo Document
+    # @return [Array<String>] A list of aliases for this command that can be
+    #   used to invoke this command
     attr_accessor :aliases
 
-    # @todo Document
-    attr_accessor :short_desc
+    # @return [String] The short description (“summary”)
+    attr_accessor :summary
 
-    # @todo Document
-    attr_accessor :long_desc
+    # @return [String] The long description (“description”)
+    attr_accessor :description
 
-    # @todo Document
+    # @return [String] The usage, without the “usage:” prefix and without the
+    #   supercommands’ names.
     attr_accessor :usage
 
-    # @todo Document
+    # @return [Array<Hash>] The list of option definitions
     attr_accessor :option_definitions
 
-    # @todo Document
+    # @return [Proc] The block that should be executed when invoking this
+    #   command (ignored for commands with subcommands)
     attr_accessor :block
 
-    # @todo Document
+    # Creates a new command using the DSL. If a string is given, the command
+    # will be defined using the string; if a block is given, the block will be
+    # used instead.
+    #
+    # If the block has one parameter, the block will be executed in the same
+    # context with the command DSL as its parameter. If the block has no
+    # parameters, the block will be executed in the context of the DSL.
+    #
+    # @param [String, nil] The string containing the command’s definition
+    #
+    # @return [Cri::Command] The newly defined command
     def self.define(string=nil, &block)
       dsl = Cri::CommandDSL.new
       if string
@@ -86,13 +100,19 @@ module Cri
       dsl.command
     end
 
-    # @todo Document
+    # Returns a new command that has support for the `-h`/`--help` option and
+    # also has a `help` subcommand. It is intended to be modified (adding
+    # name, summary, description, other subcommands, …)
+    #
+    # @return [Cri::Command] A basic root command
     def self.new_basic_root
       filename = File.dirname(__FILE__) + '/commands/basic_root.rb'
       self.define(File.read(filename))
     end
 
-    # @todo Document
+    # Returns a new command that implements showing help.
+    #
+    # @return [Cri::Command] A basic help command
     def self.new_basic_help
       filename = File.dirname(__FILE__) + '/commands/basic_help.rb'
       self.define(File.read(filename))
@@ -100,11 +120,17 @@ module Cri
 
     def initialize
       @aliases            = Set.new
-      @commands           = Set.new # TODO make this a hash (name -> cmd)
+      @commands           = Set.new
       @option_definitions = Set.new
     end
 
-    # @todo Document
+    # Modifies the command using the DSL.
+    #
+    # If the block has one parameter, the block will be executed in the same
+    # context with the command DSL as its parameter. If the block has no
+    # parameters, the block will be executed in the context of the DSL.
+    #
+    # @return [Cri::Command] The command itself
     def modify(&block)
       dsl = Cri::CommandDSL.new(self)
       if block.arity == 0
@@ -115,7 +141,8 @@ module Cri
       self
     end
 
-    # @todo Document
+    # @return [Hash] The option definitions for the command itself and all its
+    #   ancestors
     def global_option_definitions
       res = Set.new
       res.merge(option_definitions)
@@ -123,13 +150,22 @@ module Cri
       res
     end
 
-    # @todo Document
+    # Adds the given command as a subcommand to the current command.
+    #
+    # @param [Cri::Command] command The command to add as a subcommand
+    #
+    # @return [void]
     def add_command(command)
       @commands << command
       command.supercommand = self
     end
 
-    # @todo Document
+    # Defines a new subcommand for the current command using the DSL.
+    #
+    # @param [String, nil] name The name of the subcommand, or nil if no name
+    #   should be set (yet)
+    #
+    # @return [Cri::Command] The subcommand
     def define_command(name=nil, &block)
       # Execute DSL
       dsl = Cri::CommandDSL.new
@@ -149,7 +185,9 @@ module Cri
     # Returns the commands that could be referred to with the given name. If
     # the result contains more than one command, the name is ambiguous.
     #
-    # @todo Document
+    # @param [String] name The full, partial or aliases name of the command
+    #
+    # @return [Array<Cri::Command>] A list of commands matching the given name
     def commands_named(name)
       # Find by exact name or alias
       @commands.each do |cmd|
@@ -163,9 +201,15 @@ module Cri
       end
     end
 
-    # Returns the command with the given name.
+    # Returns the command with the given name. This method will display error
+    # messages and exit in case of an error (unknown or ambiguous command).
+    #
+    # The name can be a full command name, a partial command name (e.g. “com”
+    # for “commit”) or an aliased command name (e.g. “ci” for “commit”).
     #
-    # @todo Document
+    # @param [String] name The full, partial or aliases name of the command
+    #
+    # @return [Cri::Command] The command with the given name
     def command_named(name)
       commands = commands_named(name)
 
@@ -181,7 +225,14 @@ module Cri
       end
     end
 
-    # @todo Document
+    # Runs the command with the given commandline arguments.
+    #
+    # @param [Array<String>] opts_and_args A list of unparsed arguments
+    #
+    # @param [Hash] parent_opts A hash of options already handled by the
+    #   supercommand
+    #
+    # @return [void]
     def run(opts_and_args, parent_opts={})
       if subcommands.empty?
         # Parse
@@ -240,15 +291,15 @@ module Cri
       end
 
       # Append short description
-      if short_desc
+      if summary
         text << "\n"
-        text << short_desc + "\n"
+        text << summary + "\n"
       end
 
       # Append long description
-      if long_desc
+      if description
         text << "\n"
-        text << long_desc.wrap_and_indent(78, 4) + "\n"
+        text << description.wrap_and_indent(78, 4) + "\n"
       end
 
       # Append subcommands
@@ -260,7 +311,7 @@ module Cri
         self.commands.each do |cmd|
           text << sprintf("    %-#{length+4}s %s\n",
             cmd.name,
-            cmd.short_desc)
+            cmd.summary)
         end
       end
 

data/lib/cri/command_dsl.rb

@@ -2,76 +2,155 @@
 
 module Cri
 
-  # @todo Document
+  # The command DSL is a class that is used for building and modifying
+  # commands.
   class CommandDSL
 
+    # @param [Cri::Command, nil] command The command to modify, or nil if a
+    #   new command should be created
     def initialize(command=nil)
       @command = command || Cri::Command.new
     end
 
-    # @todo Document
+    # @return [Cri::Command] The built command
     def command
       @command
     end
 
-    # @todo Document
-    def subcommand(cmd=nil, &block)
-      if cmd.nil?
-        cmd = Cri::Command.define(&block)
+    # Adds a subcommand to the current command. The command can either be
+    # given explicitly, or a block can be given that defines the command.
+    #
+    # @param [Cri::Command, nil] command The command to add as a subcommand,
+    #   or nil if the block should be used to define the command that will be
+    #   added as a subcommand
+    #
+    # @return [void]
+    def subcommand(command=nil, &block)
+      if command.nil?
+        command = Cri::Command.define(&block)
       end
 
-      @command.add_command(cmd)
+      @command.add_command(command)
     end
 
-    # @todo Document
+    # Sets the command name.
+    #
+    # @param [String] arg The new command name
+    #
+    # @return [void]
     def name(arg)
       @command.name = arg
     end
 
-    # @todo Document
+    # Sets the command aliases.
+    #
+    # @param [String, Symbol, Array] args The new command aliases
+    #
+    # @return [void]
     def aliases(*args)
-      @command.aliases = args.flatten
+      @command.aliases = args.flatten.map { |a| a.to_s }
     end
 
-    # @todo Document
+    # Sets the command summary.
+    #
+    # @param [String] arg The new command summary
+    #
+    # @return [void]
     def summary(arg)
-      @command.short_desc = arg
+      @command.summary = arg
     end
 
-    # @todo Document
+    # Sets the command description.
+    #
+    # @param [String] arg The new command description
+    #
+    # @return [void]
     def description(arg)
-      @command.long_desc = arg
+      @command.description = arg
     end
 
-    # @todo Document
+    # Sets the command usage. The usage should not include the “usage:”
+    # prefix, nor should it include the command names of the supercommand.
+    #
+    # @param [String] arg The new command usage
+    #
+    # @return [void]
     def usage(arg)
       @command.usage = arg
     end
 
-    # @todo Document
+    # Adds a new option to the command. If a block is given, it will be
+    # executed when the option is successfully parsed.
+    #
+    # @param [String, Symbol] short The short option name
+    #
+    # @param [String, Symbol] long The long option name
+    #
+    # @param [String] desc The option description
+    #
+    # @option params [:forbidden, :required, :optional] :argument Whether the
+    #   argument is forbidden, required or optional
+    #
+    # @return [void]
     def option(short, long, desc, params={}, &block)
       requiredness = params[:argument] || :forbidden
       self.add_option(short, long, desc, requiredness, block)
     end
     alias_method :opt, :option
 
-    # @todo Document
+    # Adds a new option with a required argument to the command. If a block is
+    # given, it will be executed when the option is successfully parsed.
+    #
+    # @param [String, Symbol] short The short option name
+    #
+    # @param [String, Symbol] long The long option name
+    #
+    # @param [String] desc The option description
+    #
+    # @return [void]
+    #
+    # @see {#option}
     def required(short, long, desc, &block)
       self.add_option(short, long, desc, :required, block)
     end
 
-    # @todo Document
+    # Adds a new option with a forbidden argument to the command. If a block
+    # is given, it will be executed when the option is successfully parsed.
+    #
+    # @param [String, Symbol] short The short option name
+    #
+    # @param [String, Symbol] long The long option name
+    #
+    # @param [String] desc The option description
+    #
+    # @return [void]
+    #
+    # @see {#option}
     def flag(short, long, desc, &block)
       self.add_option(short, long, desc, :forbidden, block)
     end
     alias_method :forbidden, :flag
 
-    # @todo Document
+    # Adds a new option with an optional argument to the command. If a block
+    # is given, it will be executed when the option is successfully parsed.
+    #
+    # @param [String, Symbol] short The short option name
+    #
+    # @param [String, Symbol] long The long option name
+    #
+    # @param [String] desc The option description
+    #
+    # @return [void]
+    #
+    # @see {#option}
     def optional(short, long, desc, &block)
       self.add_option(short, long, desc, :optional, block)
     end
 
-    # @todo Document
+    # Sets the run block to the given block. The given block should have two
+    # or three arguments (options, arguments, and optionally the command).
+    #
+    # @return [void]
     def run(&block)
       unless block.arity != 2 || block.arity != 3
         raise ArgumentError,
@@ -83,7 +162,6 @@ module Cri
 
   protected
 
-    # @todo Document
     def add_option(short, long, desc, argument, block)
       @command.option_definitions << {
         :short    => short.to_s,

data/lib/cri/core_ext/string.rb

@@ -4,7 +4,9 @@ module Cri::CoreExtensions
 
   module String
 
-    # @todo Document
+    # Extracts individual paragraphs (separated by two newlines).
+    #
+    # @return [Array<String>] A list of paragraphs in the string
     def to_paragraphs
       lines = self.scan(/([^\n]+\n|[^\n]*$)/).map { |s| s[0].strip }
 
@@ -22,10 +24,13 @@ module Cri::CoreExtensions
 
     # Word-wraps and indents the string.
     #
-    # +width+:: The maximal width of each line. This also includes indentation,
-    #           i.e. the actual maximal width of the text is width-indentation.
+    # @param [Number] width The maximal width of each line. This also includes
+    #   indentation, i.e. the actual maximal width of the text is
+    #   `width`-`indentation`.
+    #
+    # @param [Number] indentation The number of spaces to indent each line.
     #
-    # +indentation+:: The number of spaces to indent each wrapped line.
+    # @return [String] The word-wrapped and indented string
     def wrap_and_indent(width, indentation)
       # Split into paragraphs
       paragraphs = self.to_paragraphs

data/lib/cri/option_parser.rb

@@ -3,6 +3,58 @@
 module Cri
 
   # Cri::OptionParser is used for parsing commandline options.
+  #
+  # Option definitions are hashes with the keys `:short`, `:long` and
+  # `:argument` (optionally `:description` but this is not used by the
+  # option parser, only by the help generator). `:short` is the short,
+  # one-character option, without the `-` prefix. `:long` is the long,
+  # multi-character option, without the `--` prefix. `:argument` can be
+  # :required (if an argument should be provided to the option), :optional
+  # (if an argument may be provided) or :forbidden (if an argument should
+  # not be provided).
+  #
+  # A sample array of definition hashes could look like this:
+  #
+  #     [
+  #       { :short => 'a', :long => 'all',  :argument => :forbidden },
+  #       { :short => 'p', :long => 'port', :argument => :required  },
+  #     ]
+  #
+  # For example, the following commandline options (which should not be
+  # passed as a string, but as an array of strings):
+  #
+  #     foo -xyz -a hiss -s -m please --level 50 --father=ani -n luke squeak
+  #
+  # with the following option definitions:
+  #
+  #     [
+  #       { :short => 'x', :long => 'xxx',    :argument => :forbidden },
+  #       { :short => 'y', :long => 'yyy',    :argument => :forbidden },
+  #       { :short => 'z', :long => 'zzz',    :argument => :forbidden },
+  #       { :short => 'a', :long => 'all',    :argument => :forbidden },
+  #       { :short => 's', :long => 'stuff',  :argument => :optional  },
+  #       { :short => 'm', :long => 'more',   :argument => :optional  },
+  #       { :short => 'l', :long => 'level',  :argument => :required  },
+  #       { :short => 'f', :long => 'father', :argument => :required  },
+  #       { :short => 'n', :long => 'name',   :argument => :required  }
+  #     ]
+  #
+  # will be translated into:
+  #
+  #     {
+  #       :arguments => [ 'foo', 'hiss', 'squeak' ],
+  #       :options => {
+  #         :xxx    => true,
+  #         :yyy    => true,
+  #         :zzz    => true,
+  #         :all    => true,
+  #         :stuff  => true,
+  #         :more   => 'please',
+  #         :level  => '50',
+  #         :father => 'ani',
+  #         :name   => 'luke'
+  #       }
+  #     }
   class OptionParser
 
     # Error that will be raised when an unknown option is encountered.
@@ -49,6 +101,13 @@ module Cri
 
     # Parses the commandline arguments. See the instance `parse` method for
     # details.
+    #
+    # @param [Array<String>] arguments_and_options An array containing the
+    #   commandline arguments (will probably be `ARGS` for a root command)
+    #
+    # @param [Array<Hash>] definitions An array of option definitions
+    #
+    # @return [Cri::OptionParser] The option parser self
     def self.parse(arguments_and_options, definitions)
       self.new(arguments_and_options, definitions).run
     end
@@ -56,7 +115,7 @@ module Cri
     # Creates a new parser with the given options/arguments and definitions.
     #
     # @param [Array<String>] arguments_and_options An array containing the
-    #   commandline arguments
+    #   commandline arguments (will probably be `ARGS` for a root command)
     #
     # @param [Array<Hash>] definitions An array of option definitions
     def initialize(arguments_and_options, definitions)
@@ -83,80 +142,17 @@ module Cri
       @running = false
     end
 
-    # Parses the commandline arguments into options and arguments
-    #
-    # +arguments_and_options+ is an array of commandline arguments and
-    # options. This will usually be +ARGV+.
-    #
-    # +definitions+ contains a list of hashes defining which options are
-    # allowed and how they will be handled. Such a hash has three keys:
-    #
-    # :short:: The short name of the option, e.g. +a+. Do not include the '-'
-    #          prefix.
-    #
-    # :long:: The long name of the option, e.g. +all+. Do not include the '--'
-    #         prefix.
-    #
-    # :argument:: Whether this option's argument is required (:required),
-    #             optional (:optional) or forbidden (:forbidden).
-    #
-    # A sample array of definition hashes could look like this:
-    #
-    #     [
-    #       { :short => 'a', :long => 'all',  :argument => :forbidden },
-    #       { :short => 'p', :long => 'port', :argument => :required  },
-    #     ]
+    # Parses the commandline arguments into options and arguments.
     #
     # During parsing, two errors can be raised:
     #
-    # IllegalOptionError:: An unrecognised option was encountered, i.e. an
-    #                      option that is not present in the list of option
-    #                      definitions.
-    #
-    # OptionRequiresAnArgumentError:: An option was found that did not have a
-    #                                 value, even though this value was
-    #                                 required.
-    #
-    # What will be returned, is a hash with two keys, :arguments and :options.
-    # The :arguments value contains a list of arguments, and the :options
-    # value contains a hash with key-value pairs for each option. Options
-    # without values will have a +nil+ value instead.
-    #
-    # For example, the following commandline options (which should not be
-    # passed as a string, but as an array of strings):
+    # @raise IllegalOptionError if an unrecognised option was encountered,
+    #   i.e. an option that is not present in the list of option definitions
     #
-    #     foo -xyz -a hiss -s -m please --level 50 --father=ani -n luke squeak
+    # @raise OptionRequiresAnArgumentError if an option was found that did not
+    #   have a value, even though this value was required.
     #
-    # with the following option definitions:
-    #
-    #     [
-    #       { :short => 'x', :long => 'xxx',    :argument => :forbidden },
-    #       { :short => 'y', :long => 'yyy',    :argument => :forbidden },
-    #       { :short => 'z', :long => 'zzz',    :argument => :forbidden },
-    #       { :short => 'a', :long => 'all',    :argument => :forbidden },
-    #       { :short => 's', :long => 'stuff',  :argument => :optional  },
-    #       { :short => 'm', :long => 'more',   :argument => :optional  },
-    #       { :short => 'l', :long => 'level',  :argument => :required  },
-    #       { :short => 'f', :long => 'father', :argument => :required  },
-    #       { :short => 'n', :long => 'name',   :argument => :required  }
-    #     ]
-    #
-    # will be translated into:
-    #
-    #     {
-    #       :arguments => [ 'foo', 'hiss', 'squeak' ],
-    #       :options => {
-    #         :xxx    => true,
-    #         :yyy    => true,
-    #         :zzz    => true,
-    #         :all    => true,
-    #         :stuff  => true,
-    #         :more   => 'please',
-    #         :level  => '50',
-    #         :father => 'ani',
-    #         :name   => 'luke'
-    #       }
-    #     }
+    # @return [Cri::OptionParser] The option parser self
     def run
       @running = true
 
@@ -241,8 +237,7 @@ module Cri
           add_argument(e)
         end
       end
-
-      { :options => options, :arguments => arguments }
+      self
     ensure
       @running = false
     end

data/test/test_command_dsl.rb

@@ -31,8 +31,8 @@ class Cri::CommandDSLTestCase < Cri::TestCase
     # Check
     assert_equal 'moo', command.name
     assert_equal 'dunno whatever', command.usage
-    assert_equal 'does stuff', command.short_desc
-    assert_equal 'This command does a lot of stuff.', command.long_desc
+    assert_equal 'does stuff', command.summary
+    assert_equal 'This command does a lot of stuff.', command.description
 
     # Check options
     expected_option_definitions = Set.new([
@@ -63,4 +63,16 @@ class Cri::CommandDSLTestCase < Cri::TestCase
     assert_equal 'sub',   command.subcommands.to_a[0].name
   end
 
+  def test_aliases
+    # Define
+    dsl = Cri::CommandDSL.new
+    dsl.instance_eval do
+      aliases :moo, :aah
+    end
+    command = dsl.command
+
+    # Check
+    assert_equal %w( aah moo ), command.aliases.sort
+  end
+
 end

data/test/test_option_parser.rb

@@ -6,10 +6,10 @@ class Cri::OptionParserTestCase < Cri::TestCase
     input       = %w( foo bar baz )
     definitions = []
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({},                      result[:options])
-    assert_equal([ 'foo', 'bar', 'baz' ], result[:arguments])
+    assert_equal({},                      parser.options)
+    assert_equal([ 'foo', 'bar', 'baz' ], parser.arguments)
   end
 
   def test_parse_with_invalid_option
@@ -19,7 +19,7 @@ class Cri::OptionParserTestCase < Cri::TestCase
     result = nil
 
     assert_raises(Cri::OptionParser::IllegalOptionError) do
-      result = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
     end
   end
 
@@ -29,9 +29,9 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'aaa', :short => 'a', :argument => :forbidden }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(!result[:options][:aaa])
+    assert(!parser.options[:aaa])
   end
 
   def test_parse_with_long_valueless_option
@@ -40,10 +40,10 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'aaa', :short => 'a', :argument => :forbidden }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(result[:options][:aaa])
-    assert_equal([ 'foo', 'bar' ], result[:arguments])
+    assert(parser.options[:aaa])
+    assert_equal([ 'foo', 'bar' ], parser.arguments)
   end
 
   def test_parse_with_long_valueful_option
@@ -52,10 +52,10 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'aaa', :short => 'a', :argument => :required }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({ :aaa => 'xxx' },  result[:options])
-    assert_equal([ 'foo', 'bar' ], result[:arguments])
+    assert_equal({ :aaa => 'xxx' },  parser.options)
+    assert_equal([ 'foo', 'bar' ], parser.arguments)
   end
 
   def test_parse_with_long_valueful_equalsign_option
@@ -64,10 +64,10 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'aaa', :short => 'a', :argument => :required }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({ :aaa => 'xxx' },  result[:options])
-    assert_equal([ 'foo', 'bar' ], result[:arguments])
+    assert_equal({ :aaa => 'xxx' },  parser.options)
+    assert_equal([ 'foo', 'bar' ], parser.arguments)
   end
 
   def test_parse_with_long_valueful_option_with_missing_value
@@ -79,7 +79,7 @@ class Cri::OptionParserTestCase < Cri::TestCase
     result = nil
 
     assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
     end
   end
 
@@ -93,7 +93,7 @@ class Cri::OptionParserTestCase < Cri::TestCase
     result = nil
 
     assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
     end
   end
 
@@ -103,10 +103,10 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'aaa', :short => 'a', :argument => :optional }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(result[:options][:aaa])
-    assert_equal([ 'foo' ], result[:arguments])
+    assert(parser.options[:aaa])
+    assert_equal([ 'foo' ], parser.arguments)
   end
 
   def test_parse_with_long_valueful_option_with_optional_value
@@ -115,10 +115,10 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'aaa', :short => 'a', :argument => :optional }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({ :aaa => 'xxx' },  result[:options])
-    assert_equal([ 'foo' ], result[:arguments])
+    assert_equal({ :aaa => 'xxx' },  parser.options)
+    assert_equal([ 'foo' ], parser.arguments)
   end
 
   def test_parse_with_long_valueless_option_with_optional_value_and_more_options
@@ -129,12 +129,12 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'ccc', :short => 'c', :argument => :forbidden }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(result[:options][:aaa])
-    assert(result[:options][:bbb])
-    assert(result[:options][:ccc])
-    assert_equal([ 'foo' ], result[:arguments])
+    assert(parser.options[:aaa])
+    assert(parser.options[:bbb])
+    assert(parser.options[:ccc])
+    assert_equal([ 'foo' ], parser.arguments)
   end
 
   def test_parse_with_short_valueless_options
@@ -143,10 +143,10 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'aaa', :short => 'a', :argument => :forbidden }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(result[:options][:aaa])
-    assert_equal([ 'foo', 'bar' ], result[:arguments])
+    assert(parser.options[:aaa])
+    assert_equal([ 'foo', 'bar' ], parser.arguments)
   end
 
   def test_parse_with_short_valueful_option_with_missing_value
@@ -158,7 +158,7 @@ class Cri::OptionParserTestCase < Cri::TestCase
     result = nil
 
     assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
     end
   end
 
@@ -170,12 +170,12 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'ccc', :short => 'c', :argument => :forbidden }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(result[:options][:aaa])
-    assert(result[:options][:bbb])
-    assert(result[:options][:ccc])
-    assert_equal([ 'foo', 'bar' ], result[:arguments])
+    assert(parser.options[:aaa])
+    assert(parser.options[:bbb])
+    assert(parser.options[:ccc])
+    assert_equal([ 'foo', 'bar' ], parser.arguments)
   end
 
   def test_parse_with_short_combined_valueful_options_with_missing_value
@@ -189,7 +189,7 @@ class Cri::OptionParserTestCase < Cri::TestCase
     result = nil
 
     assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
     end
   end
 
@@ -203,7 +203,7 @@ class Cri::OptionParserTestCase < Cri::TestCase
     result = nil
 
     assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
     end
   end
 
@@ -213,10 +213,10 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'aaa', :short => 'a', :argument => :optional }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(result[:options][:aaa])
-    assert_equal([ 'foo' ], result[:arguments])
+    assert(parser.options[:aaa])
+    assert_equal([ 'foo' ], parser.arguments)
   end
 
   def test_parse_with_short_valueful_option_with_optional_value
@@ -225,10 +225,10 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'aaa', :short => 'a', :argument => :optional }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({ :aaa => 'xxx' },  result[:options])
-    assert_equal([ 'foo' ], result[:arguments])
+    assert_equal({ :aaa => 'xxx' },  parser.options)
+    assert_equal([ 'foo' ], parser.arguments)
   end
 
   def test_parse_with_short_valueless_option_with_optional_value_and_more_options
@@ -239,32 +239,32 @@ class Cri::OptionParserTestCase < Cri::TestCase
       { :long => 'ccc', :short => 'c', :argument => :forbidden }
     ]
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(result[:options][:aaa])
-    assert(result[:options][:bbb])
-    assert(result[:options][:ccc])
-    assert_equal([ 'foo' ], result[:arguments])
+    assert(parser.options[:aaa])
+    assert(parser.options[:bbb])
+    assert(parser.options[:ccc])
+    assert_equal([ 'foo' ], parser.arguments)
   end
 
   def test_parse_with_single_hyphen
     input       = %w( foo - bar )
     definitions = []
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({},                    result[:options])
-    assert_equal([ 'foo', '-', 'bar' ], result[:arguments])
+    assert_equal({},                    parser.options)
+    assert_equal([ 'foo', '-', 'bar' ], parser.arguments)
   end
 
   def test_parse_with_end_marker
     input       = %w( foo bar -- -x --yyy -abc )
     definitions = []
 
-    result = Cri::OptionParser.parse(input, definitions)
+    parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({},                                      result[:options])
-    assert_equal([ 'foo', 'bar', '-x', '--yyy', '-abc' ], result[:arguments])
+    assert_equal({},                                      parser.options)
+    assert_equal([ 'foo', 'bar', '-x', '--yyy', '-abc' ], parser.arguments)
   end
 
   def test_parse_with_end_marker_between_option_key_and_value
@@ -274,7 +274,7 @@ class Cri::OptionParserTestCase < Cri::TestCase
     ]
 
     assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
     end
   end
 

metadata

@@ -2,7 +2,7 @@
 name: cri
 version: !ruby/object:Gem::Version 
   prerelease: 3
-  version: 2.0b1
+  version: 2.0rc1
 platform: ruby
 authors: 
 - Denis Defreyne
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-22 00:00:00 Z
+date: 2011-06-26 00:00:00 Z
 dependencies: []
 
 description: Cri allows building easy-to-use commandline interfaces with support for subcommands.