slop 2.4.4 → 3.0.0.rc1

data/CHANGES.md

@@ -1,18 +1,3 @@
-2.4.4 (2012-02-07)
-------------------
-
-* Ensure options taking arguments to not parsing an argument which
-  is an option (#56)
-* Ensure `:as => Range` returns a type of Range even if the value looks
-  like an Integer (#48)
-
-2.4.3 (2012-01-16)
-------------------
-
-* Allow the `:as` option to accept an object responding to :call for
-  custom type conversions (#45)
-* Ensure negative integers are not parsed as possible options (#46)
-
 2.4.2 (2011-12-18)
 ------------------
 

data/README.md

@@ -1,10 +1,7 @@
 Slop
 ====
 
-Slop is a simple, lightweight option parser with an easy to remember syntax and friendly API.
-
-Note that this is the `v2` branch. If you are looking for version 3 of Slop
-please check out the [master branch](https://github.com/injekt/slop).
+Slop is a simple option parser with an easy to remember syntax and friendly API.
 
 Installation
 ------------
@@ -25,224 +22,67 @@ Usage
 ```ruby
 # parse assumes ARGV, otherwise you can pass it your own Array
 opts = Slop.parse do
-  on :v, :verbose, 'Enable verbose mode'   # A boolean option
-  on :n, :name=, 'Your name'               # This option requires an argument
-  on :s, :sex, 'Your sex', true            # So does this one
-  on :a, :age, 'Your age', optional: true  # This one accepts an optional argument
-  on '-D', '--debug', 'Enable debug'       # The prefixed -'s are optional
-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
-```
-
-For more information about creating options, see the
-[Creating Options](https://github.com/injekt/slop/wiki/Creating-Options---v2)
-wiki page.
-
-You can also return your options as a Hash
-
-```ruby
-opts.to_hash #=> { :name => 'Lee Jarvis', :verbose => true, :age => nil, :sex => 'male' }
-```
-
-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.
-
-```ruby
-puts opts
-puts opts.help
-```
-
-Will output something like
-
-```
--v, --verbose      Enable verbose mode
--n, --name         Your name
--a, --age          Your age
-```
-
-You can also add a banner using the `banner` method
-
-```ruby
-opts = Slop.parse do
-  banner "Usage: foo.rb [options]"
+  banner "ruby foo.rb [options]\n"
+  on :name=, 'Your name'
+  on :p, :password, 'Your password', :argument => :optional
+  on :v :verbose, 'Enable verbose mode'
 end
-```
-
-Helpful Help
-------------
-
-Long form:
-
-```ruby
-Slop.parse do
-  ...
-  on :h, :help, 'Print this help message', :tail => true do
-    puts help
-    exit
-  end
-end
-```
-
-Shortcut:
 
-```ruby
-Slop.new :help => true
-# or
-Slop.new :help
+# if ARGV is `--name Lee -v`
+opts.verbose?  #=> true
+opts.password? #=> false
+opts[:name]    #=> 'lee'
 ```
 
-Parsing
--------
-
-Slop's pretty good at parsing, let's take a look at what it'll extract for you
+Slop supports several methods of writing options:
 
 ```ruby
-Slop.parse(:multiple_switches => false) do
-  on 's', 'server='
-  on 'p', 'port=', :as => :integer
-  on 'username=', :matches => /^[a-zA-Z]+$/
-  on 'password='
-end
-```
-
-Now throw some options at it:
+# 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'
 ```
--s ftp://foobar.com -p1234 --username=FooBar --password 'hello there'
-```
-
-Here's what we'll get back
-
-```
-{
-  :server => "ftp://foobar.com",
-  :port => 1234,
-  :username => "FooBar",
-  :password => "hello there"
-}
-```
-
-Events
-------
 
-If you'd like to trigger an event when an option is used, you can pass a
-block to your option. Here's how:
-
-```ruby
-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.
-
-```ruby
-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.
-
-```ruby
-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
-```
-
-Short Switches
---------------
+For more information about creating options, see the
+[Creating Options](https://github.com/injekt/slop/wiki/Creating-Options)
+wiki page.
 
-Want to enable multiple switches at once like rsync does? By default Slop will
-parse `-abc` as the options `a` `b` and `c` and set their values to true. If
-you would like to disable this, you can pass `multiple_switches => false` to
-a new Slop object. In which case Slop will then parse `-fbar` as the option
-`f` with the argument value `bar`.
+You can also return your options as a Hash:
 
 ```ruby
-Slop.parse do
-  on :a, 'First switch'
-  on :b, 'Second switch'
-  on :c, 'Third switch'
-end
-
-# Using `-ac`
-opts[:a] #=> true
-opts[:b] #=> false
-opts[:c] #=> true
-
-Slop.parse(:multiple_switches => false) do
-  on :a, 'Some switch', true
-end
-
-# Using `ahello`
-opts[:a] #=> 'hello'
+opts.to_hash #=> { :name => 'lee', :verbose => nil, :password => nil }
 ```
 
-Lists
------
+Printing Help
+-------------
 
-You can of course also parse lists into options. Here's how:
+Slop attempts to build a good looking help string to print to your users. You
+can see this by calling `opts.help` or simply `puts opts`.
 
-```ruby
-opts = Slop.parse do
-  opt :people, true, :as => Array
-end
-
-# ARGV is `--people lee,john,bill`
-opts[:people] #=> ['lee', 'john', 'bill']
-```
+Configuration Options
+---------------------
 
-Slop supports a few styles of list parsing. Check out
-[this wiki page](https://github.com/injekt/slop/wiki/Lists---v2) for more info.
+All of these options can be sent to `Slop.new` or `Slop.parse` in Hash form.
 
-Strict Mode
------------
-
-Passing `strict => true` to `Slop.parse` causes it to raise a `Slop::InvalidOptionError`
-when an invalid option is found (`false` by default):
-
-```ruby
-Slop.new(:strict => true).parse(%w/--foo/)
-# => Slop::InvalidOptionError: Unknown option -- 'foo'
-```
+* `strict` - Enable strict mode. When processing unknown options, Slop will
+  raise an `InvalidOptionError`. **default:** *false*.
+* `help` - Automatically add the `--help` option. **default:** *false*.
+* `banner` - Set this options banner text. **default:** *nil*.
+* `ignore_case` - When enabled, `-A` will look for the `-a` option if `-A`
+  does not exist. **default:** *false*.
+* `autocreate` - Autocreate options on the fly. **default:** *false*.
+* `arguments` - Force all options to expect arguments. **default:** *false*.
+* `optional_arguments` - Force all options to accept optional arguments.
+  **default:** *false*.
+* `multiple_switches` - When disabled, Slop will parse `-abc` as the option `a`
+   with the argument `bc` rather than 3 separate options. **default:** *true*.
+* `longest_flag` - The longest string flag, used to aid configuring help
+   text. **default:** *0*.
 
 Features
 --------
@@ -251,7 +91,7 @@ Check out the following wiki pages for more features:
 
 * [Ranges](https://github.com/injekt/slop/wiki/Ranges)
 * [Auto Create](https://github.com/injekt/slop/wiki/Auto-Create)
-* [Commands](https://github.com/injekt/slop/wiki/Commands---v2)
+* [Commands](https://github.com/injekt/slop/wiki/Commands)
 
 Woah woah, why you hating on OptionParser?
 ------------------------------------------
@@ -293,4 +133,4 @@ opts = Slop.parse do
 end
 
 opts.to_hash #=> { :name => 'lee', :age => 105 }
-```
+```

data/lib/slop.rb

@@ -1,710 +1,258 @@
-class Slop
-  include Enumerable
+require 'slop/option'
+require 'slop/commands'
 
-  # @return [String] The current version string
-  VERSION = '2.4.4'
+class Slop
+  VERSION = '3.0.0.rc1'
 
-  # Slops standard Error class. All exception classes should
-  # inherit from this class
+  # The main Error class, all Exception classes inherit from this class.
   class Error < StandardError; end
 
-  # Raised when an option expects an argument and none is given
+  # Raised when an option argument is expected but none are given.
   class MissingArgumentError < Error; end
 
-  # Raised when an option is required but not given
+  # Raised when an option is expected/required but not present.
   class MissingOptionError < Error; end
 
-  # Raised when an option specifies the `:match` attribute and this
-  # options argument does not match this regexp
+  # Raised when an argument does not match its intended match constraint.
   class InvalidArgumentError < Error; end
 
-  # Raised when the `:strict` option is enabled and an unknown
-  # or unspecified option is used
+  # Raised when an invalid option is found and the strict flag is enabled.
   class InvalidOptionError < Error; end
 
-  # Each option specified in `Slop#opt` creates an instance of this class
-  class Option < Struct.new(:short_flag, :long_flag, :description, :tail, :match, :help, :required, :forced, :count)
+  # Raised when an invalid command is found and the strict flag is enabled.
+  class InvalidCommandError < Error; end
+
+  # Returns a default Hash of configuration options this Slop instance uses.
+  DEFAULT_OPTIONS = {
+    :strict => false,
+    :help => false,
+    :banner => nil,
+    :ignore_case => false,
+    :autocreate => false,
+    :arguments => false,
+    :optional_arguments => false,
+    :multiple_switches => true,
+    :longest_flag => 0
+  }
 
-    # @param [Slop] slop The Slop object this Option belongs to
-    #
-    # @param [String, #to_s] short The short flag representing this Option
-    #   without prefix (ie: `a`)
-    #
-    # @param [String, #to_s] long The long flag representing this Option
-    #   without the prefix (ie: `foo`)
-    #
-    # @param [String] description This options description
-    #
-    # @param [Boolean] argument True if this option takes an argument
-    #
-    # @option options [Boolean] :optional
-    #   * When true, this option takes an optional argument, ie an argument
-    #     does not **have** to be supplied.
-    #
-    # @option options [Boolean] :argument
-    #   * True if this option takes an argument.
-    #
-    # @option options [Object] :default
-    #   * The default value for this option when no argument is given
-    #
-    # @option options [Proc, #call] :callback
-    #   * The callback object, used instead of passing a block to this option
-    #
-    # @option options [String, #to_s] :delimiter (',')
-    #   * A delimiter string when processing this option as a list
-    #
-    # @option options [Integer] :limit (0)
-    #   * A limit, used when processing this option as a list
-    #
-    # @option options [Boolean] :tail (false)
-    #   * When true, this option will be grouped at the bottom of the help
-    #     text instead of in order of processing
-    #
-    # @option options [Regexp] :match
-    #   * A regular expression this option should match
+  class << self
+
+    # items  - The Array of items to extract options from (default: ARGV).
+    # config - The Hash of configuration options to send to Slop.new().
+    # block  - An optional block used to add options.
     #
-    # @option options [String, #to_s] :unless
-    #   * Used by `omit_exec` for omitting execution of this options callback
-    #     if another option exists
+    # Examples:
     #
-    # @option options [Boolean, String] :help (true)
-    #   * If this option is a string, it'll be appended to the long flag
-    #     help text (before the description). When false, no help information
-    #     will be displayed for this option
+    #   Slop.parse(ARGV, :help => true) do
+    #     on '-n', '--name', 'Your username', :argument => true
+    #   end
     #
-    # @option options [Boolean] :required (false)
-    #   * When true, this option is considered mandatory. That is, when not
-    #     supplied, Slop will raise a `MissingOptionError`
-    def initialize(slop, short, long, description, argument, options, &blk)
-      @slop = slop
-
-      self.short_flag = short
-      self.long_flag = long
-      self.description = description
-
-      @argument = argument
-      @options = options
-
-      self.tail = @options[:tail]
-      self.match = @options[:match]
-      self.help = @options.fetch(:help, true)
-      self.required = @options[:required]
-
-      @delimiter = @options.fetch(:delimiter, ',')
-      @limit = @options.fetch(:limit, 0)
-
-      @argument_type = @options[:as]
-      @argument_value = nil
-
-      self.forced = false
-      self.count = 0
-
-      @callback = block_given? ? blk : @options[:callback]
-
-      if long_flag && long_flag.size > @slop.longest_flag
-        @slop.longest_flag = long_flag.size
-        @slop.longest_flag += help.size if help.respond_to?(:to_str)
-      end
+    # Returns a new instance of Slop.
+    def parse(items = ARGV, config = {}, &block)
+      init_and_parse(items, false, config, &block)
     end
 
-    # @return [Boolean] true if this option expects an argument
-    def expects_argument?
-      @argument || @options[:argument] || @options[:optional] == false
-    end
-
-    # @return [Boolean] true if this option accepts an optional argument
-    def accepts_optional_argument?
-      @options[:optional] || @options[:optional_argument]
-    end
-
-    # @return [String] either the long or short flag for this option
-    def key
-      long_flag || short_flag
+    # items  - The Array of items to extract options from (default: ARGV).
+    # config - The Hash of configuration options to send to Slop.new().
+    # block  - An optional block used to add options.
+    #
+    # Returns a new instance of Slop.
+    def parse!(items = ARGV, config = {}, &block)
+      init_and_parse(items, true, config, &block)
     end
 
-    # Set this options argument value.
+    # Build a Slop object from a option specification.
     #
-    # If this options argument type is expected to be an Array, this
-    # method will split the value and concat elements into the original
-    # argument value
+    # This allows you to design your options via a simple String rather
+    # than programatically. Do note though that with this method, you're
+    # unable to pass any advanced options to the on() method when creating
+    # options.
     #
-    # @param [Object] value The value to set this options argument to
-    def argument_value=(value)
-      if @argument_type.to_s.downcase == 'array'
-        @argument_value ||= []
-
-        if value.respond_to?(:to_str)
-          @argument_value.concat value.split(@delimiter, @limit)
-        end
-      else
-        @argument_value = value
-      end
-    end
-
-    # @return [Object] the argument value after it's been cast
-    #   according to the `:as` option
-    def argument_value
-      return @argument_value if forced
-      type = @argument_type.to_s.downcase
-      # Check for count first to prefer 0 over nil
-      return count if type == 'count'
-
-      value = @argument_value || @options[:default]
-      return if value.nil?
-
-      if @argument_type.respond_to?(:call)
-        @argument_type.call(value)
-      else
-        case type
-        when 'array'
-          arg_value(@argument_value)
-        when 'range'
-          arg_value(value_to_range(value))
-        when 'float'
-          arg_value(value.to_s.to_f)
-        when 'string', 'str'
-          arg_value(value.to_s)
-        when 'symbol', 'sym'
-          arg_value(value.to_s.to_sym)
-        when 'integer', 'int'
-          arg_value(value.to_s.to_i)
-        else
-          value
-        end
-      end
-    end
-
-    # Force an argument value, used when the desired argument value
-    # is negative (false or nil)
+    # string - The optspec String
+    # config - A Hash of configuration options to pass to Slop.new
     #
-    # @param [Object] value
-    def force_argument_value(value)
-      @argument_value = value
-      self.forced = true
-    end
-
-    # Execute the block or callback object associated with this Option
+    # Examples:
     #
-    # @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)
-      items.any? do |item|
-        item.to_s.sub(/\A--?/, '') == @options[:unless].to_s.sub(/\A--?/, '')
-      end
-    end
-
-    # This option in a nice pretty string, including a short flag, long
-    # flag, and description (if they exist).
+    #   opts = Slop.optspec(<<-SPEC)
+    #   ruby foo.rb [options]
+    #   ---
+    #   n,name=     Your name
+    #   a,age=      Your age
+    #   A,auth      Sign in with auth
+    #   p,passcode= Your secret pass code
+    #   SPEC
     #
-    # @see Slop#help
-    # @return [String]
-    def to_s
-      out = "    "
-      out += short_flag ? "-#{short_flag}, " : ' ' * 4
-
-      if long_flag
-        out += "--#{long_flag}"
-        if help.respond_to? :to_str
-          out += " #{help}"
-          size = long_flag.size + help.size + 1
-        else
-          size = long_flag.size
+    #   opts.fetch_option(:name).description #=> "Your name"
+    #
+    # Returns a new instance of Slop.
+    def optspec(string, config = {})
+      config[:banner], optspec = string.split(/^--+$/, 2) if string[/^--+$/]
+      lines = string.split("\n").reject(&:empty?)
+      opts  = Slop.new(config)
+
+      lines.each do |line|
+        opt, description = line.split(' ', 2)
+        short, long = opt.split(',').map { |s| s.sub(/\A--?/, '') }
+        opt = opts.on(short, long, description)
+
+        if long && long[-1] == ?$
+          long.sub!(/\=$/, '')
+          opt.config[:argument] = true
         end
-        diff = @slop.longest_flag - size
-        out += " " * (diff + 6)
-      else
-        out += " " * (@slop.longest_flag + 8)
       end
 
-      "#{out}#{description}"
-    end
-
-    # @return [String]
-    def inspect
-      "#<Slop::Option short_flag=#{short_flag.inspect} " +
-      "long_flag=#{long_flag.inspect} argument=#{@argument.inspect} " +
-      "description=#{description.inspect}>"
+      opts
     end
 
     private
 
-    def arg_value(value)
-      value if accepts_optional_argument? || expects_argument?
-    end
-
-    def value_to_range(value)
-      case value.to_s
-      when /\A(-?\d+?)(\.\.\.?|-|,)(-?\d+)\z/
-        Range.new($1.to_i, $3.to_i, $2 == '...')
-      when /\A-?\d+\z/
-        Range.new(value.to_i, value.to_i)
-      else
-        value
-      end
-    end
-
-  end
-
-  # Used to hold a list of Option objects. This class inherits from Array
-  # and overwrites `Array#[]` so we can fetch Option objects via their
-  # short or long flags
-  class Options < Array
-
-    # Fetch an Option object. This method overrides Array#[] to provide
-    # a nicer interface for fetching options via their short or long flag.
-    # The reason we don't use a Hash here is because an option cannot be
-    # identified by a single label. Instead this method tests against
-    # a short flag first, followed by a long flag. When passing this
-    # method an Integer, it will work as an Array usually would, fetching
-    # the Slop::Option at this index.
+    # Convenience method used by ::parse and ::parse!.
     #
-    # @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
-        super
-      else
-        find do |option|
-          [option.short_flag, option.long_flag].include? flag.to_s
-        end
-      end
+    # 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
 
-  # Parses the items from a CLI format into a friendly object
-  #
-  # @param [Array] items Items to parse into options.
-  # @example Specifying three options to parse:
-  #  opts = Slops.parse do
-  #    on :v, :verbose, 'Enable verbose mode'
-  #    on :n, :name,    'Your name'
-  #    on :a, :age,     'Your age'
-  #  end
-  # @return [Slop] Returns an instance of Slop
-  def self.parse(items=ARGV, options={}, &block)
-    initialize_and_parse items, false, options, &block
-  end
-
-  # Identical to {Slop.parse}, but removes parsed options from the
-  # original Array
-  #
-  # @return [Slop] Returns an instance of Slop
-  def self.parse!(items=ARGV, options={}, &block)
-    initialize_and_parse items, true, options, &block
-  end
-
-  # Build options from an optspec string
-  #
-  # @param [String] optspec The option spec string
-  # @param [Array]  options A list of options to forward to Slop.new
-  # @return [Slop]  A new instance of Slop
-  def self.optspec(optspec, *options)
-    if optspec[/^--+$/]
-      banner, optspec = optspec.split(/^--+$/, 2)
-    end
-
-    lines = optspec.split("\n").reject(&:empty?)
-    opts  = Slop.new(banner, *options)
-
-    lines.each do |line|
-      opt, description = line.split(' ', 2)
-      short, long = opt.split(',').map { |s| s.sub(/\A--?/, '') }
-      argument = long && long[-1] == ?$
-      long.sub!(/\=$/, '') if argument
-      opts.on short, long, description, argument
-    end
-
-    opts
-  end
+  # The Hash of configuration options for this Slop instance.
+  attr_reader :config
 
-  # @return [Options]
+  # The Array of Slop::Option objects tied to this Slop instance.
   attr_reader :options
 
-  # @return [Hash]
-  attr_reader :commands
-
-  # @overload banner=(string)
-  #   Set the banner
-  #   @param [String] string The text to set the banner to
-  attr_writer :banner
-
-  # @overload summary=(string)
-  #   Set the summary
-  #   @param [String] string The text to set the summary to
-  attr_writer :summary
-
-  # @overload description=(string)
-  #   Set the description
-  #   @param [String] string The text to set the description to
-  attr_writer :description
-
-  # @return [Integer] The length of the longest flag slop knows of
-  attr_accessor :longest_flag
-
-  # @return [Array] A list of aliases this command uses
-  attr_accessor :aliases
-
-  # @option opts [Boolean] :help
-  #   * Automatically add the `help` option
-  #
-  # @option opts [Boolean] :strict
-  #   * Raises when a non listed option is found, false by default
-  #
-  # @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
-  #
-  # @option opts [IO, #puts] :io ($stderr)
-  #   * An IO object for writing to when :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
+  # Create a new instance of Slop and optionally build options via a block.
   #
-  # @option opts [Boolean] :autocreate (false)
-  #   * Autocreate options depending on the Array passed to {#parse}
-  #
-  # @option opts [Boolean] :arguments (false)
-  #   * Set to true to enable all specified options to accept arguments
-  #     by default
-  #
-  # @option opts [Array] :aliases ([])
-  #   * Primary uses by commands to implement command aliases
-  #
-  # @option opts [Boolean] :completion (true)
-  #   * When true, commands will be auto completed. Ie `foobar` will be
-  #     executed simply when `foo` `fo` or `foob` are used
-  #
-  # @option options [Boolean] :all_accept_arguments (false)
-  #   * When true, every option added will take an argument, this saves
-  #     having to enable it for every option
-  def initialize(*opts, &block)
-    sloptions = opts.last.is_a?(Hash) ? opts.pop : {}
-    sloptions[:banner] = opts.shift if opts[0].respond_to?(:to_str)
-    opts.each { |o| sloptions[o] = true }
-
-    @options = Options.new
-    @commands = {}
-    @execution_block = nil
-
-    @longest_flag = 0
-    @invalid_options = []
-
-    @banner = sloptions[:banner]
-    @strict = sloptions[:strict]
-    @ignore_case = sloptions[:ignore_case]
-    @multiple_switches = sloptions.fetch(:multiple_switches, true)
-    @autocreate = sloptions[:autocreate]
-    @completion = sloptions.fetch(:completion, true)
-    @arguments = sloptions[:arguments]
-    @on_empty = sloptions[:on_empty]
-    @io = sloptions.fetch(:io, $stderr)
-    @on_noopts = sloptions[:on_noopts] || sloptions[:on_optionless]
-    @sloptions = sloptions
+  # config - A Hash of configuration options.
+  # block  - An optional block used to specify options.
+  def initialize(config = {}, &block)
+    @config = DEFAULT_OPTIONS.merge(config)
+    @options = []
+    @trash = []
+    @triggered_options = []
+    @unknown_options = []
+    @callbacks = {}
+    @separators = {}
 
     if block_given?
       block.arity == 1 ? yield(self) : instance_eval(&block)
     end
 
-    if sloptions[:help]
-      on :h, :help, 'Print this help message', :tail => true do
-        @io.puts help
-        exit unless sloptions[:exit_on_help] == false
+    if config[:help]
+      on('-h', '--help', 'Display this help message.', :tail => true) do
+        $stderr.puts help
       end
     end
   end
 
-  # Set or return banner text
+  # Set the banner.
   #
-  # @param [String] text Displayed banner text
-  # @example
-  #   opts = Slop.parse do
-  #     banner "Usage - ruby foo.rb [arguments]"
-  #   end
-  # @return [String] The current banner
-  def banner(text=nil)
-    @banner = text if text
-    @banner
-  end
-
-  # Set or return the summary
+  # banner - The String to set the banner.
   #
-  # @param [String] text Displayed summary text
-  # @example
-  #   opts = Slop.parse do
-  #     summary "do stuff with more stuff"
-  #   end
-  # @return [String] The current summary
-  def summary(text=nil)
-    @summary = text if text
-    @summary
+  # Returns nothing.
+  def banner=(banner)
+    config[:banner] = banner
   end
 
-  # Set or return the description
+  # Get or set the banner.
   #
-  # @param [String] text Displayed description text
-  # @example
-  #   opts = Slop.parse do
-  #     description "This command does a lot of stuff with other stuff."
-  #   end
-  # @return [String] The current description
-  def description(text=nil)
-    @description = text if text
-    @description
-  end
-
-  # Parse a list of options, leaving the original Array unchanged
+  # banner - The String to set the banner.
   #
-  # @param [Array] items A list of items to parse
-  def parse(items=ARGV, &block)
-    parse_items items, &block
+  # Returns the banner String.
+  def banner(banner = nil)
+    config[:banner] = banner if banner
+    config[:banner]
   end
 
-  # Parse a list of options, removing parsed options from the original Array
+  # Parse a list of items, executing and gathering options along the way.
   #
-  # @param [Array] items A list of items to parse
-  def parse!(items=ARGV, &block)
-    parse_items items, true, &block
-  end
-
-  # Enumerable interface
-  def each(&block)
-    @options.each(&block)
-  end
-
-  # @param [Symbol] key Option symbol
-  # @example
-  #   opts[:name] #=> "Emily"
-  #   opts.get(:name) #=> "Emily"
-  # @return [Object] Returns the value associated with that option. If an
-  #   option doesn't exist, a command will instead be searched for
-  def [](key)
-    option = @options[key]
-    option ? option.argument_value : @commands[key]
-  end
-  alias get []
-
-  # Specify an option with a short or long version, description and type
+  # items - The Array of items to extract options from (default: ARGV).
+  # block - An optional block which when used will yield non options.
   #
-  # @param [*] args Option configuration.
-  # @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 this option requires
-  #   an argument
-  # @option args [Hash] :options Optional option configurations.
-  # @example
-  #   opts = Slop.parse do
-  #     on :n, :name, 'Your username', true # Required argument
-  #     on :a, :age,  'Your age (optional)', :optional => true
-  #     on :g, :gender, 'Your gender', :optional => false
-  #     on :V, :verbose, 'Run in verbose mode', :default => true
-  #     on :P, :people, 'Your friends', true, :as => Array
-  #     on :h, :help, 'Print this help screen' do
-  #       puts help
-  #     end
-  #   end
-  # @return [Slop::Option]
-  def option(*args, &block)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    short, long, desc, arg, extras = clean_options(args)
-
-    options.merge!(extras)
-    options[:argument] = true if @sloptions[:all_accept_arguments]
-
-    option = Option.new(self, short, long, desc, arg, options, &block)
-    @options << option
-
-    option
+  # Returns an Array of original items.
+  def parse(items = ARGV, &block)
+    parse_items(items, false, &block)
   end
-  alias opt option
-  alias on option
 
-  # Namespace options depending on what command is executed
+  # Parse a list of items, executing and gathering options along the way.
+  # unlike parse() this method will remove any options and option arguments
+  # from the original Array.
   #
-  # @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
-  # @since 1.5.0
-  # @raise [ArgumentError] When this command already exists
-  # @return [Slop] a new instance of Slop namespaced to +label+
-  def command(label, options={}, &block)
-    if @commands.key?(label)
-      raise ArgumentError, "command `#{label}` already exists"
-    end
-
-    slop = Slop.new @sloptions.merge(options)
-    slop.aliases = Array(options.delete(:aliases) || options.delete(:alias))
-    @commands[label] = slop
-
-    slop.aliases.each { |a| @commands[a] = @commands[label] }
-
-    if block_given?
-      block.arity == 1 ? yield(slop) : slop.instance_eval(&block)
-    end
-
-    slop
-  end
-
-  # Trigger an event when Slop has no values to parse
+  # items - The Array of items to extract options from (default: ARGV).
+  # block - An optional block which when used will yield non options.
   #
-  # @param [Object, #call] obj The object (which can be anything
-  #   responding to `call`)
-  # @example
-  #   Slop.parse do
-  #     on_empty { puts 'No argument given!' }
-  #   end
-  # @since 1.5.0
-  def on_empty(obj=nil, &block)
-    @on_empty ||= (obj || block)
+  # Returns an Array of original items with options removed.
+  def parse!(items = ARGV, &block)
+    parse_items(items, true, &block)
   end
-  alias on_empty= on_empty
 
-  # Trigger an event when the arguments contain no options
+  # Add an Option.
   #
-  # @param [Object, #call] 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
-
-  # Add an execution block (for commands)
+  # objects - An Array with an optional Hash as the last element.
   #
-  # @example
-  #   opts = Slop.new do
-  #     command :foo do
-  #       on :v, :verbose
+  # Examples:
   #
-  #       execute { |o| p o.verbose? }
-  #     end
-  #   end
-  #   opts.parse %w[foo --verbose] #=> true
+  #   on '-u', '--username=', 'Your username'
+  #   on :v, :verbose, 'Enable verbose mode'
   #
-  # @param [Array] args The list of arguments to send to this command
-  #   is invoked
-  # @since 1.8.0
-  # @yield [Slop] an instance of Slop for this command
-  def execute(args=[], &block)
-    if block_given?
-      @execution_block = block
-    elsif @execution_block.respond_to?(:call)
-      @execution_block.call(self, args)
-    end
+  # Returns the created instance of Slop::Option.
+  def on(*objects, &block)
+    option = build_option(objects, &block)
+    options << option
+    option
   end
+  alias option on
+  alias opt on
 
-  # Returns the parsed list into a option/value hash
+  # Fetch an options argument value.
   #
-  # @example
-  #   opts.to_hash #=> { :name => 'Emily' }
+  # key - The Symbol or String option short or long flag.
   #
-  #   # strings!
-  #   opts.to_hash(false) #=> { 'name' => 'Emily' }
-  # @return [Hash]
-  def to_hash(symbols=true)
-    @options.reduce({}) do |hsh, option|
-      key = option.key
-      key = key.to_sym if symbols
-      hsh[key] = option.argument_value
-      hsh
-    end
+  # Returns the Object value for this option, or nil.
+  def [](key)
+    option = fetch_option(key)
+    option.value if option
   end
-  alias to_h to_hash
+  alias get []
 
-  # Return parsed items as a new Class
-  #
-  # @example
-  #   opts = Slop.new do
-  #     on :n, :name, 'Persons name', true
-  #     on :a, :age, 'Persons age', true, :as => :int
-  #     on :s, :sex, 'Persons sex m/f', true, :match => /^[mf]$/
-  #     on :A, :admin, 'Enable admin mode'
-  #   end
-  #
-  #   opts.parse %w[ --name Lee --age 22 -s m --admin ]
-  #
-  #   person = opts.to_struct("Person")
-  #   person.class  #=> Struct::Person
-  #   person.name   #=> 'Lee'
-  #   person.age    #=> 22
-  #   person.sex    #=> m
-  #   person.admin  #=> true
-  #
-  # @param [String] name The name of this class
-  # @return [Class] The new class, or nil if there are no options
-  # @since 2.0.0
-  def to_struct(name=nil)
-    hash = to_hash
-    Struct.new(name, *hash.keys).new(*hash.values) unless hash.empty?
+  # 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] }]
   end
+  alias to_h to_hash
 
-  # Fetch a list of options which were missing from the parsed list
+  # Check for an options presence.
   #
-  # @example
-  #   opts = Slop.new do
-  #     on :n, :name, 'Your name', true
-  #     on :p, :password, 'Your password', true
-  #     on :A, 'Use auth?'
-  #   end
+  # Examples:
   #
-  #   opts.parse %w[ --name Lee ]
-  #   opts.missing #=> ['password', 'a']
+  #   opts.parse %w( --foo )
+  #   opts.present?(:foo) #=> true
+  #   opts.present?(:bar) #=> false
   #
-  # @return [Array] A list of options missing from the parsed string
-  # @since 2.1.0
-  def missing
-    @options.select { |opt| not present?(opt.key) }.map(&:key)
+  # Returns true if all of the keys are present in the parsed arguments.
+  def present?(*keys)
+    keys.all? { |key| (opt = fetch_option(key)) && opt.count > 0 }
   end
 
-  # Allows you to check whether an option was specified in the parsed list
+  # Convenience method for present?(:option).
   #
-  # Merely sugar for `present?`
+  # Examples:
   #
-  # @example
-  #   #== ruby foo.rb -v
+  #   opts.parse %( --verbose )
   #   opts.verbose? #=> true
-  #   opts.name?    #=> false
-  # @see Slop#present?
-  # @return [Boolean] true if this option is present, false otherwise
-  def method_missing(meth, *args, &block)
-    meth = meth.to_s
+  #   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[-1] == ??
       present?(meth.chop)
     else
@@ -712,342 +260,305 @@ class Slop
     end
   end
 
-  # Override this method so we can check if an option? method exists
+  # 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[-1] == ?? and @options.any? { |o| o.key == method.chop }
+    if method[-1] == ?? && options.any? { |o| o.key == method.chop }
       true
     else
       super
     end
   end
 
-  # Check if an option is specified in the parsed list
+  # Fetch a list of options which were missing from the parsed list.
+  #
+  # Examples:
   #
-  # Does the same as Slop#option? but a convenience method for unacceptable
-  # method names
+  #   opts = Slop.new do
+  #     on :n, :name=
+  #     on :p, :password=
+  #   end
   #
-  # @param [Object] The object name(s) to check
-  # @since 1.5.0
-  # @return [Boolean] true if these options are present, false otherwise
-  def present?(*option_names)
-    option_names.all? { |opt| @options[opt] && @options[opt].count > 0 }
+  #   opts.parse %w[ --name Lee ]
+  #   opts.missing #=> ['password']
+  #
+  # Returns an Array of Strings representing missing options.
+  def missing
+    (options - @triggered_options).map(&:key)
   end
 
-  # Returns the banner followed by available options listed on the next line
+  # Fetch a Slop::Option object.
   #
-  # @example
-  #  opts = Slop.parse do
-  #    banner "Usage - ruby foo.rb [arguments]"
-  #    on :v, :verbose, "Enable verbose mode"
-  #  end
-  #  puts opts
-  # @return [String] Help text.
-  def to_s
-    parts = []
-
-    parts << banner if banner
-    parts << summary if summary
-    parts << wrap_and_indent(description, 80, 4) if description
-
-    if options.size > 0
-      parts << "options:"
+  # key - The Symbol or String option key.
+  #
+  # Examples:
+  #
+  #   opts.on(:foo, 'Something fooey', :argument => :optional)
+  #   opt = opts.fetch_option(:foo)
+  #   opt.class #=> Slop::Option
+  #   opt.accepts_optional_argument? #=> true
+  #
+  # Returns an Option or nil if none were found.
+  def fetch_option(key)
+    options.find { |option| [option.long, option.short].include?(clean(key)) }
+  end
 
-      heads = @options.reject(&:tail)
-      tails = @options.select(&:tail)
-      all = (heads + tails).select(&:help)
+  # Add a callback.
+  #
+  # label - The Symbol identifier to attach this callback.
+  #
+  # Returns nothing.
+  def add_callback(label, &block)
+    (@callbacks[label] ||= []) << block
+  end
 
-      parts << all.map(&:to_s).join("\n")
-    end
+  # Add string separators between options.
+  #
+  # text - The String text to print.
+  def separator(text)
+    @separators[options.size] = text
+  end
 
-    parts.join("\n\n")
+  # Print a handy Slop help string.
+  #
+  # Returns the banner followed by available option help strings.
+  def to_s
+    heads  = options.reject(&:tail?)
+    tails  = (options - heads)
+    opts = (heads + tails).select(&:help).map(&:to_s)
+    optstr = opts.map.with_index { |o, i|
+      (str = @separators[i + 1]) ? [o, str].join("\n") : o
+    }.join("\n")
+    config[:banner] ? config[:banner] + "\n" + optstr : optstr
   end
   alias help to_s
 
-  # @return [String] This Slop object will options and configuration
-  #   settings revealed
+  # Returns the String inspection text.
   def inspect
-    "#<Slop config_options=#{@sloptions.inspect}\n  " +
-    options.map(&:inspect).join("\n  ") + "\n>"
+    "#<Slop #{config.inspect} #{options.map(&:inspect)}>"
   end
 
   private
 
-  class << self
-    private
-
-    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
-
-  # traverse through the list of items sent to parse() or parse!() and
-  # attempt to do the following:
+  # Parse a list of items and process their values.
   #
-  # * Find an option object
-  # * Assign an argument to this option
-  # * Validate an option and/or argument depending on configuration options
-  # * Remove non-parsed items if `delete` is true
-  # * Yield any non-options to the block (if one is given)
-  def parse_items(items, delete=false, &block)
-    if items.empty? and @on_empty.respond_to?(:call)
-      @on_empty.call self
-      return items
-    elsif not items.any? {|i| i.to_s[/\A--?/] } and @on_noopts.respond_to?(:call)
-      @on_noopts.call self
-      return items
-    elsif execute_command(items, delete)
+  # 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.
+  #
+  # 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
 
-    trash = []
-
-    items.each_with_index do |item, index|
-      item = item.to_s
-      flag = item.sub(/\A--?/, '')
+    items.each_with_index { |item, index|
+      @trash << index && break if item == '--'
+      autocreate(items, index) if config[:autocreate]
+      process_item(items, index, &block) unless @trash.include?(index)
+    }.reject!.with_index { |item, index| delete && @trash.include?(index) }
 
-      if item == '--'
-        trash << index
-        break
-      end
-
-      autocreate(flag, index, items) if @autocreate
-      option, argument = extract_option(item, flag)
+    required_options = options.select { |opt| opt.required? && opt.count < 1 }
+    if required_options.any?
+      raise MissingOptionError,
+        "Missing required option(s): #{required_options.map(&:key).join(', ')}"
+    end
 
-      if @multiple_switches and item[/\A-[^-][A-Za-z]/] and not option
-        trash << index
-        next
-      end
+    if @unknown_options.any?
+      raise InvalidOptionError, "Unknown options #{@unknown_options.join(', ')}"
+    end
 
-      if option
-        option.count += 1 unless item[/\A--no-/]
-        trash << index
-        next if option.forced
-        option.argument_value = true
-
-        if option.expects_argument? or option.accepts_optional_argument?
-          argument ||= items.at(index + 1)
-          trash << index + 1
-
-          if not option.accepts_optional_argument? and argument =~ /\A--?[a-zA-Z][a-zA-Z0-9_-]*\z/
-            raise MissingArgumentError, "'#{option.key}' expects an argument, none given"
-          end
-
-          if argument && argument !~ /^--?[a-zA-Z_-]+/
-            if option.match and not argument.match(option.match)
-              raise InvalidArgumentError, "'#{argument}' does not match #{option.match.inspect}"
-            end
-
-            option.argument_value = argument
-            option.call option.argument_value unless option.omit_exec?(items)
-          else
-            option.argument_value = nil
-            check_optional_argument!(option, flag)
-          end
-        else
-          option.call unless option.omit_exec?(items)
-        end
-      else
-        @invalid_options << flag if item[/\A--?/] and @strict
-        block.call(item) if block_given? and not trash.include?(index)
-      end
+    if @triggered_options.empty? && @callbacks[:no_options]
+      @callbacks[:no_options].each { |cb| cb.call(self) }
     end
 
-    items.reject!.with_index { |o, i| trash.include?(i) } if delete
-    raise_if_invalid_options!
-    raise_if_missing_required_options!(items)
     items
   end
 
-  def check_optional_argument!(option, flag)
-    if option.accepts_optional_argument?
-      option.call
-    else
-      raise MissingArgumentError, "'#{flag}' expects an argument, none given"
-    end
-  end
+  # Process a list item, figure out if it's an option, execute any
+  # callbacks, assign any option arguments, and do some sanity checks.
+  #
+  # items - The Array of items to process.
+  # index - The current Integer index of the item we want to process.
+  # block - An optional block which when passed will yield non options.
+  #
+  # Returns nothing.
+  def process_item(items, index, &block)
+    item = items[index]
+    option, argument = extract_option(item) if item[0, 1] == '-'
 
-  def raise_if_invalid_options!
-    return if not @strict or @invalid_options.empty?
-    message = "Unknown option#{'s' if @invalid_options.size > 1}"
-    message << ' -- ' << @invalid_options.map { |o| "'#{o}'" }.join(', ')
-    raise InvalidOptionError, message
-  end
+    if option
+      option.count += 1 unless item[0, 5] == '--no-'
+      @trash << index
+      @triggered_options << option
 
-  def raise_if_missing_required_options!(items)
-    @options.select(&:required).each do |o|
-      if o.argument_value.nil?
-        raise MissingOptionError, "Expected option `#{o.key}` is required"
-      end
-    end
-  end
+      if config[:multiple_switches] && argument
+        execute_multiple_switches(option, argument, index)
+      elsif option.expects_argument?
+        argument ||= items.at(index + 1)
 
-  # if multiple_switches is enabled, this method filters through an items
-  # characters and attempts to find an Option object for each flag.
-  #
-  # Raises if a flag expects an argument or strict mode is enabled and a
-  # flag was not found
-  def enable_multiple_switches(item)
-    item[1..-1].each_char do |switch|
-      option = @options[switch]
-
-      if option
-        if option.expects_argument?
-          raise MissingArgumentError, "'-#{switch}' expects an argument, used in multiple_switch context"
+        if !argument || argument =~ /\A--?[a-zA-Z][a-zA-Z0-9_-]*\z/
+          raise MissingArgumentError, "#{option.key} expects an argument"
         end
 
-        option.argument_value = true
-        option.count += 1
+        execute_option(option, argument, index)
+      elsif option.accepts_optional_argument?
+        argument ||= items.at(index + 1)
+
+        if argument && argument !~ /\A--?/
+          execute_option(option, argument, index)
+        else
+          option.call(nil)
+        end
       else
-        raise InvalidOptionError, "Unknown option '-#{switch}'" if @strict
+        option.call(nil)
       end
+    else
+      @unknown_options << item if config[:strict] && item =~ /\A--?/
+      block.call(item) if block && !@trash.include?(index)
     end
   end
 
-  def wrap_and_indent(string, width, indentation)
-    string.lines.map do |paragraph|
-      lines = []
-      line = ''
+  # Execute an option, firing off callbacks and assigning arguments.
+  #
+  # option   - The Slop::Option object found by #process_item.
+  # argument - The argument Object to assign to this option.
+  # index    - The current Integer index of the object we're processing.
+  # item     - The optional String item we're processing.
+  #
+  # Returns nothing.
+  def execute_option(option, argument, index, item = nil)
+    if !option
+      if config[:multiple_switches] && config[:strict]
+        raise InvalidOptionError, "Unknown option -#{item}"
+      end
+      return
+    end
 
-      paragraph.split(/\s/).each do |word|
-        if (line + ' ' + word).length >= width
-          lines << line
-          line = ''
-        end
+    @trash << index + 1
+    option.value = argument
 
-        line << (line == '' ? '' : ' ' ) + word
-      end
-      lines << line
+    if option.match? && !argument.match(option.config[:match])
+      raise InvalidArgumentError, "#{argument} is an invalid argument"
+    end
 
-      lines.map { |l| ' ' * indentation + l }.join("\n")
-    end.join("\n")
+    option.call(option.value)
   end
 
-  # attempt to extract an option from an argument, this method allows us
-  # to parse things like 'foo=bar' and '--no-value' for negative values
-  # returns an array of the Option object and an argument if one was found
-  def extract_option(item, flag)
-    if item[0, 1] == '-'
-      option = @options[flag]
-      option ||= @options[flag.downcase] if @ignore_case
+  # Execute a `-abc` type option where a, b and c are all options. This
+  # method is only executed if the multiple_switches argument is true.
+  #
+  # option   - The first Option object.
+  # argument - The argument to this option. (Split into multiple Options).
+  # index    - The index of the current item being processed.
+  #
+  # Returns nothing.
+  def execute_multiple_switches(option, argument, index)
+    execute_option(option, argument, index)
+    argument.split('').each do |key|
+      opt = fetch_option(key)
+      opt.count = 1
+      execute_option(opt, argument, index, key)
     end
+  end
+
+  # Extract an option from a flag.
+  #
+  # flag - The flag key used to extract an option.
+  #
+  # Returns an Array of [option, argument].
+  def extract_option(flag)
+    option = fetch_option(flag)
+    option ||= fetch_option(flag.downcase) if config[:ignore_case]
 
     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, argument = @options[$1], $2
-      when /\A--no-(.+)\z/
-        option = @options[$1]
-        option.force_argument_value(false) if option
+      case flag
+      when /\A--?([^=]+)=(.+)\z/, /\A-([a-zA-Z])(.+)\z/, /\A--no-(.+)\z/
+        option, argument = fetch_option($1), ($2 || false)
       end
     end
 
     [option, argument]
   end
 
-  # attempt to execute a command if one exists, returns a positive (tru-ish)
-  # result if the command was found and executed. If completion is enabled
-  # and a flag is found to be ambiguous, this method prints an error message
-  # to the @io object informing the user
-  def execute_command(items, delete)
-    str = items[0]
-
-    if str
-      command = @commands.keys.find { |c| c.to_s == str.to_s }
-
-      if @completion and not command
-        cmds = @commands.keys.select { |c| c.to_s[0, str.length] == str }
-
-        if cmds.size > 1
-          @io.puts "Command '#{str}' is ambiguous:"
-          @io.puts "  " + cmds.map(&:to_s).sort.join(', ')
-        else
-          command = cmds.shift
-        end
-      end
-    end
-
-    if command
-      items.shift
-      opts = @commands[command]
-      delete ? opts.parse!(items) : opts.parse(items)
-      opts.execute(items.reject { |i| i == '--' })
+  # Autocreate an option on the fly. See the :autocreate Slop config option.
+  #
+  # items - The Array of items we're parsing.
+  # index - The current Integer index for the item we're processing.
+  #
+  # Returns nothing.
+  def autocreate(items, index)
+    flag = items[index]
+    unless present?(flag)
+      option = build_option(Array(flag))
+      argument = items[index + 1]
+      option.config[:argument] = (argument && argument !~ /\A--?/)
+      option.config[:autocreated] = true
+      @options << option
     end
   end
 
-  # If autocreation is enabled this method simply generates an option
-  # and add's it to the existing list of options
-  def autocreate(flag, index, items)
-    return if present? flag
-    short, long = clean_options Array(flag)
-    arg = (items[index + 1] && items[index + 1] !~ /\A--?/)
-    option = Option.new(self, short, long, nil, arg, {})
-    option.count = 1
-    @options << option
+  # Build an option from a list of objects.
+  #
+  # objects - An Array of objects used to build this option.
+  #
+  # Returns a new instance of Slop::Option.
+  def build_option(objects, &block)
+    config = {}
+    config[:argument] = true if @config[:arguments]
+    config[:optional_argument] = true if @config[:optional_arguments]
+
+    short  = extract_short_flag(objects, config)
+    long   = extract_long_flag(objects, config)
+    desc   = objects[0].respond_to?(:to_str) ? objects.shift : nil
+    config = config.merge!(objects.last) if objects.last.is_a?(Hash)
+
+    Option.new(self, short, long, desc, config, &block)
   end
 
-  # Clean up arguments sent to `on` and return a list of 5 elements:
-  # * short flag (or nil)
-  # * long flag (or nil)
-  # * description (or nil)
-  # * true/false if this option takes an argument or not
-  # * extra options (ie: :as, :optional, and :help)
-  def clean_options(args)
-    options = []
-    extras = {}
-
-    if klass = args.find { |a| a.is_a?(Class) }
-      extras[:as] = klass
-      args.delete klass
-    end
+  # Extract the short flag from an item.
+  #
+  # objects - The Array of objects passed from #build_option.
+  # config  - The Hash of configuration options built in #build_option.
+  def extract_short_flag(objects, config)
+    flag = clean(objects.first)
 
-    short = args.first.to_s.sub(/\A--?/, '')
-    if short.size == 2 && short[-1, 1] == '='
-      extras[:argument] = true
-      short.chop!
+    if flag.size == 2 && flag[-1, 1] == '='
+      config[:argument] = true
+      flag.chop!
     end
 
-    if short.size == 1
-      options.push short
-      args.shift
-    else
-      options.push nil
+    if flag.size == 1
+      objects.shift
+      flag
     end
+  end
 
-    long = args.first
-    if long.is_a?(TrueClass) || long.is_a?(FalseClass)
-      options.push nil
-    else
-      case long.to_s
-      when /\A(?:--?)?[a-z_-]+\s[A-Z\s\[\]]+\z/
-        arg, help = args.shift.split(/ /, 2)
-        extras[:optional] = help[0, 1] == '[' && help[-1, 1] == ']'
-        extras[:help] = help
-        options.push arg.sub(/\A--?/, '')
-      when /\A(?:--?)?[a-zA-Z][a-zA-Z0-9_-]+\=?\z/
-        extras[:argument] = true if long.to_s[-1, 1] == '='
-        options.push args.shift.to_s.sub(/\A--?/, '').sub(/\=\z/, '')
-      else
-        options.push nil
-      end
+  # Extract the long flag from an item.
+  #
+  # objects - The Array of objects passed from #build_option.
+  # config  - The Hash of configuration options built in #build_option.
+  def extract_long_flag(objects, config)
+    flag = objects.first.to_s
+    if flag =~ /\A(?:--?)?[a-zA-Z][a-zA-Z0-9_-]+\=?\??\z/
+      config[:argument] = true if flag[-1, 1] == '='
+      config[:optional_argument] = true if flag[-2, 2] == '=?'
+      objects.shift
+      clean(flag).sub(/\=\??\z/, '')
     end
+  end
 
-    options.push args.first.respond_to?(:to_sym) ? args.shift : nil
-    options.push((@arguments || extras[:argument]) ? true : (args.shift ? true : false))
-    options.push extras
+  # Remove any leading -- characters from a string.
+  #
+  # object - The Object we want to cast to a String and clean.
+  #
+  # Returns the newly cleaned String with leading -- characters removed.
+  def clean(object)
+    object.to_s.sub(/\A--?/, '')
   end
-end
+
+end