slop 1.2.0 → 1.2.1

data/.gitignore

@@ -1,3 +1,4 @@
+.rvmrc
 .yardoc
 doc
 *.swp

data/README.md

@@ -13,8 +13,8 @@ Installation
 ### GitHub
 
     git clone git://github.com/injekt/slop.git
-	gem build slop.gemspec
-	gem install slop-<version>.gem
+    gem build slop.gemspec
+    gem install slop-<version>.gem
 
 Usage
 -----
@@ -40,23 +40,6 @@ You can also return your options as a Hash
 	# Symbols
 	opts.to_hash(true) #=> {:name => 'Lee Jarvis', :verbose => true, :age => nil, :sex => 'male'}
 
-If you pass a block to `Slop#parse`, Slop will yield non-options as
-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.parse do |arg|
-	  puts arg
-	end
-
-	# if ARGV is `foo --name Lee bar`
-	foo
-	bar
-
 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.
 
@@ -81,7 +64,7 @@ send the Slop object to `puts` or use the `help` method.
 
 Will output something like
 
-	-v, --verbose      Enable verbose mode
+    -v, --verbose      Enable verbose mode
     -n, --name         Your name
     -a, --age          Your age
 
@@ -96,22 +79,78 @@ or
 	  banner "Usage: foo.rb [options]"
 	end
 
+Helpful Help
+------------
+
+Long form:
+
+    Slop.parse do
+      ...
+      on :h, :help, 'Print this help message', :tail => true do
+        puts help
+        exit
+      end
+    end
+
+Shortcut:
+
+    Slop.parse :help => true do
+      ...
+    end
+
 Callbacks
 ---------
 
 If you'd like to trigger an event when an option is used, you can pass a
 block to your option. Here's how:
 
-    Slop.parse do
-      on :V, :version, 'Print the version' do
-	  	puts 'Version 1.0.0'
-		exit
-	  end
-    end
+	Slop.parse do
+		on :V, :version, 'Print the version' do
+			puts 'Version 1.0.0'
+			exit
+		end
+	end
 
 Now when using the `--version` option on the command line, the trigger will
 be called and its contents executed.
 
+Yielding Non Options
+--------------------
+
+If you pass a block to `Slop#parse`, Slop will yield non-options as
+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.parse do |arg|
+	  puts arg
+	end
+
+	# if ARGV is `foo --name Lee bar`
+	foo
+	bar
+
+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
+
+	# with no command line options
+	opts[:verbose] #=> true
+
+	# with `--no-verbose`
+	opts[:verbose] #=> false
+	opts.verbose?  #=> false
+
 Ugh, Symbols
 ------------
 
@@ -141,18 +180,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
+	on :name, "Your name"
+	on :n, :name
+	on :name, true
 
 Lists
 -----
@@ -169,12 +208,51 @@ You can of course also parse lists into options. Here's how:
 You can also change both the split delimiter and limit
 
     opts = Slop.parse do
-      opt :people, true, :as => Array, :delimiter => ':', :limit => 2)
+    	opt :people, true, :as => Array, :delimiter => ':', :limit => 2)
     end
 
     # ARGV is `--people lee:injekt:bob`
     opts[:people] #=> ["lee", "injekt:bob"]
 
+Strict Mode
+-----------
+
+Passing `strict => true` to `Slop.parse` causes it to raise a `Slop::InvalidOptionError` 
+when an invalid option is found (`false` by default):
+
+    Slop.new(:strict => true).parse(%w/--foo/)
+    # => Slop::InvalidOptionError: Unknown option -- 'foo'
+
+and it handles multiple invalid options with a sprinkling of pluralization:
+
+    Slop.new(:strict => true).parse(%w/--foo --bar -z/)
+    # => Slop::InvalidOptionError: Unknown options -- 'foo', 'bar', 'z'
+
+Significantly, however, Slop will still parse the valid options:
+
+    begin
+      slop = Slop.new(:strict => true, :help => true) do
+        banner "Usage:\n\t./awesome_sauce [options]\n\nOptions:"
+        on :n, :name, 'Your name'
+      end
+      slop.parse(%w/--foo --bar -z/)
+    rescue Slop::InvalidOptionError => e
+      puts "\n#{e.message}\n\n"
+      puts slop
+      exit
+    end
+
+yields:
+
+    Unknown options -- 'foo', 'bar', 'z'
+
+    Usage:
+    	./awesome_sauce [options]
+
+    Options:
+        -n, --name      Your name
+        -h, --help      Print this help message
+
 Woah woah, why you hating on OptionParser?
 ------------------------------------------
 
@@ -211,11 +289,4 @@ thing in Slop:
 	  on :a, :age, 'Your age', true
 	end
 
-	things = opts.to_hash
-
-Contributing
-------------
-
-If you'd like to contribute to Slop (it's **really** appreciated) please fork
-the GitHub repository, create your feature/bugfix branch, add tests, and send
-me a pull request. I'd be more than happy to look at it.
+	things = opts.to_hash

data/lib/slop.rb

@@ -4,9 +4,9 @@ require 'slop/version'
 class Slop
   include Enumerable
 
-  class MissingArgumentError < ArgumentError; end
-  class InvalidArgumentError < ArgumentError; end
-  class InvalidOptionError < ArgumentError; end
+  class MissingArgumentError < RuntimeError; end
+  class InvalidArgumentError < RuntimeError; end
+  class InvalidOptionError < RuntimeError; end
 
   # Parses the items from a CLI format into a friendly object.
   #
@@ -35,7 +35,9 @@ class Slop
     initialize_and_parse(items, true, options, &block)
   end
 
+  # @return [Options]
   attr_reader :options
+
   attr_writer :banner
   attr_accessor :longest_flag
 
@@ -48,6 +50,7 @@ class Slop
     @banner = nil
     @longest_flag = 0
     @strict = options[:strict]
+    @invalid_options = []
 
     if block_given?
       block.arity == 1 ? yield(self) : instance_eval(&block)
@@ -210,6 +213,11 @@ private
       if !option && item =~ /^-[^-]/
         flag, argument = flag.split('', 2)
         option = @options[flag]
+      elsif !option && item =~ /--no-(.+)$/
+        if option = @options[$1]
+          option.force_argument_value false
+          next
+        end
       end
 
       if option
@@ -238,6 +246,7 @@ private
     end
 
     items.delete_if { |item| trash.include? item } if delete
+    raise_if_invalid_options
     items
   end
 
@@ -258,9 +267,7 @@ private
   end
 
   def check_invalid_option(item, flag)
-    if item[/^--?/] && @strict
-      raise InvalidOptionError, "Unknown option -- '#{flag}'"
-    end
+    @invalid_options << flag if item[/^--?/] && @strict
   end
 
   def clean_options(args)
@@ -288,4 +295,12 @@ private
     options
   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

@@ -80,6 +80,10 @@ class Slop
       @expects_argument = true if options[:optional] == false
       @tail = options[:tail]
       @match = options[:match]
+      @forced = false
+
+      @delimiter = options[:delimiter] || ','
+      @limit = options[:limit] || 0
 
       if @long_flag && @long_flag.size > @slop.longest_flag
         @slop.longest_flag = @long_flag.size
@@ -113,21 +117,30 @@ class Slop
     # @return [Object] the argument value after it's been case
     #   according to the `:as` option
     def argument_value
+      return @argument_value if @forced
       value = @argument_value || default
-      return if value.nil?
-
-      case @options[:as].to_s
-      when 'Array'
-        value.split(@options[:delimiter] || ',', @options[:limit] || 0)
-      when 'String';  value.to_s
-      when 'Symbol';  value.to_s.to_sym
-      when 'Integer'; value.to_s.to_i
-      when 'Float';   value.to_s.to_f
+
+      case @options[:as].to_s.downcase
+      when 'array'
+        value.split @delimiter, @limit
+      when 'string';  value.to_s
+      when 'symbol';  value.to_s.to_sym
+      when 'integer'; value.to_s.to_i
+      when 'float';   value.to_s.to_f
       else
         value
       end
     end
 
+    # Force an argument value, used when the desired argument value
+    # is negative (false or nil)
+    #
+    # @param [Object] value
+    def force_argument_value(value)
+      @argument_value = value
+      @forced = true
+    end
+
     def to_s
       out = "    "
       out += @short_flag ? "-#{@short_flag}, " : ' ' * 4

data/lib/slop/version.rb

@@ -1,3 +1,3 @@
 class Slop
-  VERSION = '1.2.0'
+  VERSION = '1.2.1'
 end

data/test/option_test.rb

@@ -62,6 +62,7 @@ class OptionTest < TestCase
 
   test 'casting' do
     assert_equal :foo, option_value(%w/--name foo/, :name, true, :as => Symbol)
+    assert_equal :foo, option_value(%w/--name foo/, :name, true, :as => :symbol)
     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
   end

data/test/slop_test.rb

@@ -216,6 +216,14 @@ class SlopTest < TestCase
     assert totallynotstrict.parse %w/--foo/
   end
 
+  test 'strict mode parses options before raising Slop::InvalidOptionError' do
+    strict = Slop.new :strict => true
+    strict.opt :n, :name, true
+
+    assert_raises(Slop::InvalidOptionError, /--foo/) { strict.parse %w/--foo --name nelson/ }
+    assert_equal 'nelson', strict[:name]
+  end
+
   test 'short option flag with no space between flag and argument' do
     slop = Slop.new
     slop.opt :p, :password, true
@@ -225,4 +233,16 @@ class SlopTest < TestCase
     assert_equal 'foo', slop[:password]
     assert_equal 'bar', slop[:shortpass]
   end
+
+  test 'prefixing --no- onto options for a negative result' do
+    slop = Slop.new
+    slop.opt :d, :debug
+    slop.opt :v, :verbose, :default => true
+    slop.parse %w/--no-debug --no-verbose --no-nothing/
+
+    refute slop.verbose?
+    refute slop.debug?
+    refute slop[:verbose]
+    refute slop[:debug]
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: slop
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors: 
 - Lee Jarvis
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-21 00:00:00 +00:00
+date: 2011-03-24 00:00:00 +00:00
 default_executable: 
 dependencies: []