rubysl-getoptlong 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3536cc041a64d512b90faa69b462239d59a7d76c
+  data.tar.gz: 83ff9342026f92d5c9a5fc2ea5af625a1f6fc2b6
+SHA512:
+  metadata.gz: a479f266722fef5c6415da317ac4bd1c2dec4eea7c5d5862bf58c370652b1326ff7d613b611ca18f88b8d3321e73548a1a2854018cf322c28bc6257891b8a099
+  data.tar.gz: c6a81a360957af20d366886f6691bcf784164e0aec3f8264c48f7848279b3d74156aa2e8461e982ac5da0f80b02ccce380dc34c1ff0d5210e315fc176c97c2b9

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+before_install:
+  - gem update --system
+  - gem --version
+  - gem install rubysl-bundler
+script: bundle exec mspec spec
+rvm:
+  - rbx-nightly-18mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rubysl-getoptlong.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2013, Brian Shirai
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+3. Neither the name of the library nor the names of its contributors may be
+   used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,29 @@
+# Rubysl::Getoptlong
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rubysl-getoptlong'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rubysl-getoptlong
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/getoptlong.rb

@@ -0,0 +1 @@
+require "rubysl/getoptlong"

data/lib/rubysl/getoptlong.rb

@@ -0,0 +1,2 @@
+require "rubysl/getoptlong/getoptlong"
+require "rubysl/getoptlong/version"

data/lib/rubysl/getoptlong/getoptlong.rb

@@ -0,0 +1,621 @@
+#
+# GetoptLong for Ruby
+#
+# Copyright (C) 1998, 1999, 2000  Motoyuki Kasahara.
+#
+# You may redistribute and/or modify this library under the same license
+# terms as Ruby.
+#
+# See GetoptLong for documentation.
+#
+# Additional documents and the latest version of `getoptlong.rb' can be
+# found at http://www.sra.co.jp/people/m-kasahr/ruby/getoptlong/
+
+# The GetoptLong class allows you to parse command line options similarly to
+# the GNU getopt_long() C library call. Note, however, that GetoptLong is a 
+# pure Ruby implementation.
+#
+# GetoptLong allows for POSIX-style options like <tt>--file</tt> as well 
+# as single letter options like <tt>-f</tt>
+#
+# The empty option <tt>--</tt> (two minus symbols) is used to end option
+# processing. This can be particularly important if options have optional
+# arguments.
+#
+# Here is a simple example of usage:
+#
+#     # == Synopsis
+#     #
+#     # hello: greets user, demonstrates command line parsing
+#     #
+#     # == Usage
+#     #
+#     # hello [OPTION] ... DIR
+#     #
+#     # -h, --help:
+#     #    show help
+#     #
+#     # --repeat x, -n x:
+#     #    repeat x times
+#     #
+#     # --name [name]:
+#     #    greet user by name, if name not supplied default is John
+#     #
+#     # DIR: The directory in which to issue the greeting.
+#     
+#     require 'getoptlong'
+#     require 'rdoc/usage'
+#     
+#     opts = GetoptLong.new(
+#       [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
+#       [ '--repeat', '-n', GetoptLong::REQUIRED_ARGUMENT ],
+#       [ '--name', GetoptLong::OPTIONAL_ARGUMENT ]
+#     )
+#     
+#     dir = nil
+#     name = nil
+#     repetitions = 1
+#     opts.each do |opt, arg|
+#       case opt
+#         when '--help'
+#           RDoc::usage
+#         when '--repeat'
+#           repetitions = arg.to_i
+#         when '--name'
+#           if arg == ''
+#             name = 'John'
+#           else
+#             name = arg
+#           end
+#       end
+#     end
+#     
+#     if ARGV.length != 1
+#       puts "Missing dir argument (try --help)"
+#       exit 0
+#     end
+#     
+#     dir = ARGV.shift
+#     
+#     Dir.chdir(dir)
+#     for i in (1..repetitions)
+#       print "Hello"
+#       if name
+#         print ", #{name}"
+#       end
+#       puts
+#     end
+#
+# Example command line:
+#
+#     hello -n 6 --name -- /tmp
+#
+class GetoptLong
+  #
+  # Orderings.
+  #
+  ORDERINGS = [REQUIRE_ORDER = 0, PERMUTE = 1, RETURN_IN_ORDER = 2]
+
+  #
+  # Argument flags.
+  #
+  ARGUMENT_FLAGS = [NO_ARGUMENT = 0, REQUIRED_ARGUMENT = 1,
+    OPTIONAL_ARGUMENT = 2]
+
+  #
+  # Status codes.
+  #
+  STATUS_YET, STATUS_STARTED, STATUS_TERMINATED = 0, 1, 2
+
+  #
+  # Error types.
+  #
+  class Error  < StandardError; end
+  class AmbigousOption   < Error; end
+  class NeedlessArgument < Error; end
+  class MissingArgument  < Error; end
+  class InvalidOption    < Error; end
+
+  #
+  # Set up option processing.
+  #
+  # The options to support are passed to new() as an array of arrays.
+  # Each sub-array contains any number of String option names which carry 
+  # the same meaning, and one of the following flags:
+  #
+  # GetoptLong::NO_ARGUMENT :: Option does not take an argument.
+  #
+  # GetoptLong::REQUIRED_ARGUMENT :: Option always takes an argument.
+  #
+  # GetoptLong::OPTIONAL_ARGUMENT :: Option may or may not take an argument.
+  #
+  # The first option name is considered to be the preferred (canonical) name.
+  # Other than that, the elements of each sub-array can be in any order.
+  #
+  def initialize(*arguments)
+    #
+    # Current ordering.
+    #
+    if ENV.include?('POSIXLY_CORRECT')
+      @ordering = REQUIRE_ORDER
+    else
+      @ordering = PERMUTE
+    end
+
+    #
+    # Hash table of option names.
+    # Keys of the table are option names, and their values are canonical
+    # names of the options.
+    #
+    @canonical_names = Hash.new
+
+    #
+    # Hash table of argument flags.
+    # Keys of the table are option names, and their values are argument
+    # flags of the options.
+    #
+    @argument_flags = Hash.new
+
+    #
+    # Whether error messages are output to $deferr.
+    #
+    @quiet = FALSE
+
+    #
+    # Status code.
+    #
+    @status = STATUS_YET
+
+    #
+    # Error code.
+    #
+    @error = nil
+
+    #
+    # Error message.
+    #
+    @error_message = nil
+
+    #
+    # Rest of catenated short options.
+    #
+    @rest_singles = ''
+
+    #
+    # List of non-option-arguments.
+    # Append them to ARGV when option processing is terminated.
+    #
+    @non_option_arguments = Array.new
+
+    if 0 < arguments.length
+      set_options(*arguments)
+    end
+  end
+
+  #
+  # Set the handling of the ordering of options and arguments.
+  # A RuntimeError is raised if option processing has already started.
+  #
+  # The supplied value must be a member of GetoptLong::ORDERINGS. It alters
+  # the processing of options as follows:
+  #
+  # <b>REQUIRE_ORDER</b> :
+  # 
+  # Options are required to occur before non-options.
+  #
+  # Processing of options ends as soon as a word is encountered that has not
+  # been preceded by an appropriate option flag.
+  #
+  # For example, if -a and -b are options which do not take arguments,
+  # parsing command line arguments of '-a one -b two' would result in 
+  # 'one', '-b', 'two' being left in ARGV, and only ('-a', '') being 
+  # processed as an option/arg pair.
+  #
+  # This is the default ordering, if the environment variable
+  # POSIXLY_CORRECT is set. (This is for compatibility with GNU getopt_long.)
+  #
+  # <b>PERMUTE</b> :
+  #  
+  # Options can occur anywhere in the command line parsed. This is the 
+  # default behavior.
+  #
+  # Every sequence of words which can be interpreted as an option (with or
+  # without argument) is treated as an option; non-option words are skipped.
+  #
+  # For example, if -a does not require an argument and -b optionally takes
+  # an argument, parsing '-a one -b two three' would result in ('-a','') and
+  # ('-b', 'two') being processed as option/arg pairs, and 'one','three'
+  # being left in ARGV.
+  #
+  # If the ordering is set to PERMUTE but the environment variable
+  # POSIXLY_CORRECT is set, REQUIRE_ORDER is used instead. This is for
+  # compatibility with GNU getopt_long.
+  #
+  # <b>RETURN_IN_ORDER</b> :
+  #
+  # All words on the command line are processed as options. Words not 
+  # preceded by a short or long option flag are passed as arguments
+  # with an option of '' (empty string).
+  #
+  # For example, if -a requires an argument but -b does not, a command line
+  # of '-a one -b two three' would result in option/arg pairs of ('-a', 'one')
+  # ('-b', ''), ('', 'two'), ('', 'three') being processed.
+  #
+  def ordering=(ordering)
+    #
+    # The method is failed if option processing has already started.
+    #
+    if @status != STATUS_YET
+      set_error(ArgumentError, "argument error")
+      raise RuntimeError,
+	"invoke ordering=, but option processing has already started"
+    end
+
+    #
+    # Check ordering.
+    #
+    if !ORDERINGS.include?(ordering)
+      raise ArgumentError, "invalid ordering `#{ordering}'"
+    end
+    if ordering == PERMUTE && ENV.include?('POSIXLY_CORRECT')
+      @ordering = REQUIRE_ORDER
+    else
+      @ordering = ordering
+    end
+  end
+
+  #
+  # Return ordering.
+  #
+  attr_reader :ordering
+
+  #
+  # Set options. Takes the same argument as GetoptLong.new.
+  #
+  # Raises a RuntimeError if option processing has already started.
+  #
+  def set_options(*arguments)
+    #
+    # The method is failed if option processing has already started.
+    #
+    if @status != STATUS_YET
+      raise RuntimeError, 
+	"invoke set_options, but option processing has already started"
+    end
+
+    #
+    # Clear tables of option names and argument flags.
+    #
+    @canonical_names.clear
+    @argument_flags.clear
+
+    arguments.each do |arg|
+      #
+      # Each argument must be an Array.
+      #
+      if !arg.is_a?(Array)
+	raise ArgumentError, "the option list contains non-Array argument"
+      end
+
+      #
+      # Find an argument flag and it set to `argument_flag'.
+      #
+      argument_flag = nil
+      arg.each do |i|
+	if ARGUMENT_FLAGS.include?(i)
+	  if argument_flag != nil
+	    raise ArgumentError, "too many argument-flags"
+	  end
+	  argument_flag = i
+	end
+      end
+      raise ArgumentError, "no argument-flag" if argument_flag == nil
+
+      canonical_name = nil
+      arg.each do |i|
+	#
+	# Check an option name.
+	#
+	next if i == argument_flag
+	begin
+	  if !i.is_a?(String) || i !~ /^-([^-]|-.+)$/
+	    raise ArgumentError, "an invalid option `#{i}'"
+	  end
+	  if (@canonical_names.include?(i))
+	    raise ArgumentError, "option redefined `#{i}'"
+	  end
+	rescue
+	  @canonical_names.clear
+	  @argument_flags.clear
+	  raise
+	end
+
+	#
+	# Register the option (`i') to the `@canonical_names' and 
+	# `@canonical_names' Hashes.
+	#
+	if canonical_name == nil
+	  canonical_name = i
+	end
+	@canonical_names[i] = canonical_name
+	@argument_flags[i] = argument_flag
+      end
+      raise ArgumentError, "no option name" if canonical_name == nil
+    end
+    return self
+  end
+
+  #
+  # Set/Unset `quiet' mode.
+  #
+  attr_writer :quiet
+
+  #
+  # Return the flag of `quiet' mode.
+  #
+  attr_reader :quiet
+
+  #
+  # `quiet?' is an alias of `quiet'.
+  #
+  alias quiet? quiet
+
+  #
+  # Explicitly terminate option processing.
+  #
+  def terminate
+    return nil if @status == STATUS_TERMINATED
+    raise RuntimeError, "an error has occured" if @error != nil
+
+    @status = STATUS_TERMINATED
+    @non_option_arguments.reverse_each do |argument|
+      ARGV.unshift(argument)
+    end
+
+    @canonical_names = nil
+    @argument_flags = nil
+    @rest_singles = nil
+    @non_option_arguments = nil
+
+    return self
+  end
+
+  #
+  # Returns true if option processing has terminated, false otherwise.
+  #
+  def terminated?
+    return @status == STATUS_TERMINATED
+  end
+
+  #
+  # Set an error (protected).
+  #
+  def set_error(type, message)
+    $deferr.print("#{$0}: #{message}\n") if !@quiet
+
+    @error = type
+    @error_message = message
+    @canonical_names = nil
+    @argument_flags = nil
+    @rest_singles = nil
+    @non_option_arguments = nil
+
+    raise type, message
+  end
+  protected :set_error
+
+  #
+  # Examine whether an option processing is failed.
+  #
+  attr_reader :error
+
+  #
+  # `error?' is an alias of `error'.
+  #
+  alias error? error
+
+  # Return the appropriate error message in POSIX-defined format.
+  # If no error has occurred, returns nil.
+  #
+  def error_message
+    return @error_message
+  end
+
+  #
+  # Get next option name and its argument, as an Array of two elements.
+  #
+  # The option name is always converted to the first (preferred)
+  # name given in the original options to GetoptLong.new.
+  #
+  # Example: ['--option', 'value']
+  #
+  # Returns nil if the processing is complete (as determined by
+  # STATUS_TERMINATED).
+  #
+  def get
+    option_name, option_argument = nil, ''
+
+    #
+    # Check status.
+    #
+    return nil if @error != nil
+    case @status
+    when STATUS_YET
+      @status = STATUS_STARTED
+    when STATUS_TERMINATED
+      return nil
+    end
+
+    #
+    # Get next option argument.
+    #
+    if 0 < @rest_singles.length
+      argument = '-' + @rest_singles
+    elsif (ARGV.length == 0)
+      terminate
+      return nil
+    elsif @ordering == PERMUTE
+      while 0 < ARGV.length && ARGV[0] !~ /^-./
+	@non_option_arguments.push(ARGV.shift)
+      end
+      if ARGV.length == 0
+	terminate
+	return nil
+      end
+      argument = ARGV.shift
+    elsif @ordering == REQUIRE_ORDER 
+      if (ARGV[0] !~ /^-./)
+	terminate
+	return nil
+      end
+      argument = ARGV.shift
+    else
+      argument = ARGV.shift
+    end
+
+    #
+    # Check the special argument `--'.
+    # `--' indicates the end of the option list.
+    #
+    if argument == '--' && @rest_singles.length == 0
+      terminate
+      return nil
+    end
+
+    #
+    # Check for long and short options.
+    #
+    if argument =~ /^(--[^=]+)/ && @rest_singles.length == 0
+      #
+      # This is a long style option, which start with `--'.
+      #
+      pattern = $1
+      if @canonical_names.include?(pattern)
+	option_name = pattern
+      else
+	#
+	# The option `option_name' is not registered in `@canonical_names'.
+	# It may be an abbreviated.
+	#
+	match_count = 0
+	@canonical_names.each_key do |key|
+	  if key.index(pattern) == 0
+	    option_name = key
+	    match_count += 1
+	  end
+	end
+	if 2 <= match_count
+	  set_error(AmbigousOption, "option `#{argument}' is ambiguous")
+	elsif match_count == 0
+	  set_error(InvalidOption, "unrecognized option `#{argument}'")
+	end
+      end
+
+      #
+      # Check an argument to the option.
+      #
+      if @argument_flags[option_name] == REQUIRED_ARGUMENT
+	if argument =~ /=(.*)$/
+	  option_argument = $1
+	elsif 0 < ARGV.length
+	  option_argument = ARGV.shift
+	else
+	  set_error(MissingArgument,
+	            "option `#{argument}' requires an argument")
+	end
+      elsif @argument_flags[option_name] == OPTIONAL_ARGUMENT
+	if argument =~ /=(.*)$/
+	  option_argument = $1
+	elsif 0 < ARGV.length && ARGV[0] !~ /^-./
+	  option_argument = ARGV.shift
+	else
+	  option_argument = ''
+	end
+      elsif argument =~ /=(.*)$/
+	set_error(NeedlessArgument,
+		  "option `#{option_name}' doesn't allow an argument")
+      end
+
+    elsif argument =~ /^(-(.))(.*)/
+      #
+      # This is a short style option, which start with `-' (not `--').
+      # Short options may be catenated (e.g. `-l -g' is equivalent to
+      # `-lg').
+      #
+      option_name, ch, @rest_singles = $1, $2, $3
+
+      if @canonical_names.include?(option_name)
+	#
+	# The option `option_name' is found in `@canonical_names'.
+	# Check its argument.
+	#
+	if @argument_flags[option_name] == REQUIRED_ARGUMENT
+	  if 0 < @rest_singles.length
+	    option_argument = @rest_singles
+	    @rest_singles = ''
+	  elsif 0 < ARGV.length
+	    option_argument = ARGV.shift
+	  else
+	    # 1003.2 specifies the format of this message.
+	    set_error(MissingArgument, "option requires an argument -- #{ch}")
+	  end
+	elsif @argument_flags[option_name] == OPTIONAL_ARGUMENT
+	  if 0 < @rest_singles.length
+	    option_argument = @rest_singles
+	    @rest_singles = ''
+	  elsif 0 < ARGV.length && ARGV[0] !~ /^-./
+	    option_argument = ARGV.shift
+	  else
+	    option_argument = ''
+	  end
+	end
+      else
+	#
+	# This is an invalid option.
+	# 1003.2 specifies the format of this message.
+	#
+	if ENV.include?('POSIXLY_CORRECT')
+	  set_error(InvalidOption, "illegal option -- #{ch}")
+	else
+	  set_error(InvalidOption, "invalid option -- #{ch}")
+	end
+      end
+    else
+      #
+      # This is a non-option argument.
+      # Only RETURN_IN_ORDER falled into here.
+      #
+      return '', argument
+    end
+
+    return @canonical_names[option_name], option_argument
+  end
+
+  #
+  # `get_option' is an alias of `get'.
+  #
+  alias get_option get
+
+  # Iterator version of `get'.
+  #
+  # The block is called repeatedly with two arguments:
+  # The first is the option name.
+  # The second is the argument which followed it (if any). 
+  # Example: ('--opt', 'value')
+  #
+  # The option name is always converted to the first (preferred)
+  # name given in the original options to GetoptLong.new.
+  #
+  def each
+    loop do
+      option_name, option_argument = get_option
+      break if option_name == nil
+      yield option_name, option_argument
+    end
+  end
+
+  #
+  # `each_option' is an alias of `each'.
+  #
+  alias each_option each
+end

data/lib/rubysl/getoptlong/version.rb

@@ -0,0 +1,5 @@
+module RubySL
+  module GetoptLong
+    VERSION = "1.0.0"
+  end
+end

data/rubysl-getoptlong.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+require './lib/rubysl/getoptlong/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubysl-getoptlong"
+  spec.version       = RubySL::GetoptLong::VERSION
+  spec.authors       = ["Brian Shirai"]
+  spec.email         = ["brixen@gmail.com"]
+  spec.description   = %q{Ruby standard library getoptlong.}
+  spec.summary       = %q{Ruby standard library getoptlong.}
+  spec.homepage      = "https://github.com/rubysl/rubysl-getoptlong"
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "mspec", "~> 1.5"
+  spec.add_development_dependency "rubysl-prettyprint", "~> 1.0"
+end

data/spec/each_option_spec.rb

@@ -0,0 +1,6 @@
+require 'getoptlong'
+require File.expand_path('../shared/each', __FILE__)
+
+describe "GetoptLong#each_option" do
+  it_behaves_like(:getoptlong_each, :each_option)
+end

data/spec/each_spec.rb

@@ -0,0 +1,6 @@
+require 'getoptlong'
+require File.expand_path('../shared/each', __FILE__)
+
+describe "GetoptLong#each" do
+  it_behaves_like(:getoptlong_each, :each)
+end

data/spec/error_message_spec.rb

@@ -0,0 +1,31 @@
+require 'getoptlong'
+
+describe "GetoptLong#error_message" do
+  before :each do
+    @stderr = $stderr
+    @argv = ARGV
+  end
+
+  after :each do
+    $stderr = @stderr
+    ARGV = @argv
+  end
+
+  it "returns nil if no error occurred" do
+    opts = GetoptLong.new
+    opts.error_message.should == nil
+  end
+
+  it "returns the error message of the last error that occurred" do
+    begin
+      ARGV = []
+
+      opts = GetoptLong.new
+      opts.quiet = true
+      opts.get
+      opts.ordering = GetoptLong::PERMUTE
+    rescue ArgumentError
+      opts.error_message.should == "argument error"
+    end
+  end
+end

data/spec/get_option_spec.rb

@@ -0,0 +1,6 @@
+require 'getoptlong'
+require File.expand_path('../shared/get', __FILE__)
+
+describe "GetoptLong#get_option" do
+  it_behaves_like(:getoptlong_get, :get_option)
+end

data/spec/get_spec.rb

@@ -0,0 +1,6 @@
+require 'getoptlong'
+require File.expand_path('../shared/get', __FILE__)
+
+describe "GetoptLong#get" do
+  it_behaves_like(:getoptlong_get, :get)
+end

data/spec/initialize_spec.rb

@@ -0,0 +1,27 @@
+require 'getoptlong'
+
+describe "GetoptLong#initialize" do
+  it "sets ordering to REQUIRE_ORDER if ENV['POSIXLY_CORRECT'] is set" do
+    begin
+      old_env_value = ENV["POSIXLY_CORRECT"]
+      ENV["POSIXLY_CORRECT"] = ""
+
+      opt = GetoptLong.new
+      opt.ordering.should == GetoptLong::REQUIRE_ORDER
+    ensure
+      ENV["POSIXLY_CORRECT"] = old_env_value
+    end
+  end
+
+  it "sets ordering to PERMUTE if ENV['POSIXLY_CORRECT'] is not set" do
+    begin
+      old_env_value = ENV["POSIXLY_CORRECT"]
+      ENV["POSIXLY_CORRECT"] = nil
+
+      opt = GetoptLong.new
+      opt.ordering.should == GetoptLong::PERMUTE
+    ensure
+      ENV["POSIXLY_CORRECT"] = old_env_value
+    end
+  end
+end

data/spec/ordering_spec.rb

@@ -0,0 +1,42 @@
+require 'getoptlong'
+
+describe "GetoptLong#ordering=" do
+  it "raises an ArgumentError if called after processing has started" do
+    begin
+      old_argv = ARGV
+      ARGV = [ "--size", "10k", "--verbose" ]
+
+      opts = GetoptLong.new([ '--size', GetoptLong::REQUIRED_ARGUMENT ],
+        [ '--verbose', GetoptLong::NO_ARGUMENT ])
+      opts.quiet = true
+      opts.get
+
+      lambda {
+        opts.ordering = GetoptLong::PERMUTE
+      }.should raise_error(ArgumentError)
+    ensure
+      ARGV = old_argv
+    end
+  end
+
+  it "raises an ArgumentError if given an invalid value" do
+    opts = GetoptLong.new
+
+    lambda {
+      opts.ordering = 12345
+    }.should raise_error(ArgumentError)
+  end
+
+  it "does not allow changing ordering to PERMUTE if ENV['POSIXLY_CORRECT'] is set" do
+    begin
+      old_env_value = ENV['POSIXLY_CORRECT']
+      ENV['POSIXLY_CORRECT'] = ""
+
+      opts = GetoptLong.new
+      opts.ordering = GetoptLong::PERMUTE
+      opts.ordering.should == GetoptLong::REQUIRE_ORDER
+    ensure
+      ENV['POSIXLY_CORRECT'] = old_env_value
+    end
+  end
+end

data/spec/set_options_spec.rb

@@ -0,0 +1,91 @@
+require 'getoptlong'
+
+describe "GetoptLong#set_options" do
+  before :each do
+    @argv = ARGV
+    ARGV = []
+    @opts = GetoptLong.new
+  end
+
+  after :each do
+    ARGV = @argv
+  end
+
+  it "allows setting command line options" do
+    ARGV = ["--size", "10k", "-v", "arg1", "arg2"]
+
+    @opts.set_options(
+      ["--size", GetoptLong::REQUIRED_ARGUMENT],
+      ["--verbose", "-v", GetoptLong::NO_ARGUMENT]
+    )
+
+    @opts.get.should == ["--size", "10k"]
+    @opts.get.should == ["--verbose", ""]
+    @opts.get.should == nil
+  end
+
+  it "discards previously defined command line options" do
+    ARGV = ["--size", "10k", "-v", "arg1", "arg2"]
+
+    @opts.set_options(
+      ["--size", GetoptLong::REQUIRED_ARGUMENT],
+      ["--verbose", "-v", GetoptLong::NO_ARGUMENT]
+    )
+
+    @opts.set_options(
+      ["-s", "--size", GetoptLong::REQUIRED_ARGUMENT],
+      ["-v", GetoptLong::NO_ARGUMENT]
+    )
+
+    @opts.get.should == ["-s", "10k"]
+    @opts.get.should == ["-v", ""]
+    @opts.get.should == nil
+  end
+
+  it "raises an ArgumentError if too many argument flags where given" do
+    lambda {
+      @opts.set_options(["--size", GetoptLong::NO_ARGUMENT, GetoptLong::REQUIRED_ARGUMENT])
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises a RuntimeError if processing has already started" do
+    @opts.get
+    lambda {
+      @opts.set_options()
+    }.should raise_error(RuntimeError)
+  end
+
+  it "raises an ArgumentError if no argument flag was given" do
+    lambda {
+      @opts.set_options(["--size"])
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises an ArgumentError if one of the given arguments is not an Array" do
+    lambda {
+      @opts.set_options(
+        ["--size", GetoptLong::REQUIRED_ARGUMENT],
+        "test")
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises an ArgumentError if the same option is given twice" do
+    lambda {
+      @opts.set_options(
+        ["--size", GetoptLong::NO_ARGUMENT],
+        ["--size", GetoptLong::OPTIONAL_ARGUMENT])
+    }.should raise_error(ArgumentError)
+
+    lambda {
+      @opts.set_options(
+        ["--size", GetoptLong::NO_ARGUMENT],
+        ["-s", "--size", GetoptLong::OPTIONAL_ARGUMENT])
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises an ArgumentError if the given option is invalid" do
+    lambda {
+      @opts.set_options(["-size", GetoptLong::NO_ARGUMENT])
+    }.should raise_error(ArgumentError)
+  end
+end

data/spec/shared/each.rb

@@ -0,0 +1,23 @@
+describe :getoptlong_each, :shared => true do
+  before(:each) do
+    @opts = GetoptLong.new(
+      [ '--size', '-s',             GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--verbose', '-v',          GetoptLong::NO_ARGUMENT ],
+      [ '--query', '-q',            GetoptLong::NO_ARGUMENT ],
+      [ '--check', '--valid', '-c', GetoptLong::NO_ARGUMENT ]
+    )
+  end
+
+  it "passes each argument/value pair to the block" do
+    begin
+      old_argv = ARGV
+      ARGV = [ "--size", "10k", "-v", "-q", "a.txt", "b.txt" ]
+
+      pairs = []
+      @opts.send(@method) { |arg, val| pairs << [ arg, val ] }
+      pairs.should == [ [ "--size", "10k" ], [ "--verbose", "" ], [ "--query", ""] ]
+    ensure
+      ARGV = old_argv
+    end
+  end
+end

data/spec/shared/get.rb

@@ -0,0 +1,75 @@
+describe :getoptlong_get, :shared => true do
+  before(:each) do
+    @opts = GetoptLong.new(
+      [ '--size', '-s',             GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--verbose', '-v',          GetoptLong::NO_ARGUMENT ],
+      [ '--query', '-q',            GetoptLong::NO_ARGUMENT ],
+      [ '--check', '--valid', '-c', GetoptLong::NO_ARGUMENT ]
+    )
+    @opts.quiet = true # silence using $deferr
+  end
+
+  it "returns the next option name and its argument as an Array" do
+    begin
+      old_argv = ARGV
+      ARGV = [ "--size", "10k", "-v", "-q", "a.txt", "b.txt" ]
+
+      @opts.send(@method).should == [ "--size", "10k" ]
+      @opts.send(@method).should == [ "--verbose", "" ]
+      @opts.send(@method).should == [ "--query", ""]
+      @opts.send(@method).should == nil
+    ensure
+      ARGV = old_argv
+    end
+  end
+
+  it "shifts ARGV on each call" do
+    begin
+      old_argv = ARGV
+      ARGV = [ "--size", "10k", "-v", "-q", "a.txt", "b.txt" ]
+
+      @opts.send(@method)
+      ARGV.should == [ "-v", "-q", "a.txt", "b.txt" ]
+
+      @opts.send(@method)
+      ARGV.should == [ "-q", "a.txt", "b.txt" ]
+
+      @opts.send(@method)
+      ARGV.should == [ "a.txt", "b.txt" ]
+
+      @opts.send(@method)
+      ARGV.should == [ "a.txt", "b.txt" ]
+    ensure
+      ARGV = old_argv
+    end
+  end
+
+  it "terminates processing when encountering '--'" do
+    begin
+      old_argv = ARGV
+      ARGV = [ "--size", "10k", "--", "-v", "-q", "a.txt", "b.txt" ]
+
+      @opts.send(@method)
+      ARGV.should == ["--", "-v", "-q", "a.txt", "b.txt"]
+
+      @opts.send(@method)
+      ARGV.should ==  ["-v", "-q", "a.txt", "b.txt"]
+
+      @opts.send(@method)
+      ARGV.should ==  ["-v", "-q", "a.txt", "b.txt"]
+    ensure
+      ARGV = old_argv
+    end
+  end
+
+  it "raises a if an argument was required, but none given" do
+    begin
+      old_argv = ARGV
+      ARGV = [ "--size" ]
+
+      lambda { @opts.send(@method) }.should raise_error(GetoptLong::MissingArgument)
+    ensure
+      ARGV = old_argv
+    end
+  end
+end

data/spec/terminate_spec.rb

@@ -0,0 +1,34 @@
+require 'getoptlong'
+
+describe "GetoptLong#terminate" do
+  before(:each) do
+    @opts = GetoptLong.new(
+      [ '--size', '-s',             GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--verbose', '-v',          GetoptLong::NO_ARGUMENT ],
+      [ '--query', '-q',            GetoptLong::NO_ARGUMENT ],
+      [ '--check', '--valid', '-c', GetoptLong::NO_ARGUMENT ]
+    )
+  end
+
+  it "terminates option proccessing" do
+    begin
+      old_argv = ARGV
+      ARGV = [ "--size", "10k", "-v", "-q", "a.txt", "b.txt" ]
+
+      @opts.get.should == [ "--size", "10k" ]
+      @opts.terminate
+      @opts.get.should == nil
+    ensure
+      ARGV = old_argv
+    end
+  end
+
+  it "returns self when option processsing is terminated" do
+    @opts.terminate.should == @opts
+  end
+
+  it "returns nil when option processing was already terminated" do
+    @opts.terminate
+    @opts.terminate.should == nil
+  end
+end

data/spec/terminated_spec.rb

@@ -0,0 +1,20 @@
+require 'getoptlong'
+
+describe "GetoptLong#terminated?" do
+  it "returns true if option processing has terminated" do
+    begin
+      old_argv_value = ARGV
+      ARGV = [ "--size", "10k" ]
+      opts = GetoptLong.new(["--size", GetoptLong::REQUIRED_ARGUMENT])
+      opts.terminated?.should == false
+
+      opts.get.should == ["--size", "10k"]
+      opts.terminated?.should == false
+
+      opts.get.should == nil
+      opts.terminated?.should == true
+    ensure
+      ARGV = old_argv_value
+    end
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: rubysl-getoptlong
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Shirai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: mspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rubysl-prettyprint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Ruby standard library getoptlong.
+email:
+- brixen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/getoptlong.rb
+- lib/rubysl/getoptlong.rb
+- lib/rubysl/getoptlong/getoptlong.rb
+- lib/rubysl/getoptlong/version.rb
+- rubysl-getoptlong.gemspec
+- spec/each_option_spec.rb
+- spec/each_spec.rb
+- spec/error_message_spec.rb
+- spec/get_option_spec.rb
+- spec/get_spec.rb
+- spec/initialize_spec.rb
+- spec/ordering_spec.rb
+- spec/set_options_spec.rb
+- spec/shared/each.rb
+- spec/shared/get.rb
+- spec/terminate_spec.rb
+- spec/terminated_spec.rb
+homepage: https://github.com/rubysl/rubysl-getoptlong
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: Ruby standard library getoptlong.
+test_files:
+- spec/each_option_spec.rb
+- spec/each_spec.rb
+- spec/error_message_spec.rb
+- spec/get_option_spec.rb
+- spec/get_spec.rb
+- spec/initialize_spec.rb
+- spec/ordering_spec.rb
+- spec/set_options_spec.rb
+- spec/shared/each.rb
+- spec/shared/get.rb
+- spec/terminate_spec.rb
+- spec/terminated_spec.rb