acclaim 0.0.2 → 0.0.3

data/.gitignore

@@ -1 +1,2 @@
 *.lock
+doc/

data/lib/acclaim.rb

@@ -1 +1,11 @@
-%w(command option option/parser options version).each { |file| require file.prepend 'acclaim/' }
+%w(
+
+command
+option
+option/arity
+option/parser
+option/parser/regexp
+option/values
+version
+
+).each { |file| require file.prepend 'acclaim/' }

data/lib/acclaim/command.rb

@@ -1,5 +1,8 @@
+require 'acclaim/command/help'
+require 'acclaim/command/version'
 require 'acclaim/option'
 require 'acclaim/option/parser'
+require 'acclaim/option/parser/regexp'
 require 'acclaim/option/values'
 
 module Acclaim
@@ -12,21 +15,21 @@ module Acclaim
   #
   # A subcommand benefits from its parent's option processing.
   #
-  #   app do something --option --option-for-something
+  #   app --global-option do something --option-for-do --option-for-something
   #
-  # A command can be instantiated in the following form:
+  # A command can be created in the following form:
   #
   #   class App::Command < Acclaim::Command
-  #     opt :verbose, names: %w(-v --verbose), description: 'Run verbosely'
+  #     option :verbose, '-v', '--verbose', 'Run verbosely'
   #   end
   #
   # A subcommand can be created by inheriting from another command:
   #
   #   class App::Command::Do < App::Command
-  #     opt :what, names: %w(-W --what), description: 'Do what?', arity: [1, 0], required: true
+  #     opt :what, '-W', '--what', 'What to do', arity: [1, 0], required: true
   #     when_called do |options, arguments|
-  #       puts "Verbose? #{options.verbose? ? 'yes' : 'no'}"
-  #       puts "Doing #{options.what} with #{arguments.inspect} now!"
+  #       puts "Verbose? #{options.verbose? ? :yes : :no}"
+  #       puts "Doing #{options.what} with #{arguments.join ' and ')}!"
   #     end
   #   end
   #
@@ -34,11 +37,11 @@ module Acclaim
   #
   #   App::Command.run *ARGV
   #
-  # Subcommands inherit their parent's option processing:
+  # See it in action:
   #
-  #   $ app --verbose -W test do arg1 arg2
+  #   $ app --verbose do --what testing acclaim safeguard
   #   Verbose? yes
-  #   Doing test with ["arg1", "arg2"] now!
+  #   Doing testing with acclaim and safeguard!
   class Command
 
     # Module containing the class methods every command class should inherit.
@@ -46,8 +49,8 @@ module Acclaim
 
       # String which calls this command.
       def line(value = nil)
-        @line = value if value
-        @line
+        @line = value
+        @line ||= name.gsub(/^.*::/, '').downcase
       end
 
       # Commands which may be given to this command.
@@ -76,6 +79,14 @@ module Acclaim
 
       alias :when_called :action
 
+      def help(opts = {})
+        subcommands << Help.create(self, opts)
+      end
+
+      def version(version_string, opts = {})
+        subcommands << Version.create(self, version_string, opts)
+      end
+
       # Parses the argument array using this command's set of options.
       def parse_options!(args)
         Option::Parser.new(args, options).parse!
@@ -94,7 +105,10 @@ module Acclaim
       # otherwise.
       def invoke(opts, args = [])
         opts.merge! parse_options!(args)
-        arg_separator = args.find { |arg| arg =~ Option::Parser::ARGUMENT_SEPARATOR }
+        handle_special_options! opts, args
+        arg_separator = args.find do |arg|
+          arg =~ Option::Parser::Regexp::ARGUMENT_SEPARATOR
+        end
         separator_index = args.index arg_separator
         subcommands.find do |subcommand|
           index = args.index subcommand.line
@@ -118,13 +132,30 @@ module Acclaim
 
       alias :call :execute
 
+      def root?
+        superclass == Acclaim::Command
+      end
+
+      def root
+        command = self
+        command = command.superclass until command.root?
+        command
+      end
+
+      private
+
+      # Handles special options such as <tt>--help</tt> or <tt>--version</tt>.
+      def handle_special_options!(opts, args)
+        const_get(:Help).execute opts, args if opts.acclaim_help?
+        const_get(:Version).execute opts, args if opts.acclaim_version?
+      end
+
     end
 
     # Add the class methods to the subclass and add it to this command's list of
     # subcommands.
     def self.inherited(sub)
       sub.extend ClassMethods
-      sub.line sub.name.gsub(/^.*::/, '').downcase
       subcommands << sub if respond_to? :subcommands
     end
 

data/lib/acclaim/command/help.rb

@@ -0,0 +1,51 @@
+module Acclaim
+  class Command
+
+    # Module which adds help support to a command.
+    module Help
+
+      def self.add_options_to!(command, opts = {})
+        switches = opts.fetch :switches, %w(-h --help)
+        description = opts.fetch :description, 'Show usage information and exit.'
+        command.option :acclaim_help, *switches, description
+      end
+
+      private_class_method :add_options_to!
+
+      def self.create(base, opts = {})
+        if opts.fetch :options, true
+          add_options_to! base, opts
+        end
+        base.const_set(:Help, Class.new(base)).tap do |help_command|
+          help_command.when_called do |options, args|
+            display_help_for base.root
+            exit
+          end
+        end
+      end
+
+      # 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?
+        command.subcommands.each { |subcommand| display_help_for subcommand }
+      end
+
+    end
+
+  end
+end

data/lib/acclaim/command/version.rb

@@ -0,0 +1,30 @@
+module Acclaim
+  class Command
+
+    # Module which adds version query support to a command.
+    module Version
+
+      def self.add_options_to!(command, opts = {})
+        switches = opts.fetch :switches, %w(-v --version)
+        description = opts.fetch :description, 'Show version and exit.'
+        command.option :acclaim_version, *switches, description
+      end
+
+      private_class_method :add_options_to!
+
+      def self.create(base, version_string, opts = {})
+        if opts.fetch :options, true
+          add_options_to! base, opts
+        end
+        base.const_set(:Version, Class.new(base)).tap do |version_command|
+          version_command.when_called do |options, args|
+            puts version_string
+            exit
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/acclaim/option.rb

@@ -1,20 +1,18 @@
 require 'acclaim/option/arity'
-require 'acclaim/option/parser'
+require 'acclaim/option/parser/regexp'
 
 module Acclaim
 
   # Represents a command-line option.
   class Option
 
-    attributes = %w().map!(&:to_sym).freeze
-
     attr_accessor :key, :names, :description, :type, :default
 
     def initialize(key, *args)
       options = args.last.is_a?(Hash) ? args.pop : {}
       self.key         = key
-      self.names       = args.find_all { |arg| arg =~ Parser::SWITCH }
-      self.description = args.find     { |arg| arg !~ Parser::SWITCH }
+      self.names       = args.find_all { |arg| arg =~ Parser::Regexp::SWITCH }
+      self.description = args.find     { |arg| arg !~ Parser::Regexp::SWITCH }
       self.type        = args.find     { |arg| arg.is_a? Class }
       self.arity       = options[:arity]
       self.default     = options[:default]

data/lib/acclaim/option/arity.rb

@@ -8,6 +8,10 @@ module Acclaim
       attr_accessor :minimum, :optional
       alias :required :minimum
 
+      # Initializes this arity with a number of required parameters and a number
+      # of optional parameters. If the latter is less than zero, then it means
+      # the option may take infinite parameters, as long as it takes at least
+      # +minimum+ parameters.
       def initialize(minimum = 0, optional = 0)
         @minimum, @optional = minimum, optional
       end

data/lib/acclaim/option/parser.rb

@@ -1,3 +1,4 @@
+require 'acclaim/option/parser/regexp'
 require 'acclaim/option/values'
 
 module Acclaim
@@ -6,31 +7,7 @@ module Acclaim
     # Parses arrays of strings and returns an Options instance containing data.
     class Parser
 
-      # Regular expression for any kind of option switch.
-      #
-      # Matches strings that begin with 1 or 2 dashes, are followed by at least
-      # one word character or number, and may be followed by any other word
-      # character, number or dash.
-      #
-      # Examples: -s, --long, -multiple, -1, --no-feature, --with_underscore,
-      #           --_private_option, etc.
-      SWITCH = /^-{1,2}[\w\d]+[\w\d-]*$/
-
-      # Regular expression for multiple short options in a single "short"
-      # switch.
-      #
-      # Matches strings that begin with a single dash and are followed by 2 or
-      # more word characters, among which is the underscore but not the dash
-      # character.
-      #
-      # Examples: -xvf, -abc, -de_f
-      MULTIPLE_SHORT_SWITCHES = /^-\w{2,}$/
-
-      # Regular expression for the string that separates options and their
-      # parameters from arguments like filenames.
-      #
-      # Matches strings made up of 2 or more dashes.
-      ARGUMENT_SEPARATOR = /^-{2,}$/
+      include Parser::Regexp
 
       class Error < StandardError
 
@@ -54,9 +31,13 @@ module Acclaim
         self.options = options
       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
+      # and arguments will be removed from the argument array, so pass in a
+      # duplicate if you need the original.
       def parse!
         preprocess_argv!
-        instance = build_options_instance! unless options.nil?
+        parse_values! unless options.nil?
       end
 
       private
@@ -64,9 +45,8 @@ module Acclaim
       # Argument array preprocessing.
       def preprocess_argv!
         split_multiple_short_options!
+        normalize_parameters!
         # TODO: normalize parameter formats?
-        # --switch=PARAM1[,PARAM2,PARAM3] - split on =, then split on comma,
-        #                                   then reinsert them into argv
         # -sPARAM1[,PARAM2,PARAM3...] - possibly incompatible with split_multiple_short_options!
         argv.compact!
       end
@@ -75,16 +55,22 @@ module Acclaim
         argv.find_all { |arg| arg =~ MULTIPLE_SHORT_SWITCHES }.each do |multiples|
           multiples_index = argv.index multiples
           argv.delete multiples
-          letters = multiples.sub!(/^-/, '').split(//)
-          letters.each { |letter| letter.prepend '-' }.tap do |options|
-            options.each_index do |option_index|
-              argv.insert multiples_index + option_index, options[option_index]
-            end
-          end
+          switches = multiples.sub!(/^-/, '').split(//).each { |letter| letter.prepend '-' }
+          argv.insert multiples_index, *switches
         end
       end
 
-      def build_options_instance!
+      def normalize_parameters!
+        argv.find_all { |arg| arg =~ SWITCH_PARAM_EQUALS }.each do |switch|
+          switch_index = argv.index switch
+          argv.delete switch
+          switch, params = switch.split /\=/
+          params = (params or '').split /,/
+          argv.insert switch_index, *[ switch, *params ]
+        end
+      end
+
+      def parse_values!
         Values.new.tap do |options_instance|
           options.each do |option|
             key = option.key.to_sym
@@ -114,11 +100,8 @@ module Acclaim
                   end
                   count = values.count
                   Error.raise_wrong_arg_number count, *option.arity if count < arity.required
-                  options_instance[key] = if arity.only? 1
-                    values.first
-                  else
-                    values
-                  end
+                  value = if arity.total == 1 then values.first else values end
+                  options_instance[key] = value unless values.empty?
                   values.each { |value| argv.delete value }
                 end
               end

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

@@ -0,0 +1,79 @@
+module Acclaim
+  class Option
+    class Parser
+
+      # Contains all regular expressions used by the parser.
+      module Regexp
+
+        # 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.
+        #
+        # Examples: <tt>-s; -mult; -5; -_</tt>
+        #
+        # <tt>'-mult'</tt> will be split into <tt>%w(-m -u -l -t)</tt>.
+        SHORT_SWITCH = /\A-[\w\d]+\Z/
+
+        # Regular expression for a long option switch.
+        #
+        # Matches strings that begin with a double dash, contain one or more
+        # word character or digit, and can be followed by either nothing or a
+        # single dash. The latter must be followed by one or more word character
+        # or digit.
+        #
+        # Examples: <tt>--long; --no-feature; --with_underscore;
+        # --_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.
+        #
+        # Matches strings that begin with a single dash and are followed by 2 or
+        # more word characters, among which is the underscore but not the dash
+        # character.
+        #
+        # Examples: -xvf, -abc, -de_f
+        MULTIPLE_SHORT_SWITCHES = /\A-\w{2,}\Z/
+
+        # Regular expression for a long switch connected to its parameters with
+        # an equal sign. Multiple parameters are be separated by commas.
+        #
+        # Matches strings that begin with a double dash, are followed by one or
+        # more word character or digit and may be followed by one dash and one
+        # or more word character or digit.
+        #
+        # After that, there must be an equals sign, which must be followed by
+        # either nothing, any number of commmas or any number of word characters
+        # or digits.
+        #
+        # Examples:
+        # <tt>
+        # --switch=PARAM; --files=f1,f2,f3; --weird=,PARAM2; --empty=,,; --none=
+        # </tt>
+        #
+        # The reason something like <tt>'--none='</tt> is allowed is because it
+        # will become <tt>['--none']</tt> when it is split up.
+        # <tt>'--empty=,,'</tt> will become <tt>['--empty']</tt>
+        # <tt>'--weird=,PARAM2'</tt> will become
+        # <tt>['--weird', '', 'PARAM2']</tt> when it is split up. What to make
+        # of those isn't a decision for a preprocessor.
+        SWITCH_PARAM_EQUALS = /\A--[\w\d]+(-?[\w\d]+)*=(,*[\w\d]*)*\Z/
+
+        # Regular expression for the string that separates options and their
+        # parameters from arguments like filenames.
+        #
+        # Matches strings made up of 2 or more dashes.
+        ARGUMENT_SEPARATOR = /\A-{2,}\Z/
+
+      end
+
+    end
+  end
+end

data/lib/acclaim/option/values.rb

@@ -4,30 +4,33 @@ module Acclaim
     # Represents a set of option values.
     class Values
 
+      # Gets a value by key.
       def [](key)
         data[key]
       end
 
+      # Sets a value by key.
       def []=(key, value)
         data[key] = value
       end
 
+      # Merge these values with the others.
       def merge!(other, &block)
         data.merge! other.data, &block
       end
 
       # Handles the following cases:
       #
-      #   options.method = value
-      #   options.method?
-      #   options.method
+      #   options.method = value  =>  options[method] = value
+      #   options.method?         =>  options[method] ? true : false
+      #   options.method          =>  options[method]
       def method_missing(method, *args, &block)
-        m = method.to_s
-        case m
+        m = method.to_s.chop!.to_sym
+        case method
           when /=$/
-            self[:"#{m.chop!}"] = args.first
+            self[m] = args.first
           when /\?$/
-            self[:"#{m.chop!}"] ? true : false
+            self[m] ? true : false
           else
             self[method]
         end

data/lib/acclaim/version.rb

@@ -3,7 +3,7 @@ module Acclaim
 
     MAJOR = 0
     MINOR = 0
-    PATCH = 2
+    PATCH = 3
     BUILD = nil
 
     STRING = [ MAJOR, MINOR, PATCH, BUILD ].compact.join '.'

data/spec/acclaim/option/arity_spec.rb

@@ -0,0 +1,236 @@
+require 'acclaim/option/arity'
+
+describe Acclaim::Option::Arity do
+
+  subject { Acclaim::Option::Arity.new(required, optional) }
+
+  context 'an arity that does not require any parameters' do
+    let(:required) { 0 }
+    let(:optional) { 0 }
+
+    describe '#only?' do
+      context 'when given zero' do
+        it 'should return true' do
+          subject.only?(0).should be_true
+        end
+      end
+
+      context 'when given a non-zero number' do
+        let(:number) { 1 }
+
+        it 'should return false' do
+          subject.only?(number).should be_false
+        end
+      end
+    end
+
+    describe '#unlimited?' do
+      it 'should return false' do
+        subject.unlimited?.should be_false
+      end
+    end
+
+    describe '#bound?' do
+      it 'should return true' do
+        subject.bound?.should be_true
+      end
+    end
+
+    describe '#total' do
+      it 'should equal zero' do
+        subject.total.should == 0
+      end
+    end
+
+    context 'but allows five optional parameters' do
+      let(:optional) { 5 }
+
+      describe '#only?' do
+        context 'when given the number of required parameters' do
+          it 'should return false' do
+            subject.only?(required).should be_false
+          end
+        end
+
+        context 'when given a number other than the required number of parameters' do
+          let(:number) { required + 10 }
+
+          it 'should return false' do
+            subject.only?(number).should be_false
+          end
+        end
+      end
+
+      describe '#unlimited?' do
+        it 'should return false' do
+          subject.unlimited?.should be_false
+        end
+      end
+
+      describe '#bound?' do
+        it 'should return true' do
+          subject.bound?.should be_true
+        end
+      end
+
+      describe '#total' do
+        it 'should equal five' do
+          subject.total.should == 5
+        end
+      end
+    end
+
+    context 'but allows for unlimited additional parameters' do
+      let(:optional) { -1 }
+
+      describe '#only?' do
+        context 'when given the number of required parameters' do
+          it 'should return false' do
+            subject.only?(required).should be_false
+          end
+        end
+
+        context 'when given a number other than the required number of parameters' do
+          let(:number) { required + 10 }
+
+          it 'should return false' do
+            subject.only?(number).should be_false
+          end
+        end
+      end
+
+      describe '#unlimited?' do
+        it 'should return true' do
+          subject.unlimited?.should be_true
+        end
+      end
+
+      describe '#bound?' do
+        it 'should return false' do
+          subject.bound?.should be_false
+        end
+      end
+
+      describe '#total' do
+        it 'should return nil' do
+          subject.total.should be_nil
+        end
+      end
+    end
+  end
+
+  context 'an arity which requires one parameter' do
+    let(:required) { 1 }
+    let(:optional) { 0 }
+
+    describe '#only?' do
+      context 'when given one' do
+        it 'should return true' do
+          subject.only?(required).should be_true
+        end
+      end
+
+      context 'when given a number other than the required number of parameters' do
+        let(:number) { required + 10 }
+        it 'should return false' do
+          subject.only?(number).should be_false
+        end
+      end
+    end
+
+    describe '#unlimited?' do
+      it 'should return false' do
+        subject.unlimited?.should be_false
+      end
+    end
+
+    describe '#bound?' do
+      it 'should return true' do
+        subject.bound?.should be_true
+      end
+    end
+
+    describe '#total' do
+      it 'should equal one' do
+        subject.total.should == 1
+      end
+    end
+
+    context 'and allows for 4 additional parameters' do
+      let(:optional) { 4 }
+
+      describe '#only?' do
+        context 'when given the number of required parameters' do
+          it 'should return false' do
+            subject.only?(required).should be_false
+          end
+        end
+
+        context 'when given a number other than the required number of parameters' do
+          let(:number) { required + 10 }
+
+          it 'should return false' do
+            subject.only?(number).should be_false
+          end
+        end
+      end
+
+      describe '#unlimited?' do
+        it 'should return false' do
+          subject.unlimited?.should be_false
+        end
+      end
+
+      describe '#bound?' do
+        it 'should return true' do
+          subject.bound?.should be_true
+        end
+      end
+
+      describe '#total' do
+        it 'should equal five' do
+          subject.total.should == 5
+        end
+      end
+    end
+
+    context 'and allows for unlimited additional parameters' do
+      let(:optional) { -1 }
+
+      describe '#only?' do
+        context 'when given the number of required parameters' do
+          it 'should return false' do
+            subject.only?(required).should be_false
+          end
+        end
+
+        context 'when given a number other than the required number of parameters' do
+          let(:number) { required + 10 }
+
+          it 'should return false' do
+            subject.only?(number).should be_false
+          end
+        end
+      end
+
+      describe '#unlimited?' do
+        it 'should return true' do
+          subject.unlimited?.should be_true
+        end
+      end
+
+      describe '#bound?' do
+        it 'should return false' do
+          subject.bound?.should be_false
+        end
+      end
+
+      describe '#total' do
+        it 'should return nil' do
+          subject.total.should be_nil
+        end
+      end
+    end
+  end
+
+end

data/spec/acclaim/option/parser_spec.rb

@@ -3,93 +3,204 @@ require 'acclaim/option/parser'
 
 describe Acclaim::Option::Parser do
 
+  let!(:args)   { [] }
+  let(:options) { nil }
+  subject { Acclaim::Option::Parser.new(args, options) }
+
   describe '#parse!' do
+    context 'when given a long switch with a parameter separated by an equals sign' do
+      let!(:args) { %w(--switch=PARAM) }
 
-    let!(:args) do
-      %w(cmd -a subcmd -b PARAM1 -cdef PARAM2 --long --parameters PARAM3 PARAM4 PARAM5 -- FILE1 FILE2)
+      it 'should separate the switch from the single parameter' do
+        subject.parse!
+        args.should == %w(--switch PARAM)
+      end
     end
 
-    subject { Acclaim::Option::Parser.new(args) }
+    context 'when given a long switch with multiple parameters separated by an equals sign' do
+      let!(:args) { %w(--files FILE1 FILE2 FILE3) }
 
-    it 'should split multiple short options' do
-      new_argv = args.dup.tap do |args|
-        args[args.index('-cdef')] = %w[-c -d -e -f]
-      end.flatten!
-      subject.parse!
-      args.should == new_argv
+      it 'should separate the switch and the parameters' do
+        subject.parse!
+        args.should == %w(--files FILE1 FILE2 FILE3)
+      end
+
+      context 'but the parameter list starts with a comma' do
+        let!(:args) { %w(--files=,FILE2,FILE3) }
+
+        it 'should treat the first parameter as if it was an empty string' do
+          subject.parse!
+          args.should == ['--files', '', 'FILE2', 'FILE3']
+        end
+      end
     end
 
-    context 'when not given an array of options' do
+    context 'when given a long siwtch with an equals sign' do
+      context 'but no parameters' do
+        let!(:args) { %w(--none=) }
 
-      it 'should not return an options instance' do
-        subject.parse!.should be_nil
+        it 'should separate the switch from the empty parameter' do
+          subject.parse!
+          args.should == %w(--none)
+        end
       end
 
-    end
+      context 'but with a parameter list that consists of three commas' do
+        let!(:args) { %w(--empty=,,,) }
 
-    context 'when given an array of options' do
+        it 'should treat the parameters as if they were not there' do
+          subject.parse!
+          args.should == %w(--empty)
+        end
 
-      let(:options) do
-        [].tap do |opts|
-          ('a'..'f').each do |c|
-            hash = {}
-            hash[:arity] = [1, 0] if c == 'b' or c == 'f'
-            hash[:required] = true if c == 'd'
-            opts << Acclaim::Option.new(c.to_sym, "-#{c}", hash)
+        context 'and ends with a parameter' do
+          let!(:args) { %w(--not-pretty=,,,PARAM4) }
+
+          it 'should treat the first three parameters as if they were empty strings' do
+            subject.parse!
+            args.should == ['--not-pretty', '', '', '', 'PARAM4']
           end
-          opts << Acclaim::Option.new(:long, '--long')
-          opts << Acclaim::Option.new(:params, '--parameters', arity: [1, 1], default: [])
         end
       end
+    end
+
+    context 'when given multiple combined short options' do
+      let!(:args) { %w(-abcd) }
+
+      it 'should split the combined option into multiple short options' do
+        subject.parse!
+        args.should == %w(-a -b -c -d)
+      end
+    end
 
-      subject { Acclaim::Option::Parser.new(args, options) }
+    context 'when not given an array of options' do
+      it 'should not return any option values' do
+        subject.parse!.should be_nil
+      end
+    end
 
-      it 'should return an options instance' do
+    context 'when given an array of options' do
+      let(:options) { [ Acclaim::Option.new(:option) ] }
+
+      it 'should return option values' do
         subject.parse!.should_not be_nil
       end
 
-      it 'should parse arguments correctly' do
-        subject.parse!.instance_eval do
-          a?.should be_true
-          b.should == 'PARAM1'
-          c?.should be_true
-          d?.should be_true
-          e?.should be_true
-          f.should == 'PARAM2'
-          long?.should be_true
-          params.should == %w(PARAM3 PARAM4)
+      context 'containing a required option' do
+        let(:options) { [ Acclaim::Option.new(:option, '-o', required: true) ] }
+
+        context 'but not given the required switch' do
+          let!(:args) { [] }
+
+          it 'should raise an error' do
+            expect { subject.parse! }.to raise_error Acclaim::Option::Parser::Error, /required/
+          end
         end
-      end
 
-      it 'should leave unparsed arguments in argv' do
-        subject.parse!
-        args.should == %w(cmd subcmd PARAM5 -- FILE1 FILE2)
+        context 'and given the required switch' do
+          let!(:args) { %w(-o) }
+
+          it 'parse the value of the option correctly' do
+            subject.parse!.option?.should be_true
+          end
+        end
       end
 
-      context 'but not given a required parameter' do
+      context 'containing an option with a required parameter' do
+        let(:options) { [ Acclaim::Option.new(:option, '-o', arity: [1,0]) ] }
 
-        let!(:args) { %w(-db) }
+        context "and not given the option's switch" do
+          let!(:args) { [] }
 
-        it 'should raise an error' do
-          expect { subject.parse! }.to raise_error Acclaim::Option::Parser::Error,
-                                                   /number of arguments/
+          it 'should not raise an error' do
+            expect { subject.parse! }.to_not raise_error Acclaim::Option::Parser::Error, /arguments/
+          end
         end
 
+        context "and given the option's switch" do
+          context 'with a parameter' do
+            let!(:args) { %w(-o PARAM) }
+
+            it 'should not raise an error' do
+              expect { subject.parse! }.to_not raise_error Acclaim::Option::Parser::Error, /arguments/
+            end
+
+            it 'should parse the value of the parameter correctly' do
+              subject.parse!.option.should == 'PARAM'
+            end
+          end
+
+          context 'without a parameter' do
+            let!(:args) { %w(-o) }
+
+            it 'should raise an error' do
+              expect { subject.parse! }.to raise_error Acclaim::Option::Parser::Error, /arguments/
+            end
+          end
+        end
       end
 
-      context 'but not passed a required option' do
+      context 'containing an option with an optional argument' do
+        let(:options) { [ Acclaim::Option.new(:volume, '-V', arity: [0,1], default: 2) ] }
+
+        context 'and not given the option a parameter' do
+          let!(:args) { %w(-V) }
 
-        let!(:args) { [] }
+          it 'should not raise an error' do
+            expect { subject.parse! }.to_not raise_error Acclaim::Option::Parser::Error, /arguments/
+          end
 
-        it 'should raise an error' do
-          expect { subject.parse! }.to raise_error Acclaim::Option::Parser::Error,
-                                                   /required/
+          it 'should initialize the option to its default' do
+            subject.parse!.volume.should == 2
+          end
         end
 
+        context 'and given the option a parameter' do
+          let!(:args) { %w(-V 5) }
+
+          it 'should not raise an error' do
+            expect { subject.parse! }.to_not raise_error Acclaim::Option::Parser::Error, /arguments/
+          end
+
+          it 'should initialize the option to the value given' do
+            subject.parse!.volume.should == '5'
+          end
+        end
       end
 
-    end
+      context 'containing an option that requires at least one argument' do
+        let(:options) { [ Acclaim::Option.new(:files, '--files', arity: [1,-1]) ] }
+
+        context 'and not given the switch any arguments' do
+          let!(:args) { %w(--files) }
+
+          it 'should raise an error' do
+            expect { subject.parse! }.to raise_error Acclaim::Option::Parser::Error, /arguments/
+          end
+        end
+
+        context 'and given the switch three arguments' do
+          let!(:args) { %w(--files FILE1 FILE2 FILE3) }
+
+          it 'should not raise an error' do
+            expect { subject.parse! }.to_not raise_error Acclaim::Option::Parser::Error, /arguments/
+          end
+
+          it 'should initialize the option to the values given' do
+            subject.parse!.files.should == %w(FILE1 FILE2 FILE3)
+          end
+
+          context 'among other arguments and commands' do
+            let!(:args) { %w(cmd subcmd --files FILE1 FILE2 -- ARG1 ARG2) }
 
+            it 'should ignore the other arguments and leave them where they are' do
+              subject.parse!
+              args.should == %w(cmd subcmd -- ARG1 ARG2)
+            end
+          end
+        end
+      end
+    end
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acclaim
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-18 00:00:00.000000000 Z
+date: 2011-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &7597280 !ruby/object:Gem::Requirement
+  requirement: &13323500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *7597280
+  version_requirements: *13323500
 description: Command-line option parser and command interface.
 email: matheus.a.m.moreira@gmail.com
 executables: []
@@ -37,11 +37,15 @@ files:
 - acclaim.gemspec
 - lib/acclaim.rb
 - lib/acclaim/command.rb
+- lib/acclaim/command/help.rb
+- lib/acclaim/command/version.rb
 - lib/acclaim/option.rb
 - lib/acclaim/option/arity.rb
 - lib/acclaim/option/parser.rb
+- lib/acclaim/option/parser/regexp.rb
 - lib/acclaim/option/values.rb
 - lib/acclaim/version.rb
+- spec/acclaim/option/arity_spec.rb
 - spec/acclaim/option/parser_spec.rb
 - spec/acclaim/option_spec.rb
 homepage: https://github.com/matheusmoreira/acclaim