acclaim 0.0.5 → 0.0.6

data/Gemfile

@@ -1,3 +1,11 @@
 source :rubygems
 
 gemspec
+
+{
+  ribbon: '~/projects/ribbon',
+  rookie: '~/projects/rookie'
+}.each do |project, path|
+  path = File.expand_path path
+  gem project.to_s, path: path if Dir.exists? path
+end

data/README.markdown

@@ -82,10 +82,10 @@ from an existing command:
       end
     end
 
-    $ app do x, y, z
-    Doing something with x, y, z
+    $ app do x y, z
+    Doing something with x y, z
 
-    $ app do --what 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

data/acclaim.gemspec

@@ -16,6 +16,8 @@ Gem::Specification.new('acclaim') do |gem|
 
   gem.files       = `git ls-files`.split "\n"
 
+  gem.add_runtime_dependency 'ribbon'
+
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'rookie'
 

data/lib/acclaim/command.rb

@@ -1,9 +1,10 @@
 require 'acclaim/command/help'
+require 'acclaim/command/parser'
 require 'acclaim/command/version'
 require 'acclaim/option'
 require 'acclaim/option/parser'
 require 'acclaim/option/parser/regexp'
-require 'acclaim/option/values'
+require 'ribbon'
 
 module Acclaim
 
@@ -71,7 +72,7 @@ module Acclaim
       alias :opt :option
 
       # The block which is executed when this command is called. It is given 2
-      # parameters; the first is an Option::Values instance which can be queried
+      # parameters; the first is an Ribbon::Object instance which can be queried
       # for settings information; the second is the remaining command line.
       def action(&block)
         @action = block
@@ -94,9 +95,14 @@ module Acclaim
         Option::Parser.new(args, options).parse!
       end
 
+      # Looks for this command's subcommands in the argument array.
+      def parse_subcommands!(args)
+        Command::Parser.new(args, subcommands).parse!
+      end
+
       # Invokes this command with a fresh set of option values.
       def run(*args)
-        invoke Option::Values.new, args
+        invoke Ribbon::Object.new, args
         rescue Option::Parser::Error => e
           puts e.message
       end
@@ -106,14 +112,16 @@ module Acclaim
       # will be executed. A subcommand may be anywhere in the array as long as
       # it is before an argument separator, which is tipically a double dash
       # (<tt>--<\tt>) and may be omitted.
+      #
+      # All argument separators will be deleted from the argument array before a
+      # command is executed.
       def invoke(opts, args = [])
-        opts.merge! parse_options!(args)
+        Ribbon::Object.merge! opts, parse_options!(args)
         handle_special_options! opts, args
-        if subcommand = find_subcommand_in(separated args)
-          args.delete subcommand.line
+        if subcommand = parse_subcommands!(args)
           subcommand.invoke(opts, args)
         else
-          args.delete_if { |arg| arg =~ Option::Parser::Regexp::ARGUMENT_SEPARATOR }
+          delete_argument_separators_in! args
           execute(opts, args)
         end
       end
@@ -146,22 +154,12 @@ module Acclaim
         const_get(:Version).execute opts, args if opts.acclaim_version?
       end
 
-      # Attempts to find a subcommand of this command in the given argument
-      # array. If a subcommand is found, it is returned, if not, nil is
-      # returned.
-      def find_subcommand_in(args)
-        subcommands.find do |subcommand|
-          args.include? subcommand.line
+      def delete_argument_separators_in!(args)
+        args.delete_if do |arg|
+          arg =~ Option::Parser::Regexp::ARGUMENT_SEPARATOR
         end
       end
 
-      # Finds the argument separator and returns an array containing all the
-      # elements before it. If a separator is not present, the original array
-      # is returned.
-      def separated(args)
-        args.take_while { |arg| arg !~ Option::Parser::Regexp::ARGUMENT_SEPARATOR }
-      end
-
     end
 
     # Add the class methods to the subclass and add it to this command's list of

data/lib/acclaim/command/parser.rb

@@ -0,0 +1,51 @@
+require 'acclaim/option/parser/regexp'
+
+module Acclaim
+  class Command
+
+    # Given an argument array and a list of commands, searches for them among
+    # the elements of the array.
+    class Parser
+
+      attr_accessor :argv, :commands
+
+      # Initializes a new command parser, with the given argument array and set
+      # of commands to search for.
+      def initialize(argv, commands)
+        self.argv = argv
+        self.commands = commands
+      end
+
+      # Parses the argument array and returns one of the given commands, if one
+      # is found, or +nil+ otherwise.
+      def parse!
+        find_command
+      end
+
+      private
+
+      # Discards all elements in the argument array after and including the
+      # argument separator, if one exists.
+      #
+      # Does not modify +argv+; returns a new array.
+      def arguments_up_to_separator
+        argv.take_while do |arg|
+          arg !~ Option::Parser::Regexp::ARGUMENT_SEPARATOR
+        end
+      end
+
+      # Searches for one of the given commands in the argument array, and
+      # returns it. Removes the string that matched the command name from
+      # +argv+. Returns +nil if no command was found.
+      def find_command
+        commands.find do |command|
+          arguments_up_to_separator.include? command.line
+        end.tap do |command|
+          argv.delete command.line if command
+        end
+      end
+
+    end
+
+  end
+end

data/lib/acclaim/option.rb

@@ -32,7 +32,7 @@ module Acclaim
     #              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
+    # parsed with a ribbon 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.
@@ -41,7 +41,7 @@ module Acclaim
       matches = args.select { |arg| arg.is_a? String }.group_by do |arg|
         arg =~ Parser::Regexp::SWITCH ? true : false
       end
-      klass = args.find { |arg| arg.is_a? Class }
+      klass = args.find { |arg| arg.is_a? Module }
       self.key         = key
       self.names       = matches.fetch true, []
       self.description = matches.fetch(false, []).first

data/lib/acclaim/option/parser.rb

@@ -1,5 +1,5 @@
 require 'acclaim/option/parser/regexp'
-require 'acclaim/option/values'
+require 'ribbon'
 
 module Acclaim
   class Option
@@ -51,7 +51,7 @@ module Acclaim
       #   options << Option.new(:verbose, '--verbose')
       #
       #   Option::Parser.new(args, options).parse!
-      #   => #<Acclaim::Option::Values:0x00000002a2fee8 @options={:file=>"log.txt", :verbose=>true}>
+      #   => { Ribbon file:log.txt, verbose:true }
       #
       #   args
       #   => ["arg1", "arg2"]
@@ -98,28 +98,28 @@ module Acclaim
       end
 
       # Parses the options and their arguments, associating that information
-      # with a Values instance.
+      # with a Ribbon::Object instance.
       def parse_values!
-        Values.new.tap do |values|
-          options.each do |option|
-            key = option.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, values
-                argv.delete *switches
-              else
-                switches.each do |switch|
-                  params = extract_parameters_of! option, switch
-                  set_option_value option, values, params
-                end
-              end
+        ribbon = Ribbon::Object.new
+        options.each do |option|
+          key = option.key
+          ribbon[key] = option.default unless ribbon[key]
+          switches = argv.find_all { |switch| option =~ switch }
+          if switches.any?
+            if option.flag?
+              found_boolean option, ribbon
+              argv.delete *switches
             else
-              Error.raise_missing_arg(option.names.join ' | ') if option.required?
+              switches.each do |switch|
+                params = extract_parameters_of! option, switch
+                found_params_for option, ribbon, params
+              end
             end
+          else
+            Error.raise_missing_arg(option.names.join ' | ') if option.required?
           end
         end
+        ribbon
       end
 
       # Finds the +switch+ in #argv and scans the next +option.arity.total+
@@ -154,26 +154,30 @@ module Acclaim
         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 = [])
+      # If the option has an custom handler associated, it will be called with
+      # the option values as the first argument and the array of parameters
+      # found as the second argument. Otherwise, the value will be set to
+      # <tt>params.first</tt>, if the option takes only one argument, or to
+      # +params+ if it takes more.
+      #
+      # The parameters will be converted according to the option's type.
+      def found_params_for(option, values, params = [])
         params = option.convert_parameters *params
-        if handler = option.handler
-          if option.flag? then handler.call values
-          else handler.call values, params end
+        if handler = option.handler then handler.call values, params
         else
-          key = option.key.to_sym
-          if option.flag? then values[key] = true
-          else
-            value = option.arity.total == 1 ? params.first : params
-            values[key] = value unless params.empty?
-          end
+          value = option.arity.total == 1 ? params.first : params
+          values[option.key.to_sym] = value unless params.empty?
         end
       end
 
+      # If the option has an custom handler associated, it will be called with
+      # only the option values as the first argument. Otherwise, the value will
+      # be set to <tt>true</tt>.
+      def found_boolean(option, values)
+        if handler = option.handler then handler.call values
+        else values[option.key.to_sym] = true end
+      end
+
     end
   end
 end

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

@@ -8,12 +8,14 @@ module Acclaim
         # Regular expression for a short option switch.
         #
         # Matches strings that begin with a single dash and contains only one
-        # word character or digit before the end of the string.
+        # word character before the end of the string.
         #
-        # Examples: <tt>-s; -5; -_</tt>
+        # Examples: <tt>-s; -_</tt>
         #
-        # <tt>'-mult'</tt> will be split into <tt>%w(-m -u -l -t)</tt>.
-        SHORT_SWITCH = /\A-[\w\d]\Z/
+        # <tt>'-mult'</tt> should match MULTIPLE_SHORT_SWITCHES, and will be
+        # split into <tt>%w(-m -u -l -t)</tt>, which in turn should match this
+        # regular expression.
+        SHORT_SWITCH = /\A-\w\Z/
 
         # Regular expression for a long option switch.
         #
@@ -58,7 +60,7 @@ module Acclaim
         # <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/
+        SWITCH_PARAM_EQUALS = /\A--[\w\d]+(-[\w\d]+)*=(,*[\w\d]*)*\Z/
 
         # Regular expression for any kind of option switch.
         #

data/lib/acclaim/option/type.rb

@@ -47,5 +47,6 @@ end
 require 'acclaim/option/type/date'
 require 'acclaim/option/type/date_time'
 require 'acclaim/option/type/string'
+require 'acclaim/option/type/symbol'
 require 'acclaim/option/type/time'
 require 'acclaim/option/type/uri'

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

@@ -1,5 +1,4 @@
 require 'acclaim/option/type'
-require 'time'
 
 module Acclaim
   class Option

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

@@ -0,0 +1,21 @@
+require 'acclaim/option/type'
+
+module Acclaim
+  class Option
+    module Type
+
+      # Handles symbols given as arguments in the command line.
+      module Symbol
+
+        # Simply returns +str.to_sym+.
+        def self.handle(str)
+          str.to_sym
+        end
+
+      end
+
+      self.accept ::Symbol, &Symbol.method(:handle)
+
+    end
+  end
+end

data/lib/acclaim/version.rb

@@ -16,7 +16,7 @@ module Acclaim
     # Patch version.
     #
     # Increments denote changes in implementation.
-    PATCH = 5
+    PATCH = 6
 
     # Build version.
     #

data/spec/acclaim/option_spec.rb

@@ -1,14 +1,24 @@
 require 'acclaim/option'
+require 'date'
+require 'time'
+require 'uri'
 
 describe Acclaim::Option do
 
+  let(:key) { :key }
+  let(:args) { [] }
+  let(:block) { nil }
+  subject { Acclaim::Option.new key, *args, &block }
+
   describe '#initialize' do
+    it 'should use the given key' do
+      subject.key.should == key
+    end
 
     context 'when given multiple strings' do
-
       let(:switches) { %w(-s --switch) }
       let(:description) { 'Description' }
-      subject { Acclaim::Option.new :key, *[switches, description].flatten }
+      let(:args) { [switches, description].flatten! }
 
       it 'should find the switches' do
         subject.names.should == switches
@@ -17,20 +27,285 @@ describe Acclaim::Option do
       it 'should find the description' do
         subject.description.should == description
       end
+    end
 
+    context 'when not given a class' do
+      it "should use String as the option's type" do
+        subject.type.should == String
+      end
     end
 
     context 'when given a class' do
-
       let(:type) { Integer }
-      subject { Acclaim::Option.new :key, type }
+      let(:args) { [type] }
 
       it "should use it as the option's type" do
         subject.type.should == type
       end
+    end
+
+    context 'when given an additional parameter hash' do
+      let(:hash) { {} }
+      let(:args) { [hash] }
+
+      context 'that does not specify an arity' do
+        it 'should be a flag' do
+          subject.should be_flag
+        end
+      end
+
+      context 'that specifies an arity' do
+        let(:hash) { { arity: arity } }
+
+        context 'which requires one argument' do
+          let(:arity) { Acclaim::Option::Arity.new 1 }
+
+          it 'should not be a flag' do
+            subject.should_not be_flag
+          end
+        end
+
+        context 'which allows one optional argument' do
+          let(:arity) { Acclaim::Option::Arity.new 0, 1 }
+
+          it 'should not be a flag' do
+            subject.should_not be_flag
+          end
+        end
+      end
+
+      context 'that does not specify a default value' do
+        it 'should have a default value of nil' do
+          subject.default.should be_nil
+        end
+      end
+
+      context 'that specifies a default value' do
+        let(:default) { 10 }
+        let(:hash) { { default: default } }
+
+        it 'should use the default value supplied' do
+          subject.default.should == default
+        end
+      end
+
+      context 'that does not specify whether the option is required' do
+        it 'should not be required' do
+          subject.should_not be_required
+        end
+      end
+
+      context 'that specifies if the option is required' do
+        let(:hash) { { required: required } }
+
+        context 'as false' do
+          let(:required) { false }
+
+          it 'should not be required' do
+            subject.should_not be_required
+          end
+        end
+
+        context 'as true' do
+          let(:required) { true }
+
+          it 'should be required' do
+            subject.should be_required
+          end
+        end
+      end
+    end
+
+    context 'when not given a block' do
+      it 'should not have a custom handler' do
+        subject.handler.should be_nil
+      end
+    end
+
+    context 'when given a block' do
+      let(:block) { proc { |*args| p args } }
+
+      it 'should have a custom handler' do
+        subject.handler.should be_a(Proc)
+      end
+    end
+  end
+
+  describe '#convert_parameters' do
+    let(:args) { [type].compact }
+    let!(:converted) { subject.convert_parameters *params }
+
+    context 'when the option was not explicitly initialized with a type' do
+      let(:type) { nil }
+      let!(:params) { %w(a b c d) }
+
+      it 'should convert the parameters to strings' do
+        converted.should == params.map(&:to_s)
+      end
+    end
+
+    context 'when the option was initialized with String as its type' do
+      let(:type) { String }
+      let(:params) { %w(a b c d) }
+
+      it 'should convert the parameters to strings' do
+        converted.should == params.map(&:to_s)
+      end
+    end
+
+    context 'when the option was initialized with Symbol as its type' do
+      let(:type) { Symbol }
+      let(:params) { %w(a b c d) }
+
+      it 'should convert the parameters to strings' do
+        converted.should == params.map(&:to_sym)
+      end
+    end
+
+    context 'when the option was initialized with Date as its type' do
+      let(:type) { Date }
+      let(:date) { Date.today }
+      let(:params) { [date.to_s] }
+
+      it 'should convert the parameters to dates' do
+        converted.should == [date]
+      end
+    end
+
+    context 'when the option was initialized with DateTime as its type' do
+      let(:type) { DateTime }
+      let(:date_time) { DateTime.now }
+      let(:params) { [date_time.to_s] }
+
+      it 'should convert the parameters to dates/times' do
+        converted.should == [date_time]
+      end
+    end
+
+    context 'when the option was initialized with Time as its type' do
+      let(:type) { Time }
+      let(:time) { Time.now }
+      let(:params) { [time.to_s] }
+
+      it 'should convert the parameters to times' do
+        converted.should == [time]
+      end
+    end
+
+    context 'when the option was initialized with URI as its type' do
+      let(:type) { URI }
+      let(:uri) { URI.parse 'https://github.com/matheusmoreira/acclaim' }
+      let(:params) { [uri.to_s] }
+
+      it 'should convert the parameters to URIs' do
+        converted.should == [uri]
+      end
+    end
+  end
+
+  describe '#=~' do
+    let(:names) { %w(-o -a --option --alternative) }
+    let(:args) { names }
+
+    context "when passed the option's short switch" do
+      let(:str) { '-o' }
+
+      it 'should match' do
+        (subject =~ str).should be_true
+      end
+    end
+
+    context "when passed the option's alternative short switch" do
+      let(:str) { '-a' }
+
+      it 'should match' do
+        (subject =~ str).should be_true
+      end
+    end
+
+    context "when passed a different short switch" do
+      let(:str) { '-d' }
+
+      it 'should not match' do
+        (subject =~ str).should be_false
+      end
+    end
+
+    context "when passed the option's long switch" do
+      let(:str) { '--option' }
+
+      it 'should match' do
+        (subject =~ str).should be_true
+      end
+    end
+
+    context "when passed the option's alternative long switch" do
+      let(:str) { '--alternative' }
+
+      it 'should match' do
+        (subject =~ str).should be_true
+      end
+    end
+
+    context "when passed a different long switch" do
+      let(:str) { '--different' }
+
+      it 'should not match' do
+        (subject =~ str).should be_false
+      end
+    end
+  end
 
+  describe '#arity' do
+    context 'when the option was not explicitly initialized with an arity' do
+      it 'should not return nil' do
+        subject.arity.should_not be_nil
+      end
     end
+  end
+
+  describe '#arity=' do
+    before(:each) { begin subject.arity = arg; rescue; end }
+
+    context 'when passed nil' do
+      let(:arg) { nil }
+
+      it "the option's arity should not be set to nil" do
+        subject.arity.should_not be_nil
+      end
+    end
+
+    context 'when passed an arity' do
+      let(:arg) { Acclaim::Option::Arity.new 5, -1 }
 
+      it "should set the option's arity" do
+        subject.arity.should == arg
+      end
+    end
+
+    context 'when passed an array' do
+      let(:arg) { [ 5, -1 ] }
+
+      it "should use the array to create the option's arity" do
+        subject.arity.should == Acclaim::Option::Arity.new(5, -1)
+      end
+    end
+
+    context 'when passed an invalid array' do
+      let(:arg) { [ 5, -1, 99 ] }
+
+      it 'should raise an argument error' do
+        expect { subject.arity = arg }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe '#require' do
+    before(:each) { subject.require }
+
+    it 'should make the option mandatory' do
+      subject.should be_required
+    end
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acclaim
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-23 00:00:00.000000000 Z
+date: 2011-12-27 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ribbon
+  requirement: &19367260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *19367260
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &8505620 !ruby/object:Gem::Requirement
+  requirement: &19366760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *8505620
+  version_requirements: *19366760
 - !ruby/object:Gem::Dependency
   name: rookie
-  requirement: &8505100 !ruby/object:Gem::Requirement
+  requirement: &19366220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *8505100
+  version_requirements: *19366220
 description: Command-line option parser and command interface.
 email: matheus.a.m.moreira@gmail.com
 executables: []
@@ -51,6 +62,7 @@ files:
 - lib/acclaim/command/help.rb
 - lib/acclaim/command/help/template.rb
 - lib/acclaim/command/help/template/command.erb
+- lib/acclaim/command/parser.rb
 - lib/acclaim/command/version.rb
 - lib/acclaim/option.rb
 - lib/acclaim/option/arity.rb
@@ -60,9 +72,9 @@ files:
 - lib/acclaim/option/type/date.rb
 - lib/acclaim/option/type/date_time.rb
 - lib/acclaim/option/type/string.rb
+- lib/acclaim/option/type/symbol.rb
 - lib/acclaim/option/type/time.rb
 - lib/acclaim/option/type/uri.rb
-- lib/acclaim/option/values.rb
 - lib/acclaim/version.rb
 - spec/acclaim/option/arity_spec.rb
 - spec/acclaim/option/parser_spec.rb
@@ -79,12 +91,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 407623794010834174
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 407623794010834174
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10

data/lib/acclaim/option/values.rb

@@ -1,49 +0,0 @@
-module Acclaim
-  class Option
-
-    # 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] = value
-      #   options.method?         =>  options[method] ? true : false
-      #   options.method          =>  options[method]
-      def method_missing(method, *args, &block)
-        m = method.to_s.chop!.to_sym
-        case method
-          when /=$/
-            self[m] = args.first
-          when /\?$/
-            self[m] ? true : false
-          else
-            self[method]
-        end
-      end
-
-      protected
-
-      # The option values
-      def data
-        @options ||= {}
-      end
-
-    end
-
-  end
-end