pry 0.10.4 → 0.11.0.pre

data/lib/pry/plugins.rb

@@ -60,6 +60,16 @@ class Pry
 
       alias active? active
       alias enabled? enabled
+
+      def supported?
+        pry_version = Gem::Version.new(VERSION)
+        spec.dependencies.each do |dependency|
+          if dependency.name == "pry"
+            return dependency.requirement.satisfied_by?(pry_version)
+          end
+        end
+        true
+      end
     end
 
     def initialize
@@ -68,11 +78,11 @@ class Pry
 
     # Find all installed Pry plugins and store them in an internal array.
     def locate_plugins
-      Gem.refresh
-      (Gem::Specification.respond_to?(:each) ? Gem::Specification : Gem.source_index.find_name('')).each do |gem|
+      gem_list.each do |gem|
         next if gem.name !~ PRY_PLUGIN_PREFIX
         plugin_name = gem.name.split('-', 2).last
-        @plugins << Plugin.new(plugin_name, gem.name, gem, true) if !gem_located?(gem.name)
+        plugin = Plugin.new(plugin_name, gem.name, gem, false)
+        @plugins << plugin.tap(&:enable!) if plugin.supported? && !plugin_located?(plugin)
       end
       @plugins
     end
@@ -95,8 +105,13 @@ class Pry
     end
 
     private
-    def gem_located?(gem_name)
-      @plugins.any? { |plugin| plugin.gem_name == gem_name }
+    def plugin_located?(plugin)
+      @plugins.any? { |existing| existing.gem_name == plugin.gem_name }
+    end
+
+    def gem_list
+      Gem.refresh
+      Gem::Specification.respond_to?(:each) ? Gem::Specification : Gem.source_index.find_name('')
     end
   end
 

data/lib/pry/pry_class.rb

@@ -32,6 +32,21 @@ class Pry
     def history
       @history ||= History.new
     end
+
+    #
+    # @example
+    #  Pry.configure do |config|
+    #     config.eager_load! # optional
+    #     config.input =     # ..
+    #     config.foo = 2
+    #  end
+    #
+    # @yield [config]
+    #   Yields a block with {Pry.config} as its argument.
+    #
+    def configure
+      yield config
+    end
   end
 
   #
@@ -81,7 +96,7 @@ class Pry
     expanded = Pathname.new(File.expand_path(file)).realpath.to_s
     # For rbx 1.9 mode [see rubinius issue #2165]
     File.exist?(expanded) ? expanded : nil
-  rescue Errno::ENOENT
+  rescue Errno::ENOENT, Errno::EACCES
     nil
   end
 
@@ -124,6 +139,11 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
     # note these have to be loaded here rather than in pry_instance as
     # we only want them loaded once per entire Pry lifetime.
     load_rc_files
+  end
+
+  def self.final_session_setup
+    return if @session_finalized
+    @session_finalized = true
     load_plugins if Pry.config.should_load_plugins
     load_requires if Pry.config.should_load_requires
     load_history if Pry.config.history.should_load
@@ -141,6 +161,9 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
   #   Pry.start(Object.new, :input => MyInput.new)
   def self.start(target=nil, options={})
     return if ENV['DISABLE_PRY']
+    if ENV['FAIL_PRY']
+      raise 'You have FAIL_PRY set to true, which results in Pry calls failing'
+    end
     options = options.to_hash
 
     if in_critical_section?
@@ -150,8 +173,8 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
     end
 
     options[:target] = Pry.binding_for(target || toplevel_binding)
-    options[:hooks] = Pry::Hooks.from_hash options.delete(:hooks) if options.key?(:hooks)
     initial_session_setup
+    final_session_setup
 
     # Unless we were given a backtrace, save the current one
     if options[:backtrace].nil?
@@ -233,7 +256,7 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
   # @param [String] command_string The Pry command (including arguments,
   #   if any).
   # @param [Hash] options Optional named parameters.
-  # @return [Object] The return value of the Pry command.
+  # @return [nil]
   # @option options [Object, Binding] :target The object to run the
   #   command under. Defaults to `TOPLEVEL_BINDING` (main).
   # @option options [Boolean] :show_output Whether to show command
@@ -258,6 +281,7 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
 
     pry = Pry.new(:output   => output, :target   => target, :commands => options[:commands])
     pry.eval command_string
+    nil
   end
 
   def self.default_editor_for_platform
@@ -306,6 +330,8 @@ Readline version #{Readline::VERSION} detected - will not auto_resize! correctly
   # Set all the configurable options back to their default values
   def self.reset_defaults
     @initial_session = true
+    @session_finalized = nil
+
     self.config = Pry::Config.new Pry::Config::Default.new
     self.cli = false
     self.current_line = 1

data/lib/pry/pry_instance.rb

@@ -16,7 +16,7 @@
 # This will show a list of available commands and their usage. For more
 # information about Pry you can refer to the following resources:
 #
-# * http://pry.github.com/
+# * http://pryrepl.org/
 # * https://github.com/pry/pry
 # * the IRC channel, which is #pry on the Freenode network
 #
@@ -124,7 +124,7 @@ class Pry
   #
   # Generate completions.
   #
-  # @param [String] input
+  # @param [String] str
   #   What the user has typed so far
   #
   # @return [Array<String>]
@@ -269,7 +269,7 @@ class Pry
     @suppress_output = false
     inject_sticky_locals!
     begin
-      if !process_command_safely(line.lstrip)
+      if !process_command_safely(line)
         @eval_string << "#{line.chomp}\n" if !line.empty? || !@eval_string.empty?
       end
     rescue RescuableException => e
@@ -373,7 +373,7 @@ class Pry
     # serialize something in the user's program, let's not assume we can serialize
     # the exception either.
     begin
-      output.puts "(pry) output error: #{e.inspect}"
+      output.puts "(pry) output error: #{e.inspect}\n#{e.backtrace.join("\n")}"
     rescue RescuableException => e
       if last_result_is_exception?
         output.puts "(pry) output error: failed to show exception"
@@ -400,12 +400,14 @@ class Pry
   # @param [String] val The line to process.
   # @return [Boolean] `true` if `val` is a command, `false` otherwise
   def process_command(val)
+    val = val.lstrip if /^\s\S/ !~ val
     val = val.chomp
     result = commands.process_line(val,
       :target => current_binding,
       :output => output,
       :eval_string => @eval_string,
-      :pry_instance => self
+      :pry_instance => self,
+      :hooks => hooks
     )
 
     # set a temporary (just so we can inject the value we want into eval_string)
@@ -433,7 +435,7 @@ class Pry
   # @return [Boolean] `true` if `val` is a command, `false` otherwise
   def process_command_safely(val)
     process_command(val)
-  rescue CommandError, Slop::InvalidOptionError, MethodSource::SourceNotFoundError => e
+  rescue CommandError, Pry::Slop::InvalidOptionError, MethodSource::SourceNotFoundError => e
     Pry.last_internal_error = e
     output.puts "Error: #{e.message}"
     true

data/lib/pry/repl.rb

@@ -23,6 +23,8 @@ class Pry
       @pry    = pry
       @indent = Pry::Indent.new
 
+      @readline_output = nil
+
       if options[:target]
         @pry.push_binding options[:target]
       end
@@ -168,20 +170,21 @@ class Pry
     # @return [String?] The next line of input, or `nil` on <Ctrl-D>.
     def read_line(current_prompt)
       handle_read_errors do
-        if defined? Coolline and input.is_a? Coolline
+        if coolline_available?
           input.completion_proc = proc do |cool|
             completions = @pry.complete cool.completed_word
             completions.compact
           end
         elsif input.respond_to? :completion_proc=
-          input.completion_proc = proc do |input|
-            @pry.complete input
+          input.completion_proc = proc do |inp|
+            @pry.complete inp
           end
         end
 
-        if defined?(Readline) and input == Readline
+        if readline_available?
+          set_readline_output
           input_readline(current_prompt, false) # false since we'll add it manually
-        elsif defined? Coolline and input.is_a? Coolline
+        elsif coolline_available?
           input_readline(current_prompt)
         else
           if input.method(:readline).arity == 1
@@ -198,5 +201,34 @@ class Pry
         input.readline(*args)
       end
     end
+
+    def readline_available?
+      defined?(Readline) && input == Readline
+    end
+
+    def coolline_available?
+      defined?(Coolline) && input.is_a?(Coolline)
+    end
+
+    # If `$stdout` is not a tty, it's probably a pipe.
+    # @example
+    #   # `piping?` returns `false`
+    #   % pry
+    #   [1] pry(main)
+    #
+    #   # `piping?` returns `true`
+    #   % pry | tee log
+    def piping?
+      return false unless $stdout.respond_to?(:tty?)
+      !$stdout.tty? && $stdin.tty? && !Pry::Helpers::BaseHelpers.windows?
+    end
+
+    # @return [void]
+    def set_readline_output
+      return if @readline_output
+      if piping?
+        @readline_output = (Readline.output = Pry.config.output)
+      end
+    end
   end
 end

data/lib/pry/repl_file_loader.rb

@@ -13,7 +13,7 @@ class Pry
   class REPLFileLoader
     def initialize(file_name)
       full_name = File.expand_path(file_name)
-      raise RuntimeError, "No such file: #{full_name}" if !File.exists?(full_name)
+      raise RuntimeError, "No such file: #{full_name}" if !File.exist?(full_name)
 
       define_additional_commands
       @content = File.read(full_name)

data/lib/pry/rubygem.rb

@@ -57,7 +57,9 @@ class Pry
       # @param [String] name
       # @return [void]
       def install(name)
-        gemrc_opts = Gem.configuration['gem'].split(' ')
+        require 'rubygems/dependency_installer'
+        gem_config = Gem.configuration['gem']
+        gemrc_opts = (gem_config.nil? ? "" : gem_config.split(' '))
         destination = if gemrc_opts.include?('--user-install')
                         Gem.user_dir
                       elsif File.writable?(Gem.dir)

data/lib/pry/slop.rb

@@ -0,0 +1,661 @@
+class Pry::Slop
+  require_relative 'slop/option'
+  require_relative 'slop/commands'
+  include Enumerable
+  VERSION = '3.4.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 = Pry::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 = {})
+      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
+
+  # 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
+
+    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
+        $stderr.puts help
+      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)
+    @commands[command.to_s] = Pry::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).
+  # 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
+
+    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.
+  #
+  # 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)
+    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
+  #
+  # 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:
+  #
+  #   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]
+    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
+
+  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, 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).
+  # index    - The index of the current item being processed.
+  #
+  # Returns nothing.
+  def execute_multiple_switches(option, argument, index)
+    execute_option(option, nil, index)
+    argument.split('').each do |key|
+      next unless opt = fetch_option(key)
+      opt.count += 1
+      execute_option(opt, nil, 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]
+    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.
+  #
+  # 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]
+    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
+  end
+
+  # 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]
+
+    if objects.last.is_a?(Hash)
+      config.merge!(objects.last)
+      objects.pop
+    end
+    short = extract_short_flag(objects, config)
+    long  = extract_long_flag(objects, config)
+    desc  = objects[0].respond_to?(:to_str) ? objects.shift : nil
+
+    Option.new(self, short, long, desc, config, &block)
+  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)
+
+    if flag.size == 2 && flag.end_with?('=')
+      config[:argument] ||= true
+      flag.chop!
+    end
+
+    if flag.size == 1
+      objects.shift
+      flag
+    end
+  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.end_with?('=')
+      config[:optional_argument] = true if flag.end_with?('=?')
+      objects.shift
+      clean(flag).sub(/\=\??\z/, '')
+    end
+  end
+
+  # 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
+
+  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