qiita_org 0.1.24 → 0.1.25

data/gems/ruby/2.7.0/gems/pry-0.13.1/lib/pry/repl.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+class Pry
+  class REPL
+    extend Pry::Forwardable
+    def_delegators :@pry, :input, :output
+
+    # @return [Pry] The instance of {Pry} that the user is controlling.
+    attr_accessor :pry
+
+    # Instantiate a new {Pry} instance with the given options, then start a
+    # {REPL} instance wrapping it.
+    # @option options See {Pry#initialize}
+    def self.start(options)
+      new(Pry.new(options)).start
+    end
+
+    # Create an instance of {REPL} wrapping the given {Pry}.
+    # @param [Pry] pry The instance of {Pry} that this {REPL} will control.
+    # @param [Hash] options Options for this {REPL} instance.
+    # @option options [Object] :target The initial target of the session.
+    def initialize(pry, options = {})
+      @pry    = pry
+      @indent = Pry::Indent.new(pry)
+
+      @readline_output = nil
+
+      @pry.push_binding options[:target] if options[:target]
+    end
+
+    # Start the read-eval-print loop.
+    # @return [Object?] If the session throws `:breakout`, return the value
+    #   thrown with it.
+    # @raise [Exception] If the session throws `:raise_up`, raise the exception
+    #   thrown with it.
+    def start
+      prologue
+      Pry::InputLock.for(:all).with_ownership { repl }
+    ensure
+      epilogue
+    end
+
+    private
+
+    # Set up the repl session.
+    # @return [void]
+    def prologue
+      pry.exec_hook :before_session, pry.output, pry.current_binding, pry
+
+      return unless pry.config.correct_indent
+
+      # Clear the line before starting Pry. This fixes issue #566.
+      output.print(Helpers::Platform.windows_ansi? ? "\e[0F" : "\e[0G")
+    end
+
+    # The actual read-eval-print loop.
+    #
+    # The {REPL} instance is responsible for reading and looping, whereas the
+    # {Pry} instance is responsible for evaluating user input and printing
+    # return values and command output.
+    #
+    # @return [Object?] If the session throws `:breakout`, return the value
+    #   thrown with it.
+    # @raise [Exception] If the session throws `:raise_up`, raise the exception
+    #   thrown with it.
+    def repl
+      loop do
+        case val = read
+        when :control_c
+          output.puts ""
+          pry.reset_eval_string
+        when :no_more_input
+          output.puts "" if output.tty?
+          break
+        else
+          output.puts "" if val.nil? && output.tty?
+          return pry.exit_value unless pry.eval(val)
+        end
+      end
+    end
+
+    # Clean up after the repl session.
+    # @return [void]
+    def epilogue
+      pry.exec_hook :after_session, pry.output, pry.current_binding, pry
+    end
+
+    # Read a line of input from the user.
+    # @return [String] The line entered by the user.
+    # @return [nil] On `<Ctrl-D>`.
+    # @return [:control_c] On `<Ctrl+C>`.
+    # @return [:no_more_input] On EOF.
+    def read
+      @indent.reset if pry.eval_string.empty?
+      current_prompt = pry.select_prompt
+      indentation = pry.config.auto_indent ? @indent.current_prefix : ''
+
+      val = read_line("#{current_prompt}#{indentation}")
+
+      # Return nil for EOF, :no_more_input for error, or :control_c for <Ctrl-C>
+      return val unless val.is_a?(String)
+
+      if pry.config.auto_indent
+        original_val = "#{indentation}#{val}"
+        indented_val = @indent.indent(val)
+
+        if output.tty? &&
+           pry.config.correct_indent &&
+           Pry::Helpers::BaseHelpers.use_ansi_codes?
+          output.print @indent.correct_indentation(
+            current_prompt,
+            indented_val,
+            calculate_overhang(current_prompt, original_val, indented_val)
+          )
+          output.flush
+        end
+      else
+        indented_val = val
+      end
+
+      indented_val
+    end
+
+    # Manage switching of input objects on encountering `EOFError`s.
+    # @return [Object] Whatever the given block returns.
+    # @return [:no_more_input] Indicates that no more input can be read.
+    def handle_read_errors
+      should_retry = true
+      exception_count = 0
+
+      begin
+        yield
+      rescue EOFError
+        pry.config.input = Pry.config.input
+        unless should_retry
+          output.puts "Error: Pry ran out of things to read from! " \
+            "Attempting to break out of REPL."
+          return :no_more_input
+        end
+        should_retry = false
+        retry
+
+      # Handle <Ctrl+C> like Bash: empty the current input buffer, but don't
+      # quit.  This is only for MRI 1.9; other versions of Ruby don't let you
+      # send Interrupt from within Readline.
+      rescue Interrupt
+        return :control_c
+
+      # If we get a random error when trying to read a line we don't want to
+      # automatically retry, as the user will see a lot of error messages
+      # scroll past and be unable to do anything about it.
+      rescue RescuableException => e
+        puts "Error: #{e.message}"
+        output.puts e.backtrace
+        exception_count += 1
+        retry if exception_count < 5
+        puts "FATAL: Pry failed to get user input using `#{input}`."
+        puts "To fix this you may be able to pass input and output file " \
+          "descriptors to pry directly. e.g."
+        puts "  Pry.config.input = STDIN"
+        puts "  Pry.config.output = STDOUT"
+        puts "  binding.pry"
+        return :no_more_input
+      end
+    end
+
+    # Returns the next line of input to be sent to the {Pry} instance.
+    # @param [String] current_prompt The prompt to use for input.
+    # @return [String?] The next line of input, or `nil` on <Ctrl-D>.
+    def read_line(current_prompt)
+      handle_read_errors do
+        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 |inp|
+            @pry.complete inp
+          end
+        end
+
+        if readline_available?
+          set_readline_output
+          input_readline(current_prompt, false) # false since we'll add it manually
+        elsif coolline_available?
+          input_readline(current_prompt)
+        elsif input.method(:readline).arity == 1
+          input_readline(current_prompt)
+        else
+          input_readline
+        end
+      end
+    end
+
+    def input_readline(*args)
+      Pry::InputLock.for(:all).interruptible_region do
+        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? && !Helpers::Platform.windows?
+    end
+
+    # @return [void]
+    def set_readline_output
+      return if @readline_output
+
+      @readline_output = (Readline.output = Pry.config.output) if piping?
+    end
+
+    # Calculates correct overhang for current line. Supports vi Readline
+    # mode and its indicators such as "(ins)" or "(cmd)".
+    #
+    # @return [Integer]
+    # @note This doesn't calculate overhang for Readline's emacs mode with an
+    #   indicator because emacs is the default mode and it doesn't use
+    #   indicators in 99% of cases.
+    def calculate_overhang(current_prompt, original_val, indented_val)
+      overhang = original_val.length - indented_val.length
+
+      if readline_available? && Readline.respond_to?(:vi_editing_mode?)
+        begin
+          # rb-readline doesn't support this method:
+          # https://github.com/ConnorAtherton/rb-readline/issues/152
+          if Readline.vi_editing_mode?
+            overhang = output.width - current_prompt.size - indented_val.size
+          end
+        rescue NotImplementedError
+          # VI editing mode is unsupported on JRuby.
+          # https://github.com/pry/pry/issues/1840
+          nil
+        end
+      end
+      [0, overhang].max
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/pry-0.13.1/lib/pry/repl_file_loader.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+class Pry
+  # A class to manage the loading of files through the REPL loop.
+  # This is an interesting trick as it processes your file as if it
+  # was user input in an interactive session. As a result, all Pry
+  # commands are available, and they are executed non-interactively. Furthermore
+  # the session becomes interactive when the repl loop processes a
+  # 'make-interactive' command in the file. The session also becomes
+  # interactive when an exception is encountered, enabling you to fix
+  # the error before returning to non-interactive processing with the
+  # 'make-non-interactive' command.
+
+  class REPLFileLoader
+    def initialize(file_name)
+      full_name = File.expand_path(file_name)
+      raise "No such file: #{full_name}" unless File.exist?(full_name)
+
+      define_additional_commands
+      @content = File.read(full_name)
+    end
+
+    # Switch to interactive mode, i.e take input from the user
+    # and use the regular print and exception handlers.
+    # @param [Pry] pry_instance the Pry instance to make interactive.
+    def interactive_mode(pry_instance)
+      pry_instance.config.input = Pry.config.input
+      pry_instance.config.print = Pry.config.print
+      pry_instance.config.exception_handler = Pry.config.exception_handler
+      Pry::REPL.new(pry_instance).start
+    end
+
+    # Switch to non-interactive mode. Essentially
+    # this means there is no result output
+    # and that the session becomes interactive when an exception is encountered.
+    # @param [Pry] pry_instance the Pry instance to make non-interactive.
+    def non_interactive_mode(pry_instance, content)
+      pry_instance.print = proc {}
+      pry_instance.exception_handler = proc do |o, _e, p|
+        p.run_command "cat --ex"
+        o.puts "...exception encountered, going interactive!"
+        interactive_mode(pry_instance)
+      end
+
+      content.lines.each do |line|
+        break unless pry_instance.eval line, generated: true
+      end
+
+      return if pry_instance.eval_string.empty?
+
+      pry_instance.output.puts(
+        "#{pry_instance.eval_string}...exception encountered, going interactive!"
+      )
+      interactive_mode(pry_instance)
+    end
+
+    # Define a few extra commands useful for flipping back & forth
+    # between interactive/non-interactive modes
+    def define_additional_commands
+      s = self
+
+      Pry::Commands.command "make-interactive", "Make the session interactive" do
+        s.interactive_mode(pry_instance)
+      end
+
+      Pry::Commands.command(
+        "load-file", "Load another file through the repl"
+      ) do |file_name|
+        s.non_interactive_mode(pry_instance, File.read(File.expand_path(file_name)))
+      end
+    end
+
+    # Actually load the file through the REPL by setting file content
+    # as the REPL input stream.
+    def load
+      non_interactive_mode(Pry.new, @content)
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/pry-0.13.1/lib/pry/ring.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+class Pry
+  # A ring is a thread-safe fixed-capacity array to which you can only add
+  # elements. Older entries are overwritten as you add new elements, so that the
+  # ring can never contain more than `max_size` elemens.
+  #
+  # @example
+  #   ring = Pry::Ring.new(3)
+  #   ring << 1 << 2 << 3
+  #   ring.to_a #=> [1, 2, 3]
+  #   ring << 4
+  #   ring.to_a #=> [2, 3, 4]
+  #
+  #   ring[0] #=> 2
+  #   ring[-1] #=> 4
+  #   ring.clear
+  #   ring[0] #=> nil
+  #
+  # @api public
+  # @since v0.12.0
+  class Ring
+    # @return [Integer] maximum buffer size
+    attr_reader :max_size
+
+    # @return [Integer] how many objects were added during the lifetime of the
+    #   ring
+    attr_reader :count
+    alias size count
+
+    # @param [Integer] max_size Maximum buffer size. The buffer will start
+    #   overwriting elements once its reaches its maximum capacity
+    def initialize(max_size)
+      @max_size = max_size
+      @mutex = Mutex.new
+      clear
+    end
+
+    # Push `value` to the current index.
+    #
+    # @param [Object] value
+    # @return [self]
+    def <<(value)
+      @mutex.synchronize do
+        @buffer[count % max_size] = value
+        @count += 1
+        self
+      end
+    end
+
+    # Read the value stored at `index`.
+    #
+    # @param [Integer, Range] index The element (if Integer) or elements
+    #   (if Range) associated with `index`
+    # @return [Object, Array<Object>, nil] element(s) at `index`, `nil` if none
+    #   exist
+    def [](index)
+      @mutex.synchronize do
+        return @buffer[(count + index) % max_size] if index.is_a?(Integer)
+        return @buffer[index] if count <= max_size
+
+        transpose_buffer_tail[index]
+      end
+    end
+
+    # @return [Array<Object>] the buffer as unwinded array
+    def to_a
+      return @buffer.dup if count <= max_size
+
+      transpose_buffer_tail
+    end
+
+    # Clear the buffer and reset count.
+    # @return [void]
+    def clear
+      @mutex.synchronize do
+        @buffer = []
+        @count = 0
+      end
+    end
+
+    private
+
+    def transpose_buffer_tail
+      tail = @buffer.slice(count % max_size, @buffer.size)
+      tail.concat @buffer.slice(0, count % max_size)
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/pry-0.13.1/lib/pry/slop.rb

@@ -0,0 +1,672 @@
+# frozen_string_literal: true
+
+class Pry
+  # rubocop:disable Metrics/ClassLength
+  class Slop
+    require_relative 'slop/option'
+    require_relative 'slop/commands'
+    include Enumerable
+    VERSION = '3.4.0'.freeze
+
+    # 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
+    }.freeze
+
+    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)
+        if items.is_a?(Hash) && config.empty?
+          config = items
+          items = ARGV
+        end
+        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
+
+      return unless config[:help]
+
+      on('-h', '--help', 'Display this help message.', tail: true) do
+        warn help
+      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
+      return if @runner.respond_to?(:call)
+
+      raise ArgumentError, "You must specify a callable object or a block to #run"
+    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_all = 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 do |o, i|
+        (str = @separators[i + 1]) ? [o, str].join("\n") : o
+      end.join("\n")
+
+      if @commands.any?
+        optstr << "\n" unless 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($PROGRAM_NAME, '.*')}" \
+                 "#{' [command]' if @commands.any?} [options]"
+      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 = meth.chop
+        present?(meth) || present?(meth.tr('_', '-'))
+      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--?/
+        yield(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)
+      unless 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 = fetch_option(Regexp.last_match(1))
+          argument = Regexp.last_match(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]
+      return 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
+
+    # 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
+
+      return unless flag.size == 1
+
+      objects.shift
+      flag
+    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
+      return unless 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
+
+    # 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
+  # rubocop:enable Metrics/ClassLength
+end