benry-cmdopt 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51be94488014a32dabfc2f524a850fa657a11c4c1d9d9b92761d00e57e24969e
+  data.tar.gz: d2078058fec806f194f0bfd1d5d6705a78430c7989d7eb9ddccadea2daa3311b
+SHA512:
+  metadata.gz: 41e0e1a914cb6022f31244d6770067bd38636f27c0ce9e30dbcd37a731bc8d3f485329e0c0b49ff3aa322250f6d475ee0c28032a1053132e0f8c2bf061b2aa7c
+  data.tar.gz: e5e3922ccf2d06e9b56997cc07e7616dfa905fedb1974953f7bc9138d7b888cab6d5b5c8025000cd574b8b608ead71ef772571fa71486c5467294d20376bdb9e

data/CHANGES.md

@@ -0,0 +1,9 @@
+=======
+CHANGES
+=======
+
+
+Release 1.0.0 (2021-01-17)
+--------------------------
+
+* First public release

data/README.md

@@ -0,0 +1,163 @@
+Benry::Cmdopt README
+====================
+
+($Release: 1.0.0 $)
+
+Benry::Cmdopt is a command option parser library, like `optparse.rb`.
+
+Compared to `optparse.rb`:
+
+* Easy to use, easy to extend, easy to understand.
+* Not add `-h` nor `--help` automatically.
+* Not add `-v` nor `--version` automatically.
+* Not regard `-x` as short cut of `--xxx`.
+  (`optparser.rb` regards `-x` as short cut of `--xxx` automatically.)
+* Provides very simple feature to build custom help message.
+* Separates command option schema class from parser class.
+
+(Benry::Cmdopt requires Ruby >= 2.3)
+
+
+Usage
+=====
+
+
+Define, parse, and print help
+-----------------------------
+
+```ruby
+require 'benry/cmdopt'
+
+## define
+cmdopt = Benry::Cmdopt.new
+cmdopt.add(:help   , "-h, --help"   , "print help message")
+cmdopt.add(:version, "    --version", "print version")
+
+## parse with error handling
+options = cmdopt.parse(ARGV) do |err|
+  $stderr.puts "ERROR: #{err.message}"
+  exit(1)
+end
+p options     # ex: {:help => true, :version => true}
+p ARGV        # options are removed from ARGV
+
+## help
+if options[:help]
+  puts "Usage: foobar [<options>] [<args>...]"
+  puts ""
+  puts "Options:"
+  puts cmdopt.build_option_help()
+  ## or
+  #format = "  %-20s : %s"
+  #cmdopt.each_option_help {|opt, help| puts format % [opt, help] }
+end
+```
+
+
+Command option parameter
+------------------------
+
+```ruby
+## required parameter
+cmdopt.add(:file, "-f, --file=<FILE>", "filename")
+cmdopt.add(:file, "    --file=<FILE>", "filename")
+cmdopt.add(:file, "-f <FILE>"        , "filename")
+
+## optional parameter
+cmdopt.add(:file, "-f, --file[=<FILE>]", "filename")
+cmdopt.add(:file, "    --file[=<FILE>]", "filename")
+cmdopt.add(:file, "-f[<FILE>]"         , "filename")
+```
+
+
+Argument varidation
+-------------------
+
+```ruby
+## type
+cmdopt.add(:indent , "-i <N>", "indent width", type: Integer)
+## pattern
+cmdopt.add(:indent , "-i <N>", "indent width", pattern: /\A\d+\z/)
+## enum
+cmdopt.add(:indent , "-i <N>", "indent width", enum: [2, 4, 8])
+## callback
+cmdopt.add(:indent , "-i <N>", "indent width") {|val|
+  val =~ /\A\d+\z/  or
+    raise "integer expected."  # raise without exception class.
+  val.to_i                     # convert argument value.
+}
+```
+
+
+Available types
+---------------
+
+* Integer   (`/\A[-+]?\d+\z/`)
+* Float     (`/\A[-+]?(\d+\.\d*\|\.\d+)z/`)
+* TrueClass (`/\A(true|on|yes|false|off|no)\z/`)
+* Date      (`/\A\d\d\d\d-\d\d?-\d\d?\z/`)
+
+
+Multiple parameters
+-------------------
+
+```ruby
+cmdopt.add(:lib , "-I <NAME>", "library names") {|optdict, key, val|
+  arr = optdict[key] || []
+  arr << val
+  arr
+}
+```
+
+
+Not support
+-----------
+
+* default value
+* `--no-xxx` style option
+
+
+Internal classes
+================
+
+* `Benry::Cmdopt::Schema` -- command option schema.
+* `Benry::Cmdopt::Parser` -- command option parser.
+* `Benry::Cmdopt::Facade` -- facade object including schema and parser.
+
+```ruby
+require 'benry/cmdopt'
+
+## define schema
+schema = Benry::Cmdopt::Schema.new
+schema.add(:help  , '-h, --help'            , "show help message")
+schema.add(:file  , '-f, --file=<FILE>'     , "filename")
+schema.add(:indent, '-i, --indent[=<WIDTH>]', "enable indent", type: Integer)
+
+## parse options
+parser = Benry::Cmdopt::Parser.new(schema)
+argv = ['-hi2', '--file=blabla.txt', 'aaa', 'bbb']
+opts = parser.parse(argv) do |err|
+  $stderr.puts "ERROR: #{err.message}"
+  exit 1
+end
+p opts   #=> [:help=>true, :indent=>2, :file=>"blabla.txt"]
+p argv   #=> ["aaa", "bbb"]
+```
+
+Notice that `Benry::Cmdopt.new()` returns facade object.
+
+```ruby
+require 'benry/cmdopt'
+
+cmdopt = Benry::Cmdopt.new()             # new facade object
+cmdopt.add(:help, '-h', "help message")  # same as schema.add(...)
+opts = cmdopt.parse(ARGV)                # same as parser.parse(...)
+```
+
+
+License and Copyright
+=====================
+
+$License: MIT License $
+
+$Copyright: copyright(c) 2021 kuwata-lab.com all rights reserved $

data/Rakefile.rb

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+
+project   = "benry-cmdopt"
+release   = ENV['RELEASE'] || "0.0.0"
+copyright = "copyright(c) 2021 kuwata-lab.com all rights reserved"
+license   = "MIT License"
+
+target_files = Dir[*%W[
+  README.md CHANGES.md MIT-LICENSE.txt Rakefile.rb
+  lib/**/*.rb
+  test/**/*_test.rb
+  #{project}.gemspec
+]]
+
+
+require 'rake/clean'
+CLEAN << "build"
+CLOBBER << Dir.glob("#{project}-*.gem")
+
+
+task :default => :help
+
+
+desc "show help"
+task :help do
+  puts "rake help                   # help"
+  puts "rake test                   # run test"
+  puts "rake package RELEASE=X.X.X  # create gem file"
+  puts "rake publish RELEASE=X.X.X  # upload gem file"
+  puts "rake clean                  # remove files"
+end
+
+
+desc "do test"
+task :test do
+  sh "ruby", *Dir.glob("test/*.rb")
+end
+
+
+desc "create package"
+task :package do
+  release != "0.0.0"  or
+    raise "specify $RELEASE"
+  ## copy
+  dir = "build"
+  rm_rf dir if File.exist?(dir)
+  mkdir dir
+  target_files.each do |file|
+    dest = File.join(dir, File.dirname(file))
+    mkdir_p dest, :verbose=>false unless File.exist?(dest)
+    cp file, "#{dir}/#{file}"
+  end
+  ## edit
+  Dir.glob("#{dir}/**/*").each do |file|
+    next unless File.file?(file)
+    File.open(file, 'rb+') do |f|
+      s1 = f.read()
+      s2 = s1
+      s2 = s2.gsub(/\$Release[:].*?\$/,   "$"+"Release: #{release} $")
+      s2 = s2.gsub(/\$Copyright[:].*?\$/, "$"+"Copyright: #{copyright} $")
+      s2 = s2.gsub(/\$License[:].*?\$/,   "$"+"License: #{license} $")
+      #
+      if s1 != s2
+        f.rewind()
+        f.truncate(0)
+        f.write(s2)
+      end
+    end
+  end
+  ## build
+  chdir dir do
+    sh "gem build #{project}.gemspec"
+  end
+  mv "#{dir}/#{project}-#{release}.gem", "."
+end
+
+
+desc "upload gem file to rubygems.org"
+task :publish do
+  release != "0.0.0"  or
+    raise "specify $RELEASE"
+  #
+  gemfile = "#{project}-#{release}.gem"
+  print "** Are you sure to publish #{gemfile}? [y/N]: "
+  answer = $stdin.gets().strip()
+  if answer.downcase == "y"
+    sh "gem push #{gemfile}"
+    sh "git tag ruby-#{project}-#{release}"
+    sh "git push --tags"
+  end
+end

data/benry-cmdopt.gemspec

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+Gem::Specification.new do |spec|
+  spec.name            = 'benry-cmdopt'
+  spec.version         = '$Release: 1.0.0 $'.split()[1]
+  spec.author          = 'kwatch'
+  spec.email           = 'kwatch@gmail.com'
+  spec.platform        = Gem::Platform::RUBY
+  spec.homepage        = 'https://github.com/kwatch/benry/tree/ruby/benry-cmdopt'
+  spec.summary         = "Command option parser, like `optparse.rb`"
+  spec.description     = <<-'END'
+Command option parser, like `optparse.rb`.
+END
+  spec.license         = 'MIT'
+  spec.files           = Dir[
+                           'README.md', 'CHANGES.md', 'MIT-LICENSE',
+			   'Rakefile.rb', 'benry-cmdopt.gemspec',
+			   'bin/*',
+                           'lib/**/*.rb',
+                           'test/**/*.rb',
+                         ]
+  #spec.executables     = ['benry-cmdopt']
+  spec.bindir          = 'bin'
+  spec.require_path    = 'lib'
+  spec.test_files      = Dir['test/**/*_test.rb']
+  #spec.extra_rdoc_files = ['README.md', 'CHANGES.md']
+
+  spec.add_development_dependency 'minitest'    , '~> 5.8'
+  spec.add_development_dependency 'minitest-ok' , '~> 0.3'
+end

data/lib/benry/cmdopt.rb

@@ -0,0 +1,504 @@
+# -*- coding: utf-8 -*-
+
+###
+### $Release$
+### $Copyright$
+### $License$
+###
+
+require 'date'
+require 'set'
+
+
+module Benry
+
+
+  ##
+  ## Command option parser.
+  ##
+  ## Usage:
+  ##     ## define
+  ##     cmdopt = Benry::Cmdopt.new
+  ##     cmdopt.add(:help   , "-h, --help"   , "print help message")
+  ##     cmdopt.add(:version, "    --version", "print version")
+  ##     ## parse
+  ##     options = cmdopt.parse(ARGV) do |err|
+  ##       $stderr.puts "ERROR: #{err.message}"
+  ##       exit(1)
+  ##     end
+  ##     p options     # ex: {:help => true, :version => true}
+  ##     p ARGV        # options are removed from ARGV
+  ##     ## help
+  ##     if options[:help]
+  ##       puts "Usage: foobar [<options>] [<args>...]"
+  ##       puts ""
+  ##       puts "Options:"
+  ##       puts cmdopt.build_option_help()
+  ##       ## or
+  ##       #format = "  %-20s : %s"
+  ##       #cmdopt.each_option_help {|opt, help| puts format % [opt, help] }
+  ##     end
+  ##
+  ## Command option parameter:
+  ##     ## required
+  ##     cmdopt.add(:file, "-f, --file=<FILE>", "filename")
+  ##     cmdopt.add(:file, "    --file=<FILE>", "filename")
+  ##     cmdopt.add(:file, "-f <FILE>"        , "filename")
+  ##     ## optional
+  ##     cmdopt.add(:file, "-f, --file[=<FILE>]", "filename")
+  ##     cmdopt.add(:file, "    --file[=<FILE>]", "filename")
+  ##     cmdopt.add(:file, "-f[<FILE>]"         , "filename")
+  ##
+  ## Validation:
+  ##     ## type
+  ##     cmdopt.add(:indent , "-i <N>", "indent width", type: Integer)
+  ##     ## pattern
+  ##     cmdopt.add(:indent , "-i <N>", "indent width", pattern: /\A\d+\z/)
+  ##     ## enum
+  ##     cmdopt.add(:indent , "-i <N>", "indent width", enum: [2, 4, 8])
+  ##     ## callback
+  ##     cmdopt.add(:indent , "-i <N>", "indent width") {|val|
+  ##       val =~ /\A\d+\z/  or
+  ##         raise "integer expected."  # raise without exception class.
+  ##       val.to_i                     # convert argument value.
+  ##     }
+  ##
+  ## Available types:
+  ##     * Integer   (`/\A[-+]?\d+\z/`)
+  ##     * Float     (`/\A[-+]?(\d+\.\d*\|\.\d+)z/`)
+  ##     * TrueClass (`/\A(true|on|yes|false|off|no)\z/`)
+  ##     * Date      (`/\A\d\d\d\d-\d\d?-\d\d?\z/`)
+  ##
+  ## Multiple parameters:
+  ##     cmdopt.add(:lib , "-I <NAME>", "library names") {|optdict, key, val|
+  ##       arr = optdict[key] || []
+  ##       arr << val
+  ##       arr
+  ##     }
+  ##
+  ## Not support:
+  ##     * default value
+  ##     * `--no-xxx` style option
+  ##
+  module Cmdopt
+
+
+    VERSION = '$Release: 1.0.0 $'.split()[1]
+
+
+    def self.new
+      #; [!7kkqv] creates Facade object.
+      return Facade.new
+    end
+
+
+    class Facade
+
+      def initialize
+        @schema = SCHEMA_CLASS.new
+      end
+
+      def add(key, optdef, help, type: nil, pattern: nil, enum: nil, &callback)
+        #; [!vmb3r] defines command option.
+        @schema.add(key, optdef, help, type: type, pattern: pattern, enum: enum, &callback)
+        #; [!tu4k3] returns self.
+        self
+      end
+
+      def build_option_help(width_or_format=nil, all: false)
+        #; [!dm4p8] returns option help message.
+        return @schema.build_option_help(width_or_format, all: all)
+      end
+
+      def each_option_help(&block)
+        #; [!bw9qx] yields each option definition string and help message.
+        @schema.each_option_help(&block)
+        self
+      end
+
+      def parse(argv, &error_handler)
+        #; [!7gc2m] parses command options.
+        #; [!no4xu] returns option values as dict.
+        #; [!areof] handles only OptionError when block given.
+        #; [!peuva] returns nil when OptionError handled.
+        parser = PARSER_CLASS.new(@schema)
+        return parser.parse(argv, &error_handler)
+      end
+
+    end
+
+
+    class Schema
+
+      def initialize()
+        @items = []
+      end
+
+      def add(key, optdef, help, type: nil, pattern: nil, enum: nil, &callback)
+        #; [!rhhji] raises SchemaError when key is not a Symbol.
+        key.nil? || key.is_a?(Symbol)  or
+          raise error("add(#{key.inspect}): 1st arg should be a Symbol as an option key.")
+        #; [!vq6eq] raises SchemaError when help message is missing."
+        help.nil? || help.is_a?(String)  or
+          raise error("add(#{key.inspect}, #{optdef.inspect}): help message required as 3rd argument.")
+        #; [!7hi2d] takes command option definition string.
+        short, long, param, optional = parse_optdef(optdef)
+        #; [!p9924] option key is omittable only when long option specified.
+        #; [!jtp7z] raises SchemaError when key is nil and no long option.
+        key || long  or
+          raise error("add(#{key.inspect}, #{optdef.inspect}): long option required when option key (1st arg) not specified.")
+        key ||= long.gsub(/-/, '_').intern
+        #; [!7xmr5] raises SchemaError when type is not registered.
+        #; [!s2aaj] raises SchemaError when option has no params but type specified.
+        if type
+          PARAM_TYPES.key?(type)  or
+            raise error("#{type.inspect}: unregistered type.")
+          param  or
+            raise error("#{type.inspect}: type specified in spite of option has no params.")
+        end
+        #; [!bi2fh] raises SchemaError when pattern is not a regexp.
+        #; [!01fmt] raises SchmeaError when option has no params but pattern specified.
+        if pattern
+          pattern.is_a?(Regexp)  or
+            raise error("#{pattern.inspect}: regexp expected.")
+          param  or
+            raise error("#{pattern.inspect}: pattern specified in spite of option has no params.")
+        end
+        #; [!melyd] raises SchmeaError when enum is not a Array nor Set.
+        #; [!xqed8] raises SchemaError when enum specified for no param option.
+        if enum
+          enum.is_a?(Array) || enum.is_a?(Set)  or
+            raise error("#{enum.inspect}: array or set expected.")
+          param  or
+            raise error("#{enum.inspect}: enum specified in spite of option has no params.")
+        end
+        #; [!yht0v] keeps command option definitions.
+        item = SchemaItem.new(key, optdef, short, long, param, help,
+                   optional: optional, type: type, pattern: pattern, enum: enum, &callback)
+        @items << item
+        item
+      end
+
+      def build_option_help(width_or_format=nil, all: false)
+        #; [!0aq0i] can take integer as width.
+        #; [!pcsah] can take format string.
+        #; [!dndpd] detects option width automatically when nothing specified.
+        case width_or_format
+        when nil    ; format = _default_format()
+        when Integer; format = "  %-#{width_or_format}s: %s"
+        when String ; format = width_or_format
+        else
+          raise ArgumentError.new("#{width_or_format.inspect}: width (integer) or format (string) expected.")
+        end
+        #; [!v7z4x] skips option help if help message is not specified.
+        #; [!to1th] includes all option help when `all` is true.
+        buf = []
+        width = nil
+        each_option_help do |opt, help|
+          #buf << format % [opt, help] << "\n" if help || all
+          if help
+            #; [!848rm] supports multi-lines help message.
+            n = 0
+            help.each_line do |line|
+              if (n += 1) == 1
+                buf << format % [opt, line.chomp] << "\n"
+              else
+                width ||= (format % ['', '']).length
+                buf << (' ' * width) << line.chomp << "\n"
+              end
+            end
+          elsif all
+            buf << format % [opt, ''] << "\n"
+          end
+        end
+        return buf.join()
+      end
+
+      def _default_format(min_width=20, max_width=35)
+        #; [!hr45y] detects preffered option width.
+        w = 0
+        each_option_help do |opt, help|
+          w = opt.length if w < opt.length
+        end
+        w = min_width if w < min_width
+        w = max_width if w > max_width
+        #; [!kkh9t] returns format string.
+        return "  %-#{w}s : %s"
+      end
+      private :_default_format
+
+      def each_option_help(&block)
+        #; [!4b911] yields each optin definition str and help message.
+        @items.each do |item|
+          yield item.optdef, item.help
+        end
+        #; [!zbxyv] returns self.
+        self
+      end
+
+      def find_short_option(short)
+        #; [!b4js1] returns option definition matched to short name.
+        #; [!s4d1y] returns nil when nothing found.
+        return @items.find {|item| item.short == short }
+      end
+
+      def find_long_option(long)
+        #; [!atmf9] returns option definition matched to long name.
+        #; [!6haoo] returns nil when nothing found.
+        return @items.find {|item| item.long == long }
+      end
+
+      private
+
+      def error(msg)
+        return SchemaError.new(msg)
+      end
+
+      def parse_optdef(optdef)
+        #; [!qw0ac] parses command option definition string.
+        #; [!ae733] parses command option definition which has a required param.
+        #; [!4h05c] parses command option definition which has an optional param.
+        #; [!b7jo3] raises SchemaError when command option definition is invalid.
+        case optdef
+        when /\A[ \t]*-(\w),[ \t]*--(\w[-\w]*)(?:=(\S*?)|\[=(\S*?)\])?\z/
+          short, long, param1, param2 = $1, $2, $3, $4
+        when /\A[ \t]*-(\w)(?:[ \t]+(\S+)|\[(\S+)\])?\z/
+          short, long, param1, param2 = $1, nil, $2, $3
+        when /\A[ \t]*--(\w[-\w]*)(?:=(\S*?)|\[=(\S*?)\])?\z/
+          short, long, param1, param2 = nil, $1, $2, $3
+        when /(--\w[-\w])*[ \t]+(\S+)/
+          raise error("#{optdef}: invalid option definition (use '#{$1}=#{$2}' instead of '#{$1} #{$2}').")
+        else
+          raise error("#{optdef}: invalid option definition.")
+        end
+        return short, long, param1 || param2, !!param2
+      end
+
+    end
+
+
+    class SchemaItem    # avoid Struct
+
+      def initialize(key, optdef, short, long, param, help, optional: nil, type: nil, pattern: nil, enum: nil, &callback)
+        @key      = key
+        @optdef   = optdef
+        @short    = short
+        @long     = long
+        @param    = param
+        @help     = help
+        @optional = optional
+        @type     = type
+        @pattern  = pattern
+        @enum     = enum
+        @callback = callback
+      end
+
+      attr_reader :key, :optdef, :short, :long, :param, :help, :optional, :type, :pattern, :enum, :callback
+
+      def optional_param?
+        @optional
+      end
+
+      def validate_and_convert(val, optdict)
+        #; [!h0s0o] raises RuntimeError when value not matched to pattern.
+        if @pattern && val != true
+          val =~ @pattern  or
+            raise "pattern unmatched."
+        end
+        #; [!j4fuz] calls type-specific callback when type specified.
+        if @type && val != true
+          proc_ = PARAM_TYPES[@type]
+          val = proc_.call(val)
+        end
+        #; [!5jrdf] raises RuntimeError when value not in enum.
+        if @enum && val != true
+          @enum.include?(val)  or
+            raise "expected one of #{@enum.join('/')}."
+        end
+        #; [!jn9z3] calls callback when callback specified.
+        #; [!iqalh] calls callback with different number of args according to arity.
+        if @callback
+          n_args = @callback.arity
+          val = n_args == 1 ? @callback.call(val) \
+                            : @callback.call(optdict, @key, val)
+        end
+        #; [!x066l] returns new value.
+        return val
+      end
+
+    end
+
+
+    PARAM_TYPES = {
+      String => proc {|val|
+        val
+      },
+      Integer => proc {|val|
+        #; [!6t8cs] converts value into integer.
+        #; [!nzwc9] raises error when failed to convert value into integer.
+        val =~ /\A[-+]?\d+\z/  or
+          raise "integer expected."
+        val.to_i
+      },
+      Float => proc {|val|
+        #; [!gggy6] converts value into float.
+        #; [!t4elj] raises error when faield to convert value into float.
+        val =~ /\A[-+]?(\d+\.\d*|\.\d+)\z/  or
+          raise "float expected."
+        val.to_f
+      },
+      TrueClass => proc {|val|
+        #; [!47kx4] converts 'true'/'on'/'yes' into true.
+        #; [!3n810] converts 'false'/'off'/'no' into false.
+        #; [!h8ayh] raises error when failed to convert value into true nor false.
+        case val
+        when /\A(?:true|on|yes)\z/i
+          true
+        when /\A(?:false|off|no)\z/i
+          false
+        else
+          raise "boolean expected."
+        end
+      },
+      Date => proc {|val|
+        #; [!sru5j] converts 'YYYY-MM-DD' into date object.
+        #; [!h9q9y] raises error when failed to convert into date object.
+        #; [!i4ui8] raises error when specified date not exist.
+        val =~ /\A(\d\d\d\d)-(\d\d?)-(\d\d?)\z/  or
+          raise "invalid date format (ex: '2000-01-01')"
+        begin
+          Date.new($1.to_i, $2.to_i, $3.to_i)
+        rescue ArgumentError => ex
+          raise "date not exist."
+        end
+      },
+    }
+
+
+    class Parser
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def parse(argv, &error_handler)
+        optdict = new_options_dict()
+        while !argv.empty? && argv[0] =~ /\A-/
+          optstr = argv.shift
+          #; [!y04um] skips rest options when '--' found in argv.
+          if optstr == '--'
+            break
+          elsif optstr =~ /\A--/
+            #; [!uh7j8] parses long options.
+            parse_long_option(optstr, optdict, argv)
+          else
+            #; [!nwnjc] parses short options.
+            parse_short_options(optstr, optdict, argv)
+          end
+        end
+        #; [!3wmsy] returns command option values as a dict.
+        return optdict
+      rescue OptionError => ex
+        #; [!qpuxh] handles only OptionError when block given.
+        raise unless block_given?()
+        yield ex
+        #; [!dhpw1] returns nil when OptionError handled.
+        nil
+      end
+
+      def error(msg)
+        return OptionError.new(msg)
+      end
+
+      protected
+
+      def parse_long_option(optstr, optdict, _argv)
+        #; [!3i994] raises OptionError when invalid long option format.
+        optstr =~ /\A--(\w[-\w]*)(?:=(.*))?\z/  or
+          raise error("#{optstr}: invalid long option.")
+        name = $1; val = $2
+        #; [!er7h4] raises OptionError when unknown long option.
+        item = @schema.find_long_option(name)  or
+          raise error("#{optstr}: unknown long option.")
+        #; [!2jd9w] raises OptionError when no arguments specified for arg required long option.
+        #; [!qyq8n] raises optionError when an argument specified for no arg long option.
+        if item.optional_param?
+          # do nothing
+        elsif item.param
+          val  or raise error("#{optstr}: argument required.")
+        else
+          val.nil?  or raise error("#{optstr}: unexpected argument.")
+        end
+        #; [!o596x] validates argument value.
+        val ||= true
+        begin
+          val = item.validate_and_convert(val, optdict)
+        rescue RuntimeError => ex
+          raise error("#{optstr}: #{ex.message}")
+        end
+        optdict[item.key] = val
+      end
+
+      def parse_short_options(optstr, optdict, argv)
+        n = optstr.length
+        i = 0
+        while (i += 1) < n
+          char = optstr[i]
+          #; [!4eh49] raises OptionError when unknown short option specified.
+          item = @schema.find_short_option(char)  or
+            raise error("-#{char}: unknown option.")
+          #
+          if !item.param
+            val = true
+          elsif !item.optional_param?
+            #; [!utdbf] raises OptionError when argument required but not specified.
+            #; [!f63hf] short option arg can be specified without space separator.
+            val = i+1 < n ? optstr[(i+1)..-1] : argv.shift  or
+              raise error("-#{char}: argument required.")
+            i = n
+          else
+            #; [!yjq6b] optional arg should be specified without space separator.
+            #; [!wape4] otpional arg can be omit.
+            val = i+1 < n ? optstr[(i+1)..-1] : true
+            i = n
+          end
+          #; [!yu0kc] validates short option argument.
+          begin
+            val = item.validate_and_convert(val, optdict)
+          rescue RuntimeError => ex
+            if val == true
+              raise error("-#{char}: #{ex.message}")
+            else
+              s = item.optional_param? ? '' : ' '
+              raise error("-#{char}#{s}#{val}: #{ex.message}")
+            end
+          end
+          optdict[item.key] = val
+        end
+      end
+
+      def new_options_dict()
+        #; [!vm6h0] returns new hash object.
+        return OPTIONS_CLASS.new
+      end
+
+    end
+
+
+    OPTIONS_CLASS = Hash
+    SCHEMA_CLASS = Schema
+    PARSER_CLASS = Parser
+
+
+    class SchemaError < StandardError
+    end
+
+
+    class OptionError < StandardError
+    end
+
+
+  end
+
+
+end