slop 3.6.0 → 4.0.0

data/lib/slop/parser.rb

@@ -0,0 +1,111 @@
+module Slop
+  class Parser
+
+    # Our Options instance.
+    attr_reader :options
+
+    # A Hash of configuration options.
+    attr_reader :config
+
+    # Returns an Array of String arguments that were not parsed.
+    attr_reader :arguments
+
+    def initialize(options, **config)
+      @options = options
+      @config  = config
+      reset
+    end
+
+    # Reset the parser, useful to use the same instance to parse a second
+    # time without duplicating state.
+    def reset
+      @arguments = []
+      @options.each(&:reset)
+      self
+    end
+
+    # Traverse `strings` and process options one by one. Anything after
+    # `--` is ignored. If a flag includes a equals (=) it will be split
+    # so that `flag, argument = s.split('=')`.
+    #
+    # The `call` method will be executed immediately for each option found.
+    # Once all options have been executed, any found options will have
+    # the `finish` method called on them.
+    #
+    # Returns a Slop::Result.
+    def parse(strings)
+      pairs = strings.each_cons(2).to_a
+      # this ensures we still support the last string being a flag,
+      # otherwise it'll only be used as an argument.
+      pairs << [strings.last, nil]
+
+      @arguments = strings.dup
+
+      pairs.each do |flag, arg|
+        # ignore everything after '--', flag or not
+        break if !flag || flag == '--'
+
+        # support `foo=bar`
+        if flag.include?("=")
+          flag, arg = flag.split("=")
+        end
+
+        if opt = try_process(flag, arg)
+          # since the option was parsed, we remove it from our
+          # arguments (plus the arg if necessary)
+          arguments.delete(flag)
+          arguments.delete(arg) if opt.expects_argument?
+        end
+      end
+
+      Result.new(self).tap do |result|
+        used_options.each { |o| o.finish(result) }
+      end
+    end
+
+    # Returns an Array of Option instances that were used.
+    def used_options
+      options.select { |o| o.count > 0 }
+    end
+
+    # Returns an Array of Option instances that were not used.
+    def unused_options
+      options.to_a - used_options
+    end
+
+    private
+
+    # We've found an option, process and return it
+    def process(option, arg)
+      option.ensure_call(arg)
+      option
+    end
+
+    # Try and find an option to process
+    def try_process(flag, arg)
+      if option = matching_option(flag)
+        process(option, arg)
+      elsif flag =~ /\A-[^-]/ && flag.size > 2
+        # try and process as a set of grouped short flags. drop(1) removes
+        # the prefixed -, then we add them back to each flag separately.
+        flags = flag.split("").drop(1).map { |f| "-#{f}" }
+        last  = flags.pop
+
+        flags.each { |f| try_process(f, nil) }
+        try_process(last, arg) # send the argument to the last flag
+      else
+        if flag.start_with?("-") && !suppress_errors?
+          raise UnknownOption, "unknown option `#{flag}'"
+        end
+      end
+    end
+
+    def suppress_errors?
+      config[:suppress_errors]
+    end
+
+    def matching_option(flag)
+      options.find { |o| o.flags.include?(flag) }
+    end
+  end
+end

data/lib/slop/result.rb

@@ -0,0 +1,79 @@
+module Slop
+  # This class encapsulates a Parser and Options pair. The idea is that
+  # the Options class shouldn't have to deal with what happens when options
+  # are parsed, and the Parser shouldn't have to deal with the state of
+  # options once parsing is complete. This keeps the API really simple; A
+  # Parser parses, Options handles options, and this class handles the
+  # result of those actions. This class contains the important most used
+  # methods.
+  class Result
+    attr_reader :parser, :options
+
+    def initialize(parser)
+      @parser  = parser
+      @options = parser.options
+    end
+
+    # Returns an options value, nil if the option does not exist.
+    def [](flag)
+      (o = option(flag)) && o.value
+    end
+    alias get []
+
+    # Returns an Option if it exists. Ignores any prefixed hyphens.
+    def option(flag)
+      cleaned = -> (f) { f.to_s.sub(/\A--?/, '') }
+      options.find do |o|
+        o.flags.any? { |f| cleaned.(f) == cleaned.(flag) }
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      if respond_to_missing?(name)
+        (o = option(name.to_s.chomp("?"))) && used_options.include?(o)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name.to_s.end_with?("?") || super
+    end
+
+    # Returns an Array of Option instances that were used.
+    def used_options
+      parser.used_options
+    end
+
+    # Returns an Array of Option instances that were not used.
+    def unused_options
+      parser.unused_options
+    end
+
+    # Example:
+    #
+    #   opts = Slop.parse do |o|
+    #     o.string '--host'
+    #     o.int '-p'
+    #   end
+    #
+    #   # ruby run.rb connect --host 123 helo
+    #   opts.arguments #=> ["connect", "helo"]
+    #
+    # Returns an Array of String arguments that were not parsed.
+    def arguments
+      parser.arguments
+    end
+    alias args arguments
+
+    # Returns a hash with option key => value.
+    def to_hash
+      Hash[options.reject(&:null?).map { |o| [o.key, o.value] }]
+    end
+    alias to_h to_hash
+
+    def to_s(**opts)
+      options.to_s(**opts)
+    end
+  end
+end

data/lib/slop/types.rb

@@ -0,0 +1,52 @@
+module Slop
+  class StringOption < Option
+    def call(value)
+      value.to_s
+    end
+  end
+
+  class BoolOption < Option
+    def call(_value)
+      true
+    end
+
+    def default_value
+      config[:default] || false
+    end
+
+    def expects_argument?
+      false
+    end
+  end
+  BooleanOption = BoolOption
+
+  class IntegerOption < Option
+    def call(value)
+      value =~ /\A\d+\z/ && value.to_i
+    end
+  end
+  IntOption = IntegerOption
+
+  class ArrayOption < Option
+    def call(value)
+      @value ||= []
+      @value.concat value.split(delimiter)
+    end
+
+    def default_value
+      config[:default] || []
+    end
+
+    def delimiter
+      config[:delimiter] || ","
+    end
+  end
+
+  # an option that discards the return value
+  class NullOption < BoolOption
+    def null?
+      true
+    end
+  end
+
+end

data/slop.gemspec

@@ -1,8 +1,11 @@
+$:.unshift './lib'
+require 'slop'
+
 Gem::Specification.new do |s|
   s.name        = 'slop'
-  s.version     = '3.6.0'
+  s.version     = Slop::VERSION
   s.summary     = 'Simple Lightweight Option Parsing'
-  s.description = 'A simple DSL for gathering options and parsing the command line'
+  s.description = 'A DSL for gathering options and parsing command line flags'
   s.author      = 'Lee Jarvis'
   s.email       = 'ljjarvis@gmail.com'
   s.homepage    = 'http://github.com/leejarvis/slop'
@@ -10,7 +13,7 @@ Gem::Specification.new do |s|
   s.test_files  = `git ls-files -- test/*`.split("\n")
   s.license     = 'MIT'
 
-  s.required_ruby_version = '>= 1.8.7'
+  s.required_ruby_version = '>= 2.0.0'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'minitest', '~> 5.0.0'

data/test/error_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+# All raised errors tested here
+
+describe Slop::MissingArgument do
+  it "raises when an argument is missing" do
+    opts = Slop::Options.new
+    opts.string "-n", "--name"
+    assert_raises(Slop::MissingArgument) { opts.parse %w(--name) }
+  end
+
+  it "does not raise when errors are suppressed" do
+    opts = Slop::Options.new(suppress_errors: true)
+    opts.string "-n", "--name"
+    opts.parse %w(--name)
+  end
+end
+
+describe Slop::UnknownOption do
+  it "raises when an option is unknown" do
+    opts = Slop::Options.new
+    opts.string "-n", "--name"
+    assert_raises(Slop::UnknownOption) { opts.parse %w(--foo) }
+  end
+
+  it "does not raise when errors are suppressed" do
+    opts = Slop::Options.new(suppress_errors: true)
+    opts.string "-n", "--name"
+    opts.parse %w(--foo)
+  end
+end

data/test/option_test.rb

@@ -1,145 +1,24 @@
-require 'helper'
+require 'test_helper'
 
-class OptionTest < TestCase
-  def option(*args, &block)
-    Slop.new.on(*args, &block)
+describe Slop::Option do
+  def option(*args)
+    Slop::Option.new(*args)
   end
 
-  def option_with_argument(*args, &block)
-    options = args.shift
-    slop = Slop.new
-    option = slop.opt(*args)
-    slop.parse(options)
-    slop.options.find {|opt| opt.key == option.key }
+  describe "#flag" do
+    it "returns the flags joined by a comma" do
+      assert_equal "-f, --bar", option(%w(-f --bar), nil).flag
+      assert_equal "--bar", option(%w(--bar), nil).flag
+    end
   end
 
-  def option_value(*args, &block)
-    option_with_argument(*args, &block).value
-  end
-
-  test "expects_argument?" do
-    assert option(:f=).expects_argument?
-    assert option(:foo=).expects_argument?
-    assert option(:foo, :argument => true).expects_argument?
-  end
-
-  test "accepts_optional_argument?" do
-    refute option(:f=).accepts_optional_argument?
-    assert option(:f=, :argument => :optional).accepts_optional_argument?
-    assert option(:f, :optional_argument => true).accepts_optional_argument?
-  end
-
-  test "key" do
-    assert_equal 'foo', option(:foo).key
-    assert_equal 'foo', option(:f, :foo).key
-    assert_equal 'f', option(:f).key
-  end
-
-  test "call" do
-    foo = nil
-    option(:f, :callback => proc { foo = "bar" }).call
-    assert_equal "bar", foo
-    option(:f) { foo = "baz" }.call
-    assert_equal "baz", foo
-    option(:f) { |o| assert_equal 1, o }.call(1)
-  end
-
-  # type casting
-
-  test "proc/custom type cast" do
-    assert_equal 1, option_value(%w'-f 1', :f=, :as => proc {|x| x.to_i })
-    assert_equal "oof", option_value(%w'-f foo', :f=, :as => proc {|x| x.reverse })
-  end
-
-  test "integer type cast" do
-    opts = Slop.new
-    opts.on :f=, :as => Integer
-    opts.parse %w'-f 1'
-    assert_equal 1, opts[:f]
-
-    opts = Slop.new(:strict => true) { on :r=, :as => Integer }
-    assert_raises(Slop::InvalidArgumentError) { opts.parse %w/-r abc/ }
-  end
-
-  test "float type cast" do
-    opts = Slop.new(:strict => true) { on :r=, :as => Float }
-    assert_raises(Slop::InvalidArgumentError) { opts.parse %w/-r abc/ }
-  end
-
-  test "symbol type cast" do
-    assert_equal :foo, option_value(%w'-f foo', :f=, :as => Symbol)
-  end
-
-  test "range type cast" do
-    assert_equal((1..10), option_value(%w/-r 1..10/, :r=, :as => Range))
-    assert_equal((1..10), option_value(%w/-r 1-10/, :r=, :as => Range))
-    assert_equal((1..10), option_value(%w/-r 1,10/, :r=, :as => Range))
-    assert_equal((1...10), option_value(%w/-r 1...10/, :r=, :as => Range))
-    assert_equal((-1..10), option_value(%w/-r -1..10/, :r=, :as => Range))
-    assert_equal((1..-10), option_value(%w/-r 1..-10/, :r=, :as => Range))
-    assert_equal((1..1), option_value(%w/-r 1/, :r=, :as => Range))
-    assert_equal((-1..10), option_value(%w/-r -1..10/, :r, :as => Range, :optional_argument => true))
-
-    opts = Slop.new(:strict => true) { on :r=, :as => Range }
-    assert_raises(Slop::InvalidArgumentError) { opts.parse %w/-r abc/ }
-  end
-
-  test "array type cast" do
-    assert_equal %w/lee john bill/, option_value(%w/-p lee,john,bill/, :p=, :as => Array)
-    assert_equal %w/lee john bill jeff jill/, option_value(%w/-p lee,john,bill -p jeff,jill/, :p=, :as => Array)
-    assert_equal %w/lee john bill/, option_value(%w/-p lee:john:bill/, :p=, :as => Array, :delimiter => ':')
-    assert_equal %w/lee john,bill/, option_value(%w/-p lee,john,bill/, :p=, :as => Array, :limit => 2)
-    assert_equal %w/lee john:bill/, option_value(%w/-p lee:john:bill/, :p=, :as => Array, :limit => 2, :delimiter => ':')
-  end
-
-  test "regexp type cast" do
-    assert_equal Regexp.new("foo"), option_value(%w/-p foo/, :p=, :as => Regexp)
-  end
-
-  test "adding custom types" do
-    opts = Slop.new
-    opt = opts.on :f=, :as => :reverse
-    opt.types[:reverse] = proc { |v| v.reverse }
-    opts.parse %w'-f bar'
-    assert_equal 'rab', opt.value
-  end
-
-  test "count type" do
-    assert_equal 3, option_value(%w/-c -c -c/, :c, :as => :count)
-    assert_equal 0, option_value(%w/-a -b -z/, :c, :as => :count)
-    assert_equal 3, option_value(%w/-vvv/, :v, :as => :count)
-  end
-
-  # end type casting tests
-
-  test "using a default value as fallback" do
-    opts = Slop.new
-    opts.on :f, :argument => :optional, :default => 'foo'
-    opts.parse %w'-f'
-    assert_equal 'foo', opts[:f]
-  end
-
-  test "printing options" do
-    slop = Slop.new
-    slop.opt :n, :name=, 'Your name'
-    slop.opt :age=, 'Your age'
-    slop.opt :V, 'Display the version'
-
-    assert_equal "    -n, --name      Your name", slop.fetch_option(:name).to_s
-    assert_equal "        --age       Your age", slop.fetch_option(:age).to_s
-    assert_equal "    -V,             Display the version", slop.fetch_option(:V).help
-  end
-
-  test "printing options that have defaults" do
-    opts = Slop.new
-    opts.on :n, :name=, 'Your name', :default => 'Lee'
-
-    assert_equal "    -n, --name      Your name (default: Lee)", opts.fetch_option(:name).to_s
-  end
+  describe "#key" do
+    it "uses the last flag and strips trailing hyphens" do
+      assert_equal :foo, option(%w(-f --foo), nil).key
+    end
 
-  test "overwriting the help text" do
-    slop = Slop.new
-    slop.on :foo, :help => '    -f, --foo  SOMETHING FOOEY'
-    assert_equal '    -f, --foo  SOMETHING FOOEY', slop.fetch_option(:foo).help
+    it "can be overridden" do
+      assert_equal :bar, option(%w(-f --foo), nil, key: "bar").key
+    end
   end
 end