slop 1.5.5 → 1.6.0

data/CHANGES.md

@@ -0,0 +1,41 @@
+1.6.0 (2011-05-18)
+------------------
+
+* Add `:ignore_case` to Slop options for case insensitive option matching
+* Add `:on_noopts` for triggering an event when the arguments contain no
+  options
+* Add `:unless` to Slop::Option for omitting execution of the Options block
+  when this object exists in the Array of items passed to Slop.new
+* Bugfix: Do not parse negative integers as options. A valid option must
+  start with an alphabet character
+* Bugfix: Allow a Range to accept a negative Integer at either end
+
+1.5.5 (2011-05-03)
+------------------
+
+* Bugfix: only attempt to extract options prefixed with `-`
+
+1.5.4 (2011-05-01)
+------------------
+
+* Bugfix: `parse!` should not remove items with the same value as items used
+  in option arguments. Fixes #22 (Utkarsh Kukreti)
+
+1.5.3 (2011-04-22)
+------------------
+
+* Bugfix: Use integers when fetching array indexes, not strings
+
+1.5.2 (2011-04-17)
+------------------
+
+* Bugfix: Ensure `ARGV` is empty when using the `on_empty` event
+
+1.5.0 (2011-04-15)
+------------------
+
+* Add `Slop#get` as alias to `Slop#[]`
+* Add `Slop#present?` as alias for `Slop#<option>?`
+* Add `Option#count` for monitoring how many times an option is called
+* Add `:io` for using a custom IO object when using the `:help` option
+* Numerous performance tweaks

data/lib/slop.rb

@@ -16,7 +16,7 @@ class Slop
   class InvalidOptionError < RuntimeError; end
 
   # @return [String] The current version string
-  VERSION = '1.5.5'
+  VERSION = '1.6.0'
 
   # Parses the items from a CLI format into a friendly object.
   #
@@ -69,6 +69,9 @@ class Slop
   #   :help => true is used
   # @option opts [Boolean] :exit_on_help (true) When false and coupled with
   #   the :help option, Slop will not exit inside of the `help` option
+  # @option opts [Boolean] :ignore_case (false) Ignore options case
+  # @option opts [Proc, #call] :on_noopts Trigger an event when no options
+  #   are found
   def initialize(*opts, &block)
     sloptions = {}
     sloptions.merge! opts.pop if opts.last.is_a? Hash
@@ -83,8 +86,10 @@ class Slop
 
     @banner = sloptions[:banner]
     @strict = sloptions[:strict]
+    @ignore_case = sloptions[:ignore_case]
     @multiple_switches = sloptions[:multiple_switches]
     @on_empty = sloptions[:on_empty]
+    @on_noopts = sloptions[:on_noopts] || sloptions[:on_optionless]
     @sloptions = sloptions
 
     io = sloptions[:io] || $stderr
@@ -117,14 +122,14 @@ class Slop
 
   # Parse a list of options, leaving the original Array unchanged.
   #
-  # @param items
+  # @param [Array] items A list of items to parse
   def parse(items=ARGV, &block)
     parse_items items, &block
   end
 
   # Parse a list of options, removing parsed options from the original Array.
   #
-  # @param items
+  # @param [Array] items A list of items to parse
   def parse!(items=ARGV, &block)
     parse_items items, true, &block
   end
@@ -152,7 +157,8 @@ class Slop
   # @option args [Symbol, String] :short_flag Short option name.
   # @option args [Symbol, String] :long_flag Full option name.
   # @option args [String] :description Option description for use in Slop#help
-  # @option args [Boolean] :argument Specifies whether a required option or not.
+  # @option args [Boolean] :argument Specifies whether this option requires
+  #   an argument
   # @option args [Hash] :options Optional option configurations.
   # @example
   #   opts = Slop.parse do
@@ -210,10 +216,10 @@ class Slop
     slop
   end
 
-  # Add an object to be called when Slop has no values to parse
+  # Trigger an event when Slop has no values to parse
   #
   # @param [Object, nil] proc The object (which can be anything
-  #   responding to :call)
+  #   responding to `call`)
   # @example
   #   Slop.parse do
   #     on_empty { puts 'No argument given!' }
@@ -224,6 +230,20 @@ class Slop
   end
   alias :on_empty= :on_empty
 
+  # Trigger an event when the arguments contain no options
+  #
+  # @param [Object, nil] obj The object to be triggered (anything
+  #   responding to `call`)
+  # @example
+  #   Slop.parse do
+  #     on_noopts { puts 'No options here!' }
+  #   end
+  # @since 1.6.0
+  def on_noopts(obj=nil, &block)
+    @on_noopts ||= (obj || block)
+  end
+  alias :on_optionless :on_noopts
+
   # Returns the parsed list into a option/value hash.
   #
   # @example
@@ -253,6 +273,7 @@ class Slop
   # Slop#option? but a convenience method for unacceptable method names.
   #
   # @param [Object] The object name to check
+  # @since 1.5.0
   # @return [Boolean] true if this option is present
   def present?(option_name)
     !!get(option_name)
@@ -298,7 +319,10 @@ class Slop
   def parse_items(items, delete=false, &block)
     if items.empty? && @on_empty.respond_to?(:call)
       @on_empty.call self
-      return
+      return items
+    elsif !items.any? {|i| i.to_s[/\A--?/] } && @on_noopts.respond_to?(:call)
+      @on_noopts.call self
+      return items
     end
 
     return if execute_command(items, delete)
@@ -308,26 +332,8 @@ class Slop
     items.each_with_index do |item, index|
       item = item.to_s
       flag = item.sub(/\A--?/, '')
-      option = @options[flag] if item[/\A-/]
-
-      unless option
-        case item
-        when /\A-[^-]/
-          if @multiple_switches
-            enable_multiple_switches(item)
-            next
-          else
-            flag, argument = flag.split('', 2)
-            option = @options[flag]
-          end
-        when /\A--([^=]+)=(.+)\z/
-          option = @options[$1]
-          argument = $2
-        when /\A--no-(.+)\z/
-          option = @options[$1]
-          option.force_argument_value(false) if option
-        end
-      end
+      option, argument = extract_option(item, flag)
+      next if @multiple_switches
 
       if option
         option.count += 1
@@ -343,13 +349,13 @@ class Slop
           if argument
             check_matching_argument!(option, argument)
             option.argument_value = argument
-            option.callback.call option.argument_value if option.callback
+            option.call option.argument_value unless option.omit_exec?(items)
           else
             option.argument_value = nil
             check_optional_argument!(option, flag)
           end
-        elsif option.callback
-          option.callback.call nil
+        else
+          option.call unless option.omit_exec?(items)
         end
       else
         check_invalid_option!(item, flag)
@@ -363,7 +369,7 @@ class Slop
   end
 
   def check_valid_argument!(option, argument)
-    if !option.accepts_optional_argument? && argument =~ /\A--?.+\z/
+    if !option.accepts_optional_argument? && flag?(argument)
       raise MissingArgumentError,
         "'#{option.key}' expects an argument, none given"
     end
@@ -378,7 +384,7 @@ class Slop
 
   def check_optional_argument!(option, flag)
     if option.accepts_optional_argument?
-      option.callback.call nil if option.callback
+      option.call
     else
       raise MissingArgumentError,
         "'#{flag}' expects an argument, none given"
@@ -414,6 +420,33 @@ class Slop
     end
   end
 
+  def extract_option(item, flag)
+    if item[0, 1] == '-'
+      option = @options[flag]
+      if !option && @ignore_case
+        option = @options[flag.downcase]
+      end
+    end
+    unless option
+      case item
+      when /\A-[^-]/
+        if @multiple_switches
+          enable_multiple_switches(item)
+        else
+          flag, argument = flag.split('', 2)
+          option = @options[flag]
+        end
+      when /\A--([^=]+)=(.+)\z/
+        option = @options[$1]
+        argument = $2
+      when /\A--no-(.+)\z/
+        option = @options[$1]
+        option.force_argument_value(false) if option
+      end
+    end
+    [option, argument]
+  end
+
   def execute_command(items, delete)
     command = items[0]
     command = @commands.keys.find { |cmd| cmd.to_s == command.to_s }
@@ -438,7 +471,7 @@ class Slop
 
     long = args.first
     boolean = [true, false].include?(long)
-    if !boolean && long.to_s =~ /\A(?:--?)?[a-zA-Z0-9_-]+\z/
+    if !boolean && long.to_s =~ /\A(?:--?)?[a-zA-Z][a-zA-Z0-9_-]+\z/
       options.push args.shift.to_s.sub(/\A--?/, '')
     else
       options.push nil
@@ -447,4 +480,8 @@ class Slop
     options.push args.first.respond_to?(:to_sym) ? args.shift : nil
     options.push args.shift ? true : false # force true/false
   end
+
+  def flag?(str)
+    str =~ /\A--?[a-zA-Z][a-zA-Z0-9_-]+\z/
+  end
 end

data/lib/slop/option.rb

@@ -10,9 +10,6 @@ class Slop
     # @return [String] This options description
     attr_reader :description
 
-    # @return [Proc, #call] The object to execute when this option is used
-    attr_reader :callback
-
     # @return [Boolean] True if the option should be grouped at the
     #   tail of the help list
     attr_reader :tail
@@ -35,6 +32,10 @@ class Slop
     # @return [Integer] The amount of times this option has been invoked
     attr_accessor :count
 
+    # @return [Object] Omit execution of this Options block or callback if
+    #   this object exists in the Array of items passed to `Slop.new`
+    attr_accessor :unless
+
     # @param [Slop] slop
     # @param [String, #to_s] short
     # @param [String, #to_s] long
@@ -49,6 +50,7 @@ class Slop
     # @option options [Integer] :limit (0)
     # @option options [Boolean] :tail (false)
     # @option options [Regexp] :match
+    # @option options [String, #to_s] :unless
     # @option options [Boolean, String] :help
     def initialize(slop, short, long, description, argument, options={}, &blk)
       @slop = slop
@@ -64,6 +66,7 @@ class Slop
       @match = options[:match]
       @delimiter = options[:delimiter] || ','
       @limit = options[:limit] || 0
+      @unless = options[:unless]
       @help = options[:help]
       @help = true if @help.nil?
 
@@ -92,7 +95,7 @@ class Slop
       @long_flag || @short_flag
     end
 
-    # @return [Object] the argument value after it's been case
+    # @return [Object] the argument value after it's been cast
     #   according to the `:as` option
     def argument_value
       return @argument_value if @forced
@@ -122,8 +125,24 @@ class Slop
       @forced = true
     end
 
+    # Execute the block or callback object associated with this Option
+    #
+    # @param [Object] The object to be sent to `:call`
+    def call(obj=nil)
+      @callback.call(obj) if @callback.respond_to?(:call)
+    end
+
+    # @param [Array] items The original array of objects passed to `Slop.new`
+    # @return [Boolean] true if this options `:unless` argument exists
+    #   inside *items*
+    def omit_exec?(items)
+      string = @unless.to_s.sub(/\A--?/, '')
+      items.any? { |i| i.to_s.sub(/\A--?/, '') == string }
+    end
+
     # This option in a nice pretty string, including a short flag, long
-    #   flag, and description (if they exist).
+    # flag, and description (if they exist).
+    #
     # @see Slop#help
     # @return [String]
     def to_s
@@ -160,12 +179,12 @@ class Slop
 
     def value_to_range(value)
       case value.to_s
-      when /\A(\d+?)(?:\.\.|-|,)(\d+)\z/
-        Integer($1) .. Integer($2)
-      when /\A(\d+?)\.\.\.(\d+)\z/
-        Integer($1) ... Integer($2)
-      when /\A\d+\z/
-        Integer(value)
+      when /\A(-?\d+?)(?:\.\.|-|,)(-?\d+)\z/
+        $1.to_i .. $2.to_i
+      when /\A(-?\d+?)\.\.\.(-?\d+)\z/
+        $1.to_i ... $2.to_i
+      when /\A-?\d+\z/
+        value.to_i
       else
         value
       end

data/lib/slop/options.rb

@@ -12,7 +12,13 @@ class Slop
       end
     end
 
+    # Fetch an Option object
+    #
     # @param [Object] flag The short/long flag representing the option
+    # @example
+    #   opts = Slop.parse { on :v, "Verbose mode" }
+    #   opts.options[:v] #=> Option
+    #   opts.options[:v].description #=> "Verbose mode"
     # @return [Option] the option assoiated with this flag
     def [](flag)
       if flag.is_a?(Integer)

data/test/option_test.rb

@@ -33,10 +33,14 @@ class OptionTest < TestCase
   end
 
   test 'has a callback when passed a block or callback option' do
-    assert option(:f){}.callback
-    assert option(:callback => proc {}).callback
+    item = nil
+    option(:f){ item = "foo" }.call
+    assert_equal "foo", item
 
-    refute option(:f).callback
+    assert option(:callback => proc { item = "bar" }).call
+    assert_equal "bar", item
+
+    refute option(:f).call
   end
 
   test 'splits argument_value with :as => array' do
@@ -66,6 +70,11 @@ class OptionTest < TestCase
     assert_equal :foo, option_value(%w/--name foo/, :name, true, :as => :sym)
     assert_equal 30, option_value(%w/--age 30/, :age, true, :as => Integer)
     assert_equal "1.0", option_value(%w/--id 1/, :id, true, :as => Float).to_s
+
+    assert_equal -1, option_value(%w/-i -1/, :i, true, :as => Integer)
+    assert_equal -1, option_value(%w/-i -1.1/, :i, true, :as => Integer)
+    assert_equal "-1.1", option_value(%w/-i -1.1/, :i, true, :as => Float).to_s
+    assert_equal "foo", option_value(%w/--foo1 foo/, :foo1, true)
   end
 
   test 'ranges' do
@@ -73,6 +82,8 @@ class OptionTest < TestCase
     assert_equal (1..10), option_value(%w/-r 1-10/, :r, true, :as => Range)
     assert_equal (1..10), option_value(%w/-r 1,10/, :r, true, :as => Range)
     assert_equal (1...10), option_value(%w/-r 1...10/, :r, true, :as => Range)
+    assert_equal (-1..10), option_value(%w/-r -1..10/, :r, true, :as => Range)
+    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/
@@ -145,4 +156,16 @@ class OptionTest < TestCase
     assert_equal 1, slop.options[:x].count
     assert_equal 3, slop.options[:v].count
   end
+
+  test 'omit block execution with :unless option' do
+    item = nil
+    opts = Slop.new do
+      on :foo
+      on :bar, true, :unless => 'foo' do; item = "foo"; end
+    end
+    opts.parse %w/--foo --bar 1/
+
+    assert_equal "1", opts[:bar]
+    refute item
+  end
 end

data/test/slop_test.rb

@@ -29,6 +29,15 @@ class SlopTest < TestCase
     assert_kind_of Slop, slop
   end
 
+  test 'parsing calls to_s on all of the items in the array' do
+    opts = Slop.parse([:'--foo']) { on :foo }
+    assert opts.foo?
+  end
+
+  test '#opt returns an Slop::Option' do
+    assert_kind_of Slop::Option, Slop.new.option(:n)
+  end
+
   test 'enumerating options' do
     slop = Slop.new
     slop.opt(:f, :foo, 'foo')
@@ -50,6 +59,13 @@ class SlopTest < TestCase
     end
 
     assert_equal 'foo', item1
+    assert_equal [], Slop.new { on_empty {} }.parse
+  end
+
+  test 'callback when arguments contain no options' do
+    item = nil
+    Slop.new { on_optionless { item = 'foo' } }.parse %w/a b c/
+    assert_equal 'foo', item
   end
 
   test 'multiple switches with the :multiple_switches flag' do
@@ -136,6 +152,7 @@ class SlopTest < TestCase
     end
     assert_equal %w/a/, opts.parse!(%w/--name lee a/)
     assert_equal %w/--name lee a/, opts.parse(%w/--name lee a/)
+    assert_equal ['foo', :bar, 1], opts.parse(['foo', :bar, 1])
   end
 
   test '#parse does not remove parsed items' do
@@ -359,4 +376,11 @@ class SlopTest < TestCase
     opts = Slop.new(:help => true, :io => io, :exit_on_help => false)
     assert opts.parse %w/--help/
   end
+
+  test 'ignoring case' do
+    opts = Slop.new(:ignore_case => true)
+    opts.on :n, :name, true
+    opts.parse %w/--NAME lee/
+    assert_equal 'lee', opts[:name]
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: slop
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.5.5
+  version: 1.6.0
 platform: ruby
 authors: 
 - Lee Jarvis
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-03 00:00:00 +01:00
+date: 2011-05-18 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -26,6 +26,7 @@ files:
 - .gemtest
 - .gitignore
 - .yardopts
+- CHANGES.md
 - LICENSE
 - README.md
 - Rakefile