ThiagoLelis-backgroundjob 1.0.4 → 1.0.5

data/lib/main/cast.rb

@@ -1,100 +1,100 @@
-module Main
-  module Cast
-    def self.export m
-      module_function m
-      public m
-    end
-
-    List = []
-
-    def self.cast m, &b
-      define_method m, &b
-      export m
-      List << m.to_s
-    end
-
-    cast :boolean do |obj|
-      case obj.to_s
-        when %r/^(true|t|1)$/ 
-          true
-        when %r/^(false|f|0)$/ 
-          false
-        else
-          !!obj
-      end
-    end
-
-    cast :integer do |obj|
-      Integer obj
-    end
-
-    cast :float do |obj|
-      Float obj
-    end
-
-    cast :number do |obj|
-      Float obj rescue Integer obj
-    end
-
-    cast :string do |obj|
-      String obj
-    end
-
-    cast :symbol do |obj|
-      String(obj).to_sym
-    end
-
-    cast :uri do |obj|
-      require 'uri'
-      ::URI.parse obj.to_s
-    end
-
-    cast :time do |obj|
-      require 'time'
-      ::Time.parse obj.to_s
-    end
-
-    cast :date do |obj|
-      require 'date'
-      ::Date.parse obj.to_s
-    end
-
-    cast :list do |*objs|
-      [*objs].flatten.join(',').split(/,/)
-    end
-
-  # add list_of_xxx methods
-    List.dup.each do |type|
-      next if type.to_s =~ %r/list/ 
-      m = "list_of_#{ type }"
-      define_method m do |*objs|
-        list(*objs).map{|obj| send type, obj}
-      end
-      export m 
-      List << m
-    end
-
-  # add list_of_xxx_from_file
-    List.dup.each do |type|
-      next if type.to_s =~ %r/list/ 
-      m = "list_of_#{ type }"
-      define_method m do |*objs|
-        list(*objs).map{|obj| send type, obj}
-      end
-      export m 
-      List << m
-    end
-
-    def self.[] sym
-      prefix = sym.to_s.downcase.to_sym
-      candidates = List.select{|m| m =~ %r/^#{ prefix }/i}
-      m = candidates.shift
-      raise ArgumentError, "unsupported cast: #{ sym.inspect } (#{ List.join ',' })" unless
-        m
-      raise ArgumentError, "ambiguous cast: #{ sym.inspect } (#{ List.join ',' })" unless
-        candidates.empty? or m.to_s == sym.to_s
-      this = self
-      lambda{|obj| method(m).call obj}
-    end
-  end
-end
+module Main
+  module Cast
+    def self.export m
+      module_function m
+      public m
+    end
+
+    List = []
+
+    def self.cast m, &b
+      define_method m, &b
+      export m
+      List << m.to_s
+    end
+
+    cast :boolean do |obj|
+      case obj.to_s
+        when %r/^(true|t|1)$/ 
+          true
+        when %r/^(false|f|0)$/ 
+          false
+        else
+          !!obj
+      end
+    end
+
+    cast :integer do |obj|
+      Integer obj
+    end
+
+    cast :float do |obj|
+      Float obj
+    end
+
+    cast :number do |obj|
+      Float obj rescue Integer obj
+    end
+
+    cast :string do |obj|
+      String obj
+    end
+
+    cast :symbol do |obj|
+      String(obj).to_sym
+    end
+
+    cast :uri do |obj|
+      require 'uri'
+      ::URI.parse obj.to_s
+    end
+
+    cast :time do |obj|
+      require 'time'
+      ::Time.parse obj.to_s
+    end
+
+    cast :date do |obj|
+      require 'date'
+      ::Date.parse obj.to_s
+    end
+
+    cast :list do |*objs|
+      [*objs].flatten.join(',').split(/,/)
+    end
+
+  # add list_of_xxx methods
+    List.dup.each do |type|
+      next if type.to_s =~ %r/list/ 
+      m = "list_of_#{ type }"
+      define_method m do |*objs|
+        list(*objs).map{|obj| send type, obj}
+      end
+      export m 
+      List << m
+    end
+
+  # add list_of_xxx_from_file
+    List.dup.each do |type|
+      next if type.to_s =~ %r/list/ 
+      m = "list_of_#{ type }"
+      define_method m do |*objs|
+        list(*objs).map{|obj| send type, obj}
+      end
+      export m 
+      List << m
+    end
+
+    def self.[] sym
+      prefix = sym.to_s.downcase.to_sym
+      candidates = List.select{|m| m =~ %r/^#{ prefix }/i}
+      m = candidates.shift
+      raise ArgumentError, "unsupported cast: #{ sym.inspect } (#{ List.join ',' })" unless
+        m
+      raise ArgumentError, "ambiguous cast: #{ sym.inspect } (#{ List.join ',' })" unless
+        candidates.empty? or m.to_s == sym.to_s
+      this = self
+      lambda{|obj| method(m).call obj}
+    end
+  end
+end

data/lib/main/factories.rb

@@ -1,20 +1,20 @@
-module Main
-  def Main.create *a, &b
-    ::Main::Base.create(::Main::Base, *a, &b)
-  end
-
-  def Main.new *a, &b
-    create(::Main::Base, &b).new *a
-  end
-
-  def Main.run argv = ARGV, env = ENV, opts = {}, &block
-    Base.create(&block).new(argv, env, opts).run
-  end
-
-  module ::Kernel
-    def Main argv = ARGV, env = ENV, opts = {}, &block
-      ::Main.run argv, env, opts, &block
-    end
-    alias_method 'main', 'Main'
-  end
-end
+module Main
+  def Main.create *a, &b
+    ::Main::Base.create(::Main::Base, *a, &b)
+  end
+
+  def Main.new *a, &b
+    create(::Main::Base, &b).new *a
+  end
+
+  def Main.run argv = ARGV, env = ENV, opts = {}, &block
+    Base.create(&block).new(argv, env, opts).run
+  end
+
+  module ::Kernel
+    def Main argv = ARGV, env = ENV, opts = {}, &block
+      ::Main.run argv, env, opts, &block
+    end
+    alias_method 'main', 'Main'
+  end
+end

data/lib/main/getoptlong.rb

@@ -1,470 +1,470 @@
-#                                                         -*- Ruby -*-
-# Copyright (C) 1998, 1999, 2000  Motoyuki Kasahara
-#
-# You may redistribute it and/or modify it under the same license
-# terms as Ruby.
-#
-
-#
-# Documents and latest version of `getoptlong.rb' are found at:
-#    http://www.sra.co.jp/people/m-kasahr/ruby/getoptlong/
-#
-
-#
-# Parse command line options just like GNU getopt_long().
-#
-module Main
-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 AmbigousOption   < StandardError; end
-  class NeedlessArgument < StandardError; end
-  class MissingArgument  < StandardError; end
-  class InvalidOption    < StandardError; end
-
-  #
-  # Initializer.
-  #
-  def initialize(argv, *arguments)
-    @argv = argv
-    #
-    # Current ordering.
-    #
-    if ENV.include?('POSIXLY_CORRECT')
-      @ordering = REQUIRE_ORDER
-    else
-      @ordering = PERMUTE
-    end
-
-    #
-    # Hash table of option names.
-    # Keyes of the table are option names, and their values are canonical
-    # names of the options.
-    #
-    @canonical_names = Hash.new
-
-    #
-    # Hash table of argument flags.
-    # Keyes 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 stderr.
-    #
-    @quiet = FALSE
-
-    #
-    # Status code.
-    #
-    @status = STATUS_YET
-
-    #
-    # Error code.
-    #
-    @error = nil
-
-    #
-    # Error message.
-    #
-    @error_message = nil
-
-    #
-    # Rest of catinated 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 ordering.
-  #
-  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
-  #
-  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 `quit' mode.
-  #
-  attr_writer :quiet
-
-  #
-  # Return the flag of `quiet' mode.
-  #
-  attr_reader :quiet
-
-  #
-  # `quiet?' is an alias of `quiet'.
-  #
-  alias quiet? quiet
-
-  #
-  # Termintate 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
-
-  #
-  # Examine whether option processing is termintated or not.
-  #
-  def terminated?
-    return @status == STATUS_TERMINATED
-  end
-
-  #
-  # Set an error (protected).
-  #
-  def set_error(type, message)
-    #$stderr.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 an error message.
-  #
-  def error_message
-    return @error_message
-  end
-
-  #
-  # Get next option name and its argument as an array.
-  #
-  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 catinated (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'.
-  #
-  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
-end
+#                                                         -*- Ruby -*-
+# Copyright (C) 1998, 1999, 2000  Motoyuki Kasahara
+#
+# You may redistribute it and/or modify it under the same license
+# terms as Ruby.
+#
+
+#
+# Documents and latest version of `getoptlong.rb' are found at:
+#    http://www.sra.co.jp/people/m-kasahr/ruby/getoptlong/
+#
+
+#
+# Parse command line options just like GNU getopt_long().
+#
+module Main
+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 AmbigousOption   < StandardError; end
+  class NeedlessArgument < StandardError; end
+  class MissingArgument  < StandardError; end
+  class InvalidOption    < StandardError; end
+
+  #
+  # Initializer.
+  #
+  def initialize(argv, *arguments)
+    @argv = argv
+    #
+    # Current ordering.
+    #
+    if ENV.include?('POSIXLY_CORRECT')
+      @ordering = REQUIRE_ORDER
+    else
+      @ordering = PERMUTE
+    end
+
+    #
+    # Hash table of option names.
+    # Keyes of the table are option names, and their values are canonical
+    # names of the options.
+    #
+    @canonical_names = Hash.new
+
+    #
+    # Hash table of argument flags.
+    # Keyes 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 stderr.
+    #
+    @quiet = FALSE
+
+    #
+    # Status code.
+    #
+    @status = STATUS_YET
+
+    #
+    # Error code.
+    #
+    @error = nil
+
+    #
+    # Error message.
+    #
+    @error_message = nil
+
+    #
+    # Rest of catinated 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 ordering.
+  #
+  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
+  #
+  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 `quit' mode.
+  #
+  attr_writer :quiet
+
+  #
+  # Return the flag of `quiet' mode.
+  #
+  attr_reader :quiet
+
+  #
+  # `quiet?' is an alias of `quiet'.
+  #
+  alias quiet? quiet
+
+  #
+  # Termintate 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
+
+  #
+  # Examine whether option processing is termintated or not.
+  #
+  def terminated?
+    return @status == STATUS_TERMINATED
+  end
+
+  #
+  # Set an error (protected).
+  #
+  def set_error(type, message)
+    #$stderr.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 an error message.
+  #
+  def error_message
+    return @error_message
+  end
+
+  #
+  # Get next option name and its argument as an array.
+  #
+  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 catinated (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'.
+  #
+  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
+end