slop 1.4.0 → 1.4.1

data/README.md

@@ -1,7 +1,7 @@
 Slop
 ====
 
-Slop is a simple option collector with an easy to remember syntax and friendly API.
+Slop is a simple option parser with an easy to remember syntax and friendly API.
 
 Installation
 ------------
@@ -18,49 +18,49 @@ Installation
 
 Usage
 -----
-	# parse assumes ARGV, otherwise you can pass it your own Array
-	opts = Slop.parse do
-	  on :v, :verbose, 'Enable verbose mode' 	   # boolean value
-	  on :n, :name, 'Your name', true              # compulsory argument
-	  on :s, :sex, 'Your sex', :optional => false  # the same thing
-	  on :a, :age, 'Your age', :optional => true   # optional argument
-	end
-
-	# if ARGV is `-v --name 'lee jarvis' -s male`
-	opts.verbose? #=> true
-	opts.name?    #=> true
-	opts[:name]   #=> 'lee jarvis'
-	opts.age?     #=> false
-	opts[:age]    #=> nil
+    # parse assumes ARGV, otherwise you can pass it your own Array
+    opts = Slop.parse do
+      on :v, :verbose, 'Enable verbose mode' 	   # boolean value
+      on :n, :name, 'Your name', true              # compulsory argument
+      on :s, :sex, 'Your sex', :optional => false  # the same thing
+      on :a, :age, 'Your age', :optional => true   # optional argument
+    end
+
+    # if ARGV is `-v --name 'lee jarvis' -s male`
+    opts.verbose? #=> true
+    opts.name?    #=> true
+    opts[:name]   #=> 'lee jarvis'
+    opts.age?     #=> false
+    opts[:age]    #=> nil
 
 You can also return your options as a Hash
 
-	opts.to_hash #=> {'name' => 'Lee Jarvis', 'verbose' => true, 'age' => nil, 'sex' => 'male'}
+    opts.to_hash #=> {'name' => 'Lee Jarvis', 'verbose' => true, 'age' => nil, 'sex' => 'male'}
 
-	# Symbols
-	opts.to_hash(true) #=> {:name => 'Lee Jarvis', :verbose => true, :age => nil, :sex => 'male'}
+    # Symbols
+    opts.to_hash(true) #=> {:name => 'Lee Jarvis', :verbose => true, :age => nil, :sex => 'male'}
 
 If you don't like the method `on` (because it sounds like the option **expects**
 a block), you can use the `opt` or `option` alternatives.
 
-	on :v, :verbose
-	opt :v, :verbose
-	option :v, :verbose
+    on :v, :verbose
+    opt :v, :verbose
+    option :v, :verbose
 
 If you don't like that Slop evaluates your block, or you want slop access
 inside of your block without referring to `self`, you can pass a block argument to
 `parse`.
 
-	Slop.parse do |opts|
-	  opts.on :v, :verbose
-	  opts.on :n, :name, 'Your name', true
-	end
+    Slop.parse do |opts|
+      opts.on :v, :verbose
+      opts.on :n, :name, 'Your name', true
+    end
 
 If you want some pretty output for the user to see your options, you can just
 send the Slop object to `puts` or use the `help` method.
 
-	puts opts
-	puts opts.help
+    puts opts
+    puts opts.help
 
 Will output something like
 
@@ -70,14 +70,18 @@ Will output something like
 
 You can also add a banner using the `banner` method
 
-	opts = Slop.parse
-	opts.banner = "Usage: foo.rb [options]"
+    opts = Slop.parse
+    opts.banner = "Usage: foo.rb [options]"
+
+or
+
+    opts = Slop.parse do
+      banner "Usage: foo.rb [options]"
+    end
 
 or
 
-	opts = Slop.parse do
-	  banner "Usage: foo.rb [options]"
-	end
+    opts = Slop.new "Usage: foo.rb [options]"
 
 Helpful Help
 ------------
@@ -116,12 +120,12 @@ Now throw some options at it:
 
 Here's what we'll get back
 
-	{
-		:server=>"ftp://foobar.com",
-		:port=>1234,
-		:username=>"FooBar",
-		:password=>"hello there"
-	}
+    {
+    	:server=>"ftp://foobar.com",
+    	:port=>1234,
+    	:username=>"FooBar",
+    	:password=>"hello there"
+    }
 
 Callbacks
 ---------
@@ -147,17 +151,17 @@ they're found, just like
 [OptionParser](http://rubydoc.info/stdlib/optparse/1.9.2/OptionParser:order)
 does it.
 
-	opts = Slop.new do
-	  on :n, :name, :optional => false
-	end
+    opts = Slop.new do
+      on :n, :name, :optional => false
+    end
 
-	opts.parse do |arg|
-	  puts arg
-	end
+    opts.parse do |arg|
+      puts arg
+    end
 
-	# if ARGV is `foo --name Lee bar`
-	foo
-	bar
+    # if ARGV is `foo --name Lee bar`
+    foo
+    bar
 
 Negative Options
 ----------------
@@ -165,16 +169,16 @@ Negative Options
 Slop also allows you to prefix `--no-` to an option which will force the option
 to return a false value.
 
-	opts = Slop.parse do
-		on :v, :verbose, :default => true
-	end
+    opts = Slop.parse do
+    	on :v, :verbose, :default => true
+    end
 
-	# with no command line options
-	opts[:verbose] #=> true
+    # with no command line options
+    opts[:verbose] #=> true
 
-	# with `--no-verbose`
-	opts[:verbose] #=> false
-	opts.verbose?  #=> false
+    # with `--no-verbose`
+    opts[:verbose] #=> false
+    opts.verbose?  #=> false
 
 Short Switches
 --------------
@@ -196,16 +200,49 @@ by passing the `:multiple_switches` option to a new Slop object.
     opts[:b] #=> false
     opts[:c] #=> true
 
+Lists
+-----
+
+You can of course also parse lists into options. Here's how:
+
+    opts = Slop.parse do
+      opt :people, true, :as => Array
+    end
+
+    # ARGV is `--people lee,john,bill`
+    opts[:people] #=> ['lee', 'john', 'bill']
+
+You can also change both the split delimiter and limit
+
+    opts = Slop.parse do
+      opt :people, true, :as => Array, :delimiter => ':', :limit => 2)
+    end
+
+    # ARGV is `--people lee:injekt:bob`
+    opts[:people] #=> ["lee", "injekt:bob"]
+
+Ranges
+------
+
+What would Slop be if it didn't know what ranges were?
+
+    opts = Slop.parse do
+      opt :r, :range, true, :as => Range
+    end
+
+    # ARGV is `--range 1..10` or 1-10, or 1,10 (yes Slop supports them all)
+    opts[:range].to_a #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
 Ugh, Symbols
 ------------
 
 Fine, don't use them
 
-	Slop.parse do
-	  on :n, :name, 'Your name'
-	  on 'n', 'name', 'Your name'
-	  on '-n', '--name', 'Your name'
-	end
+    Slop.parse do
+      on :n, :name, 'Your name'
+      on 'n', 'name', 'Your name'
+      on '-n', '--name', 'Your name'
+    end
 
 All of these options will do the same thing
 
@@ -214,9 +251,9 @@ Ugh, Blocks
 
 C'mon man, this is Ruby, GTFO if you don't like blocks.
 
-	opts = Slop.new
-	opts.on :v, :verbose
-	opts.parse
+    opts = Slop.new
+    opts.on :v, :verbose
+    opts.parse
 
 Smart
 -----
@@ -225,39 +262,18 @@ Slop is pretty smart when it comes to building your options, for example if you
 want your option to have a flag attribute, but no `--option` attribute, you
 can do this:
 
-	on :n, "Your name"
+    on :n, "Your name"
 
 and Slop will detect a description in place of an option, so you don't have to
 do this:
 
-	on :n, nil, "Your name", true
+    on :n, nil, "Your name", true
 
 You can also try other variations:
 
-	on :name, "Your name"
-	on :n, :name
-	on :name, true
-
-Lists
------
-
-You can of course also parse lists into options. Here's how:
-
-	opts = Slop.parse do
-	  opt :people, true, :as => Array
-	end
-
-	# ARGV is `--people lee,john,bill`
-	opts[:people] #=> ['lee', 'john', 'bill']
-
-You can also change both the split delimiter and limit
-
-    opts = Slop.parse do
-      opt :people, true, :as => Array, :delimiter => ':', :limit => 2)
-    end
-
-    # ARGV is `--people lee:injekt:bob`
-    opts[:people] #=> ["lee", "injekt:bob"]
+    on :name, "Your name"
+    on :n, :name
+    on :name, true
 
 Strict Mode
 -----------
@@ -306,33 +322,33 @@ I'm not, honestly! I love OptionParser. I really do, it's a fantastic library.
 So why did I build Slop? Well, I find myself using OptionParser to simply
 gather a bunch of key/value options, usually you would do something like this:
 
-	require 'optparse'
+    require 'optparse'
 
-	things = {}
+    things = {}
 
-	opt = OptionParser.new do |opt|
-	  opt.on('-n', '--name NAME', 'Your name') do |name|
-	    things[:name] = name
-	  end
+    opt = OptionParser.new do |opt|
+      opt.on('-n', '--name NAME', 'Your name') do |name|
+        things[:name] = name
+      end
 
-	  opt.on('-a', '--age AGE', 'Your age') do |age|
-		things[:age] = age
-	  end
+      opt.on('-a', '--age AGE', 'Your age') do |age|
+    	things[:age] = age
+      end
 
-	  # you get the point
-	end
+      # you get the point
+    end
 
-	opt.parse
-	# do something with things
+    opt.parse
+    things #=> { :name => 'lee', :age => 105 }
 
 Which is all great and stuff, but it can lead to some repetition, the same
 thing in Slop:
 
-	require 'slop'
+    require 'slop'
 
-	opts = Slop.parse do
-	  on :n, :name, 'Your name', true
-	  on :a, :age, 'Your age', true
-	end
+    opts = Slop.parse do
+      on :n, :name, 'Your name', true
+      on :a, :age, 'Your age', true
+    end
 
-	things = opts.to_hash
+    opts.to_hash(true) #=> { :name => 'lee', :age => 105 }

data/lib/slop.rb

@@ -16,7 +16,7 @@ class Slop
   class InvalidOptionError < RuntimeError; end
 
   # @return [String] The current version string
-  VERSION = '1.4.0'
+  VERSION = '1.4.1'
 
   # Parses the items from a CLI format into a friendly object.
   #
@@ -57,10 +57,10 @@ class Slop
   def initialize(*opts, &block)
     sloptions = {}
     sloptions.merge! opts.pop if opts.last.is_a? Hash
+    @banner = opts.shift if opts[0].respond_to?(:to_str)
     opts.each { |o| sloptions[o] = true }
 
     @options = Options.new
-    @banner = nil
     @longest_flag = 0
     @strict = sloptions[:strict]
     @invalid_options = []
@@ -163,7 +163,7 @@ class Slop
   #   # symbols!
   #   opts.to_hash(true) #=> { :name => 'Emily' }
   # @return [Hash]
-  def to_hash(symbols=nil)
+  def to_hash(symbols=false)
     @options.to_hash(symbols)
   end
   alias :to_h :to_hash
@@ -195,7 +195,7 @@ class Slop
   end
   alias :help :to_s
 
-private
+  private
 
   def self.initialize_and_parse(items, delete, options, &block)
     if items.is_a?(Hash) && options.empty?
@@ -322,8 +322,8 @@ private
     end
 
     long = args.first
-    boolean = long.is_a?(TrueClass) || long.is_a?(FalseClass)
-    if !boolean && long.to_s =~ /\A(--?)?[a-zA-Z0-9_-]+\z/
+    boolean = [true, false].include?(long)
+    if !boolean && long.to_s =~ /\A(?:--?)?[a-zA-Z0-9_-]+\z/
       options.push args.shift.to_s.sub(/\A--?/, '')
     else
       options.push nil
@@ -331,8 +331,6 @@ private
 
     options.push args.first.respond_to?(:to_sym) ? args.shift : nil
     options.push args.shift ? true : false # force true/false
-
-    options
   end
 
   def raise_if_invalid_options

data/lib/slop/option.rb

@@ -91,6 +91,8 @@ class Slop
       case @options[:as].to_s.downcase
       when 'array'
         value.split @delimiter, @limit
+      when 'range'
+        value_to_range value
       when 'string';  value.to_s
       when 'symbol';  value.to_s.to_sym
       when 'integer'; value.to_s.to_i
@@ -141,5 +143,18 @@ class Slop
       "long_flag=#{@long_flag.inspect} " +
       "description=#{@description.inspect}>"
     end
+
+    private
+
+    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)
+      else
+        value
+      end
+    end
   end
 end

data/test/option_test.rb

@@ -67,6 +67,17 @@ class OptionTest < TestCase
     assert_equal "1.0", option_value(%w/--id 1/, :id, true, :as => Float).to_s
   end
 
+  test 'ranges' do
+    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
+    # maybe this should raise is Slop#strict?
+    assert_equal "1abc10", option_value(%w/-r 1abc10/, :r, true, :as => Range)
+  end
+
   test 'printing options' do
     slop = Slop.new
     slop.opt :n, :name, 'Your name', true

data/test/slop_test.rb

@@ -5,6 +5,14 @@ class SlopTest < TestCase
     Slop.new.send(:clean_options, args)
   end
 
+  def temp_argv(items)
+    old_argv = ARGV.clone
+    ARGV.replace items
+    yield
+  ensure
+    ARGV.replace old_argv
+  end
+
   test 'includes Enumerable' do
     assert Slop.included_modules.include?(Enumerable)
   end
@@ -30,6 +38,12 @@ class SlopTest < TestCase
     slop.each { |option| assert option }
   end
 
+  test 'defaulting to ARGV' do
+    temp_argv(%w/--name lee/) do
+      assert_equal('lee', Slop.parse { on :name, true }[:name])
+    end
+  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 }
@@ -88,6 +102,9 @@ class SlopTest < TestCase
 
     slop.banner = nil
     assert_equal "", slop.to_s
+
+    slop = Slop.new "foo bar"
+    assert_equal "foo bar", slop.banner
   end
 
   test 'storing long option lengths' do

metadata

@@ -2,7 +2,7 @@
 name: slop
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors: 
 - Lee Jarvis
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-03 00:00:00 +01:00
+date: 2011-04-14 00:00:00 +01:00
 default_executable: 
 dependencies: []