slop 3.6.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95327fe15a3e8091259a7a045f9ede744256ae52
-  data.tar.gz: 6804548aa33795082ef1068a7c3021e3305258c5
+  metadata.gz: 52a2290f6608ad9ab25b6b4b07dd6ec213421edf
+  data.tar.gz: f752d959151a6f15f978922b389c2952553dfbc9
 SHA512:
-  metadata.gz: c625631bde9b8289e1f50337de14139a762f12b873b2f94b7a1d406a3605202269dbef1ee19c8a3978379415afb902528ccc438f76fe3d563deb0a0f180f3413
-  data.tar.gz: b8de8a12ee0aca903b74950009d10c4f66b437430c9983eb2ba61ef2ac988ce686cff56428f1caf0f3c2098d076ad9a3d4da5d901ce9768a2df5aae7b8870af7
+  metadata.gz: c6d233481d6ce8340a7ee563fb615187f3152f27211bf00f07ab006ec140d7f61ab427c92c3cb6a228351494ad5a7a5c8ee65d297af9f42c888d61bf240c4b6c
+  data.tar.gz: 97fcb2ff7f34071efa6b0b5091c6cc6058cc0c1d06e7f9669a27df4afb924fe083b3b1813cebfc3b761911c1d7230a95720ef8a298dfd645dfd1f99d9403a5c4

data/.travis.yml

@@ -1,8 +1,5 @@
 rvm:
-  - 1.9.3
-  - 2.1
-  - ruby-head
-  - jruby-19mode
+  - 2.0.0
 notifications:
   email:
     on_success: change

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Lee Jarvis
+Copyright (c) Lee Jarvis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -2,201 +2,249 @@ Slop
 ====
 
 Slop is a simple option parser with an easy to remember syntax and friendly API.
-API Documentation is available [here](http://leejarvis.github.com/rdoc/slop/).
+
+Version 4 of Slop is aimed at Ruby 2.0 or later. Please use
+[Version 3](https://github.com/leejarvis/slop/tree/v3) for Ruby 1.9 support.
 
 [![Build Status](https://travis-ci.org/leejarvis/slop.png?branch=master)](http://travis-ci.org/leejarvis/slop)
 
+Installation
+------------
+
+    gem install slop
+
 Usage
 -----
 
 ```ruby
-opts = Slop.parse do
-  banner 'Usage: foo.rb [options]'
-
-  on 'name=', 'Your name'
-  on 'p', 'password', 'An optional password', argument: :optional
-  on 'v', 'verbose', 'Enable verbose mode'
+opts = Slop.parse do |o|
+  o.string '-h', '--host', 'a hostname'
+  o.integer '--port', 'custom port', default: 80
+  o.bool '-v', '--verbose', 'enable verbose mode'
+  o.bool '-q', '--quiet', 'suppress output (quiet mode)'
+  o.on '--version', 'print the version' do
+    puts Slop::VERSION
+    exit
+  end
 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}
-```
+ARGV #=> -v --host 192.168.0.1
 
-Installation
-------------
+opts[:host]   #=> 192.168.0.1
+opts.verbose? #=> true
+opts.quiet?   #=> false
 
-    gem install slop
+opts.to_hash  #=> { host: "192.168.0.1", port: 80, verbose: true, quiet: false }
+```
 
-Printing Help
--------------
+Option types
+------------
 
-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`.
+Built in Option types are as follows:
 
-Configuration Options
----------------------
+```ruby
+o.string  #=> Slop::StringOption, expects an argument
+o.bool    #=> Slop::BoolOption, no argument, aliased to BooleanOption
+o.integer #=> Slop::IntegerOption, expects an argument, aliased to IntOption
+o.array   #=> Slop::ArrayOption, expects an argument
+o.null    #=> Slop::NullOption, no argument and ignored from `to_hash`
+o.on      #=> alias for o.null
+```
 
-All of these options can be sent to `Slop.new` or `Slop.parse` in Hash form.
+You can see all built in types in `slop/types.rb`. Suggestions or pull requests
+for more types are welcome.
 
-| Option | Description | Default/Example |
-| ------ | ----------- | --------------- |
-| strict | Enable strict mode. Slop will raise an `InvalidOptionError` for unkown options. | `false` |
-| help   | Automatically add the `--help` option. | `false` |
-| banner | Set the help banner text. | `nil` |
-| ignore_case | When enabled, `-A` will look for the `-a` option if `-A` does not exist. | `false` |
-| autocreate | Autocreate options on the fly. | `false` |
-| arguments | Force all options to expect arguments. | `false` |
-| optional_arguments | Force all options to accept optional arguments. | `false` |
-| multiple_switches | When disabled, Slop will parse `-abc` as the option `a` with the argument `bc` rather than 3 separate options. | `true` |
+Advanced Usage
+--------------
 
-Lists
------
+This example is really just to describe how the underlying API works.
+It's not necessarily the best way to do it.
 
 ```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"]
+opts = Slop::Options.new
+opts.banner = "usage: connect [options] ..."
+opts.separator ""
+opts.separator "Connection options:"
+opts.string "-H", "--hostname", "a hostname"
+opts.int "-p", "--port", "a port", default: 80
+opts.separator ""
+opts.separator "Extra options:"
+opts.array "--files", "a list of files to import"
+opts.bool "-v", "--verbose", "enable verbose mode"
+
+parser = Slop::Parser.new(opts)
+result = parser.parse(["--hostname", "192.168.0.1"])
+
+result.to_hash #=> { hostname: "192.168.0.1", port: 80,
+                 #     files: [], verbose: false }
+
+puts opts # prints out help
 ```
 
-You can also specify a delimiter and limit.
+Arguments
+---------
+
+It's common to want to retrieve an array of arguments that were not processed
+by the parser (i.e options or consumed arguments). You can do that with the
+`Result#arguments` method:
 
 ```ruby
-opts = Slop.parse do
-  on :list=, as: Array, delimiter: ':', limit: 2
+args = %w(connect --host google.com GET)
+opts = Slop.parse args do |o|
+  o.string '--host'
 end
-# ruby run.rb --list one:two:three
-opts[:list] #=> ["one", "two:three"]
+
+p opts.arguments #=> ["connect", "GET"] # also aliased to `args`
 ```
 
-Ranges
+Arrays
 ------
 
+Slop has a built in `ArrayOption` for handling array values:
+
 ```ruby
-opts = Slop.parse do
-  on :range=, as: Range
+opts = Slop.parse do |o|
+  # the delimiter defaults to ','
+  o.array '--files', 'a list of files', delimiter: ','
 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,
-using 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
+# both of these will return o[:files] as ["foo.txt", "bar.rb"]:
+# --files foo.txt,bar.rb
+# --files foo.txt --files bar.rb
 ```
 
-Commands
---------
+Custom option types
+-------------------
 
-Slop supports git style sub-commands, like so:
+Slop uses option type classes for every new option added. They default to the
+`NullOption`. When you type `o.array` Slop looks for an option called
+`Slop::ArrayOption`. This class must contain at least 1 method, `call`. This
+method is executed at parse time, and the return value of this method is
+used for the option value. We can use this to build custom option types:
 
 ```ruby
-opts = Slop.parse do
-  on '-v', 'Print the version' do
-    puts "Version 1.0"
+module Slop
+  class PathOption < Option
+    def call(value)
+      Pathname.new(value)
+    end
   end
+end
 
-  command 'add' do
-    on :v, :verbose, 'Enable verbose mode'
-    on :name=, 'Your name'
+opts = Slop.parse %w(--path ~/) do |o|
+  o.path '--path', 'a custom path name'
+end
 
-    run do |opts, args|
-      puts "You ran 'add' with options #{opts.to_hash} and args: #{args.inspect}"
+p opts[:path] #=> #<Pathname:~/>
+```
+
+Custom options can also implement a `finish` method. This method by default
+does nothing, but it's executed once *all* options have been parsed. This
+allows us to go back and mutate state without having to rely on options
+being parsed in a particular order. Here's an example:
+
+```ruby
+module Slop
+  class FilesOption < ArrayOption
+    def finish(opts)
+      if opts.expand?
+        self.value = value.map { |f| File.expand_path(f) }
+      end
     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" } }
+opts = Slop.parse %w(--files foo.txt,bar.rb -e) do |o|
+  o.files '--files', 'an array of files'
+  o.bool '-e', '--expand', 'if used, list of files will be expanded'
+end
+
+p opts[:files] #=> ["/full/path/foo.txt", "/full/path/bar.rb"]
 ```
 
-Remaining arguments
--------------------
+Errors
+------
 
-The *parse!*  method will remove any options and option arguments from the original Array:
+Slop will raise errors for the following:
 
-```ruby
-# restarguments.rb
-opts = Slop.parse! do
-  on :foo
-end
-```
+* An option used without an argument when it expects one: `Slop::MissingArgument`
+* An option used that Slop doesn't know about: `Slop::UnknownOption`
 
-Example:
+These errors inherit from `Slop::Error`, so you can rescue them all.
+Alternatively you can suppress these errors with the `suppress_errors` config
+option:
 
-```
-ruby restarguments.rb --foo bar
-```
+```ruby
+opts = Slop.parse suppress_errors: true do
+  o.string '-name'
+end
 
-```
-opts.to_hash = { :foo => true }
+# or per option:
 
-ARGV #=> ["bar"]
+opts = Slop.parse do
+  o.string '-host', suppress_errors: true
+  o.int '-port'
+end
 ```
 
-Woah woah, why you hating on OptionParser?
-------------------------------------------
+Printing help
+-------------
 
-I'm not, honestly! I love OptionParser. I really do, it's a fantastic library.
-So why did I build Slop? Well, I find myself using OptionParser to simply
-gather a bunch of key/value options, usually you would do something like this:
+The return value of `Slop.parse` is a `Slop::Result` which provides a nice
+help string to display your options. Just `puts opts` or call `opts.to_s`:
 
 ```ruby
-require 'optparse'
+opts = Slop.parse do |o|
+  o.string '-h', '--host', 'hostname'
+  o.int '-p', '--port', 'port (default: 80)', default: 80
+  o.string '--username'
+  o.separator ''
+  o.separator 'other options:'
+  o.bool '--quiet', 'suppress output'
+  o.on '-v', '--version' do
+    puts "1.1.1"
+  end
+end
 
-things = {}
+puts opts
+```
 
-opt = OptionParser.new do |opt|
-  opt.on('-n', '--name NAME', 'Your name') do |name|
-    things[:name] = name
-  end
+Output:
 
-  opt.on('-a', '--age AGE', 'Your age') do |age|
-    things[:age] = age.to_i
-  end
+```
+% ruby run.rb
+usage: run.rb [options]
+    -h, --host     hostname
+    -p, --port     port (default: 80)
+    --username
+
+other options:
+    --quiet        suppress output
+    -v, --version
+```
 
-  # you get the point
-end
+This method takes an optional `prefix` value, which defaults to `" " * 4`:
 
-opt.parse
-things #=> { :name => 'lee', :age => 105 }
+```
+puts opts.to_s(prefix: "  ")
 ```
 
-Which is all great and stuff, but it can lead to some repetition. The same
-thing in Slop:
+It'll deal with aligning your descriptions according to the longest option
+flag.
 
-```ruby
-require 'slop'
+Here's an example of adding your own help option:
 
-opts = Slop.parse do
-  on :n, :name=, 'Your name'
-  on :a, :age=, 'Your age', as: Integer
+```ruby
+o.on '--help' do
+  puts o
+  exit
 end
-
-opts.to_hash #=> { :name => 'lee', :age => 105 }
 ```
+
+Commands
+--------
+
+As of version 4, Slop does not have built in support for git-style subcommands.
+You can use version 3 of Slop (see `v3` branch). I also expect there to be some
+external libraries released soon that wrap around Slop to provide support for
+this feature. I'll update this document when that happens.

data/lib/slop.rb

@@ -1,687 +1,56 @@
 require 'slop/option'
-require 'slop/commands'
+require 'slop/options'
+require 'slop/parser'
+require 'slop/result'
+require 'slop/types'
+require 'slop/error'
 
-class Slop
-  include Enumerable
+module Slop
+  # The current version of Slop, of course.
+  VERSION = '4.0.0'
 
-  VERSION = '3.6.0'
-
-  # The main Error class, all Exception classes inherit from this class.
-  class Error < StandardError; end
-
-  # Raised when an option argument is expected but none are given.
-  class MissingArgumentError < Error; end
-
-  # Raised when an option is expected/required but not present.
-  class MissingOptionError < Error; end
-
-  # Raised when an argument does not match its intended match constraint.
-  class InvalidArgumentError < Error; end
-
-  # Raised when an invalid option is found and the strict flag is enabled.
-  class InvalidOptionError < Error; end
-
-  # 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
-  }
-
-  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.
-    #
-    # Examples:
-    #
-    #   Slop.parse(ARGV, :help => true) do
-    #     on '-n', '--name', 'Your username', :argument => true
-    #   end
-    #
-    # Returns a new instance of Slop.
-    def parse(items = ARGV, config = {}, &block)
-      parse! items.dup, config, &block
-    end
-
-    # 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)
-      config, items = items, ARGV if items.is_a?(Hash) && config.empty?
-      slop = new config, &block
-      slop.parse! items
-      slop
-    end
-
-    # Build a Slop object from a option specification.
-    #
-    # 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.
-    #
-    # string - The optspec String
-    # config - A Hash of configuration options to pass to Slop.new
-    #
-    # Examples:
-    #
-    #   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
-    #
-    #   opts.fetch_option(:name).description #=> "Your name"
-    #
-    # Returns a new instance of Slop.
-    def optspec(string, config = {})
-      warn "[DEPRECATED] `Slop.optspec` is deprecated and will be removed in version 4"
-      config[:banner], optspec = string.split(/^--+$/, 2) if string[/^--+$/]
-      lines = optspec.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.end_with?('=')
-          long.sub!(/\=$/, '')
-          opt.config[:argument] = true
-        end
-      end
-
-      opts
-    end
-
-  end
-
-  # The Hash of configuration options for this Slop instance.
-  attr_reader :config
-
-  # The Array of Slop::Option objects tied to this Slop instance.
-  attr_reader :options
-
-  # The Hash of sub-commands for this Slop instance.
-  attr_reader :commands
-
-  # Create a new instance of Slop and optionally build options via a block.
-  #
-  # config - A Hash of configuration options.
-  # block  - An optional block used to specify options.
-  def initialize(config = {}, &block)
-    @config = DEFAULT_OPTIONS.merge(config)
-    @options = []
-    @commands = {}
-    @trash = []
-    @triggered_options = []
-    @unknown_options = []
-    @callbacks = {}
-    @separators = {}
-    @runner = nil
-    @command = config.delete(:command)
-
-    if block_given?
-      block.arity == 1 ? yield(self) : instance_eval(&block)
-    end
-
-    if config[:help]
-      on('-h', '--help', 'Display this help message.', :tail => true) do
-        puts help
-        exit
-      end
-    end
-  end
-
-  # Is strict mode enabled?
-  #
-  # Returns true if strict mode is enabled, false otherwise.
-  def strict?
-    config[:strict]
-  end
-
-  # Set the banner.
-  #
-  # banner - The String to set the banner.
-  def banner=(banner)
-    config[:banner] = banner
-  end
-
-  # Get or set the banner.
-  #
-  # banner - The String to set the banner.
-  #
-  # Returns the banner String.
-  def banner(banner = nil)
-    config[:banner] = banner if banner
-    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)
-    options = @config.merge(options)
-    @commands[command.to_s] = Slop.new(options.merge(:command => command.to_s), &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).
-  # block - An optional block which when used will yield non options.
-  #
-  # Returns an Array of original items.
-  def parse(items = ARGV, &block)
-    parse! items.dup, &block
-    items
-  end
-
-  # 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.
-  #
-  # items - The Array of items to extract options from (default: ARGV).
-  # block - An optional block which when used will yield non options.
-  #
-  # Returns an Array of original items with options removed.
-  def parse!(items = ARGV, &block)
-    if items.empty? && @callbacks[:empty]
-      @callbacks[:empty].each { |cb| cb.call(self) }
-      return items
-    end
-
-    # reset the trash so it doesn't carry over if you parse multiple
-    # times with the same instance
-    @trash.clear
-
-    if cmd = @commands[items[0]]
-      items.shift
-      return cmd.parse! 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) }
-
-    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
-
-    if @runner.respond_to?(:call)
-      @runner.call(self, items) unless config[:help] and present?(:help)
-    end
-
-    items
-  end
-
-  # Add an Option.
-  #
-  # objects - An Array with an optional Hash as the last element.
-  #
-  # Examples:
-  #
-  #   on '-u', '--username=', 'Your username'
-  #   on :v, :verbose, 'Enable verbose mode'
-  #
-  # Returns the created instance of Slop::Option.
-  def on(*objects, &block)
-    option = build_option(objects, &block)
-    original = options.find do |o|
-      o.long and o.long == option.long or o.short and o.short == option.short
-    end
-    options.delete(original) if original
-    options << option
-    option
-  end
-  alias option on
-  alias opt on
-
-  # Fetch an options argument value.
-  #
-  # key - The Symbol or String option short or long flag.
-  #
-  # Returns the Object value for this option, or nil.
-  def [](key)
-    option = fetch_option(key)
-    option.value if option
-  end
-  alias get []
-
-  # Returns a new Hash with option flags as keys and option values as values.
-  #
-  # 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
-
-  # Enumerable interface. Yields each Slop::Option.
-  def each(&block)
-    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
+  # Parse an array of options (defaults to ARGV). Accepts an
+  # optional hash of configuration options and block.
   #
   # Example:
   #
-  #   Slop.parse do
-  #     on :v, :verbose
-  #
-  #     run do |opts, args|
-  #       puts "Arguments: #{args.inspect}" if opts.verbose?
-  #     end
+  #   opts = Slop.parse(["-host", "localhost"]) do |o|
+  #     o.string '-host', 'a hostname', default: '0.0.0.0'
   #   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:
+  #   opts.to_hash #=> { host: 'localhost' }
   #
-  #   opts.parse %w( --foo )
-  #   opts.present?(:foo) #=> true
-  #   opts.present?(:bar) #=> false
-  #
-  # 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
-
-  # 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_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.
-  #
-  # Examples:
-  #
-  #   opts = Slop.new do
-  #     on :n, :name=
-  #     on :p, :password=
-  #   end
-  #
-  #   opts.parse %w[ --name Lee ]
-  #   opts.missing #=> ['password']
-  #
-  # Returns an Array of Strings representing missing options.
-  def missing
-    (options - @triggered_options).map(&:key)
-  end
-
-  # Fetch a Slop::Option object.
-  #
-  # 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
-
-  # 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.
-  #
-  # Returns nothing.
-  def add_callback(label, &block)
-    (@callbacks[label] ||= []) << block
-  end
-
-  # Add string separators between options.
-  #
-  # text - The String text to print.
-  def separator(text)
-    if @separators[options.size]
-      @separators[options.size] << "\n#{text}"
-    else
-      @separators[options.size] = text
-    end
-  end
-
-  # 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.each_with_index.map { |o, i|
-      (str = @separators[i + 1]) ? [o, str].join("\n") : o
-    }.join("\n")
-
-    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]
-    if banner.nil?
-      banner = "Usage: #{File.basename($0, '.*')}"
-      banner << " #{@command}" if @command
-      banner << " [command]" if @commands.any?
-      banner << " [options]"
-    end
-    if banner
-      "#{banner}\n#{@separators[0] ? "#{@separators[0]}\n" : ''}#{optstr}"
-    else
-      optstr
-    end
-  end
-  alias help to_s
-
-  private
-
-  # 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?('?')
-      meth.chop!
-      present?(meth) || present?(meth.gsub('_', '-'))
-    else
-      super
-    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)
-    return unless item = items[index]
-    option, argument = extract_option(item) if item.start_with?('-')
-
-    if option
-      option.count += 1 unless item.start_with?('--no-')
-      option.count += 1 if option.key[0, 3] == "no-"
-      @trash << index
-      @triggered_options << option
-
-      if option.expects_argument?
-        argument ||= items.at(index + 1)
-
-        if !argument || argument =~ /\A--?[a-zA-Z][a-zA-Z0-9_-]*\z/
-          raise MissingArgumentError, "#{option.key} expects an argument"
-        end
-
-        execute_option(option, argument, index, item)
-      elsif option.accepts_optional_argument?
-        argument ||= items.at(index + 1)
-
-        if argument && argument =~ /\A([^\-?]|-\d)+/
-          execute_option(option, argument, index, item)
-        else
-          option.call(nil)
-        end
-      elsif config[:multiple_switches] && argument
-        execute_multiple_switches(option, argument, items, index)
-      else
-        option.value = option.count > 0
-        option.call(nil)
-      end
-    else
-      @unknown_options << item if strict? && item =~ /\A--?/
-      block.call(item) if block && !@trash.include?(index)
-    end
-  end
-
-  # 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] && strict?
-        raise InvalidOptionError, "Unknown option -#{item}"
-      end
-      return
-    end
-
-    if argument
-      unless item && item.end_with?("=#{argument}")
-        @trash << index + 1 unless option.argument_in_value
-      end
-      option.value = argument
-    else
-      option.value = option.count > 0
-    end
-
-    if option.match? && !argument.match(option.config[:match])
-      raise InvalidArgumentError, "#{argument} is an invalid argument"
-    end
-
-    option.call(option.value)
-  end
-
-  # 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).
-  # items    - The Array of items currently being parsed.
-  # index    - The index of the current item being processed.
-  #
-  # Returns nothing.
-  def execute_multiple_switches(option, argument, items, index)
-    execute_option(option, nil, index)
-    flags = argument.split('')
-    flags.each do |key|
-      if opt = fetch_option(key)
-        opt.count += 1
-        if (opt.expects_argument? || opt.accepts_optional_argument?) &&
-            (flags[-1] == opt.key) && (val = items[index+1])
-          execute_option(opt, val, index, key)
-        else
-          execute_option(opt, nil, index, key)
-        end
-      else
-        raise InvalidOptionError, "Unknown option -#{key}" if strict?
-      end
-    end
+  # Returns a Slop::Result.
+  def self.parse(items = ARGV, **config, &block)
+    Options.new(config, &block).parse(items)
   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]
-    option ||= fetch_option(flag.gsub(/([^-])-/, '\1_'))
-
-    unless option
-      case flag
-      when /\A--?([^=]+)=(.+)\z/, /\A-([a-zA-Z])(.+)\z/, /\A--no-(.+)\z/
-        option, argument = fetch_option($1), ($2 || false)
-        option.argument_in_value = true if option
-      end
-    end
-
-    [option, argument]
-  end
-
-  # Autocreate an option on the fly. See the :autocreate Slop config option.
+  # Example:
   #
-  # items - The Array of items we're parsing.
-  # index - The current Integer index for the item we're processing.
+  #   Slop.option_defined?(:string) #=> true
+  #   Slop.option_defined?(:omg)    #=> false
   #
-  # Returns nothing.
-  def autocreate(items, index)
-    flag = items[index]
-    if !fetch_option(flag) && !@trash.include?(index)
-      option = build_option(Array(flag))
-      argument = items[index + 1]
-      option.config[:argument] = (argument && argument !~ /\A--?/)
-      option.config[:autocreated] = true
-      options << option
-    end
+  # Returns true if an option is defined.
+  def self.option_defined?(name)
+    const_defined?(string_to_option(name.to_s))
   end
 
-  # Build an option from a list of objects.
-  #
-  # objects - An Array of objects used to build this option.
+  # Example:
   #
-  # 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]
-
-    if objects.last.is_a?(Hash)
-      config.merge!(objects.pop)
-    end
-
-    short = extract_short_flag(objects, config)
-    long  = extract_long_flag(objects, config)
-    desc  = objects.shift if objects[0].respond_to?(:to_str)
-
-    Option.new(self, short, long, desc, config, &block)
-  end
-
-  def extract_short_flag(objects, config)
-    flag = objects[0].to_s
-    if flag =~ /\A-?\w=?\z/
-      config[:argument] ||= flag.end_with?('=')
-      objects.shift
-      flag.delete('-=')
-    end
-  end
-
-  # Extract the long flag from an item.
+  #   Slop.string_to_option("string")     #=> "StringOption"
+  #   Slop.string_to_option("some_thing") #=> "SomeThingOption"
   #
-  # 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-Z0-9][a-zA-Z0-9_.-]+\=?\??\z/
-      config[:argument] ||= true if flag.end_with?('=')
-      config[:optional_argument] = true if flag.end_with?('=?')
-      objects.shift
-      clean(flag).sub(/\=\??\z/, '')
-    end
+  # Returns a camel-cased class looking string with Option suffix.
+  def self.string_to_option(s)
+    s.gsub(/(?:^|_)([a-z])/) { $1.capitalize } + "Option"
   end
 
-  # Remove any leading -- characters from a string.
+  # Example:
   #
-  # object - The Object we want to cast to a String and clean.
+  #   Slop.string_to_option_class("string") #=> Slop::StringOption
+  #   Slop.string_to_option_class("foo")    #=> uninitialized constant FooOption
   #
-  # Returns the newly cleaned String with leading -- characters removed.
-  def clean(object)
-    object.to_s.sub(/\A--?/, '')
+  # Returns the full qualified option class. Uses `#string_to_option`.
+  def self.string_to_option_class(s)
+    const_get(string_to_option(s))
   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