slop 3.3.3 → 3.4.0

data/CHANGES.md

@@ -1,3 +1,11 @@
+3.4.0 (2013-01-12)
+------------------
+
+* Implement new command system (#95)
+* Deprecate Slop::Commands
+* Ensure 'no-foo' options are not inverted when parsing '--no-foo' (#86)
+* Code refactoring and simplification (Kenichi Kamiya, #84, #85)
+
 3.3.3 (2012-08-29)
 ------------------
 

data/README.md

@@ -2,61 +2,33 @@ Slop
 ====
 
 Slop is a simple option parser with an easy to remember syntax and friendly API.
-
-This README is targeted at Slop v3.
+API Documentation is available [here](http://injekt.github.com/rdoc/slop/).
 
 [![Build Status](https://secure.travis-ci.org/injekt/slop.png)](http://travis-ci.org/injekt/slop)
 
-Installation
-------------
-
-### Rubygems
-
-    gem install slop
-
-### GitHub
-
-    git clone git://github.com/injekt/slop.git
-    gem build slop.gemspec
-    gem install slop-<version>.gem
-
 Usage
 -----
 
 ```ruby
-# parse assumes ARGV, otherwise you can pass it your own Array
 opts = Slop.parse do
-  banner "ruby foo.rb [options]\n"
-  on :name=, 'Your name'
-  on :p, :password, 'Your password', :argument => :optional
-  on :v, :verbose, 'Enable verbose mode'
+  banner 'Usage: foo.rb [options]'
+
+  on 'name=', 'Your name'
+  on 'p', 'password', 'An optional password', argument: :optional
+  on 'v', 'verbose', 'Enable verbose mode'
 end
 
 # if ARGV is `--name Lee -v`
 opts.verbose?  #=> true
 opts.password? #=> false
 opts[:name]    #=> 'lee'
+opts.to_hash   #=> {:name=>"Lee", :password=>nil, :verbose=>true}
 ```
 
-Slop supports several methods of writing options:
-
-```ruby
-# These options all do the same thing
-on '-n', '--name', 'Your name', :argument => true
-on 'n', :name=, 'Your name'
-on :n, '--name=', 'Your name'
-
-# As do these
-on 'p', '--password', 'Your password', :argument => :optional
-on :p, :password, 'Your password', :optional_argument => true
-on '-p', 'password=?', 'Your password'
-```
-
-You can also return your options as a Hash:
+Installation
+------------
 
-```ruby
-opts.to_hash #=> { :name => 'lee', :verbose => true, :password => nil }
-```
+    gem install slop
 
 Printing Help
 -------------
@@ -84,13 +56,88 @@ All of these options can be sent to `Slop.new` or `Slop.parse` in Hash form.
 * `longest_flag` - The longest string flag, used to aid configuring help
    text. **default:** *0*.
 
-Features
+Lists
+-----
+
+```ruby
+opts = Slop.parse do
+  on :list=, as: Array
+end
+# ruby run.rb --list one,two
+opts[:list] #=> ["one", "two"]
+# ruby run.rb --list one,two --list three
+opts[:list] #=> ["one", "two", "three"]
+```
+
+You can also specify a delimiter and limit.
+
+```ruby
+opts = Slop.parse do
+  on :list=, as: Array, delimiter: ':', limit: 2
+end
+# ruby run.rb --list one:two:three
+opts[:list] #=> ["one", "two:three"]
+```
+
+Ranges
+------
+
+```ruby
+opts = Slop.parse do
+  on :range=, as: Range
+end
+# ruby run.rb --range 1..10
+opts[:range] #=> 1..10
+# ruby run.rb --range 1...10
+opts[:range] #=> 1...10
+# ruby run.rb --range 1-10
+opts[:range] #=> 1..10
+# ruby run.rb --range 1,10
+opts[:range] #=> 1..10
+```
+
+Autocreate
+----------
+
+Slop has an 'autocreate' feature. This feature is intended to create
+options on the fly, without having to specify them yourself. In some case,
+uses this code could be all you need in your application:
+
+```ruby
+# ruby run.rb --foo bar --baz --name lee
+opts = Slop.parse(autocreate: true)
+opts.to_hash #=> {:foo=>"bar", :baz=>true, :name=>"lee"}
+opts.fetch_option(:name).expects_argument? #=> true
+```
+
+Commands
 --------
 
-Check out the following wiki pages for more features:
+Slop supports git style sub-commands, like so:
+
+```ruby
+opts = Slop.parse do
+  on '-v', 'Print the version' do
+    puts "Version 1.0"
+  end
 
-* [Ranges](https://github.com/injekt/slop/wiki/Ranges)
-* [Auto Create](https://github.com/injekt/slop/wiki/Auto-Create)
+  command 'add' do
+    on :v, :verbose, 'Enable verbose mode'
+    on :name, 'Your name'
+
+    run do |opts, args|
+      puts "You ran 'add' with options #{opts.to_hash} and args: #{args.inspect}"
+    end
+  end
+end
+
+# ruby run.rb -v
+#=> Version 1.0
+# ruby run.rb add -v foo --name Lee
+#=> You ran 'add' with options {:verbose=>true,:name=>"Lee"} and args ["foo"]
+opts.to_hash(true) # Pass true to tell Slop to merge sub-command option values.
+# => { :v => nil, :add => { :v => true, :name => "Lee" } }
+```
 
 Woah woah, why you hating on OptionParser?
 ------------------------------------------
@@ -132,4 +179,4 @@ opts = Slop.parse do
 end
 
 opts.to_hash #=> { :name => 'lee', :age => 105 }
-```
+```

data/Rakefile

@@ -10,4 +10,20 @@ Rake::TestTask.new do |t|
   t.test_files = Dir['test/*_test.rb']
 end
 
+begin
+  require 'rdoc/task'
+
+  # requires sdoc and horo gems
+  RDoc::Task.new do |rdoc|
+    rdoc.title = 'Slop API Documentation'
+    rdoc.rdoc_dir = 'doc'
+    rdoc.options << '-f' << 'sdoc'
+    rdoc.options << '-T' << 'rails'
+    rdoc.options << '-e' << 'UTF-8'
+    rdoc.options << '-g'
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
+rescue LoadError
+end
+
 task :default => :test

data/lib/slop.rb

@@ -4,7 +4,7 @@ require 'slop/commands'
 class Slop
   include Enumerable
 
-  VERSION = '3.3.3'
+  VERSION = '3.4.0'
 
   # The main Error class, all Exception classes inherit from this class.
   class Error < StandardError; end
@@ -51,7 +51,7 @@ class Slop
     #
     # Returns a new instance of Slop.
     def parse(items = ARGV, config = {}, &block)
-      init_and_parse(items, false, config, &block)
+      parse! items.dup, config, &block
     end
 
     # items  - The Array of items to extract options from (default: ARGV).
@@ -60,7 +60,10 @@ class Slop
     #
     # Returns a new instance of Slop.
     def parse!(items = ARGV, config = {}, &block)
-      init_and_parse(items, true, config, &block)
+      config, items = items, ARGV if items.is_a?(Hash) && config.empty?
+      slop = Slop.new config, &block
+      slop.parse! items
+      slop
     end
 
     # Build a Slop object from a option specification.
@@ -106,22 +109,6 @@ class Slop
       opts
     end
 
-    private
-
-    # Convenience method used by ::parse and ::parse!.
-    #
-    # items  - The Array of items to parse.
-    # delete - When true, executes #parse! over #parse.
-    # config - The Hash of configuration options to pass to Slop.new.
-    # block  - The optional block to pass to Slop.new
-    #
-    # Returns a newly created instance of Slop.
-    def init_and_parse(items, delete, config, &block)
-      config, items = items, ARGV if items.is_a?(Hash) && config.empty?
-      slop = Slop.new(config, &block)
-      delete ? slop.parse!(items) : slop.parse(items)
-      slop
-    end
   end
 
   # The Hash of configuration options for this Slop instance.
@@ -137,11 +124,13 @@ class Slop
   def initialize(config = {}, &block)
     @config = DEFAULT_OPTIONS.merge(config)
     @options = []
+    @commands = {}
     @trash = []
     @triggered_options = []
     @unknown_options = []
     @callbacks = {}
     @separators = {}
+    @runner = nil
 
     if block_given?
       block.arity == 1 ? yield(self) : instance_eval(&block)
@@ -164,8 +153,6 @@ class Slop
   # Set the banner.
   #
   # banner - The String to set the banner.
-  #
-  # Returns nothing.
   def banner=(banner)
     config[:banner] = banner
   end
@@ -180,6 +167,33 @@ class Slop
     config[:banner]
   end
 
+  # Set the description (used for commands).
+  #
+  # desc - The String to set the description.
+  def description=(desc)
+    config[:description] = desc
+  end
+
+  # Get or set the description (used for commands).
+  #
+  # desc - The String to set the description.
+  #
+  # Returns the description String.
+  def description(desc = nil)
+    config[:description] = desc if desc
+    config[:description]
+  end
+
+  # Add a new command.
+  #
+  # command - The Symbol or String used to identify this command.
+  # options - A Hash of configuration options (see Slop::new)
+  #
+  # Returns a new instance of Slop mapped to this command.
+  def command(command, options = {}, &block)
+    @commands[command.to_s] = Slop.new(options, &block)
+  end
+
   # Parse a list of items, executing and gathering options along the way.
   #
   # items - The Array of items to extract options from (default: ARGV).
@@ -187,7 +201,8 @@ class Slop
   #
   # Returns an Array of original items.
   def parse(items = ARGV, &block)
-    parse_items(items, false, &block)
+    parse! items.dup, &block
+    items
   end
 
   # Parse a list of items, executing and gathering options along the way.
@@ -199,7 +214,39 @@ class Slop
   #
   # Returns an Array of original items with options removed.
   def parse!(items = ARGV, &block)
-    parse_items(items, true, &block)
+    if items.empty? && @callbacks[:empty]
+      @callbacks[:empty].each { |cb| cb.call(self) }
+      return items
+    end
+
+    if cmd = @commands[items[0]]
+      return cmd.parse! items[1..-1]
+    end
+
+    items.each_with_index do |item, index|
+      @trash << index && break if item == '--'
+      autocreate(items, index) if config[:autocreate]
+      process_item(items, index, &block) unless @trash.include?(index)
+    end
+    items.reject!.with_index { |item, index| @trash.include?(index) }
+
+    missing_options = options.select { |opt| opt.required? && opt.count < 1 }
+    if missing_options.any?
+      raise MissingOptionError,
+      "Missing required option(s): #{missing_options.map(&:key).join(', ')}"
+    end
+
+    if @unknown_options.any?
+      raise InvalidOptionError, "Unknown options #{@unknown_options.join(', ')}"
+    end
+
+    if @triggered_options.empty? && @callbacks[:no_options]
+      @callbacks[:no_options].each { |cb| cb.call(self) }
+    end
+
+    @runner.call(self, items) if @runner.respond_to?(:call)
+
+    items
   end
 
   # Add an Option.
@@ -232,8 +279,14 @@ class Slop
   alias get []
 
   # Returns a new Hash with option flags as keys and option values as values.
-  def to_hash
-    Hash[options.map { |opt| [opt.key.to_sym, opt.value] }]
+  #
+  # include_commands - If true, merge options from all sub-commands.
+  def to_hash(include_commands = false)
+    hash = Hash[options.map { |opt| [opt.key.to_sym, opt.value] }]
+    if include_commands
+      @commands.each { |cmd, opts| hash.merge!(cmd.to_sym => opts.to_hash) }
+    end
+    hash
   end
   alias to_h to_hash
 
@@ -242,6 +295,29 @@ class Slop
     options.each(&block)
   end
 
+  # Specify code to be executed when these options are parsed.
+  #
+  # callable - An object responding to a call method.
+  #
+  # yields - The instance of Slop parsing these options
+  #          An Array of unparsed arguments
+  #
+  # Example:
+  #
+  #   Slop.parse do
+  #     on :v, :verbose
+  #
+  #     run do |opts, args|
+  #       puts "Arguments: #{args.inspect}" if opts.verbose?
+  #     end
+  #   end
+  def run(callable = nil, &block)
+    @runner = callable || block
+    unless @runner.respond_to?(:call)
+      raise ArgumentError, "You must specify a callable object or a block to #run"
+    end
+  end
+
   # Check for an options presence.
   #
   # Examples:
@@ -255,35 +331,11 @@ class Slop
     keys.all? { |key| (opt = fetch_option(key)) && opt.count > 0 }
   end
 
-  # Convenience method for present?(:option).
-  #
-  # Examples:
-  #
-  #   opts.parse %( --verbose )
-  #   opts.verbose? #=> true
-  #   opts.other?   #=> false
-  #
-  # Returns true if this option is present. If this method does not end
-  # with a ? character it will instead call super().
-  def method_missing(method, *args, &block)
-    meth = method.to_s
-    if meth.end_with?('?')
-      present?(meth.chop)
-    else
-      super
-    end
-  end
-
   # Override this method so we can check if an option? method exists.
   #
   # Returns true if this option key exists in our list of options.
-  def respond_to?(method)
-    method = method.to_s
-    if method.end_with?('?') && options.any? { |o| o.key == method.chop }
-      true
-    else
-      super
-    end
+  def respond_to_missing?(method_name, include_private = false)
+    options.any? { |o| o.key == method_name.to_s.chop } || super
   end
 
   # Fetch a list of options which were missing from the parsed list.
@@ -319,6 +371,22 @@ class Slop
     options.find { |option| [option.long, option.short].include?(clean(key)) }
   end
 
+  # Fetch a Slop object associated with this command.
+  #
+  # command - The String or Symbol name of the command.
+  #
+  # Examples:
+  #
+  #   opts.command :foo do
+  #     on :v, :verbose, 'Enable verbose mode'
+  #   end
+  #
+  #   # ruby run.rb foo -v
+  #   opts.fetch_command(:foo).verbose? #=> true
+  def fetch_command(command)
+    @commands[command.to_s]
+  end
+
   # Add a callback.
   #
   # label - The Symbol identifier to attach this callback.
@@ -350,59 +418,43 @@ class Slop
       (str = @separators[i + 1]) ? [o, str].join("\n") : o
     }.join("\n")
 
-    if config[:banner]
-      config[:banner] << "\n"
-      config[:banner] << "#{@separators[0]}\n" if @separators[0]
-      config[:banner] + optstr
+    if @commands.any?
+      optstr << "\n" if !optstr.empty?
+      optstr << "\nAvailable commands:\n\n"
+      optstr << commands_to_help
+      optstr << "\n\nSee `<command> --help` for more information on a specific command."
+    end
+
+    banner = config[:banner]
+    banner = "Usage: #{File.basename($0, '.*')}#{' [command]' if @commands.any?} [options]" if banner.nil?
+    if banner
+      "#{banner}\n#{@separators[0] ? "#{@separators[0]}\n" : ''}#{optstr}"
     else
       optstr
     end
   end
   alias help to_s
 
-  # Returns the String inspection text.
-  def inspect
-    "#<Slop #{config.inspect} #{options.map(&:inspect)}>"
-  end
-
   private
 
-  # Parse a list of items and process their values.
+  # Convenience method for present?(:option).
   #
-  # items  - The Array of items to process.
-  # delete - True to remove any triggered options and arguments from the
-  #          original list of items.
-  # block  - An optional block which when passed will yields non-options.
+  # Examples:
   #
-  # Returns the original Array of items.
-  def parse_items(items, delete, &block)
-    if items.empty? && @callbacks[:empty]
-      @callbacks[:empty].each { |cb| cb.call(self) }
-      return items
-    end
-
-    items.each_with_index do |item, index|
-      @trash << index && break if item == '--'
-      autocreate(items, index) if config[:autocreate]
-      process_item(items, index, &block) unless @trash.include?(index)
-    end
-    items.reject!.with_index { |item, index| @trash.include?(index) } if delete
-
-    missing_options = options.select { |opt| opt.required? && opt.count < 1 }
-    if missing_options.any?
-      raise MissingOptionError,
-      "Missing required option(s): #{missing_options.map(&:key).join(', ')}"
-    end
-
-    if @unknown_options.any?
-      raise InvalidOptionError, "Unknown options #{@unknown_options.join(', ')}"
-    end
-
-    if @triggered_options.empty? && @callbacks[:no_options]
-      @callbacks[:no_options].each { |cb| cb.call(self) }
+  #   opts.parse %( --verbose )
+  #   opts.verbose? #=> true
+  #   opts.other?   #=> false
+  #
+  # Returns true if this option is present. If this method does not end
+  # with a ? character it will instead call super().
+  def method_missing(method, *args, &block)
+    meth = method.to_s
+    if meth.end_with?('?')
+      meth.chop!
+      present?(meth) || present?(meth.gsub('_', '-'))
+    else
+      super
     end
-
-    items
   end
 
   # Process a list item, figure out if it's an option, execute any
@@ -419,6 +471,7 @@ class Slop
 
     if option
       option.count += 1 unless item.start_with?('--no-')
+      option.count += 1 if option.key[0, 3] == "no-"
       @trash << index
       @triggered_options << option
 
@@ -548,7 +601,7 @@ class Slop
     config[:optional_argument] = true if @config[:optional_arguments]
 
     if objects.last.is_a?(Hash)
-      config = config.merge!(objects.last)
+      config.merge!(objects.last)
       objects.pop
     end
     short = extract_short_flag(objects, config)
@@ -599,4 +652,12 @@ class Slop
     object.to_s.sub(/\A--?/, '')
   end
 
+  def commands_to_help
+    padding = 0
+    @commands.each { |c, _| padding = c.size if c.size > padding }
+    @commands.map do |cmd, opts|
+      "  #{cmd}#{' ' * (padding - cmd.size)}   #{opts.description}"
+    end.join("\n")
+  end
+
 end

data/lib/slop/commands.rb

@@ -39,6 +39,10 @@ class Slop
       @banner = nil
       @triggered_command = nil
 
+      warn "[DEPRECATED] Slop::Commands is deprecated and will be removed in "\
+        "Slop version 4. Check out http://injekt.github.com/slop/#commands for "\
+        "a new implementation of commands."
+
       if block_given?
         block.arity == 1 ? yield(self) : instance_eval(&block)
       end
@@ -108,18 +112,19 @@ class Slop
       key.to_s == @triggered_command
     end
 
+    # Enumerable interface.
+    def each(&block)
+      @commands.each(&block)
+    end
+
     # Parse a list of items.
     #
     # items - The Array of items to parse.
     #
     # Returns the original Array of items.
     def parse(items = ARGV)
-      parse_items(items)
-    end
-
-    # Enumerable interface.
-    def each(&block)
-      @commands.each(&block)
+      parse! items.dup
+      items
     end
 
     # Parse a list of items, removing any options or option arguments found.
@@ -128,7 +133,22 @@ class Slop
     #
     # Returns the original Array of items with options removed.
     def parse!(items = ARGV)
-      parse_items(items, true)
+      if opts = commands[items[0].to_s]
+        @triggered_command = items.shift
+        execute_arguments! items
+        opts.parse! items
+        execute_global_opts! items
+      else
+        if opts = commands['default']
+          opts.parse! items
+        else
+          if config[:strict] && items[0]
+            raise InvalidCommandError, "Unknown command `#{items[0]}`"
+          end
+        end
+        execute_global_opts! items
+      end
+      items
     end
 
     # Returns a nested Hash with Slop options and values. See Slop#to_hash.
@@ -141,8 +161,12 @@ class Slop
       defaults = commands.delete('default')
       globals = commands.delete('global')
       helps = commands.reject { |_, v| v.options.none? }
-      helps.merge!('Global options' => globals.to_s) if globals
-      helps.merge!('Other options' => defaults.to_s) if defaults
+      if globals && globals.options.any?
+        helps.merge!('Global options' => globals.to_s)
+      end
+      if defaults && defaults.options.any?
+        helps.merge!('Other options' => defaults.to_s)
+      end
       banner = @banner ? "#{@banner}\n" : ""
       banner + helps.map { |key, opts| "  #{key}\n#{opts}" }.join("\n\n")
     end
@@ -155,43 +179,18 @@ class Slop
 
     private
 
-    # Parse a list of items.
-    #
-    # items - The Array of items to parse.
-    # bang  - When true, #parse! will be called instead of #parse.
-    #
-    # Returns the Array of items (with options removed if bang == true).
-    def parse_items(items, bang = false)
-      if opts = commands[items[0].to_s]
-        @triggered_command = items.shift
-        execute_arguments(items, bang)
-        bang ? opts.parse!(items) : opts.parse(items)
-        execute_global_opts(items, bang)
-      else
-        if opts = commands['default']
-          bang ? opts.parse!(items) : opts.parse(items)
-        else
-          if config[:strict] && items[0]
-            raise InvalidCommandError, "Unknown command `#{items[0]}`"
-          end
-        end
-        execute_global_opts(items, bang)
-      end
-      items
-    end
-
     # Returns nothing.
-    def execute_arguments(items, bang)
+    def execute_arguments!(items)
       @arguments = items.take_while { |arg| !arg.start_with?('-') }
-      items.shift(@arguments.size) if bang
+      items.shift @arguments.size
     end
 
     # Returns nothing.
-    def execute_global_opts(items, bang)
+    def execute_global_opts!(items)
       if global_opts = commands['global']
-        bang ? global_opts.parse!(items) : global_opts.parse(items)
+        global_opts.parse! items
       end
     end
 
   end
-end
+end

data/lib/slop/option.rb

@@ -56,7 +56,7 @@ class Slop
       @config.each_key do |key|
         predicate = :"#{key}?"
         unless self.class.method_defined? predicate
-          self.class.send(:define_method, predicate) { !!@config[key] }
+          self.class.__send__(:define_method, predicate) { !!@config[key] }
         end
       end
     end
@@ -126,16 +126,15 @@ class Slop
     def to_s
       return config[:help] if config[:help].respond_to?(:to_str)
 
-      out = "    "
-      out += short ? "-#{short}, " : ' ' * 4
+      out = "    #{short ? "-#{short}, " : ' ' * 4}"
 
       if long
-        out += "--#{long}"
+        out << "--#{long}"
         size = long.size
         diff = @slop.config[:longest_flag] - size
-        out += " " * (diff + 6)
+        out << (' ' * (diff + 6))
       else
-        out += " " * (@slop.config[:longest_flag] + 8)
+        out << (' ' * (@slop.config[:longest_flag] + 8))
       end
 
       "#{out}#{description}"

data/slop.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'slop'
-  s.version     = '3.3.3'
+  s.version     = '3.4.0'
   s.summary     = 'Option gathering made easy'
   s.description = 'A simple DSL for gathering options and parsing the command line'
   s.author      = 'Lee Jarvis'
@@ -9,6 +9,8 @@ Gem::Specification.new do |s|
   s.files       = `git ls-files`.split("\n")
   s.test_files  = `git ls-files -- test/*`.split("\n")
 
+  s.required_ruby_version = '>= 1.8.7'
+
   s.add_development_dependency 'rake'
   s.add_development_dependency 'minitest'
 end

data/test/commands_test.rb

@@ -13,6 +13,16 @@ class CommandsTest < TestCase
         add_callback(:empty) { 'version 1' }
       end
     end
+
+    @empty_commands = Slop::Commands.new do
+      default do
+      end
+
+      global do
+      end
+
+      on 'verbose'
+    end
   end
 
   test "it nests instances of Slop" do
@@ -75,6 +85,10 @@ class CommandsTest < TestCase
     assert_kind_of Slop, @commands.global
   end
 
+  test "empty default/global blocks don't add their titles in the help output" do
+    assert_empty @empty_commands.to_s
+  end
+
   test "parse does nothing when there's nothing to parse" do
     assert @commands.parse []
   end
@@ -99,4 +113,26 @@ class CommandsTest < TestCase
     assert_equal %w( file1 file2 ), @commands.arguments
   end
 
+  test "context and return value of constructor block" do
+    peep = nil
+    ret = Slop::Commands.new { peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop::Commands.new { |a| peep = self }
+    assert !peep.equal?(ret)
+    assert_same peep, self
+
+    peep = nil
+    ret = Slop::Commands.new { |a, b| peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop::Commands.new { |a, *rest| peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+  end
+
 end

data/test/slop_test.rb

@@ -314,7 +314,7 @@ class SlopTest < TestCase
   end
 
   test "separators" do
-    opts = Slop.new do
+    opts = Slop.new(:banner => false) do
       on :foo
       separator "hello"
       separator "world"
@@ -331,10 +331,24 @@ class SlopTest < TestCase
 
   test "printing help with :help => true" do
     temp_stderr do |string|
-      opts = Slop.new(:help => true)
+      opts = Slop.new(:help => true, :banner => false)
       opts.parse %w( --help )
       assert_equal "    -h, --help      Display this help message.\n", string
     end
+
+    temp_stderr do |string|
+      opts = Slop.new(:help => true)
+      opts.parse %w( --help )
+      assert_equal "Usage: rake_test_loader [options]\n    -h, --help      Display this help message.\n", string
+    end
+  end
+
+  test "fallback to substituting - for _ when using <option>?" do
+    opts = Slop.new do
+      on 'foo-bar'
+    end
+    opts.parse %w( --foo-bar )
+    assert opts.foo_bar?
   end
 
   test "option=value syntax does NOT consume following argument" do
@@ -344,4 +358,94 @@ class SlopTest < TestCase
     assert_equal %w' baz hello ', args
   end
 
+  test "context and return value of constructor block" do
+    peep = nil
+    ret = Slop.new { peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop.new { |a| peep = self }
+    assert !peep.equal?(ret)
+    assert_same peep, self
+
+    peep = nil
+    ret = Slop.new { |a, b| peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop.new { |a, *rest| peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop.parse([]) { peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop.parse([]) { |a| peep = self }
+    assert !peep.equal?(ret)
+    assert_same peep, self
+
+    peep = nil
+    ret = Slop.parse([]) { |a, b| peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop.parse([]) { |a, *rest| peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+  end
+
+  test "to_s do not break self" do
+    slop = Slop.new do
+      banner "foo"
+    end
+
+    assert_equal "foo", slop.banner
+    slop.to_s
+    assert_equal "foo", slop.banner
+  end
+
+  test "options with prefixed --no should not default to inverted behaviour unless intended" do
+    opts = Slop.new { on :bar }
+    opts.parse %w'--no-bar'
+    assert_equal false, opts[:bar]
+
+    opts = Slop.new { on 'no-bar' }
+    opts.parse %w'--no-bar'
+    assert_equal true, opts['no-bar']
+  end
+
+  test "method missing() is a private method" do
+    assert Slop.new.private_methods.map(&:to_sym).include?(:method_missing)
+  end
+
+  test "respond_to?() arity checker is similar of other objects" do
+    slop = Slop.new
+    obj = Object.new
+
+    assert_same obj.respond_to?(:__id__), slop.respond_to?(:__id__)
+    assert_same obj.respond_to?(:__id__, false), slop.respond_to?(:__id__, false)
+    assert_same obj.respond_to?(:__id__, true), slop.respond_to?(:__id__, true)
+
+    assert_raises ArgumentError do
+      slop.respond_to? :__id__, false, :INVALID_ARGUMENT
+    end
+  end
+
+  test "adding a runner" do
+    orun = proc { |r| assert_instance_of Slop, r }
+    arun = proc { |r| assert_equal ['foo', 'bar'], r }
+
+    Slop.parse(%w'foo --foo bar -v bar') do
+      on :v
+      on :foo=
+      run { |o, a| orun[o]; arun[a] }
+    end
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slop
 version: !ruby/object:Gem::Version
-  version: 3.3.3
+  version: 3.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-29 00:00:00.000000000 Z
+date: 2013-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -75,19 +75,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: 3713237527878732625
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3713237527878732625
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -99,3 +93,4 @@ test_files:
 - test/helper.rb
 - test/option_test.rb
 - test/slop_test.rb
+has_rdoc: