slop 0.2.0 → 1.0.0.rc1

data/lib/slop/option.rb

@@ -1,190 +1,108 @@
 class Slop
-  class Option
-
-    # @return [Symbol,#to_s]
-    attr_reader :flag
-
-    # @return [Symbol,#to_s]
-    attr_reader :option
-
-    # @return [String]
-    attr_reader :description
-
-    # @return [Object]
-    attr_reader :default
-
-    # @return [Proc]
-    attr_reader :callback
-
-    # The maximum size of any --option, recorded for
-    # padding out any output string with smaller option lengths
-    # with the correct amount of whitespace
-    #
-    # @return [Fixnum]
-    @@max_option_size = 0
-
-    # @param [Hash] options Option attributes
-    # @option options [Symbol,#to_s] :flag
-    # @option options [Symbol,#to_s] :option
-    # @option options [Symbol,#to_s] :description
-    # @option options [Boolean] :argument
-    # @option options [Boolean] :optional
-    # @option options [Object] :default
-    # @option options [Object] :as
-    # @option options [Proc] :callback
-    # @option options [String,#to_s] :delimiter
-    # @option options [Integer] :limit
-    def initialize(options={}, &blk)
-      @options = options
-      @flag = options[:flag]
-      @option = options[:option] || options[:opt]
-      @description = options[:description] || options[:desc]
-      @argument = options[:argument] || false
-      @optional = options[:optional] || options[:optional_argument]
-      @argument ||= @optional
-      @default = options[:default]
-      @as = options[:as]
-      @callback = options[:callback]
-
-      # Array properties
-      @delimiter = options[:delimiter] || ','
-      @limit = options[:limit] || 0
-
-      @argument_value = nil
-
-      if @option
-        if requires_argument?
-          size = (@option.size * 2) + 4
-        else
-          size = @option.size + 2
-        end
-
-        @@max_option_size = size if @@max_option_size < size
+  class Options < Array
+    def to_hash
+      each_with_object({}) do |option, out|
+        out[option.key] = option.argument_value
       end
     end
 
-    # Set the argument value
-    # @param [Object] value
-    def argument_value=(value)
-      @argument_value = value
-    end
-
-    # @return [Object] the argument value after it's been cast
-    #   according to the `:as` option
-    def argument_value
-      @argument_value ||= @default
-      return unless @argument_value
-
-      case @as.to_s.downcase[0, 3]
-      when 'arr'; @argument_value.split(@delimiter, @limit)
-      when 'int'; @argument_value.to_i
-      when 'sym'; @argument_value.to_sym
+    def [](item)
+      item = item.to_s
+      if item =~ /^\d+/
+        super
       else
-        @argument_value
+        find do |option|
+          option.short_flag == item || option.long_flag == item
+        end
       end
     end
+  end
 
-    # @param [to_s] flag
-    # @return [Boolean] true if this option contains a flag
-    def has_flag?(flag)
-      @flag.to_s == flag.to_s
-    end
+  class Option
 
-    # @param [to_s] option
-    # @return [Boolean] true if this option contains an option label
-    def has_option?(option)
-      @option.to_s == option.to_s
-    end
+    attr_reader :short_flag
+    attr_reader :long_flag
+    attr_reader :description
+    attr_reader :callback
+    attr_writer :argument_value
 
-    # @return [Boolean] true if this option has a default value
-    def has_default?
-      !@default.nil?
-    end
+    @@longest_flag = 0
 
-    # @return [Boolean] true if this option has a switch value
-    def has_switch?
-      !!@options[:switch]
-    end
+    def initialize(short, long, description, argument, options={}, &block)
+      @short_flag, @long_flag = short, long
+      @description, @expects_argument = description, argument
+      @options = options
 
-    # @return [Boolean] true if the option has a callback
-    def has_callback?
-      !!@callback
-    end
+      if @long_flag && @long_flag.size > @@longest_flag
+        @@longest_flag = @long_flag.size
+      end
 
-    # execute this options callback
-    def execute_callback
-      @callback.call if has_callback?
+      @callback = block if block_given?
+      @callback ||= options[:callback]
+      @argument_value = nil
     end
 
-    # does the option require an argument?
-    # @return [Boolean]
-    def requires_argument?
-      !!@argument
+    def expects_argument?
+      @expects_argument || @options[:argument]
     end
 
-    # Is the argument optional?
-    # @return [Boolean]
-    def optional_argument?
+    def accepts_optional_argument?
       @options[:optional]
     end
 
-    # @return
-    def [](key)
-      @options[key]
-    end
-
-    # Replace options argument value with the switch value supplied, used
-    # when supplying the `switch` option making switch flags easy to alter
-    #
-    # @example
-    #   option :v, :verbose, :default => false, :switch => true
-    #
-    # Now when the `-v` or `--verbose` option is supplied, verbose will
-    # be set to `true`, rather than the default `false` option
-    def switch_argument_value
-      @argument_value = @options[:switch]
+    def has_callback?
+      !!@callback && @callback.respond_to?(:call)
     end
 
-    # return a key for an option, prioritize
-    # option before flag as it's more descriptive
     def key
-      @option || @flag
+      @long_flag || @short_flag
     end
 
-    def to_s
-      str = "\t"
+    def default
+      @options[:default]
+    end
 
-      if @flag
-        str << "-#{@flag}"
+    def argument_value
+      value = @argument_value || default
+      return unless value
+
+      case @options[:as].to_s
+      when 'Array'
+        value.split(@options[:delimiter] || ',', @options[:limit] || 0)
+      when 'String';  value.to_s
+      when 'Symbol';  value.to_s.to_sym
+      when 'Integer'; value.to_i
+      when 'Float';   value.to_f
       else
-        str << " " * 4
+        value
       end
+    end
 
-      if @option
-        str << ", " if @flag
-        optionstr = "--#{@option}"
+    def to_s
+      out = "    "
+      out += @short_flag ?  "-#{@short_flag}, " : ' ' * 4
 
-        if requires_argument?
-          if optional_argument?
-            optionstr << " [#{@option}]"
-          else
-            optionstr << " <#{@option}>"
-          end
-        end
-        size_diff = @@max_option_size - ((@option.size * 2) + 4)
-        optionstr << " " * size_diff if size_diff > 0
-        str << optionstr
+      out += "--#{@long_flag}" if @long_flag
+
+      if @long_flag
+        diff = @@longest_flag - @long_flag.size
+        spaces = " " * (diff + 6)
+        out += spaces
       else
-        str << " " * (@@max_option_size + 2)
+        spaces = " " * (@@longest_flag + 8)
+        out += spaces
       end
 
-      str << "\t\t#{@description}" if @description
-      str
+      out += @description if @description
+
+      out
     end
 
     def inspect
-      "#<#{self.class}: #{@options}>"
+      "#<Slop::Option short_flag=#{@short_flag.inspect} " +
+      "long_flag=#{@long_flag.inspect} " +
+      "description=#{@description.inspect} "
     end
-
   end
-end
+
+end

data/lib/slop/version.rb

@@ -0,0 +1,3 @@
+class Slop
+  VERSION = '1.0.0.rc1'
+end

data/slop.gemspec

@@ -0,0 +1,17 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'slop/version'
+
+Gem::Specification.new do |s|
+  s.name = 'slop'
+  s.version = Slop::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Option gathering made easy'
+  s.description = 'A simple DSL for gathering options and parsing the command line'
+  s.author = 'Lee Jarvis'
+  s.email = 'lee@jarvis.co'
+  s.homepage = 'http://github.com/injekt/slop'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.require_paths = ["lib"]
+end

data/test/helper.rb

@@ -0,0 +1,14 @@
+class TestCase < MiniTest::Unit::TestCase
+  def self.test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/, '_')}".to_sym
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} is already defined in #{self}" if defined
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        flunk "No implementation provided for #{name}"
+      end
+    end
+  end
+end

data/test/option_test.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/helper'
+
+class OptionTest < TestCase
+  def option(*args, &block)
+    Slop.new.option(*args, &block)
+  end
+
+  def option_with_argument(*args, &block)
+    options = args.shift
+    slop = Slop.new
+    option = slop.opt(*args)
+    slop.parse(options)
+    slop.find {|opt| opt.key == option.key }
+  end
+
+  def option_value(*args, &block)
+    option_with_argument(*args, &block).argument_value
+  end
+
+  test 'expects an argument if argument is true' do
+    assert option(:f, :foo, 'foo', true).expects_argument?
+    assert option(:f, :argument => true).expects_argument?
+
+    refute option(:f, :foo).expects_argument?
+  end
+
+  test 'accepts an optional argument if optional is true' do
+    assert option(:f, :optional => true).accepts_optional_argument?
+    assert option(:f, false, :optional => true).accepts_optional_argument?
+
+    refute option(:f, true).accepts_optional_argument?
+  end
+
+  test 'has a callback when passed a block or callback option' do
+    assert option(:f){}.has_callback?
+    assert option(:callback => proc {}).has_callback?
+
+    refute option(:f).has_callback?
+  end
+
+  test 'splits argument_value with :as => array' do
+    assert_equal %w/lee john bill/, option_value(
+      %w/--people lee,john,bill/, :people, true, :as => Array
+    )
+
+    assert_equal %w/lee john bill/, option_value(
+      %w/--people lee:john:bill/,
+      :people, true, :as => Array, :delimiter => ':'
+    )
+
+    assert_equal ['lee', 'john,bill'], option_value(
+      %w/--people lee,john,bill/,
+      :people, true, :as => Array, :limit => 2
+    )
+
+    assert_equal ['lee', 'john:bill'], option_value(
+      %w/--people lee:john:bill/,
+      :people, true, :as => Array, :limit => 2, :delimiter => ':'
+    )
+  end
+
+  test 'returns a symbol with :as => Symbol' do
+    assert_equal :foo, option_value(%w/--name foo/, :name, true, :as => Symbol)
+  end
+
+  test 'returns an integer with :as => Integer' do
+    assert_equal 30, option_value(%w/--age 30/, :age, true, :as => Integer)
+  end
+
+  test 'printing options' do
+    slop = Slop.new
+    slop.opt :n, :name, 'Your name', true
+    slop.opt :age, 'Your age', true
+    slop.opt :V, 'Display the version'
+
+    assert_equal "    -n, --name      Your name", slop.options[:name].to_s
+    assert_equal "        --age       Your age", slop.options[:age].to_s
+    assert_equal "    -V,             Display the version", slop.options[:V].to_s
+  end
+end

data/test/slop_test.rb

@@ -0,0 +1,113 @@
+require File.dirname(__FILE__) + '/helper'
+
+class SlopTest < TestCase
+  def clean_options(*args)
+    Slop.new.send(:clean_options, args)
+  end
+
+  def parse(items, &block)
+    Slop.parse(items, &block)
+  end
+
+  test 'includes Enumerable' do
+    assert Slop.included_modules.include?(Enumerable)
+  end
+
+  test 'parse returns a Slop object' do
+    slop = Slop.parse([])
+    assert_kind_of Slop, slop
+  end
+
+  test 'enumerating options' do
+    slop = Slop.new
+    slop.opt(:f, :foo, 'foo')
+    slop.opt(:b, :bar, 'bar')
+
+    slop.each { |option| assert option }
+  end
+
+  test 'parsing options' do
+
+  end
+
+  test '#parse does not remove parsed items' do
+    items = %w/--foo/
+    Slop.new { |opt| opt.on :foo }.parse(items)
+    assert_equal %w/--foo/, items
+  end
+
+  test '#parse! removes parsed items' do
+    items = %w/--foo/
+    Slop.new { |opt| opt.on :foo }.parse!(items)
+    assert_empty items
+  end
+
+  test 'the shit out of clean_options' do
+    assert_equal(
+      ['s', 'short', 'short option', false],
+      clean_options('-s', '--short', 'short option')
+    )
+
+    assert_equal(
+      [nil, 'long', 'long option only', true],
+      clean_options('--long', 'long option only', true)
+    )
+
+    assert_equal(
+      ['S', 'symbol', 'symbolize', false],
+      clean_options(:S, :symbol, 'symbolize')
+    )
+
+    assert_equal(
+      ['a', nil, 'alphabetical only', true],
+      clean_options('a', 'alphabetical only', true)
+    )
+
+    assert_equal( # for description-less options
+      [nil, 'optiononly', nil, false],
+      clean_options('--optiononly')
+    )
+
+    assert_equal(['c', nil, nil, true], clean_options(:c, true))
+    assert_equal(['c', nil, nil, false], clean_options(:c, false))
+  end
+
+  test '[] returns an options argument value or nil' do
+    slop = Slop.new
+    slop.opt :n, :name, true
+    slop.parse %w/--name lee/
+
+    assert_equal 'lee', slop[:name]
+    assert_equal 'lee', slop[:n]
+  end
+
+  test 'arguments ending ? test for option existance' do
+    slop = Slop.new
+    slop.opt :v, :verbose
+    slop.opt :d, :debug
+    slop.parse %w/--verbose/
+
+    assert slop[:verbose]
+    assert slop.verbose?
+
+    refute slop[:debug]
+    refute slop.debug?
+  end
+
+  test 'raises if an option expects an argument and none is given' do
+    slop = Slop.new
+    slop.opt :name, true
+    slop.opt :age, :optional => true
+
+    assert_raises(Slop::MissingArgumentError, /name/) { slop.parse %w/--name/ }
+    assert slop.parse %w/--name 'foo'/
+  end
+
+  test 'printing help' do
+    slop = Slop.new
+    slop.banner = 'Usage: foo [options]'
+    slop.parse
+
+    assert slop.to_s =~ /^Usage: foo/
+  end
+end