acclaim 0.0.4 → 0.0.5

data/README.markdown

@@ -2,4 +2,184 @@
 
 Command-line option parsing and command interface.
 
-Extracted from [Safeguard](https://github.com/matheusmoreira/safeguard).
+## Introduction
+
+Acclaim makes it easy to describe commands and options for a command-line
+application in a structured manner. Commands are classes that inherit from
+`Acclaim::Command`:
+
+    require 'acclaim'
+
+    module App
+      class Command < Acclaim::Command
+        option :verbose, '-v', '--verbose'
+
+        when_called do |options, args|
+          puts 'Hello World!'
+          puts args.join ', ' if options.verbose? and args.any?
+        end
+      end
+    end
+
+    $ app --verbose a b c
+    Hello World!
+    a, b, c
+
+Every command has a set of options and block that is executed when it is called.
+The options are parsed into an object and passed to the command's block along
+with the remaining command line arguments. The first argument of the `option`
+method is the key used to store the value of the option, the other strings are
+either switches or a description:
+
+    option :verbose, '-v', '--verbose', '--run-verbosely', 'Run verbosely.'
+
+Acclaim provides especial `help` and `version` commands that may be added to
+your program. The help command will automatically generate and print a help page
+for all commands and options. The version command will print your program's
+version and exit. To use them:
+
+    class App::Command
+      help
+      version '1.2.3'
+    end
+
+    $ app -h
+    $ app --help
+    $ app help
+
+          -v, --verbose, --run-verbosely    Run verbosely.
+          -h, --help    Show usage information and exit.
+          -v, --version    Show version and exit.
+
+    $ app -v
+    $ app --version
+    $ app version
+    1.2.3
+
+Both methods can take a hash as the last parameter, which accepts the same
+configurations. If you don't want the options, or if you want to specify a
+different set of switches or a different description, you can write something
+like:
+
+    help options: false
+    version '1.2.3', switches: %w(--version),
+                     description: "Shows this program's version."
+
+### Subcommands
+
+Essentially, a command given to another command. Subcommands benefit from all
+the option processing done by its parents. To create one, you simply inherit
+from an existing command:
+
+    class App::Command::Do < App::Command
+
+      # option is aliased as opt
+      opt :what, '--what', 'What to do.', default: 'something', arity: [1, 0]
+
+      # when_called is aliased as action
+      action do |options, args|
+        puts "Doing #{options.what} with #{args.join ', '}"
+      end
+    end
+
+    $ app do x, y, z
+    Doing something with x, y, z
+
+    $ app do --what x, y, z
+    Doing x with y, z
+
+Options may also take an Hash as the last parameter. Among the things that can
+be configured is the default value for the option and its arity. The default
+value is `nil` by default and is used if the option is not given. The arity of
+the option represents the minimum number of arguments it __must__ take and the
+number of optional arguments it __may__ take. It is specified as an array in the
+form `[minimum, optional]`. Options that take zero arguments, which is the
+default, are flags.
+
+So, options can take from zero to an unlimited number of arguments, right?
+
+    class App::Command::Do < App::Command
+
+      # Negative number of optional arguments denote unlimited argument count
+      opt :what, '--what', default: 'something', arity: [0, -1]
+
+      action do |options, args|
+        what = (options.what.join ', ' rescue options.what)
+        subjects = args.join ', '
+        puts "Doing #{what} with #{subjects}"
+    end
+
+    $ app do --what x y z
+    Doing x, y, z with
+
+Now, our option is eating up all the arguments in the command line! Hope is not
+lost, however. Even though the list of arguments may be unlimited, parsing will
+still stop if either another switch or an argument separator is encountered. An
+argument separator is a group of two or more dashes:
+
+    $ app do --what w x -- y z
+    Doing w, x with y, z
+
+An important thing to understand is that options are not parsed all at once;
+first, the main command's options are parsed, then the remaining arguments are
+searched for subcommands. If one is found, its options are parsed, the remaining
+arguments are searched and so on. If a subcommand can't be found, the most
+specific command found is executed.
+
+Options are deleted from the command line as they are parsed, so the following
+will not work:
+
+    $ app do --what w x --verbose y z
+    Doing w, x, y, z with
+
+This happens because `--verbose` is an option of the main command. Since it will
+be parsed and deleted from the argument array, when `do` gets its turn it will
+be parsing the `%w(--what w x y z)` array.
+
+### Option Type Handlers
+
+Arguments given to options are by default strings. To make life easier, you may
+specify the type of the arguments by passing a class among the arguments:
+
+    class App::Command::Do
+      opt :when, '--when', 'When to do it.', Date,
+                 default: Date.today, arity: [1,0]
+
+      action do |options, args|
+        what = (options.what.join ', ' rescue options.what)
+        subjects = args.join ', '
+        date = options.when
+        puts 'Merry Christmas!' if date.month == 12 and date.day == 25
+        date = date.strftime '%m/%d/%Y'
+        puts "Doing #{what} with #{subjects} on #{date}"
+      end
+    end
+
+    $ app do --what w x --when 2011-12-25 y z
+    Merry Christmas!
+    Doing w, x with y, z on 12/25/2011
+
+There are type handlers included for `Date`s, `Time`s, `DateTime`s, `URI`s and
+`String`s, but if you need more you can always write your own:
+
+    Acclaim::Option::Type.add_handler_for(Symbol) { |str| str.to_sym }
+
+    class App::Command::Handle < App::Command
+      opt :syms, '--symbol', '--symbols', Symbol, arity: [1,-1], required: true
+
+      when_called do |options, args|
+        options.syms.each { |sym| puts "#{sym.class} => #{sym.inspect}" }
+      end
+    end
+
+    $ app handle --symbols a s d
+    Symbol => :a
+    Symbol => :s
+    Symbol => :d
+
+`add_handler_for` takes a class and a block, which will be called for every
+argument of that class that must be parsed.
+
+---
+
+Originally extracted from [Safeguard](https://github.com/matheusmoreira/safeguard).

data/lib/acclaim.rb

@@ -1,11 +1,11 @@
+# Acclaim is a command line option parsing and command interface for Ruby.
+module Acclaim
+end
+
 %w(
 
 command
 option
-option/arity
-option/parser
-option/parser/regexp
-option/values
 version
 
 ).each { |file| require file.prepend 'acclaim/' }

data/lib/acclaim/command.rb

@@ -81,12 +81,12 @@ module Acclaim
 
       # Adds help subcommand and options to this command.
       def help(opts = {})
-        subcommands << Help.create(self, opts)
+        Help.create(self, opts)
       end
 
       # Adds help subcommand and options to this command.
       def version(version_string, opts = {})
-        subcommands << Version.create(self, version_string, opts)
+        Version.create(self, version_string, opts)
       end
 
       # Parses the argument array using this command's set of options.
@@ -113,6 +113,7 @@ module Acclaim
           args.delete subcommand.line
           subcommand.invoke(opts, args)
         else
+          args.delete_if { |arg| arg =~ Option::Parser::Regexp::ARGUMENT_SEPARATOR }
           execute(opts, args)
         end
       end
@@ -120,7 +121,7 @@ module Acclaim
       # Calls this command's action block with the given option values and
       # arguments.
       def execute(opts, args)
-        @action.call opts, args
+        @action.call opts, args if @action
       end
 
       alias :call :execute

data/lib/acclaim/command/help.rb

@@ -1,9 +1,17 @@
+require 'acclaim/command/help/template'
+
 module Acclaim
   class Command
 
     # Module which adds help support to a command.
     module Help
 
+      # Adds a special help option to the given +command+.
+      #
+      # The last argument is an option +Hash+, which accepts the following
+      # options:
+      #
+      # [:switches]  The switches used when creating the help option.
       def self.add_options_to!(command, opts = {})
         switches = opts.fetch :switches, %w(-h --help)
         description = opts.fetch :description, 'Show usage information and exit.'
@@ -12,6 +20,16 @@ module Acclaim
 
       private_class_method :add_options_to!
 
+      # Creates a help subcommand that inherits from the given +base+ command
+      # and stores the class in the +Help+ constant of +base+. When called, the
+      # command displays a help screen including information for all commands
+      # and then exits.
+      #
+      # The last argument is an option +Hash+, which accepts the following
+      # options:
+      #
+      # [:options]   If +true+, will add a help option to the +base+ command.
+      # [:switches]  The switches used when creating the help option.
       def self.create(base, opts = {})
         if opts.fetch :options, true
           add_options_to! base, opts
@@ -27,21 +45,7 @@ module Acclaim
       # Displays a very simple help screen for the given command and all its
       # subcommands.
       def self.display_help_for(command)
-        # TODO rewrite this VERY CRUDE implementation.
-        # Look into how to code a text formatter later.
-        help_string = ''
-        command.options.tap do |options|
-          if options.any?
-            help_string << "\nCommand '#{command.line}':\n\n" unless command.root?
-            max = options.map { |option| option.names.join(', ').length }.max
-            options.each do |option|
-              switches = option.names.join ', '
-              help_string << ' ' * 4 << switches << ' ' * (4 + max - switches.length)
-              help_string << option.description << "\n"
-            end
-          end
-        end
-        puts help_string unless help_string.empty?
+        puts Template.for(command) if command.options.any?
         command.subcommands.each { |subcommand| display_help_for subcommand }
       end
 

data/lib/acclaim/command/help/template.rb

@@ -0,0 +1,30 @@
+require 'erb'
+
+module Acclaim
+  class Command
+    module Help
+
+      # Manages help templates.
+      module Template
+
+        # Loads an ERB template file from the
+        # +lib/acclaim/command/help/template+ folder and instantiates a new ERB
+        # instance with its contents.
+        def self.load(template)
+          filename = File.join File.dirname(__FILE__), 'template', template
+          ERB.new File.read(filename), nil, '%<>'
+        end
+
+        # Computes the result of the template +file+ using the +command+'s
+        # binding.
+        def self.for(command, file = 'command.erb')
+          template = self.load file
+          b = command.instance_eval { binding }
+          template.result b
+        end
+
+      end
+
+    end
+  end
+end

data/lib/acclaim/command/help/template/command.erb

@@ -0,0 +1,8 @@
+<% unless root? or options.empty? %>
+  Command '<%= line %>':
+<% end %>
+
+<% options.each do |option| %>
+      <%= option.names.join ', ' %>    <%= option.description %>
+<% end %>
+

data/lib/acclaim/command/version.rb

@@ -4,6 +4,12 @@ module Acclaim
     # Module which adds version query support to a command.
     module Version
 
+      # Adds a special version option to the given +command+.
+      #
+      # The last argument is an option +Hash+, which accepts the following
+      # options:
+      #
+      # [:switches]  The switches used when creating the version option.
       def self.add_options_to!(command, opts = {})
         switches = opts.fetch :switches, %w(-v --version)
         description = opts.fetch :description, 'Show version and exit.'
@@ -12,6 +18,16 @@ module Acclaim
 
       private_class_method :add_options_to!
 
+      # Creates a <tt>version</tt> subcommand that inherits from the given
+      # +base+ command and stores the class in the +Version+ constant of +base+.
+      # When called, the command displays the +version_string+ of the program
+      # and then exits.
+      #
+      # The last argument is an option +Hash+, which accepts the following
+      # options:
+      #
+      # [:options]   If +true+, will add a version option to the +base+ command.
+      # [:switches]  The switches used when creating the version option.
       def self.create(base, version_string, opts = {})
         if opts.fetch :options, true
           add_options_to! base, opts

data/lib/acclaim/option.rb

@@ -9,6 +9,33 @@ module Acclaim
 
     attr_accessor :key, :names, :description, :type, :default, :handler
 
+    # Initializes a command line option. The +key+ is the object used to
+    # associate this option with a value. The other arguments may be:
+    #
+    # [short switches]  Strings starting with <tt>'-'</tt>, like:
+    #                   <tt>'-h'</tt>; <tt>'-v'</tt>
+    # [long switches]   Strings starting with <tt>'--'</tt>, like:
+    #                   <tt>'--help'</tt>; <tt>'--version'</tt>
+    # [description]     Strings that don't start with either <tt>'-'</tt>
+    #                   nor <tt>'--'</tt>, like:
+    #                   <tt>'Display this help text and exit.'</tt>;
+    #                   <tt>'Display version and exit.'</tt>
+    # [class]           The <tt>Class</tt> which will be used in parameter
+    #                   conversion. The default is <tt>String</tt>.
+    #
+    # The last argument can be a hash of options, which may specify:
+    #
+    # [:arity]     The number of required and optional arguments. See Arity for
+    #              defails.
+    # [:default]   The default value for this option.
+    # [:required]  Whether or not the option must be present on the command
+    #              line.
+    #
+    # Additionally, if a block is given, it will be called when the option is
+    # parsed with a Values instance and the parameters given to the option. The
+    # parameters will already be converted to this option's specified type; if
+    # this is not desirable consider not specifying a class to the option or
+    # registering a custom type handler.
     def initialize(key, *args, &block)
       options = args.last.is_a?(Hash) ? args.pop : {}
       matches = args.select { |arg| arg.is_a? String }.group_by do |arg|
@@ -25,18 +52,24 @@ module Acclaim
       self.handler     = block
     end
 
+    # Converts all given arguments using the type handler for this option's
+    # type.
     def convert_parameters(*args)
       args.map { |arg| Type[type].call arg }
     end
 
+    # Returns true if the given string is equal to any of this option's names.
     def =~(str)
       names.include? str.strip
     end
 
+    # Returns this option's arity. See Arity for details.
     def arity
       @arity ||= Arity.new
     end
 
+    # Sets this option's arity. The value given may be an Arity, or an array in
+    # the form of <tt>[ required_parameters, optional_parameters ]</tt>.
     def arity=(arity_or_array)
       @arity = if arity.nil? or arity_or_array.is_a? Arity
         arity_or_array
@@ -45,18 +78,22 @@ module Acclaim
       end
     end
 
+    # Whether or not this option is required on the command line.
     def required?
       @required
     end
 
+    # Sets whether or not this option is required.
     def required=(value)
-      @required = value
+      @required = (value ? true : false)
     end
 
+    # Require that this option be given on the command line.
     def require
       self.required = true
     end
 
+    # Returns true if this option takes no arguments.
     def flag?
       not arity or arity == [0, 0]
     end

data/lib/acclaim/option/arity.rb

@@ -39,6 +39,8 @@ module Acclaim
         bound? ? minimum + optional : nil
       end
 
+      # Converts this arity to an array in the form of
+      # <tt>[ required, optional ]</tt>.
       def to_a
         [ minimum, optional ]
       end
@@ -46,10 +48,16 @@ module Acclaim
       alias :to_ary   :to_a
       alias :to_array :to_a
 
+      # Equivalent to <tt>to_a.hash</tt>.
       def hash
         to_a.hash
       end
 
+      # Converts both +self+ and +arity+ to an array and compares them. This is
+      # so that comparing directly with an array is possible:
+      #
+      #   Arity.new(1, 3) == [1, 3]
+      #   => true
       def ==(arity)
         to_a == arity.to_a
       end
@@ -57,11 +65,21 @@ module Acclaim
       alias :eql? :==
       alias :===  :==
 
+      # Returns a string in the following format:
+      #
+      #   Arity: minimum +optional
+      #
+      # The value of +optional+ will be <tt>'infinite'</tt> if #unlimited? is
+      # +true+.
       def to_s
         "Arity: #{minimum} +#{unlimited? ? 'infinite' : optional}"
       end
 
-      alias :inspect :to_s
+      # Returns the output of #to_s, enclosed in angle brackets (<tt>'<'</tt>
+      # and <tt>'>'</tt>).
+      def inspect
+        "<#{to_s}>"
+      end
 
     end
 

data/lib/acclaim/option/parser.rb

@@ -9,12 +9,19 @@ module Acclaim
 
       include Parser::Regexp
 
+      # Errors raised by the parser.
       class Error < StandardError
 
+        # Raises an Error with the following error message:
+        #
+        #   Wrong number of arguments (actual for minimum)
         def self.raise_wrong_arg_number(actual, minimum, optional)
           raise self, "Wrong number of arguments (#{actual} for #{minimum})"
         end
 
+        # Raises an Error with the following error message:
+        #
+        #   Missing required argument (arg)
         def self.raise_missing_arg(arg)
           raise self, "Missing required argument (#{arg})"
         end
@@ -32,9 +39,22 @@ module Acclaim
       end
 
       # Parses the meaning of the options given to this parser. If none were
-      # given, the argument array will only be preprocessed. Any parsed options
+      # given, the argument array will be preprocessed only. Any parsed options
       # and arguments will be removed from the argument array, so pass in a
       # duplicate if you need the original.
+      #
+      #   include Acclaim
+      #
+      #   args = %w(-F log.txt --verbose arg1 arg2)
+      #   options = []
+      #   options << Option.new(:file, '-F', arity: [1,0], required: true)
+      #   options << Option.new(:verbose, '--verbose')
+      #
+      #   Option::Parser.new(args, options).parse!
+      #   => #<Acclaim::Option::Values:0x00000002a2fee8 @options={:file=>"log.txt", :verbose=>true}>
+      #
+      #   args
+      #   => ["arg1", "arg2"]
       def parse!
         preprocess_argv!
         parse_values! unless options.nil?
@@ -42,15 +62,16 @@ module Acclaim
 
       private
 
-      # Argument array preprocessing.
+      # Preprocesses the argument array.
       def preprocess_argv!
         split_multiple_short_options!
         normalize_parameters!
-        # TODO: normalize parameter formats?
-        # -sPARAM1[,PARAM2,PARAM3...] - possibly incompatible with split_multiple_short_options!
         argv.compact!
       end
 
+      # Splits multiple short options.
+      #
+      #   %w(-abcdef PARAM1 PARAM2) => %w(-a -b -c -d -e -f PARAM1 PARAM2)
       def split_multiple_short_options!
         argv.find_all { |arg| arg =~ MULTIPLE_SHORT_SWITCHES }.each do |multiples|
           multiples_index = argv.index multiples
@@ -60,6 +81,12 @@ module Acclaim
         end
       end
 
+      # Splits switches that are connected to a comma-separated parameter list.
+      #
+      #   %w(--switch=)              => %w(--switch)
+      #   %w(--switch=PARAM1,PARAM2) => %w(--switch PARAM1 PARAM2)
+      #   %w(--switch=PARAM1,)       => %w(--switch PARAM1)
+      #   %w(--switch=,PARAM2)       =>   [ '--switch', '', 'PARAM2' ]
       def normalize_parameters!
         argv.find_all { |arg| arg =~ SWITCH_PARAM_EQUALS }.each do |switch|
           switch_index = argv.index switch
@@ -70,20 +97,22 @@ module Acclaim
         end
       end
 
+      # Parses the options and their arguments, associating that information
+      # with a Values instance.
       def parse_values!
-        Values.new.tap do |options_instance|
+        Values.new.tap do |values|
           options.each do |option|
             key = option.key
-            options_instance[key] = option.default unless options_instance[key]
+            values[key] = option.default unless values[key]
             switches = argv.find_all { |switch| option =~ switch }
             if switches.any?
               if option.flag?
-                set_option_value option, options_instance
+                set_option_value option, values
+                argv.delete *switches
               else
                 switches.each do |switch|
                   params = extract_parameters_of! option, switch
-                  argv.delete switch
-                  set_option_value option, options_instance, params
+                  set_option_value option, values, params
                 end
               end
             else
@@ -93,6 +122,14 @@ module Acclaim
         end
       end
 
+      # Finds the +switch+ in #argv and scans the next +option.arity.total+
+      # elements if +option.arity.bound?+ is +true+, or all parameters
+      # otherwise. In either case, the algorithm will stop if it finds +nil+,
+      # another switch or an argument separator among the parameters.
+      #
+      # Deletes the switch and every value that was extracted from #argv. Raises
+      # an Error if the number of parameters found is less than
+      # +option.arity.required+.
       def extract_parameters_of!(option, switch)
         arity = option.arity
         switch_index = argv.index switch
@@ -113,9 +150,15 @@ module Acclaim
         end
         count = values.count
         Error.raise_wrong_arg_number count, *arity if count < arity.required
+        argv.delete switch
         values.each { |value| argv.delete value }
       end
 
+      # If the option has an custom handler associated, call it with the
+      # parameters. Otherwise, if the option is a flag, the value corresponding
+      # to the option's key will be set to +true+, if it is not, the value will
+      # be set to params.first+ if +params+ contains only one element or to
+      # +params+ if it contains more.
       def set_option_value(option, values, params = [])
         params = option.convert_parameters *params
         if handler = option.handler

data/lib/acclaim/option/parser/regexp.rb

@@ -7,13 +7,13 @@ module Acclaim
 
         # Regular expression for a short option switch.
         #
-        # Matches strings that begin with a single dash and contain only word
-        # characters or digits until the end of the string.
+        # Matches strings that begin with a single dash and contains only one
+        # word character or digit before the end of the string.
         #
-        # Examples: <tt>-s; -mult; -5; -_</tt>
+        # Examples: <tt>-s; -5; -_</tt>
         #
         # <tt>'-mult'</tt> will be split into <tt>%w(-m -u -l -t)</tt>.
-        SHORT_SWITCH = /\A-[\w\d]+\Z/
+        SHORT_SWITCH = /\A-[\w\d]\Z/
 
         # Regular expression for a long option switch.
         #
@@ -26,12 +26,6 @@ module Acclaim
         # --_private-option; --1-1</tt>
         LONG_SWITCH = /\A--[\w\d]+(-[\w\d]+)*\Z/
 
-        # Regular expression for any kind of option switch.
-        #
-        # Matches either a SHORT_SWITCH or a LONG_SWITCH. See their descriptions
-        # for details.
-        SWITCH = /(#{SHORT_SWITCH})|(#{LONG_SWITCH})/
-
         # Regular expression for multiple short options in a single "short"
         # switch.
         #
@@ -66,6 +60,12 @@ module Acclaim
         # of those isn't a decision for a preprocessor.
         SWITCH_PARAM_EQUALS = /\A--[\w\d]+(-?[\w\d]+)*=(,*[\w\d]*)*\Z/
 
+        # Regular expression for any kind of option switch.
+        #
+        # Matches anything that matches any of the other switch regular
+        # expressions.
+        SWITCH = /(#{SHORT_SWITCH})|(#{LONG_SWITCH})|(#{MULTIPLE_SHORT_SWITCHES})|(#{SWITCH_PARAM_EQUALS})/
+
         # Regular expression for the string that separates options and their
         # parameters from arguments like filenames.
         #

data/lib/acclaim/option/type.rb

@@ -4,45 +4,41 @@ module Acclaim
     # Associates a class with a handler block.
     module Type
 
-      instance_eval do
-
-        # Yields class, proc pairs if a block was given. Returns an enumerator
-        # otherwise.
-        def each(&block)
-          table.each &block
-        end
+      # Yields class, proc pairs if a block was given. Returns an enumerator
+      # otherwise.
+      def self.each(&block)
+        table.each &block
+      end
 
-        # Returns all registered classes.
-        def all
-          table.keys
-        end
+      # Returns all registered classes.
+      def self.all
+        table.keys
+      end
 
-        alias registered all
+      # Registers a handler for a class.
+      def self.register(klass, &block)
+        table[klass] = block
+      end
 
-        # Registers a handler for a class.
-        def register(klass, &block)
-          table[klass] = block
-        end
+      # Returns the handler for the given class.
+      def self.handler_for(klass)
+        table[klass]
+      end
 
+      class << self
+        alias registered all
         alias add_handler_for register
         alias accept register
-
-        # Returns the handler for the given class.
-        def handler_for(klass)
-          table[klass]
-        end
-
         alias [] handler_for
+      end
 
-        private
-
-        # The hash used to associate classes with their handlers.
-        def table
-          @table ||= {}
-        end
-
+      # The hash used to associate classes with their handlers.
+      def self.table
+        @table ||= {}
       end
 
+      private_class_method :table
+
     end
 
   end

data/lib/acclaim/option/type/date.rb

@@ -8,6 +8,7 @@ module Acclaim
       # Handles dates given as arguments in the command line.
       module Date
 
+        # Parses a +Date+ from the string.
         def self.handle(str)
           ::Date.parse str
         end

data/lib/acclaim/option/type/date_time.rb

@@ -8,6 +8,7 @@ module Acclaim
       # Handles dates and times given as arguments in the command line.
       module DateTime
 
+        # Parses a +DateTime+ from the string.
         def self.handle(str)
           ::DateTime.parse str
         end

data/lib/acclaim/option/type/string.rb

@@ -8,6 +8,7 @@ module Acclaim
       # Handles strings given as arguments in the command line.
       module String
 
+        # Simply returns +str.to_s+.
         def self.handle(str)
           str.to_s
         end

data/lib/acclaim/option/type/time.rb

@@ -8,6 +8,7 @@ module Acclaim
       # Handles times given as arguments in the command line.
       module Time
 
+        # Parses a +Time+ from the string.
         def self.handle(str)
           ::Time.parse str
         end

data/lib/acclaim/option/type/uri.rb

@@ -8,6 +8,7 @@ module Acclaim
       # Handles URIs given as arguments in the command line.
       module URI
 
+        # Parses an +URI+ from the string.
         def self.handle(str)
           ::URI.parse str
         end

data/lib/acclaim/version.rb

@@ -1,11 +1,30 @@
 module Acclaim
+
+  # Acclaim's version.
   module Version
 
+    # Major version.
+    #
+    # Increments denote backward-incompatible changes and additions.
     MAJOR = 0
+
+    # Minor version.
+    #
+    # Increments denote backward-compatible changes and additions.
     MINOR = 0
-    PATCH = 4
+
+    # Patch version.
+    #
+    # Increments denote changes in implementation.
+    PATCH = 5
+
+    # Build version.
+    #
+    # Used for pre-release versions.
     BUILD = nil
 
+    # Complete version string, which is every individual version number joined
+    # by a dot (<tt>'.'</tt>), in descending order of prescedence.
     STRING = [ MAJOR, MINOR, PATCH, BUILD ].compact.join '.'
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acclaim
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2011-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &13170100 !ruby/object:Gem::Requirement
+  requirement: &8505620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13170100
+  version_requirements: *8505620
 - !ruby/object:Gem::Dependency
   name: rookie
-  requirement: &13169620 !ruby/object:Gem::Requirement
+  requirement: &8505100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13169620
+  version_requirements: *8505100
 description: Command-line option parser and command interface.
 email: matheus.a.m.moreira@gmail.com
 executables: []
@@ -49,6 +49,8 @@ files:
 - lib/acclaim.rb
 - lib/acclaim/command.rb
 - lib/acclaim/command/help.rb
+- lib/acclaim/command/help/template.rb
+- lib/acclaim/command/help/template/command.erb
 - lib/acclaim/command/version.rb
 - lib/acclaim/option.rb
 - lib/acclaim/option/arity.rb