[DRE-commits] [pry] 01/06: Embed a copy of ruby-slop 3.x (Closes: #794657)

Antonio Terceiro terceiro at moszumanska.debian.org
Wed Aug 19 23:04:08 UTC 2015


This is an automated email from the git hooks/post-receive script.

terceiro pushed a commit to branch master
in repository pry.

commit bf0cdf29889e1ab34defc6987ec95b040883fa34
Author: Antonio Terceiro <terceiro at debian.org>
Date:   Thu Aug 20 00:21:49 2015 +0200

    Embed a copy of ruby-slop 3.x (Closes: #794657)
---
 debian/changelog                        |   7 +
 debian/copyright                        |   4 +
 debian/patches/series                   |   1 +
 debian/patches/use-embedded-pry.patch   |  11 +
 debian/rules                            |   4 +
 debian/slop-3.6.0/.gitignore            |   7 +
 debian/slop-3.6.0/.travis.yml           |   9 +
 debian/slop-3.6.0/CHANGES.md            | 309 ++++++++++++++
 debian/slop-3.6.0/Gemfile               |   3 +
 debian/slop-3.6.0/LICENSE               |  20 +
 debian/slop-3.6.0/README.md             | 202 ++++++++++
 debian/slop-3.6.0/Rakefile              |  29 ++
 debian/slop-3.6.0/lib/slop.rb           | 687 ++++++++++++++++++++++++++++++++
 debian/slop-3.6.0/lib/slop/commands.rb  | 196 +++++++++
 debian/slop-3.6.0/lib/slop/option.rb    | 214 ++++++++++
 debian/slop-3.6.0/metadata.yml          |  90 +++++
 debian/slop-3.6.0/slop.gemspec          |  17 +
 debian/slop-3.6.0/test/commands_test.rb |  26 ++
 debian/slop-3.6.0/test/helper.rb        |  12 +
 debian/slop-3.6.0/test/option_test.rb   | 145 +++++++
 debian/slop-3.6.0/test/slop_test.rb     | 518 ++++++++++++++++++++++++
 21 files changed, 2511 insertions(+)

diff --git a/debian/changelog b/debian/changelog
index b5bb1f6..b90eee4 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,10 @@
+pry (0.10.1-2) UNRELEASED; urgency=medium
+
+  * Team upload.
+  * Embed a copy of ruby-slop 3.x (Closes: #794657)
+
+ -- Antonio Terceiro <terceiro at debian.org>  Thu, 20 Aug 2015 00:20:40 +0200
+
 pry (0.10.1-1) unstable; urgency=medium
 
   * Team upload
diff --git a/debian/copyright b/debian/copyright
index 8f4a002..0706eba 100644
--- a/debian/copyright
+++ b/debian/copyright
@@ -6,6 +6,10 @@ Files: *
 Copyright: 2012-2013 John Mair (banisterfiend)
 License: Expat
 
+Files: debian/slop-3.6.0/*
+Copyright: 2012 Lee Jarvis
+License: Expat
+
 Files: debian/*
 Copyright: 2012-2014 Youhei SASAKI <uwabami at gfd-dennou.org>
            2014 Jonas Genannt <jonas.genannt at capi2name.de>
diff --git a/debian/patches/series b/debian/patches/series
index ed3892b..1e52c76 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,3 +1,4 @@
 0001-Import-upstream-rspec-files.patch
 0002-Modify-upstream-spec-for-Debian-Package.patch
 dont-try-to-write-outside-build-dir
+use-embedded-pry.patch
diff --git a/debian/patches/use-embedded-pry.patch b/debian/patches/use-embedded-pry.patch
new file mode 100644
index 0000000..8911ac4
--- /dev/null
+++ b/debian/patches/use-embedded-pry.patch
@@ -0,0 +1,11 @@
+--- a/lib/pry.rb
++++ b/lib/pry.rb
+@@ -125,7 +125,7 @@ require 'method_source'
+ require 'shellwords'
+ require 'stringio'
+ require 'coderay'
+-require 'slop'
++require 'pry/slop'
+ require 'rbconfig'
+ require 'tempfile'
+ require 'pathname'
diff --git a/debian/rules b/debian/rules
index 07664bc..6b670e2 100755
--- a/debian/rules
+++ b/debian/rules
@@ -14,6 +14,10 @@ override_dh_auto_build:
 	touch $(CURDIR)/spec/fixtures/slinky/slinky.rb
 	dh_auto_build
 
+override_dh_auto_install:
+	dh_install debian/slop-3.6.0/lib/* usr/lib/ruby/vendor_ruby/pry
+	dh_auto_install
+
 override_dh_auto_clean:
 	dh_auto_clean
 	rm -fr $(CURDIR)/spec/fixtures/cat_load_path
diff --git a/debian/slop-3.6.0/.gitignore b/debian/slop-3.6.0/.gitignore
new file mode 100644
index 0000000..e20dac6
--- /dev/null
+++ b/debian/slop-3.6.0/.gitignore
@@ -0,0 +1,7 @@
+.rvmrc
+.yardoc
+doc
+*.swp
+*.gem
+*.rbc
+Gemfile.lock
diff --git a/debian/slop-3.6.0/.travis.yml b/debian/slop-3.6.0/.travis.yml
new file mode 100644
index 0000000..6fba0ce
--- /dev/null
+++ b/debian/slop-3.6.0/.travis.yml
@@ -0,0 +1,9 @@
+rvm:
+  - 1.9.3
+  - 2.1
+  - ruby-head
+  - jruby-19mode
+notifications:
+  email:
+    on_success: change
+    on_failure: always
diff --git a/debian/slop-3.6.0/CHANGES.md b/debian/slop-3.6.0/CHANGES.md
new file mode 100644
index 0000000..c500beb
--- /dev/null
+++ b/debian/slop-3.6.0/CHANGES.md
@@ -0,0 +1,309 @@
+3.6.0 (2014-06-18)
+------------------
+
+* Add example of rest arguments usage in the readme file #139
+* Default values on options are printed in the help message #134
+
+3.5.0 (2014-03-12)
+------------------
+
+* Add support for `as: Regexp` #132
+
+3.4.7 (2013-11-14)
+------------------
+
+* Ensure trash is cleared on every parse so you can parse multiple
+  times with the same instance (#130)
+
+3.4.5 (2013-05-14)
+------------------
+
+* Allow specifying long options starting with numbers (#110, Peter Zotov)
+* Ensure short-options still consume trailing arguments, ie `-abc foo`
+  should assign `foo` to the option `c` if it expects an argument (#114).
+
+3.4.4 (2013-03-12)
+------------------
+
+* Disable the run callback when the help option is used and `-h`
+  or `--help` is passed. #106
+* Ensure default `--help` option exits by default (#107, Autumn Perrault).
+
+3.4.3 (2013-01-14)
+------------------
+
+* Ensure `parse!` removes commands and their options.
+
+3.4.2 (2013-01-14)
+------------------
+
+* Expose the Hash commands as public API.
+* Deprecated `Slop.optspec`.
+* Ensure help output prints to stdout, not stderr.
+
+3.4.1 (2013-01-13)
+------------------
+
+* Ensure options replace any existing duplicates
+* Command config options now inherit config options from top level Slop.
+* Command help output now adds command in usage string.
+
+3.4.0 (2013-01-12)
+------------------
+
+* Implement new command system (#95)
+* Deprecate Slop::Commands
+* Ensure 'no-foo' options are not inverted when parsing '--no-foo' (#86)
+* Code refactoring and simplification (Kenichi Kamiya, #84, #85)
+
+3.3.3 (2012-08-29)
+------------------
+
+* Ensure autocreate arguments are not created as options (#77)
+* Ensure options are not swallowed when using short options with argument
+  included (#74)
+
+3.3.2 (2012-06-26)
+------------------
+
+* Ensure multiple options are not executed unless they exist (#70)
+
+3.3.1 (2012-05-31)
+------------------
+
+* Stop multiple switches from trashing arguments (Conrad Irwin, #66)
+
+3.3.0 (2012-05-30)
+------------------
+
+* Fix `:as => :count` when using multiple switches.
+* Ensure range typecast allows negative range values.
+* Ignore nil objects send to #parse instead of choking.
+
+3.2.0 (2012-05-15)
+------------------
+
+* Ensure boolean options appear correctly in `to_hash` output. (#59)
+
+3.1.1 (2012-04-24)
+------------------
+
+* Ensure separators before any options are still being processed (#62)
+
+3.1.0 (2012-04-23)
+------------------
+
+* Allow options to be fetched via underscores instead of dashes
+  (as a fallback) (Eric Anderson, #51)
+* Added `Slop#strict?` method.
+* Added strict checks for Integer/Float type casting. (Amon Sha)
+* Ensure separators are not replacing existing separators (#61)
+
+3.0.4 (2012-01-31)
+------------------
+
+* Ensure `option=argument` syntax does not consume following arguments (#55).
+
+3.0.3 (2012-01-30)
+------------------
+
+* Ensure options passed after option terminator do not raise an exception
+  (#54, Amon Sha)
+
+3.0.2 (2012-01-27)
+------------------
+
+* Ensure `--option=value` is being evaluated before multiple switches (#52)
+
+3.0.1 (2012-01-27)
+------------------
+
+* Ensure tests run green on 1.8.7
+* Ensure `:argument => :optional` works with `:option=` format.
+* Ruby 1.8.7 compat fix (dont chain Enumerable methods!) (Eric Anderson)
+
+3.0.0 (2012-01-24)
+------------------
+
+* value_to_range returns an x..x range if the value looks like an integer.
+* Lots of code refactoring
+* Use TomDoc documentation
+* Added `Slop::Commands` and removed existing command system
+* Configuration options altered:
+	* `:optional` has been renamed to `:optional_argument`
+	* Added `:required` for mandatory options
+	* `:argument` now accepts an `:optional` symbol as well as boolean value
+* Removed Slop instance methods:
+	* description=, description
+	* summary=, summary
+	* command
+	* on_empty
+	* on_noopts
+	* execute
+	* to_struct
+* Added Slop instance methods:
+	* separator
+	* fetch_option
+	* add_callback
+
+2.4.3 (2012-01-16)
+------------------
+
+* Allow the `:as` option to accept an object responding to :call for
+  custom type conversions (#45)
+* Ensure negative integers are not parsed as possible options (#46)
+
+2.4.2 (2011-12-18)
+------------------
+
+* Fix checking of required options (Dominik Honnef)
+
+2.4.1 (2011-12-08)
+------------------
+
+* Ensure optional arguments are returned correctly
+
+2.4.0 (2011-11-26)
+------------------
+
+* Avoid `define_method` for checking an options presence (and caching it) #37
+* Ensure the short option allows an appended `=` for accepting arguments
+* Implement `respond_to?`
+
+2.3.1 (2011-11-11)
+------------------
+
+* Return `nil` for any options using casting which don't expect arguments (#33)
+* Fix parenthesis warning on 1.8.7 (@shevegen)
+* Ensure long argument is a string before attempting to use `#[]` method on it
+
+2.3.0 (2011-11-04)
+------------------
+
+* Allow flags to have suffixed `=` char for options which accept an argument
+
+2.2.0 (2011-11-02)
+------------------
+
+* Support `bup.options` style optspec parsing
+    * http://apenwarr.ca/log/?m=201111
+
+* Allow `:as` to accept a `count` value (Conrad Irwin):
+
+    `on :v, :verbose, :as => :count # -vv; opts[:verbose] #=> 2`
+
+2.1.0 (2011-08-03)
+------------------
+
+* Added `Slop#missing` for returning a list of missing options parsed
+* Allow `Slop#present?` to accept multiple arguments
+* Added `:all_accept_arguments` to Slop configuration options, this saves
+  having to specify that every option takes an argument
+* Added `Slop#to_struct` for building new classes from options
+
+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)
+------------------
+
+* Ensure optional items with no arguments still return true when searching
+  for presence
+
+1.9.0 (2011-06-15)
+------------------
+
+* Add command completion and support for an error message when ambiguous
+  commands are used
+* Add command aliases
+* Fix: Ensure parsed elements are removed from original arguments when using
+  `:multiple_switches`
+* Ensure anything after `--` is parsed as an argument and not option even
+  if prefixed with `/--?/`
+* Performance improvements when making many calls to `Slop#option?` for
+  checking an options presence (Rob Gleeson)
+* Ensure `execute` passes command arguments to the block
+* Support for summary and description (Denis Defreyne)
+
+1.8.0 (2011-06-12)
+------------------
+
+* Added `execute` method to Slop for commands. This block will be invoked
+  when a specific command is used. The Slop object will be yielded to the
+  block
+* Allow passing a class name to `on` to be used as an `:as` option. ie:
+  `on :people, 'Some people', Array`
+* Get smart with parsing options optparse style: `on '--name NAME'` and
+  `on 'password [OPTIONAL]'`
+* Feature: `:arguments` setting to enable argument passing for all options
+
+1.7.0 (2011-06-06)
+------------------
+
+* Feature: Autocreate (auto create options at parse time, making assumptions)
+* Feature: When parsing options as arrays, push multiple arguments into a
+  single array
+
+1.6.1 (2011-06-01)
+------------------
+
+* Fix tests and using a temporary Array for ARGV, fixes RubyGems Test issues
+* General cleanup of code
+
+1.6.0 (2011-05-18)
+------------------
+
+* Add `:ignore_case` to Slop options for case insensitive option matching
+* Add `:on_noopts` for triggering an event when the arguments contain no
+  options
+* Add `:unless` to Slop::Option for omitting execution of the Options block
+  when this object exists in the Array of items passed to Slop.new
+* Bugfix: Do not parse negative integers as options. A valid option must
+  start with an alphabet character
+* Bugfix: Allow a Range to accept a negative Integer at either end
+
+1.5.5 (2011-05-03)
+------------------
+
+* Bugfix: only attempt to extract options prefixed with `-`
+
+1.5.4 (2011-05-01)
+------------------
+
+* Bugfix: `parse!` should not remove items with the same value as items used
+  in option arguments. Fixes #22 (Utkarsh Kukreti)
+
+1.5.3 (2011-04-22)
+------------------
+
+* Bugfix: Use integers when fetching array indexes, not strings
+
+1.5.2 (2011-04-17)
+------------------
+
+* Bugfix: Ensure `ARGV` is empty when using the `on_empty` event
+
+1.5.0 (2011-04-15)
+------------------
+
+* Add `Slop#get` as alias to `Slop#[]`
+* 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
diff --git a/debian/slop-3.6.0/Gemfile b/debian/slop-3.6.0/Gemfile
new file mode 100644
index 0000000..896d547
--- /dev/null
+++ b/debian/slop-3.6.0/Gemfile
@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec
\ No newline at end of file
diff --git a/debian/slop-3.6.0/LICENSE b/debian/slop-3.6.0/LICENSE
new file mode 100644
index 0000000..ab47fd7
--- /dev/null
+++ b/debian/slop-3.6.0/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2012 Lee Jarvis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/debian/slop-3.6.0/README.md b/debian/slop-3.6.0/README.md
new file mode 100644
index 0000000..334c34b
--- /dev/null
+++ b/debian/slop-3.6.0/README.md
@@ -0,0 +1,202 @@
+Slop
+====
+
+Slop is a simple option parser with an easy to remember syntax and friendly API.
+API Documentation is available [here](http://leejarvis.github.com/rdoc/slop/).
+
+[![Build Status](https://travis-ci.org/leejarvis/slop.png?branch=master)](http://travis-ci.org/leejarvis/slop)
+
+Usage
+-----
+
+```ruby
+opts = Slop.parse do
+  banner 'Usage: foo.rb [options]'
+
+  on 'name=', 'Your name'
+  on 'p', 'password', 'An optional password', argument: :optional
+  on 'v', 'verbose', 'Enable verbose mode'
+end
+
+# if ARGV is `--name Lee -v`
+opts.verbose?  #=> true
+opts.password? #=> false
+opts[:name]    #=> 'lee'
+opts.to_hash   #=> {:name=>"Lee", :password=>nil, :verbose=>true}
+```
+
+Installation
+------------
+
+    gem install slop
+
+Printing Help
+-------------
+
+Slop attempts to build a good looking help string to print to your users. You
+can see this by calling `opts.help` or simply `puts opts`.
+
+Configuration Options
+---------------------
+
+All of these options can be sent to `Slop.new` or `Slop.parse` in Hash form.
+
+| Option | Description | Default/Example |
+| ------ | ----------- | --------------- |
+| strict | Enable strict mode. Slop will raise an `InvalidOptionError` for unkown options. | `false` |
+| help   | Automatically add the `--help` option. | `false` |
+| banner | Set the help banner text. | `nil` |
+| ignore_case | When enabled, `-A` will look for the `-a` option if `-A` does not exist. | `false` |
+| autocreate | Autocreate options on the fly. | `false` |
+| arguments | Force all options to expect arguments. | `false` |
+| optional_arguments | Force all options to accept optional arguments. | `false` |
+| multiple_switches | When disabled, Slop will parse `-abc` as the option `a` with the argument `bc` rather than 3 separate options. | `true` |
+
+Lists
+-----
+
+```ruby
+opts = Slop.parse do
+  on :list=, as: Array
+end
+# ruby run.rb --list one,two
+opts[:list] #=> ["one", "two"]
+# ruby run.rb --list one,two --list three
+opts[:list] #=> ["one", "two", "three"]
+```
+
+You can also specify a delimiter and limit.
+
+```ruby
+opts = Slop.parse do
+  on :list=, as: Array, delimiter: ':', limit: 2
+end
+# ruby run.rb --list one:two:three
+opts[:list] #=> ["one", "two:three"]
+```
+
+Ranges
+------
+
+```ruby
+opts = Slop.parse do
+  on :range=, as: Range
+end
+# ruby run.rb --range 1..10
+opts[:range] #=> 1..10
+# ruby run.rb --range 1...10
+opts[:range] #=> 1...10
+# ruby run.rb --range 1-10
+opts[:range] #=> 1..10
+# ruby run.rb --range 1,10
+opts[:range] #=> 1..10
+```
+
+Autocreate
+----------
+
+Slop has an 'autocreate' feature. This feature is intended to create
+options on the fly, without having to specify them yourself. In some case,
+using this code could be all you need in your application:
+
+```ruby
+# ruby run.rb --foo bar --baz --name lee
+opts = Slop.parse(autocreate: true)
+opts.to_hash #=> {:foo=>"bar", :baz=>true, :name=>"lee"}
+opts.fetch_option(:name).expects_argument? #=> true
+```
+
+Commands
+--------
+
+Slop supports git style sub-commands, like so:
+
+```ruby
+opts = Slop.parse do
+  on '-v', 'Print the version' do
+    puts "Version 1.0"
+  end
+
+  command 'add' do
+    on :v, :verbose, 'Enable verbose mode'
+    on :name=, 'Your name'
+
+    run do |opts, args|
+      puts "You ran 'add' with options #{opts.to_hash} and args: #{args.inspect}"
+    end
+  end
+end
+
+# ruby run.rb -v
+#=> Version 1.0
+# ruby run.rb add -v foo --name Lee
+#=> You ran 'add' with options {:verbose=>true,:name=>"Lee"} and args ["foo"]
+opts.to_hash(true) # Pass true to tell Slop to merge sub-command option values.
+# => { :v => nil, :add => { :v => true, :name => "Lee" } }
+```
+
+Remaining arguments
+-------------------
+
+The *parse!*  method will remove any options and option arguments from the original Array:
+
+```ruby
+# restarguments.rb
+opts = Slop.parse! do
+  on :foo
+end
+```
+
+Example:
+
+```
+ruby restarguments.rb --foo bar
+```
+
+```
+opts.to_hash = { :foo => true }
+
+ARGV #=> ["bar"]
+```
+
+Woah woah, why you hating on OptionParser?
+------------------------------------------
+
+I'm not, honestly! I love OptionParser. I really do, it's a fantastic library.
+So why did I build Slop? Well, I find myself using OptionParser to simply
+gather a bunch of key/value options, usually you would do something like this:
+
+```ruby
+require 'optparse'
+
+things = {}
+
+opt = OptionParser.new do |opt|
+  opt.on('-n', '--name NAME', 'Your name') do |name|
+    things[:name] = name
+  end
+
+  opt.on('-a', '--age AGE', 'Your age') do |age|
+    things[:age] = age.to_i
+  end
+
+  # you get the point
+end
+
+opt.parse
+things #=> { :name => 'lee', :age => 105 }
+```
+
+Which is all great and stuff, but it can lead to some repetition. The same
+thing in Slop:
+
+```ruby
+require 'slop'
+
+opts = Slop.parse do
+  on :n, :name=, 'Your name'
+  on :a, :age=, 'Your age', as: Integer
+end
+
+opts.to_hash #=> { :name => 'lee', :age => 105 }
+```
diff --git a/debian/slop-3.6.0/Rakefile b/debian/slop-3.6.0/Rakefile
new file mode 100644
index 0000000..02cb12e
--- /dev/null
+++ b/debian/slop-3.6.0/Rakefile
@@ -0,0 +1,29 @@
+begin
+  require 'bundler/gem_tasks'
+rescue LoadError
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = Dir['test/*_test.rb']
+end
+
+# begin
+#   require 'rdoc/task'
+
+#   # requires sdoc and horo gems
+#   RDoc::Task.new do |rdoc|
+#     rdoc.title = 'Slop API Documentation'
+#     rdoc.rdoc_dir = 'doc'
+#     rdoc.options << '-f' << 'sdoc'
+#     rdoc.options << '-T' << 'rails'
+#     rdoc.options << '-e' << 'UTF-8'
+#     rdoc.options << '-g'
+#     rdoc.rdoc_files.include('lib/**/*.rb')
+#   end
+# rescue LoadError
+# end
+
+task :default => :test
diff --git a/debian/slop-3.6.0/lib/slop.rb b/debian/slop-3.6.0/lib/slop.rb
new file mode 100644
index 0000000..6943176
--- /dev/null
+++ b/debian/slop-3.6.0/lib/slop.rb
@@ -0,0 +1,687 @@
+require 'slop/option'
+require 'slop/commands'
+
+class Slop
+  include Enumerable
+
+  VERSION = '3.6.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 = 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 = {})
+      warn "[DEPRECATED] `Slop.optspec` is deprecated and will be removed in version 4"
+      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
+
+  # The Hash of sub-commands for this Slop instance.
+  attr_reader :commands
+
+  # 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
+    @command = config.delete(:command)
+
+    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
+        puts help
+        exit
+      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)
+    options = @config.merge(options)
+    @commands[command.to_s] = Slop.new(options.merge(:command => command.to_s), &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
+
+    # reset the trash so it doesn't carry over if you parse multiple
+    # times with the same instance
+    @trash.clear
+
+    if cmd = @commands[items[0]]
+      items.shift
+      return cmd.parse! items
+    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
+
+    if @runner.respond_to?(:call)
+      @runner.call(self, items) unless config[:help] and present?(:help)
+    end
+
+    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)
+    original = options.find do |o|
+      o.long and o.long == option.long or o.short and o.short == option.short
+    end
+    options.delete(original) if original
+    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]
+    if banner.nil?
+      banner = "Usage: #{File.basename($0, '.*')}"
+      banner << " #{@command}" if @command
+      banner << " [command]" if @commands.any?
+      banner << " [options]"
+    end
+    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, items, 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).
+  # items    - The Array of items currently being parsed.
+  # index    - The index of the current item being processed.
+  #
+  # Returns nothing.
+  def execute_multiple_switches(option, argument, items, index)
+    execute_option(option, nil, index)
+    flags = argument.split('')
+    flags.each do |key|
+      if opt = fetch_option(key)
+        opt.count += 1
+        if (opt.expects_argument? || opt.accepts_optional_argument?) &&
+            (flags[-1] == opt.key) && (val = items[index+1])
+          execute_option(opt, val, index, key)
+        else
+          execute_option(opt, nil, index, key)
+        end
+      else
+        raise InvalidOptionError, "Unknown option -#{key}" if strict?
+      end
+    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.pop)
+    end
+
+    short = extract_short_flag(objects, config)
+    long  = extract_long_flag(objects, config)
+    desc  = objects.shift if objects[0].respond_to?(:to_str)
+
+    Option.new(self, short, long, desc, config, &block)
+  end
+
+  def extract_short_flag(objects, config)
+    flag = objects[0].to_s
+    if flag =~ /\A-?\w=?\z/
+      config[:argument] ||= flag.end_with?('=')
+      objects.shift
+      flag.delete('-=')
+    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-Z0-9][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
diff --git a/debian/slop-3.6.0/lib/slop/commands.rb b/debian/slop-3.6.0/lib/slop/commands.rb
new file mode 100644
index 0000000..cebb560
--- /dev/null
+++ b/debian/slop-3.6.0/lib/slop/commands.rb
@@ -0,0 +1,196 @@
+class Slop
+  class Commands
+    include Enumerable
+
+    attr_reader :config, :commands, :arguments
+    attr_writer :banner
+
+    # Create a new instance of Slop::Commands and optionally build
+    # Slop instances via a block. Any configuration options used in
+    # this method will be the default configuration options sent to
+    # each Slop object created.
+    #
+    # config - An optional configuration Hash.
+    # block  - Optional block used to define commands.
+    #
+    # Examples:
+    #
+    #   commands = Slop::Commands.new do
+    #     on :new do
+    #       on '-o', '--outdir=', 'The output directory'
+    #       on '-v', '--verbose', 'Enable verbose mode'
+    #     end
+    #
+    #     on :generate do
+    #       on '--assets', 'Generate assets', :default => true
+    #     end
+    #
+    #     global do
+    #       on '-D', '--debug', 'Enable debug mode', :default => false
+    #     end
+    #   end
+    #
+    #   commands[:new].class #=> Slop
+    #   commands.parse
+    #
+    def initialize(config = {}, &block)
+      @config = config
+      @commands = {}
+      @banner = nil
+      @triggered_command = nil
+
+      warn "[DEPRECATED] Slop::Commands is deprecated and will be removed in "\
+        "Slop version 4. Check out http://leejarvis.github.io/slop/#commands for "\
+        "a new implementation of commands."
+
+      if block_given?
+        block.arity == 1 ? yield(self) : instance_eval(&block)
+      end
+    end
+
+    # Optionally set the banner for this command help output.
+    #
+    # banner - The String text to set the banner.
+    #
+    # Returns the String banner if one is set.
+    def banner(banner = nil)
+      @banner = banner if banner
+      @banner
+    end
+
+    # Add a Slop instance for a specific command.
+    #
+    # command - A String or Symbol key used to identify this command.
+    # config  - A Hash of configuration options to pass to Slop.
+    # block   - An optional block used to pass options to Slop.
+    #
+    # Returns the newly created Slop instance mapped to command.
+    def on(command, config = {}, &block)
+      commands[command.to_s] = Slop.new(@config.merge(config), &block)
+    end
+
+    # Add a Slop instance used when no other commands exist.
+    #
+    # config - A Hash of configuration options to pass to Slop.
+    # block  - An optional block used to pass options to Slop.
+    #
+    # Returns the newly created Slop instance mapped to default.
+    def default(config = {}, &block)
+      on('default', config, &block)
+    end
+
+    # Add a global Slop instance.
+    #
+    # config - A Hash of configuration options to pass to Slop.
+    # block  - An optional block used to pass options to Slop.
+    #
+    # Returns the newly created Slop instance mapped to global.
+    def global(config = {}, &block)
+      on('global', config, &block)
+    end
+
+    # Fetch the instance of Slop tied to a command.
+    #
+    # key - The String or Symbol key used to locate this command.
+    #
+    # Returns the Slop instance if this key is found, nil otherwise.
+    def [](key)
+      commands[key.to_s]
+    end
+    alias get []
+
+    # Check for a command presence.
+    #
+    # Examples:
+    #
+    #   cmds.parse %w( foo )
+    #   cmds.present?(:foo) #=> true
+    #   cmds.present?(:bar) #=> false
+    #
+    # Returns true if the given key is present in the parsed arguments.
+    def present?(key)
+      key.to_s == @triggered_command
+    end
+
+    # Enumerable interface.
+    def each(&block)
+      @commands.each(&block)
+    end
+
+    # Parse a list of items.
+    #
+    # items - The Array of items to parse.
+    #
+    # Returns the original Array of items.
+    def parse(items = ARGV)
+      parse! items.dup
+      items
+    end
+
+    # Parse a list of items, removing any options or option arguments found.
+    #
+    # items - The Array of items to parse.
+    #
+    # Returns the original Array of items with options removed.
+    def parse!(items = ARGV)
+      if opts = commands[items[0].to_s]
+        @triggered_command = items.shift
+        execute_arguments! items
+        opts.parse! items
+        execute_global_opts! items
+      else
+        if opts = commands['default']
+          opts.parse! items
+        else
+          if config[:strict] && items[0]
+            raise InvalidCommandError, "Unknown command `#{items[0]}`"
+          end
+        end
+        execute_global_opts! items
+      end
+      items
+    end
+
+    # Returns a nested Hash with Slop options and values. See Slop#to_hash.
+    def to_hash
+      Hash[commands.map { |k, v| [k.to_sym, v.to_hash] }]
+    end
+
+    # Returns the help String.
+    def to_s
+      defaults = commands.delete('default')
+      globals = commands.delete('global')
+      helps = commands.reject { |_, v| v.options.none? }
+      if globals && globals.options.any?
+        helps.merge!('Global options' => globals.to_s)
+      end
+      if defaults && defaults.options.any?
+        helps.merge!('Other options' => defaults.to_s)
+      end
+      banner = @banner ? "#{@banner}\n" : ""
+      banner + helps.map { |key, opts| "  #{key}\n#{opts}" }.join("\n\n")
+    end
+    alias help to_s
+
+    # Returns the inspection String.
+    def inspect
+      "#<Slop::Commands #{config.inspect} #{commands.values.map(&:inspect)}>"
+    end
+
+    private
+
+    # Returns nothing.
+    def execute_arguments!(items)
+      @arguments = items.take_while { |arg| !arg.start_with?('-') }
+      items.shift @arguments.size
+    end
+
+    # Returns nothing.
+    def execute_global_opts!(items)
+      if global_opts = commands['global']
+        global_opts.parse! items
+      end
+    end
+
+  end
+end
diff --git a/debian/slop-3.6.0/lib/slop/option.rb b/debian/slop-3.6.0/lib/slop/option.rb
new file mode 100644
index 0000000..f2f6a19
--- /dev/null
+++ b/debian/slop-3.6.0/lib/slop/option.rb
@@ -0,0 +1,214 @@
+class Slop
+  class Option
+
+    # The default Hash of configuration options this class uses.
+    DEFAULT_OPTIONS = {
+      :argument => false,
+      :optional_argument => false,
+      :tail => false,
+      :default => nil,
+      :callback => nil,
+      :delimiter => ',',
+      :limit => 0,
+      :match => nil,
+      :optional => true,
+      :required => false,
+      :as => String,
+      :autocreated => false
+    }
+
+    attr_reader :short, :long, :description, :config, :types
+    attr_accessor :count, :argument_in_value
+
+    # Incapsulate internal option information, mainly used to store
+    # option specific configuration data, most of the meat of this
+    # class is found in the #value method.
+    #
+    # slop        - The instance of Slop tied to this Option.
+    # short       - The String or Symbol short flag.
+    # long        - The String or Symbol long flag.
+    # description - The String description text.
+    # config      - A Hash of configuration options.
+    # block       - An optional block used as a callback.
+    def initialize(slop, short, long, description, config = {}, &block)
+      @slop = slop
+      @short = short
+      @long = long
+      @description = description
+      @config = DEFAULT_OPTIONS.merge(config)
+      @count = 0
+      @callback = block_given? ? block : config[:callback]
+      @value = nil
+
+      @types = {
+        :string  => proc { |v| v.to_s },
+        :symbol  => proc { |v| v.to_sym },
+        :integer => proc { |v| value_to_integer(v) },
+        :float   => proc { |v| value_to_float(v) },
+        :range   => proc { |v| value_to_range(v) },
+        :regexp  => proc { |v| Regexp.new(v) },
+        :count   => proc { |v| @count }
+      }
+
+      if long && long.size > @slop.config[:longest_flag]
+        @slop.config[:longest_flag] = long.size
+      end
+
+      @config.each_key do |key|
+        predicate = :"#{key}?"
+        unless self.class.method_defined? predicate
+          self.class.__send__(:define_method, predicate) { !!@config[key] }
+        end
+      end
+    end
+
+    # Returns true if this option expects an argument.
+    def expects_argument?
+      config[:argument] && config[:argument] != :optional
+    end
+
+    # Returns true if this option accepts an optional argument.
+    def accepts_optional_argument?
+      config[:optional_argument] || config[:argument] == :optional
+    end
+
+    # Returns the String flag of this option. Preferring the long flag.
+    def key
+      long || short
+    end
+
+    # Call this options callback if one exists, and it responds to call().
+    #
+    # Returns nothing.
+    def call(*objects)
+      @callback.call(*objects) if @callback.respond_to?(:call)
+    end
+
+    # Set the new argument value for this option.
+    #
+    # We use this setter method to handle concatenating lists. That is,
+    # when an array type is specified and used more than once, values from
+    # both options will be grouped together and flattened into a single array.
+    def value=(new_value)
+      if config[:as].to_s.downcase == 'array'
+        @value ||= []
+
+        if new_value.respond_to?(:split)
+          @value.concat new_value.split(config[:delimiter], config[:limit])
+        end
+      else
+        @value = new_value
+      end
+    end
+
+    # Fetch the argument value for this option.
+    #
+    # Returns the Object once any type conversions have taken place.
+    def value
+      value = @value.nil? ? config[:default] : @value
+
+      if [true, false, nil].include?(value) && config[:as].to_s != 'count'
+        return value
+      end
+
+      type = config[:as]
+      if type.respond_to?(:call)
+        type.call(value)
+      else
+        if callable = types[type.to_s.downcase.to_sym]
+          callable.call(value)
+        else
+          value
+        end
+      end
+    end
+
+    # Returns the help String for this option.
+    def to_s
+      return config[:help] if config[:help].respond_to?(:to_str)
+
+      out = "    #{short ? "-#{short}, " : ' ' * 4}"
+
+      if long
+        out << "--#{long}"
+        size = long.size
+        diff = @slop.config[:longest_flag] - size
+        out << (' ' * (diff + 6))
+      else
+        out << (' ' * (@slop.config[:longest_flag] + 8))
+      end
+
+      if config[:default]
+        default = config[:default]
+        "#{out}#{description} (default: #{default})"
+      else
+        "#{out}#{description}"
+      end
+    end
+    alias help to_s
+
+    # Returns the String inspection text.
+    def inspect
+      "#<Slop::Option [-#{short} | --#{long}" +
+      "#{'=' if expects_argument?}#{'=?' if accepts_optional_argument?}]" +
+      " (#{description}) #{config.inspect}"
+    end
+
+    private
+
+    # Convert an object to an Integer if possible.
+    #
+    # value - The Object we want to convert to an integer.
+    #
+    # Returns the Integer value if possible to convert, else a zero.
+    def value_to_integer(value)
+      if @slop.strict?
+        begin
+          Integer(value.to_s, 10)
+        rescue ArgumentError
+          raise InvalidArgumentError, "#{value} could not be coerced into Integer"
+        end
+      else
+        value.to_s.to_i
+      end
+    end
+
+    # Convert an object to a Float if possible.
+    #
+    # value - The Object we want to convert to a float.
+    #
+    # Returns the Float value if possible to convert, else a zero.
+    def value_to_float(value)
+      if @slop.strict?
+        begin
+          Float(value.to_s)
+        rescue ArgumentError
+          raise InvalidArgumentError, "#{value} could not be coerced into Float"
+        end
+      else
+        value.to_s.to_f
+      end
+    end
+
+    # Convert an object to a Range if possible.
+    #
+    # value - The Object we want to convert to a range.
+    #
+    # Returns the Range value if one could be found, else the original object.
+    def value_to_range(value)
+      case value.to_s
+      when /\A(\-?\d+)\z/
+        Range.new($1.to_i, $1.to_i)
+      when /\A(-?\d+?)(\.\.\.?|-|,)(-?\d+)\z/
+        Range.new($1.to_i, $3.to_i, $2 == '...')
+      else
+        if @slop.strict?
+          raise InvalidArgumentError, "#{value} could not be coerced into Range"
+        else
+          value
+        end
+      end
+    end
+
+  end
+end
diff --git a/debian/slop-3.6.0/metadata.yml b/debian/slop-3.6.0/metadata.yml
new file mode 100644
index 0000000..d5af654
--- /dev/null
+++ b/debian/slop-3.6.0/metadata.yml
@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: slop
+version: !ruby/object:Gem::Version
+  version: 3.6.0
+platform: ruby
+authors:
+- Lee Jarvis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+description: A simple DSL for gathering options and parsing the command line
+email: ljjarvis at gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGES.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/slop.rb
+- lib/slop/commands.rb
+- lib/slop/option.rb
+- slop.gemspec
+- test/commands_test.rb
+- test/helper.rb
+- test/option_test.rb
+- test/slop_test.rb
+homepage: http://github.com/leejarvis/slop
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Simple Lightweight Option Parsing
+test_files:
+- test/commands_test.rb
+- test/helper.rb
+- test/option_test.rb
+- test/slop_test.rb
diff --git a/debian/slop-3.6.0/slop.gemspec b/debian/slop-3.6.0/slop.gemspec
new file mode 100644
index 0000000..d535e60
--- /dev/null
+++ b/debian/slop-3.6.0/slop.gemspec
@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name        = 'slop'
+  s.version     = '3.6.0'
+  s.summary     = 'Simple Lightweight Option Parsing'
+  s.description = 'A simple DSL for gathering options and parsing the command line'
+  s.author      = 'Lee Jarvis'
+  s.email       = 'ljjarvis at gmail.com'
+  s.homepage    = 'http://github.com/leejarvis/slop'
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- test/*`.split("\n")
+  s.license     = 'MIT'
+
+  s.required_ruby_version = '>= 1.8.7'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest', '~> 5.0.0'
+end
diff --git a/debian/slop-3.6.0/test/commands_test.rb b/debian/slop-3.6.0/test/commands_test.rb
new file mode 100644
index 0000000..8f0e84a
--- /dev/null
+++ b/debian/slop-3.6.0/test/commands_test.rb
@@ -0,0 +1,26 @@
+require 'helper'
+
+class CommandsTest < TestCase
+
+  def setup
+    @opts = Slop.new do |o|
+      o.on :v, :version
+      o.command :add do |add|
+        add.on :v, 'verbose mode'
+      end
+    end
+  end
+
+  test "parse! removes the command AND its options" do
+    items = %w'add -v'
+    @opts.parse! items
+    assert_equal [], items
+  end
+
+  test "parse does not remove the command or its options" do
+    items = %w'add -v'
+    @opts.parse items
+    assert_equal ['add', '-v'], items
+  end
+
+end
diff --git a/debian/slop-3.6.0/test/helper.rb b/debian/slop-3.6.0/test/helper.rb
new file mode 100644
index 0000000..e6ec32f
--- /dev/null
+++ b/debian/slop-3.6.0/test/helper.rb
@@ -0,0 +1,12 @@
+$VERBOSE = true
+
+require 'slop'
+
+require 'minitest/autorun'
+require 'stringio'
+
+class TestCase < Minitest::Test
+  def self.test(name, &block)
+    define_method("test_#{name.gsub(/\W/, '_')}", &block) if block
+  end
+end
\ No newline at end of file
diff --git a/debian/slop-3.6.0/test/option_test.rb b/debian/slop-3.6.0/test/option_test.rb
new file mode 100644
index 0000000..cec73c9
--- /dev/null
+++ b/debian/slop-3.6.0/test/option_test.rb
@@ -0,0 +1,145 @@
+require 'helper'
+
+class OptionTest < TestCase
+  def option(*args, &block)
+    Slop.new.on(*args, &block)
+  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 }
+  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
+
+  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
+  end
+end
diff --git a/debian/slop-3.6.0/test/slop_test.rb b/debian/slop-3.6.0/test/slop_test.rb
new file mode 100644
index 0000000..3b630f5
--- /dev/null
+++ b/debian/slop-3.6.0/test/slop_test.rb
@@ -0,0 +1,518 @@
+require 'helper'
+
+class SlopTest < TestCase
+
+  def build_option(*args)
+    opt = Slop.new.send(:build_option, args)
+    config = opt.config.reject { |k, v| v == Slop::Option::DEFAULT_OPTIONS[k] }
+    [opt.short, opt.long, opt.description, config]
+  end
+
+  def temp_argv(items)
+    old_argv = ARGV.clone
+    ARGV.replace items
+    yield
+  ensure
+    ARGV.replace old_argv
+  end
+
+  def temp_stdout
+    $stdout = StringIO.new
+    yield $stdout.string
+  ensure
+    $stdout = STDOUT
+  end
+
+  test "includes Enumerable" do
+    assert_includes Slop.included_modules, Enumerable
+  end
+
+  test "enumerates Slop::Option objects in #each" do
+    Slop.new { on :f; on :b; }.each { |o| assert_kind_of Slop::Option, o }
+  end
+
+  test "build_option" do
+    assert_equal ['f', nil, nil, {}], build_option(:f)
+    assert_equal [nil, 'foo', nil, {}], build_option(:foo)
+    assert_equal ['f', nil, 'Some description', {}], build_option(:f, 'Some description')
+    assert_equal ['f', 'foo', nil, {}], build_option(:f, :foo)
+    assert_equal [nil, '1.8', 'Use v. 1.8', {}], build_option('--1.8', 'Use v. 1.8')
+
+    # with arguments
+    assert_equal ['f', nil, nil, {:argument=>true}], build_option('f=')
+    assert_equal [nil, 'foo', nil, {:argument=>true}], build_option('foo=')
+    assert_equal [nil, 'foo', nil, {:optional_argument=>true}], build_option('foo=?')
+  end
+
+  test "parsing option=value" do
+    slop = Slop.new { on :foo= }
+    slop.parse %w' --foo=bar '
+    assert_equal 'bar', slop[:foo]
+
+    slop = Slop.new(:multiple_switches => false) { on :f=; on :b= }
+    slop.parse %w' -fabc -bdef '
+    assert_equal 'abc', slop[:f]
+    assert_equal 'def', slop[:b]
+  end
+
+  test "fetch_option" do
+    slop = Slop.new
+    opt1 = slop.on :f, :foo
+    opt2 = slop.on :bar
+
+    assert_equal opt1, slop.fetch_option(:foo)
+    assert_equal opt1, slop.fetch_option(:f)
+    assert_equal opt2, slop.fetch_option(:bar)
+    assert_equal opt2, slop.fetch_option('--bar')
+    assert_nil slop.fetch_option(:baz)
+  end
+
+  test "default all options to take arguments" do
+    slop = Slop.new(:arguments => true)
+    opt1 = slop.on :foo
+    opt2 = slop.on :bar, :argument => false
+
+    assert opt1.expects_argument?
+    refute opt2.expects_argument?
+  end
+
+  test "extract_option" do
+    slop = Slop.new
+    extract = proc { |flag| slop.send(:extract_option, flag) }
+    slop.on :opt=
+
+    assert_kind_of Array, extract['--foo']
+    assert_equal 'bar', extract['--foo=bar'][1]
+    assert_equal 'bar', extract['-f=bar'][1]
+    assert_nil extract['--foo'][0]
+    assert_kind_of Slop::Option, extract['--opt'][0]
+    assert_equal false, extract['--no-opt'][1]
+  end
+
+  test "non-options yielded to parse()" do
+    foo = nil
+    slop = Slop.new
+    slop.parse ['foo'] do |x| foo = x end
+    assert_equal 'foo', foo
+  end
+
+  test "::parse returns a Slop object" do
+    assert_kind_of Slop, Slop.parse([])
+  end
+
+  test "parse" do
+    slop = Slop.new
+    assert_equal ['foo'], slop.parse(%w'foo')
+    assert_equal ['foo'], slop.parse!(%w'foo')
+  end
+
+  test "parse!" do
+    slop = Slop.new { on :foo= }
+    assert_equal [], slop.parse!(%w'--foo bar')
+    slop = Slop.new {  on :baz }
+    assert_equal ['etc'], slop.parse!(%w'--baz etc')
+  end
+
+  test "new() accepts a hash of configuration options" do
+    slop = Slop.new(:foo => :bar)
+    assert_equal :bar, slop.config[:foo]
+  end
+
+  test "defaulting to ARGV" do
+    temp_argv(%w/--name lee/) do
+      opts = Slop.parse { on :name= }
+      assert_equal 'lee', opts[:name]
+    end
+  end
+
+  test "automatically adding the help option" do
+    slop = Slop.new :help => true
+    refute_empty slop.options
+    assert_equal 'Display this help message.', slop.options.first.description
+  end
+
+  test "default help exits" do
+    temp_stdout do
+      slop = Slop.new :help => true
+      assert_raises SystemExit do
+        slop.parse %w/--help/
+      end
+    end
+  end
+
+  test ":arguments and :optional_arguments config options" do
+    slop = Slop.new(:arguments => true) { on :foo }
+    assert slop.fetch_option(:foo).expects_argument?
+
+    slop = Slop.new(:optional_arguments => true) { on :foo }
+    assert slop.fetch_option(:foo).accepts_optional_argument?
+  end
+
+  test "yielding non-options when a block is passed to parse()" do
+    items = []
+    opts = Slop.new { on :name= }
+    opts.parse(%w/--name lee a b c/) { |v| items << v }
+    assert_equal ['a', 'b', 'c'], items
+  end
+
+  test "on empty callback" do
+    opts = Slop.new
+    foo = nil
+    opts.add_callback(:empty) { foo = "bar" }
+    opts.parse []
+    assert_equal "bar", foo
+  end
+
+  test "on no_options callback" do
+    opts = Slop.new
+    foo = nil
+    opts.add_callback(:no_options) { foo = "bar" }
+    opts.parse %w( --foo --bar etc hello )
+    assert_equal "bar", foo
+  end
+
+  test "to_hash()" do
+    opts = Slop.new { on :foo=; on :bar; on :baz; on :zip }
+    opts.parse(%w'--foo hello --no-bar --baz')
+    assert_equal({ :foo => 'hello', :bar => false, :baz => true, :zip => nil }, opts.to_hash)
+  end
+
+  test "missing() returning all missing option keys" do
+    opts = Slop.new { on :foo; on :bar }
+    opts.parse %w'--foo'
+    assert_equal ['bar'], opts.missing
+  end
+
+  test "autocreating options" do
+    opts = Slop.new :autocreate => true
+    opts.parse %w[ --foo bar --baz ]
+    assert opts.fetch_option(:foo).expects_argument?
+    assert opts.fetch_option(:foo).autocreated?
+    assert_equal 'bar', opts.fetch_option(:foo).value
+    refute opts.fetch_option(:baz).expects_argument?
+    assert_equal nil, opts.fetch_option(:bar)
+
+    opts = Slop.new :autocreate => true do
+      on :f, :foo=
+    end
+    opts.parse %w[ --foo bar --baz stuff ]
+    assert_equal 'bar', opts[:foo]
+    assert_equal 'stuff', opts[:baz]
+  end
+
+  test "option terminator" do
+    opts = Slop.new { on :foo= }
+    items = %w' foo -- --foo bar '
+    opts.parse! items
+    assert_equal %w' foo --foo bar ', items
+  end
+
+  test "raising an InvalidArgumentError when the argument doesn't match" do
+    opts = Slop.new { on :foo=, :match => /^[a-z]+$/ }
+    assert_raises(Slop::InvalidArgumentError) { opts.parse %w' --foo b4r '}
+  end
+
+  test "raising a MissingArgumentError when the option expects an argument" do
+    opts = Slop.new { on :foo= }
+    assert_raises(Slop::MissingArgumentError) { opts.parse %w' --foo '}
+  end
+
+  test "raising a MissingOptionError when a required option is missing" do
+    opts = Slop.new { on :foo, :required => true }
+    assert_raises(Slop::MissingOptionError) { opts.parse %w'' }
+  end
+
+  test "raising InvalidOptionError when strict mode is enabled and an unknown option appears" do
+    opts = Slop.new :strict => true
+    assert_raises(Slop::InvalidOptionError) { opts.parse %w'--foo' }
+    assert_raises(Slop::InvalidOptionError) { opts.parse %w'-fabc' }
+  end
+
+  test "raising InvalidOptionError for multiple short options" do
+    opts = Slop.new :strict => true
+    opts.on :L
+    assert_raises(Slop::InvalidOptionError) { opts.parse %w'-Ly' }
+
+    # but not with no strict mode!
+    opts = Slop.new
+    opts.on :L
+    assert opts.parse %w'-Ly'
+  end
+
+  test "multiple_switches is enabled by default" do
+    opts = Slop.new { on :f; on :b }
+    opts.parse %w[ -fb ]
+    assert opts.present?(:f)
+    assert opts.present?(:b)
+  end
+
+  test "multiple_switches disabled" do
+    opts = Slop.new(:multiple_switches => false) { on :f= }
+    opts.parse %w[ -fabc123 ]
+    assert_equal 'abc123', opts[:f]
+  end
+
+  test "muiltiple_switches should not trash arguments" do
+    opts = Slop.new{ on :f; on :b }
+    args = opts.parse!(%w'-fb foo')
+    assert_equal %w'foo', args
+  end
+
+  test "multiple options should still accept trailing arguments" do
+    opts = Slop.new { on :a; on :b= }
+    opts.parse %w'-ab foo'
+    assert_equal 'foo', opts[:b]
+  end
+
+  test "setting/getting the banner" do
+    opts = Slop.new :banner => 'foo'
+    assert_equal 'foo', opts.banner
+
+    opts = Slop.new
+    opts.banner 'foo'
+    assert_equal 'foo', opts.banner
+
+    opts = Slop.new
+    opts.banner = 'foo'
+    assert_equal 'foo', opts.banner
+  end
+
+  test "get/[] fetching an options argument value" do
+    opts = Slop.new { on :foo=; on :bar; on :baz }
+    opts.parse %w' --foo hello --bar '
+    assert_equal 'hello', opts[:foo]
+    assert_equal true, opts[:bar]
+    assert_nil opts[:baz]
+  end
+
+  test "checking for an options presence" do
+    opts = Slop.new { on :foo; on :bar }
+    opts.parse %w' --foo '
+    assert opts.present?(:foo)
+    refute opts.present?(:bar)
+  end
+
+  test "ignoring case" do
+    opts = Slop.new { on :foo }
+    opts.parse %w' --FOO bar '
+    assert_nil opts[:foo]
+
+    opts = Slop.new(:ignore_case => true) { on :foo= }
+    opts.parse %w' --FOO bar '
+    assert_equal 'bar', opts[:foo]
+  end
+
+  test "supporting dash" do
+    opts = Slop.new { on :foo_bar= }
+    opts.parse %w' --foo-bar baz '
+    assert_equal 'baz', opts[:foo_bar]
+    assert opts.foo_bar?
+  end
+
+  test "supporting underscore" do
+    opts = Slop.new { on :foo_bar= }
+    opts.parse %w' --foo_bar baz '
+    assert_equal 'baz', opts[:foo_bar]
+    assert opts.foo_bar?
+  end
+
+  # test "parsing an optspec and building options" do
+  #   optspec = <<-SPEC
+  #   ruby foo.rb [options]
+  #   --
+  #   v,verbose  enable verbose mode
+  #   q,quiet   enable quiet mode
+  #   n,name=    set your name
+  #   p,pass=?   set your password
+  #   SPEC
+  #   opts = Slop.optspec(optspec.gsub(/^\s+/, ''))
+  #   opts.parse %w[ --verbose --name Lee ]
+
+  #   assert_equal 'Lee', opts[:name]
+  #   assert opts.present?(:verbose)
+  #   assert_equal 'enable quiet mode', opts.fetch_option(:quiet).description
+  #   assert opts.fetch_option(:pass).accepts_optional_argument?
+  # end
+
+  test "ensure negative integers are not processed as options" do
+    items = %w(-1)
+    Slop.parse!(items)
+    assert_equal %w(-1), items
+  end
+
+  test "separators" do
+    opts = Slop.new(:banner => false) do
+      on :foo
+      separator "hello"
+      separator "world"
+      on :bar
+    end
+    assert_equal "        --foo      \nhello\nworld\n        --bar      ", opts.help
+
+    opts = Slop.new do
+      banner "foo"
+      separator "bar"
+    end
+    assert_equal "foo\nbar\n", opts.help
+  end
+
+  test "printing help with :help => true" do
+    temp_stdout do |string|
+      opts = Slop.new(:help => true, :banner => false)
+      assert_raises SystemExit do
+        opts.parse %w( --help )
+      end
+      assert_equal "    -h, --help      Display this help message.\n", string
+    end
+
+    temp_stdout do |string|
+      opts = Slop.new(:help => true)
+      assert_raises SystemExit do
+        opts.parse %w( --help )
+      end
+      assert_equal "Usage: rake_test_loader [options]\n    -h, --help      Display this help message.\n", string
+    end
+  end
+
+  test "fallback to substituting - for _ when using <option>?" do
+    opts = Slop.new do
+      on 'foo-bar'
+    end
+    opts.parse %w( --foo-bar )
+    assert opts.foo_bar?
+  end
+
+  test "option=value syntax does NOT consume following argument" do
+    opts = Slop.new { on :foo=; on 'bar=?' }
+    args = %w' --foo=bar baz --bar=zing hello '
+    opts.parse!(args)
+    assert_equal %w' baz hello ', args
+  end
+
+  test "context and return value of constructor block" do
+    peep = nil
+    ret = Slop.new { peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop.new { |a| peep = self }
+    assert !peep.equal?(ret)
+    assert_same peep, self
+
+    peep = nil
+    ret = Slop.new { |a, b| peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop.new { |a, *rest| peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop.parse([]) { peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop.parse([]) { |a| peep = self }
+    assert !peep.equal?(ret)
+    assert_same peep, self
+
+    peep = nil
+    ret = Slop.parse([]) { |a, b| peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+
+    peep = nil
+    ret = Slop.parse([]) { |a, *rest| peep = self }
+    assert_same ret, peep
+    assert !equal?(peep)
+  end
+
+  test "to_s do not break self" do
+    slop = Slop.new do
+      banner "foo"
+    end
+
+    assert_equal "foo", slop.banner
+    slop.to_s
+    assert_equal "foo", slop.banner
+  end
+
+  test "options with prefixed --no should not default to inverted behaviour unless intended" do
+    opts = Slop.new { on :bar }
+    opts.parse %w'--no-bar'
+    assert_equal false, opts[:bar]
+
+    opts = Slop.new { on 'no-bar' }
+    opts.parse %w'--no-bar'
+    assert_equal true, opts['no-bar']
+  end
+
+  test "method missing() is a private method" do
+    assert Slop.new.private_methods.map(&:to_sym).include?(:method_missing)
+  end
+
+  test "respond_to?() arity checker is similar of other objects" do
+    slop = Slop.new
+    obj = Object.new
+
+    assert_same obj.respond_to?(:__id__), slop.respond_to?(:__id__)
+    assert_same obj.respond_to?(:__id__, false), slop.respond_to?(:__id__, false)
+    assert_same obj.respond_to?(:__id__, true), slop.respond_to?(:__id__, true)
+
+    assert_raises ArgumentError do
+      slop.respond_to? :__id__, false, :INVALID_ARGUMENT
+    end
+  end
+
+  test "adding a runner" do
+    orun = proc { |r| assert_instance_of Slop, r }
+    arun = proc { |r| assert_equal ['foo', 'bar'], r }
+
+    Slop.parse(%w'foo --foo bar -v bar') do
+      on :v
+      on :foo=
+      run { |o, a| orun[o]; arun[a] }
+    end
+  end
+
+  test "ensure a runner does not execute when a help option is present" do
+    items = []
+    Slop.parse(%w'--help foo bar') do
+      run { |o, a| items.concat a }
+    end
+    assert_equal %w'--help foo bar', items
+    items.clear
+    temp_stdout do
+      assert_raises SystemExit do
+        Slop.parse(%w'--help foo bar', :help => true) do
+          run { |o, a| items.concat a }
+        end
+      end
+      assert_empty items
+    end
+  end
+
+  test "duplicate options should not exist, new options should replace old ones" do
+    i = nil
+    Slop.parse(%w'-v') do
+      on(:v) { i = 'first' }
+      on(:v) { i = 'second' }
+    end
+    assert_equal 'second', i
+  end
+
+  test "taking out the trash" do
+    args = []
+    opts = Slop.new { on :f, :foo }
+    opts.run { |_, a| args = a }
+    opts.parse! %w(--foo bar)
+    assert_equal %w(bar), args
+    opts.parse! %w(foo)
+    assert_equal %w(foo), args
+  end
+
+end

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-ruby-extras/pry.git



More information about the Pkg-ruby-extras-commits mailing list