slop 1.4.1 → 1.5.0

data/README.md

@@ -315,6 +315,44 @@ yields:
         -n, --name      Your name
         -h, --help      Print this help message
 
+Commands
+--------
+
+Slop allows you to nest more instances of Slop inside of `commands`. These
+instances will then be used to parse arguments if they're called upon.
+
+Slop will use the first argument in the list of items passed to `parse` to
+check if it is a `command`.
+
+    Slop.parse ['foo', '--bar', 'baz']
+
+Slop will look to see if the `foo` command exists, and if it does, it'll pass
+the options `['--bar', 'baz']` to the instance of Slop that belongs to `foo`.
+Here's how commands might look:
+
+    opts = Slop.new do
+      command :foo do
+        on :b, :bar, 'something', true
+      end
+
+      command :clean do
+        on :v, :verbose, do
+          puts 'Enabled verbose mode for clean'
+        end
+      end
+
+      # non-command specific options
+      on :v, :version do
+        puts 'version 1'
+      end
+    end
+
+* Run with `run.rb -v`
+* Output:  `version 1`
+
+* Run with: `run.rb clean -v`
+* Output:   `Enabled verbose mode for clean`
+
 Woah woah, why you hating on OptionParser?
 ------------------------------------------
 

data/lib/slop.rb

@@ -16,7 +16,7 @@ class Slop
   class InvalidOptionError < RuntimeError; end
 
   # @return [String] The current version string
-  VERSION = '1.4.1'
+  VERSION = '1.5.0'
 
   # Parses the items from a CLI format into a friendly object.
   #
@@ -44,6 +44,9 @@ class Slop
   # @return [Options]
   attr_reader :options
 
+  # @return [Hash]
+  attr_reader :commands
+
   attr_writer :banner
   attr_accessor :longest_flag
 
@@ -54,6 +57,9 @@ class Slop
   # @option opts [Boolean] :multiple_switches Allows `-abc` to be processed
   #   as the options 'a', 'b', 'c' and will force their argument values to
   #   true. By default Slop with parse this as 'a' with the argument 'bc'
+  # @option opts [String] :banner The banner text used for the help
+  # @option opts [Proc, #call] :on_empty Any object that respondes to `call`
+  #   which is executed when Slop has no items to parse
   def initialize(*opts, &block)
     sloptions = {}
     sloptions.merge! opts.pop if opts.last.is_a? Hash
@@ -61,10 +67,16 @@ class Slop
     opts.each { |o| sloptions[o] = true }
 
     @options = Options.new
+    @commands = {}
+
     @longest_flag = 0
-    @strict = sloptions[:strict]
     @invalid_options = []
+
+    @banner ||= sloptions[:banner]
+    @strict = sloptions[:strict]
     @multiple_switches = sloptions[:multiple_switches]
+    @on_empty = sloptions[:on_empty]
+    @sloptions = sloptions
 
     if block_given?
       block.arity == 1 ? yield(self) : instance_eval(&block)
@@ -106,9 +118,8 @@ class Slop
   end
 
   # Enumerable interface
-  def each
-    return enum_for(:each) unless block_given?
-    @options.each { |option| yield option }
+  def each(&block)
+    @options.each(&block)
   end
 
   # Return the value of an option via the subscript operator.
@@ -119,7 +130,7 @@ class Slop
   # @return [Object] Returns the value associated with that option.
   def [](key)
     option = @options[key]
-    option.argument_value if option
+    option ? option.argument_value : @commands[key]
   end
 
   # Specify an option with a short or long version, description and type.
@@ -155,6 +166,50 @@ class Slop
   alias :opt :option
   alias :on :option
 
+
+  # Namespace options depending on what command is executed
+  #
+  # @param [Symbol, String] label
+  # @param [Hash] options
+  # @example
+  #   opts = Slop.new do
+  #     command :create do
+  #       on :v, :verbose
+  #     end
+  #   end
+  #
+  #   # ARGV is `create -v`
+  #   opts.commands[:create].verbose? #=> true
+  # @return [Slop] a new instance of Slop namespaced to +label+
+  def command(label, options={}, &block)
+    if @commands[label]
+      raise ArgumentError, "command `#{label}` already exists"
+    end
+
+    options = @sloptions.merge(options)
+    slop = Slop.new(options)
+    @commands[label] = slop
+
+    if block_given?
+      block.arity == 1 ? yield(slop) : slop.instance_eval(&block)
+    end
+
+    slop
+  end
+
+  # Add an object to be called when Slop has no values to parse
+  #
+  # @param [Object, nil] proc The object (which can be anything
+  #   responding to :call)
+  # @example
+  #   Slop.parse do
+  #     on_empty { puts 'No argument given!' }
+  #   end
+  def on_empty(obj=nil, &block)
+    @on_empty ||= (obj || block)
+  end
+  alias :on_empty= :on_empty
+
   # Returns the parsed list into a option/value hash.
   #
   # @example
@@ -197,21 +252,32 @@ class Slop
 
   private
 
-  def self.initialize_and_parse(items, delete, options, &block)
-    if items.is_a?(Hash) && options.empty?
-      options = items
-      items = ARGV
-    end
+  class << self
+    private
 
-    slop = new(options, &block)
-    delete ? slop.parse!(items) : slop.parse(items)
-    slop
+    def initialize_and_parse(items, delete, options, &block)
+      if items.is_a?(Hash) && options.empty?
+        options = items
+        items = ARGV
+      end
+
+      slop = new(options, &block)
+      delete ? slop.parse!(items) : slop.parse(items)
+      slop
+    end
   end
 
   def parse_items(items, delete=false, &block)
+    if items.empty? && @on_empty.respond_to?(:call)
+      @on_empty.call self
+      return
+    end
+
+    return if execute_command(items, delete)
+
     trash = []
 
-    items.each do |item|
+    items.each_with_index do |item, index|
       item = item.to_s
       flag = item.sub(/^--?/, '')
       option = @options[flag]
@@ -230,7 +296,8 @@ class Slop
           option = @options[$1]
           argument = $2
         when /\A--no-(.+)\z/
-          option.force_argument_value(false) if option = @options[$1]
+          option = @options[$1]
+          option.force_argument_value(false) if option
         end
       end
 
@@ -240,47 +307,47 @@ class Slop
         option.argument_value = true
 
         if option.expects_argument? || option.accepts_optional_argument?
-          argument ||= items.at(items.index(item) + 1)
-          check_valid_argument(option, argument)
+          argument ||= items.at(index + 1)
+          check_valid_argument!(option, argument)
           trash << argument
 
           if argument
-            check_matching_argument(option, argument)
+            check_matching_argument!(option, argument)
             option.argument_value = argument
             option.callback.call option.argument_value if option.callback
           else
             option.argument_value = nil
-            check_optional_argument(option, flag)
+            check_optional_argument!(option, flag)
           end
         elsif option.callback
           option.callback.call nil
         end
       else
-        check_invalid_option(item, flag)
+        check_invalid_option!(item, flag)
         block.call(item) if block_given? && !trash.include?(item)
       end
     end
 
     items.delete_if { |item| trash.include? item } if delete
-    raise_if_invalid_options
+    raise_if_invalid_options!
     items
   end
 
-  def check_valid_argument(option, argument)
+  def check_valid_argument!(option, argument)
     if !option.accepts_optional_argument? && argument =~ /\A--?.+\z/
       raise MissingArgumentError,
         "'#{option.key}' expects an argument, none given"
     end
   end
 
-  def check_matching_argument(option, argument)
+  def check_matching_argument!(option, argument)
     if option.match && !argument.match(option.match)
       raise InvalidArgumentError,
         "'#{argument}' does not match #{option.match.inspect}"
     end
   end
 
-  def check_optional_argument(option, flag)
+  def check_optional_argument!(option, flag)
     if option.accepts_optional_argument?
       option.callback.call nil if option.callback
     else
@@ -289,10 +356,18 @@ class Slop
     end
   end
 
-  def check_invalid_option(item, flag)
+  def check_invalid_option!(item, flag)
     @invalid_options << flag if item[/\A--?/] && @strict
   end
 
+  def raise_if_invalid_options!
+    return if !@strict || @invalid_options.empty?
+    message = "Unknown option"
+    message << 's' if @invalid_options.size > 1
+    message << ' -- ' << @invalid_options.map { |o| "'#{o}'" }.join(', ')
+    raise InvalidOptionError, message
+  end
+
   def enable_multiple_switches(item)
     item[1..-1].split('').each do |switch|
       if option = @options[switch]
@@ -310,6 +385,17 @@ class Slop
     end
   end
 
+  def execute_command(items, delete)
+    command = items[0]
+    command = @commands.keys.find { |cmd| cmd.to_s == command.to_s }
+    if @commands.key?(command)
+      items.shift
+      opts = @commands[command]
+      delete ? opts.parse!(items) : opts.parse(items)
+      true
+    end
+  end
+
   def clean_options(args)
     options = []
 
@@ -332,12 +418,4 @@ class Slop
     options.push args.first.respond_to?(:to_sym) ? args.shift : nil
     options.push args.shift ? true : false # force true/false
   end
-
-  def raise_if_invalid_options
-    return if !@strict || @invalid_options.empty?
-    message = "Unknown option"
-    message << 's' if @invalid_options.size > 1
-    message << ' -- ' << @invalid_options.map { |o| "'#{o}'" }.join(', ')
-    raise InvalidOptionError, message
-  end
 end

data/lib/slop/option.rb

@@ -152,6 +152,8 @@ class Slop
         Integer($1) .. Integer($2)
       when /\A(\d+?)\.\.\.(\d+)\z/
         Integer($1) ... Integer($2)
+      when /\A\d+\z/
+        Integer(value)
       else
         value
       end

data/test/commands_test.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/helper'
+
+class CommandsTest < TestCase
+  test 'creating commands' do
+    slop = Slop.new do
+      command :foo do on :f, :foo, 'foo option' end
+      command :bar do on :f, :foo; on :b, :bar, true end
+    end
+
+    slop.commands.each_value do |command|
+      assert_kind_of Slop, command
+    end
+
+    assert 'foo option', slop.commands[:foo].options[:foo].description
+
+    slop.parse %w/bar --bar baz/
+    assert 'baz', slop.commands[:bar][:bar]
+    assert_nil slop.commands['bar']
+  end
+
+  test 'repeating existing commands' do
+    slop = Slop.new
+    assert slop.command :foo
+    assert_raises(ArgumentError) { slop.command :foo }
+  end
+
+  test 'commands inheriting options' do
+    slop = Slop.new :strict do
+      command :foo do end
+    end
+    assert slop.commands[:foo].instance_variable_get(:@strict)
+  end
+
+  test 'commands setting options' do
+    slop = Slop.new :strict => false do
+      command :foo, :strict => true do end
+    end
+    assert slop.commands[:foo].instance_variable_get(:@strict)
+  end
+
+  test 'inception' do
+    slop = Slop.new do
+      command(:foo) { command(:bar) { command(:baz) { on :f, 'D:' } } }
+    end
+    desc = slop.commands[:foo].commands[:bar].commands[:baz].options[:f].description
+    assert_equal 'D:', desc
+  end
+
+  test 'commands with banners' do
+    slop = Slop.new do
+      command(:foo, :banner => 'bar') { }
+      command(:bar) { banner 'bar' }
+    end
+    assert_equal 'bar', slop.commands[:foo].banner
+    assert_equal 'bar', slop.commands[:bar].banner
+  end
+
+  test 'executing on_empty on separate commands' do
+    incmd = inslop = false
+    slop = Slop.new do
+      command(:foo) { on(:bar) {}; on_empty { incmd = true }}
+      on_empty { inslop = true }
+    end
+    slop.parse %w//
+    assert inslop
+    refute incmd
+    inslop = false
+    slop.parse %w/foo/
+    assert incmd
+    refute inslop
+  end
+end

data/test/option_test.rb

@@ -74,8 +74,10 @@ class OptionTest < TestCase
     assert_equal (1...10), option_value(%w/-r 1...10/, :r, true, :as => Range)
 
     # default back to the string unless a regex is successful
+    # return value.to_i if the value is /\A\d+\z/
     # maybe this should raise is Slop#strict?
     assert_equal "1abc10", option_value(%w/-r 1abc10/, :r, true, :as => Range)
+    assert_equal 1, option_value(%w/-r 1/, :r, true, :as => Range)
   end
 
   test 'printing options' do

data/test/slop_test.rb

@@ -1,5 +1,3 @@
-require File.dirname(__FILE__) + '/helper'
-
 class SlopTest < TestCase
   def clean_options(*args)
     Slop.new.send(:clean_options, args)
@@ -19,7 +17,6 @@ class SlopTest < TestCase
 
   test 'new accepts a hash or array of symbols' do
     slop = Slop.new :strict, :multiple_switches => true
-
     [ :@multiple_switches, :@strict ].each do |var|
       assert slop.instance_variable_get var
     end
@@ -44,6 +41,14 @@ class SlopTest < TestCase
     end
   end
 
+  test 'callback when option array is empty' do
+    item1 = item2 = nil
+    Slop.new { on_empty { item1 = 'foo' } }.parse
+
+    assert_equal 'foo', item1
+    assert_nil item2
+  end
+
   test 'multiple switches with the :multiple_switches flag' do
     slop = Slop.new :multiple_switches => true, :strict => true
     %w/a b c/.each { |f| slop.on f }
@@ -86,10 +91,8 @@ class SlopTest < TestCase
 
   test 'preserving order when yielding non-options' do
     items = []
-
     slop = Slop.new { on(:name, true) { |name| items << name } }
     slop.parse(%w/foo --name bar baz/) { |value| items << value }
-
     assert_equal %w/foo bar baz/, items
   end
 
@@ -105,6 +108,9 @@ class SlopTest < TestCase
 
     slop = Slop.new "foo bar"
     assert_equal "foo bar", slop.banner
+
+    slop = Slop.new :banner => "foo bar"
+    assert_equal "foo bar", slop.banner
   end
 
   test 'storing long option lengths' do
@@ -120,7 +126,6 @@ class SlopTest < TestCase
     opts = Slop.new do
       on :name, true
     end
-
     assert_equal %w/a/, opts.parse!(%w/--name lee a/)
     assert_equal %w/--name lee a/, opts.parse(%w/--name lee a/)
   end
@@ -173,13 +178,21 @@ class SlopTest < TestCase
     assert_equal(['c', nil, nil, false], clean_options(:c, false))
   end
 
-  test '[] returns an options argument value or nil' do
+  test '[] returns an options argument value or a command or nil (in that order)' do
     slop = Slop.new
     slop.opt :n, :name, true
-    slop.parse %w/--name lee/
+    slop.opt :foo
+    slop.command(:foo) { }
+    slop.command(:bar) { }
+    slop.parse %w/--name lee --foo/
 
     assert_equal 'lee', slop[:name]
     assert_equal 'lee', slop[:n]
+
+    assert_equal true, slop[:foo]
+    assert_kind_of Slop, slop[:bar]
+
+    assert_nil slop[:baz]
   end
 
   test 'arguments ending ? test for option existance' do
@@ -238,7 +251,6 @@ class SlopTest < TestCase
     slop = Slop.new
     slop.banner = 'Usage: foo [options]'
     slop.parse
-
     assert slop.to_s =~ /^Usage: foo/
   end
 
@@ -299,7 +311,6 @@ class SlopTest < TestCase
 
   test 'parsing options with options as arguments' do
     slop = Slop.new { on :f, :foo, true }
-
     assert_raises(Slop::MissingArgumentError) { slop.parse %w/-f --bar/ }
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: slop
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors: 
 - Lee Jarvis
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-14 00:00:00 +01:00
+date: 2011-04-16 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -33,6 +33,7 @@ files:
 - lib/slop/option.rb
 - lib/slop/options.rb
 - slop.gemspec
+- test/commands_test.rb
 - test/helper.rb
 - test/option_test.rb
 - test/slop_test.rb
@@ -65,6 +66,7 @@ signing_key:
 specification_version: 3
 summary: Option gathering made easy
 test_files: 
+- test/commands_test.rb
 - test/helper.rb
 - test/option_test.rb
 - test/slop_test.rb