slop 1.9.1 → 2.0.0

data/CHANGES.md

@@ -1,3 +1,22 @@
+2.0.0 (2011-07-07)
+-----------
+
+* Deprecations:
+  * Removed `Slop::Options#to_hash` continue using `Slop#to_hash` directly.
+    This method also now returns symbols by default instead of strings. If
+    you want strings use `opts.to_hash(false)`
+  * `:multiple_switches` is now enabled by default, to parse `fbar` as the
+    option `f` with value `bar` you must disable `:multiple_switches`
+  * Removed `Slop::Options#to_help` and merged its contents into `Slop#help`
+  * Removed `lib/slop/options.rb` and merged `Slop::Options` into slop.rb
+  * Removed `lib/slop/option.rb` and merged `Slop::Option` into slop.rb
+  * These changes make Slop much easier to vendor in libraries
+* `Slop::Option` now inherits from `Struct.new`
+* Added Slop::Error subclassing from StandardError which all exception
+  classes should inherit from
+* Added Slop::MissingOptionError and `:required` option to Slop::Option.
+  This exception is raised when a mandatory option is not used
+
 1.9.1 (2011-06-16)
 ------------------
 
@@ -84,4 +103,4 @@
 * Add `Slop#present?` as alias for `Slop#<option>?`
 * Add `Option#count` for monitoring how many times an option is called
 * Add `:io` for using a custom IO object when using the `:help` option
-* Numerous performance tweaks
+* Numerous performance tweaks

data/README.md

@@ -39,7 +39,7 @@ wiki page.
 
 You can also return your options as a Hash
 
-    opts.to_hash #=> {'name' => 'Lee Jarvis', 'verbose' => true, 'age' => nil, 'sex' => 'male'}
+    opts.to_hash #=> {:name => 'Lee Jarvis', :verbose => true, :age => nil, :sex => 'male'}
 
 If you want some pretty output for the user to see your options, you can just
 send the Slop object to `puts` or use the `help` method.
@@ -83,7 +83,7 @@ Parsing
 
 Slop's pretty good at parsing, let's take a look at what it'll extract for you
 
-    Slop.parse do
+    Slop.parse(:multiple_switches => false) do
       on 's', 'server', true
       on 'p', 'port', true, :as => :integer
       on 'username', true, :matches => /[^a-zA-Z]+$/
@@ -97,10 +97,10 @@ Now throw some options at it:
 Here's what we'll get back
 
     {
-    	:server=>"ftp://foobar.com",
-    	:port=>1234,
-    	:username=>"FooBar",
-    	:password=>"hello there"
+    	:server => "ftp://foobar.com",
+    	:port => 1234,
+    	:username => "FooBar",
+    	:password => "hello there"
     }
 
 Events
@@ -160,22 +160,29 @@ Short Switches
 --------------
 
 Want to enable multiple switches at once like rsync does? By default Slop will
-parse `-abcd` as the option `a` with the argument `bcd`, this can be disabled
-by passing the `:multiple_switches` option to a new Slop object.
+parse `-abc` as the options `a` `b` and `c` and set their values to true. If
+you would like to disable this, you can pass `multiple_switches => false` to
+a new Slop object. In which case Slop will then parse `-fbar` as the option
+`f` with the argument value `bar`.
 
-    opts = Slop.new(:strict, :multiple_switches) do
+    Slop.parse do
       on :a, 'First switch'
       on :b, 'Second switch'
       on :c, 'Third switch'
     end
 
-    opts.parse
-
     # Using `-ac`
     opts[:a] #=> true
     opts[:b] #=> false
     opts[:c] #=> true
 
+    Slop.parse(:multiple_switches => false) do
+      on :a, 'Some switch', true
+    end
+
+    # Using `ahello`
+    opts[:a] #=> 'hello'
+
 Lists
 -----
 
@@ -245,4 +252,4 @@ thing in Slop:
       on :a, :age, 'Your age', true, :as => :int
     end
 
-    opts.to_hash(true) #=> { :name => 'lee', :age => 105 }
+    opts.to_hash #=> { :name => 'lee', :age => 105 }

data/Rakefile

@@ -3,8 +3,4 @@ task :test do
   Dir.glob("test/*_test.rb").each { |test| require "./#{test}" }
 end
 
-task :test_all do
-  sh "rvm 1.8.7,jruby,rbx,1.9.2 exec rake test"
-end
-
-task :default => :test
+task :default => :test

data/lib/slop.rb

@@ -1,22 +1,240 @@
-require 'slop/options'
-require 'slop/option'
-
 class Slop
   include Enumerable
 
+  # Slops standard Error class. All exception classes should
+  # inherit from this class
+  class Error < StandardError; end
+
   # Raised when an option expects an argument and none is given
-  class MissingArgumentError < RuntimeError; end
+  class MissingArgumentError < Error; end
+
+  # Raised when an option is required but not given
+  class MissingOptionError < Error; end
 
   # Raised when an option specifies the `:match` attribute and this
   # options argument does not match this regexp
-  class InvalidArgumentError < RuntimeError; end
+  class InvalidArgumentError < Error; end
 
   # Raised when the `:strict` option is enabled and an unknown
   # or unspecified option is used
-  class InvalidOptionError < RuntimeError; end
+  class InvalidOptionError < Error; end
+
+  # Each option specified in `Slop#opt` creates an instance of this class
+  class Option < Struct.new(:short_flag, :long_flag, :description,
+    :tail, :match, :help, :required, :forced, :count)
+
+    # @param [Slop] slop
+    # @param [String, #to_s] short
+    # @param [String, #to_s] long
+    # @param [String] description
+    # @param [Boolean] argument
+    # @param [Hash] options
+    # @option options [Boolean] :optional
+    # @option options [Boolean] :argument
+    # @option options [Object] :default
+    # @option options [Proc, #call] :callback
+    # @option options [String, #to_s] :delimiter (',')
+    # @option options [Integer] :limit (0)
+    # @option options [Boolean] :tail (false)
+    # @option options [Regexp] :match
+    # @option options [String, #to_s] :unless
+    # @option options [Boolean, String] :help (true)
+    # @option options [Boolean] :required (false)
+    def initialize(slop, short, long, description, argument, options, &blk)
+      @slop = slop
+
+      self.short_flag = short
+      self.long_flag = long
+      self.description = description
+
+      @argument = argument
+      @options = options
+
+      self.tail = @options[:tail]
+      self.match = @options[:match]
+      self.help = @options.fetch(:help, true)
+      self.required = @options[:required]
+
+      @delimiter = @options.fetch(:delimiter, ',')
+      @limit = @options.fetch(:limit, 0)
+      @argument_type = @options[:as].to_s.downcase
+      @argument_value = nil
+
+      self.forced = false
+      self.count = 0
+
+      @callback = blk if block_given?
+      @callback ||= @options[:callback]
+
+      build_longest_flag
+    end
+
+    # @return [Boolean] true if this option expects an argument
+    def expects_argument?
+      @argument || @options[:argument] || @options[:optional] == false
+    end
+
+    # @return [Boolean] true if this option accepts an optional argument
+    def accepts_optional_argument?
+      @options[:optional]
+    end
+
+    # @return [String] either the long or short flag for this option
+    def key
+      long_flag || short_flag
+    end
+
+    # Set this options argument value.
+    #
+    # If this options argument type is expected to be an Array, this
+    # method will split the value and concat elements into the original
+    # argument value
+    #
+    # @param [Object] value The value to set this options argument to
+    def argument_value=(value)
+      if @argument_type == 'array'
+        @argument_value ||= []
+
+        if value.respond_to?(:to_str)
+          @argument_value.concat value.split(@delimiter, @limit)
+        end
+      else
+        @argument_value = value
+      end
+    end
+
+    # @return [Object] the argument value after it's been cast
+    #   according to the `:as` option
+    def argument_value
+      return @argument_value if forced
+      value = @argument_value || @options[:default]
+      return if value.nil?
+
+      case @argument_type
+      when 'array'; @argument_value
+      when 'range'; value_to_range value
+      when 'float'; value.to_s.to_f
+      when 'string', 'str';  value.to_s
+      when 'symbol', 'sym';  value.to_s.to_sym
+      when 'integer', 'int'; value.to_s.to_i
+      else
+        value
+      end
+    end
+
+    # Force an argument value, used when the desired argument value
+    # is negative (false or nil)
+    #
+    # @param [Object] value
+    def force_argument_value(value)
+      @argument_value = value
+      self.forced = true
+    end
+
+    # Execute the block or callback object associated with this Option
+    #
+    # @param [Object] The object to be sent to `:call`
+    def call(obj=nil)
+      @callback.call(obj) if @callback.respond_to?(:call)
+    end
+
+    # @param [Array] items The original array of objects passed to `Slop.new`
+    # @return [Boolean] true if this options `:unless` argument exists
+    #   inside *items*
+    def omit_exec?(items)
+      string = @options[:unless].to_s.sub(/\A--?/, '')
+      items.any? { |i| i.to_s.sub(/\A--?/, '') == string }
+    end
+
+    # This option in a nice pretty string, including a short flag, long
+    # flag, and description (if they exist).
+    #
+    # @see Slop#help
+    # @return [String]
+    def to_s
+      out = "    "
+      out += short_flag ? "-#{short_flag}, " : ' ' * 4
+
+      if long_flag
+        out += "--#{long_flag}"
+        if help.respond_to? :to_str
+          out += " #{help}"
+          size = long_flag.size + help.size + 1
+        else
+          size = long_flag.size
+        end
+        diff = @slop.longest_flag - size
+        out += " " * (diff + 6)
+      else
+        out += " " * (@slop.longest_flag + 8)
+      end
+
+      "#{out}#{description}"
+    end
+
+    # @return [String]
+    def inspect
+      "#<Slop::Option short_flag=#{short_flag.inspect} " +
+      "long_flag=#{long_flag.inspect} argument=#{@argument.inspect} " +
+      "description=#{description.inspect}>"
+    end
+
+    private
+
+    def value_to_range(value)
+      case value.to_s
+      when /\A(-?\d+?)(?:\.\.|-|,)(-?\d+)\z/
+        $1.to_i .. $2.to_i
+      when /\A(-?\d+?)\.\.\.(-?\d+)\z/
+        $1.to_i ... $2.to_i
+      when /\A-?\d+\z/
+        value.to_i
+      else
+        value
+      end
+    end
+
+    def build_longest_flag
+      if long_flag && long_flag.size > @slop.longest_flag
+        @slop.longest_flag = long_flag.size
+        @slop.longest_flag += help.size if help.respond_to? :to_str
+      end
+    end
+
+  end
+
+  # Used to hold a list of Option objects. This class inherits from Array
+  # and overwrites `Array#[]` so we can fetch Option objects via their
+  # short or long flags
+  class Options < Array
+
+    # Fetch an Option object. This method overrides Array#[] to provide
+    # a nicer interface for fetching options via their short or long flag.
+    # The reason we don't use a Hash here is because an option cannot be
+    # identified by a single label. Instead this method tests against
+    # a short flag first, followed by a long flag. When passing this
+    # method an Integer, it will work as an Array usually would, fetching
+    # the Slop::Option at this index.
+    #
+    # @param [Object] flag The short/long flag representing the option
+    # @example
+    #   opts = Slop.parse { on :v, "Verbose mode" }
+    #   opts.options[:v] #=> Option
+    #   opts.options[:v].description #=> "Verbose mode"
+    # @return [Option] the option assoiated with this flag
+    def [](flag)
+      if flag.is_a? Integer
+        super
+      else
+        find do |option|
+          [option.short_flag, option.long_flag].include? flag.to_s
+        end
+      end
+    end
+  end
 
   # @return [String] The current version string
-  VERSION = '1.9.1'
+  VERSION = '2.0.0'
 
   # Parses the items from a CLI format into a friendly object
   #
@@ -107,7 +325,7 @@ class Slop
   #
   # @option opts [Array] :aliases ([])
   #   * Primary uses by commands to implement command aliases
-
+  #
   # @option opts [Boolean] :completion (true)
   #   * When true, commands will be auto completed. Ie `foobar` will be
   #     executed simply when `foo` `fo` or `foob` are used
@@ -126,7 +344,7 @@ class Slop
     @banner = sloptions[:banner]
     @strict = sloptions[:strict]
     @ignore_case = sloptions[:ignore_case]
-    @multiple_switches = sloptions[:multiple_switches]
+    @multiple_switches = sloptions.fetch(:multiple_switches, true)
     @autocreate = sloptions[:autocreate]
     @completion = sloptions.fetch(:completion, true)
     @arguments = sloptions[:arguments]
@@ -340,13 +558,18 @@ class Slop
   # Returns the parsed list into a option/value hash
   #
   # @example
-  #   opts.to_hash #=> { 'name' => 'Emily' }
+  #   opts.to_hash #=> { :name => 'Emily' }
   #
-  #   # symbols!
-  #   opts.to_hash(true) #=> { :name => 'Emily' }
+  #   # strings!
+  #   opts.to_hash(false) #=> { 'name' => 'Emily' }
   # @return [Hash]
-  def to_hash(symbols=false)
-    @options.to_hash symbols
+  def to_hash(symbols=true)
+    @options.reduce({}) do |hsh, option|
+      key = option.key
+      key = key.to_sym if symbols
+      hsh[key] = option.argument_value
+      hsh
+    end
   end
   alias :to_h :to_hash
 
@@ -398,8 +621,16 @@ class Slop
     parts << banner if banner
     parts << summary if summary
     parts << wrap_and_indent(description, 80, 4) if description
-    parts << "options:" if options.size > 0
-    parts << options.to_help if options.size > 0
+
+    if options.size > 0
+      parts << "options:"
+
+      heads = @options.reject(&:tail)
+      tails = @options.select(&:tail)
+      all = (heads + tails).select(&:help)
+
+      parts << all.map(&:to_s).join("\n")
+    end
 
     parts.join("\n\n")
   end
@@ -463,8 +694,9 @@ class Slop
       next if ignore_all
       autocreate(flag, index, items) if @autocreate
       option, argument = extract_option(item, flag)
-      if @multiple_switches && !option
-        trash << index if item[/\A-[^-]/]
+
+      if @multiple_switches && item[/\A-[^-]/] && !option
+        trash << index
         next
       end
 
@@ -504,6 +736,7 @@ class Slop
 
     items.reject!.with_index { |o, i| trash.include?(i) } if delete
     raise_if_invalid_options!
+    raise_if_missing_required_options!(items)
     items
   end
 
@@ -522,6 +755,14 @@ class Slop
     raise InvalidOptionError, message
   end
 
+  def raise_if_missing_required_options!(items)
+    @options.select(&:required).each do |o|
+      unless items.select {|i| i[/\A--?/] }.any? {|i| i.to_s.sub(/\A--?/, '') == o.key }
+        raise MissingOptionError, "Expected option `#{o.key}` is required"
+      end
+    end
+  end
+
   # if multiple_switches is enabled, this method filters through an items
   # characters and attempts to find an Option object for each flag.
   #
@@ -669,4 +910,4 @@ class Slop
     options.push @arguments ?  true : (args.shift ? true : false)
     options.push extras
   end
-end
+end

data/slop.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'slop'
-  s.version = '1.9.1'
+  s.version = '2.0.0'
   s.summary = 'Option gathering made easy'
   s.description = 'A simple DSL for gathering options and parsing the command line'
   s.author = 'Lee Jarvis'

data/test/option_test.rb

@@ -168,4 +168,13 @@ class OptionTest < TestCase
     assert_equal "1", opts[:bar]
     refute item
   end
+
+  test 'raises MissingOptionError when an option is :required' do
+    opts = Slop.new do
+      on :foo, :required => true
+    end
+
+    assert_raises(Slop::MissingOptionError, /foo is required/) { opts.parse %w[ --bar ] }
+    assert_raises(Slop::MissingOptionError, /foo is required/) { opts.parse %w[ foo ] }
+  end
 end

data/test/slop_test.rb

@@ -319,7 +319,7 @@ class SlopTest < TestCase
     slop.opt :V, :verbose, :default => false
     slop.parse %w/--name lee --version/
 
-    assert_equal({'name' => 'lee', 'version' => true, 'verbose' => false}, slop.to_hash)
+    assert_equal({'name' => 'lee', 'version' => true, 'verbose' => false}, slop.to_hash(false))
     assert_equal({:name => 'lee', :version => true, :verbose => false}, slop.to_hash(true))
   end
 
@@ -375,11 +375,11 @@ class SlopTest < TestCase
     assert_equal 'nelson', strict[:name]
   end
 
-  test 'short option flag with no space between flag and argument' do
-    slop = Slop.new
+  test 'short option flag with no space between flag and argument, with :multiple_switches => false' do
+    slop = Slop.new :multiple_switches => false
     slop.opt :p, :password, true
     slop.opt :s, :shortpass, true
-    slop.parse %w/-p foo -sbar/
+    slop.parse %w/-pfoo -sbar/
 
     assert_equal 'foo', slop[:password]
     assert_equal 'bar', slop[:shortpass]

metadata

@@ -1,33 +1,23 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: slop
-version: !ruby/object:Gem::Version 
-  hash: 49
+version: !ruby/object:Gem::Version
+  version: 2.0.0
   prerelease: 
-  segments: 
-  - 1
-  - 9
-  - 1
-  version: 1.9.1
 platform: ruby
-authors: 
+authors:
 - Lee Jarvis
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-16 00:00:00 +01:00
+date: 2011-07-07 00:00:00.000000000 +01:00
 default_executable: 
 dependencies: []
-
 description: A simple DSL for gathering options and parsing the command line
 email: lee@jarvis.co
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gemtest
 - .gitignore
 - .yardopts
@@ -36,8 +26,6 @@ files:
 - README.md
 - Rakefile
 - lib/slop.rb
-- lib/slop/option.rb
-- lib/slop/options.rb
 - slop.gemspec
 - test/commands_test.rb
 - test/helper.rb
@@ -46,38 +34,29 @@ files:
 has_rdoc: true
 homepage: http://github.com/injekt/slop
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Option gathering made easy
-test_files: 
+test_files:
 - test/commands_test.rb
 - test/helper.rb
 - test/option_test.rb

data/lib/slop/option.rb

@@ -1,205 +0,0 @@
-class Slop
-  class Option
-
-    # @return [String, #to_s] The short flag used for this option
-    attr_reader :short_flag
-
-    # @return [String, #to_s] The long flag used for this option
-    attr_reader :long_flag
-
-    # @return [String] This options description
-    attr_reader :description
-
-    # @return [Boolean] True if the option should be grouped at the
-    #   tail of the help list
-    attr_reader :tail
-
-    # @return [Regexp] If provided, an options argument **must** match this
-    #   regexp, otherwise Slop will raise an InvalidArgumentError
-    attr_reader :match
-
-    # @return [Object] true/false, or an optional help string to append
-    attr_reader :help
-
-    # @return [Boolean] true if this options argument value has been forced
-    attr_accessor :forced
-
-    # @return [Integer] The amount of times this option has been invoked
-    attr_accessor :count
-
-    # @param [Slop] slop
-    # @param [String, #to_s] short
-    # @param [String, #to_s] long
-    # @param [String] description
-    # @param [Boolean] argument
-    # @param [Hash] options
-    # @option options [Boolean] :optional
-    # @option options [Boolean] :argument
-    # @option options [Object] :default
-    # @option options [Proc, #call] :callback
-    # @option options [String, #to_s] :delimiter (',')
-    # @option options [Integer] :limit (0)
-    # @option options [Boolean] :tail (false)
-    # @option options [Regexp] :match
-    # @option options [String, #to_s] :unless
-    # @option options [Boolean, String] :help (true)
-    def initialize(slop, short, long, description, argument, options, &blk)
-      @slop = slop
-      @short_flag = short
-      @long_flag = long
-      @description = description
-      @argument = argument
-      @options = options
-
-      @tail = options[:tail]
-      @match = options[:match]
-      @delimiter = options.fetch(:delimiter, ',')
-      @limit = options.fetch(:limit, 0)
-      @help = options.fetch(:help, true)
-      @argument_type = options[:as].to_s.downcase
-
-      @forced = false
-      @argument_value = nil
-      @count = 0
-
-      @callback = blk if block_given?
-      @callback ||= options[:callback]
-
-      build_longest_flag
-    end
-
-    # @return [Boolean] true if this option expects an argument
-    def expects_argument?
-      @argument || @options[:argument] || @options[:optional] == false
-    end
-
-    # @return [Boolean] true if this option accepts an optional argument
-    def accepts_optional_argument?
-      @options[:optional]
-    end
-
-    # @return [String] either the long or short flag for this option
-    def key
-      @long_flag || @short_flag
-    end
-
-    # Set this options argument value.
-    #
-    # If this options argument type is expected to be an Array, this
-    # method will split the value and concat elements into the original
-    # argument value
-    #
-    # @param [Object] value The value to set this options argument to
-    def argument_value=(value)
-      if @argument_type == 'array'
-        @argument_value ||= []
-        if value.respond_to?(:to_str)
-          @argument_value.concat value.split(@delimiter, @limit)
-        end
-      else
-        @argument_value = value
-      end
-    end
-
-    # @return [Object] the argument value after it's been cast
-    #   according to the `:as` option
-    def argument_value
-      return @argument_value if @forced
-      value = @argument_value || @options[:default]
-      return if value.nil?
-
-      case @argument_type
-      when 'array'; @argument_value
-      when 'range'; value_to_range value
-      when 'float'; value.to_s.to_f
-      when 'string', 'str';  value.to_s
-      when 'symbol', 'sym';  value.to_s.to_sym
-      when 'integer', 'int'; value.to_s.to_i
-      else
-        value
-      end
-    end
-
-    # Force an argument value, used when the desired argument value
-    # is negative (false or nil)
-    #
-    # @param [Object] value
-    def force_argument_value(value)
-      @argument_value = value
-      @forced = true
-    end
-
-    # Execute the block or callback object associated with this Option
-    #
-    # @param [Object] The object to be sent to `:call`
-    def call(obj=nil)
-      @callback.call(obj) if @callback.respond_to?(:call)
-    end
-
-    # @param [Array] items The original array of objects passed to `Slop.new`
-    # @return [Boolean] true if this options `:unless` argument exists
-    #   inside *items*
-    def omit_exec?(items)
-      string = @options[:unless].to_s.sub(/\A--?/, '')
-      items.any? { |i| i.to_s.sub(/\A--?/, '') == string }
-    end
-
-    # This option in a nice pretty string, including a short flag, long
-    # flag, and description (if they exist).
-    #
-    # @see Slop#help
-    # @return [String]
-    def to_s
-      out = "    "
-      out += @short_flag ? "-#{@short_flag}, " : ' ' * 4
-
-      if @long_flag
-        out += "--#{@long_flag}"
-        if @help.respond_to? :to_str
-          out += " #{@help}"
-          size = @long_flag.size + @help.size + 1
-        else
-          size = @long_flag.size
-        end
-        diff = @slop.longest_flag - size
-        out += " " * (diff + 6)
-      else
-        out += " " * (@slop.longest_flag + 8)
-      end
-
-      "#{out}#{@description}"
-    end
-
-    # @return [String]
-    def inspect
-      "#<Slop::Option short_flag=#{@short_flag.inspect} " +
-      "long_flag=#{@long_flag.inspect} argument=#{@argument.inspect} " +
-      "description=#{@description.inspect}>"
-    end
-
-    private
-
-    def value_to_range(value)
-      case value.to_s
-      when /\A(-?\d+?)(?:\.\.|-|,)(-?\d+)\z/
-        $1.to_i .. $2.to_i
-      when /\A(-?\d+?)\.\.\.(-?\d+)\z/
-        $1.to_i ... $2.to_i
-      when /\A-?\d+\z/
-        value.to_i
-      else
-        value
-      end
-    end
-
-    def build_longest_flag
-      if @long_flag && @long_flag.size > @slop.longest_flag
-        if @help.respond_to? :to_str
-          @slop.longest_flag = @long_flag.size + @help.size
-        else
-          @slop.longest_flag = @long_flag.size
-        end
-      end
-    end
-  end
-end

data/lib/slop/options.rb

@@ -1,49 +0,0 @@
-class Slop
-  class Options < Array
-
-    # @param [Boolean] symbols true to cast hash keys to symbols
-    # @see Slop#to_hash
-    # @return [Hash]
-    def to_hash(symbols)
-      reduce({}) do |hsh, option|
-        key = option.key
-        key = key.to_sym if symbols
-        hsh[key] = option.argument_value
-        hsh
-      end
-    end
-
-    # Fetch an Option object. This method overrides Array#[] to provide
-    # a nicer interface for fetching options via their short or long flag.
-    # The reason we don't use a Hash here is because an option cannot be
-    # identified by a single label. Instead this method tests against
-    # a short flag first, followed by a long flag. When passing this
-    # method an Integer, it will work as an Array usually would, fetching
-    # the Slop::Option at this index.
-    #
-    # @param [Object] flag The short/long flag representing the option
-    # @example
-    #   opts = Slop.parse { on :v, "Verbose mode" }
-    #   opts.options[:v] #=> Option
-    #   opts.options[:v].description #=> "Verbose mode"
-    # @return [Option] the option assoiated with this flag
-    def [](flag)
-      if flag.is_a? Integer
-        super
-      else
-        find do |option|
-          [option.short_flag, option.long_flag].include? flag.to_s
-        end
-      end
-    end
-
-    # @see Slop#help
-    # @return [String] All options in a pretty help string
-    def to_help
-      heads = reject(&:tail)
-      tails = select(&:tail)
-      all = (heads + tails).select(&:help)
-      all.map(&:to_s).join("\n")
-    end
-  end
-end