argparser 1.0.1 → 2.0.0.RC1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8989066f5d2d643a0c693f7446b86cf179328017
-  data.tar.gz: 87f9acd817c83aaa29037f0e662cca0aff4c3bf9
+  metadata.gz: 58593645fe6bb77546efd38e6426d090f297e947
+  data.tar.gz: 09097746fde57e2adfe85f103fa1ae59e3b19cfa
 SHA512:
-  metadata.gz: 3a5558cf118a3bb6e8be1ad5ba2e4e4c3a8009561afadb0a060b36adc1f434059662fbdda8d06d6c253885b1cfe6cb28cd314123bb0cc0fcce383545efb7c8cc
-  data.tar.gz: 706d455288bc26ed3a4a8e7e81fdf4c7d30c72cee3b51383188252ec38e278065ff7d38694a57fbfea0249bc86b6b9325fade9c326edea58acb657c87985afca
+  metadata.gz: 28adb1c9eca795de1ea6ec51a5f8af9ca1b09851e49645ac458744b46db0f2e223d65c1d184e70cd66ee3f8775870613c8a5096ede50fa74aa08f3befab340d2
+  data.tar.gz: 7f6af691f64f2ecace8d8aec79573a615df41a747f29f1a91748b1352ecbfc137569fcdb698fc6fb35befdd04b202bf7e6f32de81e28cb430083cbc1032ad9d9

data/HISTORY.md

@@ -1,3 +1,25 @@
+# 2.0.0.RC2
+2015-04-28 Holidays
+
+* All exclamation marks removed from method names
+* `Option/Argument#set_value` renamed to `#add_value`
+* `Option/Argument#add_value`, `set_default` and `#reset` now return `self`
+* `Option/Argument#value` now is read-only
+* `Option/Argument#value?` now returns true in case of parsed option w/o param
+* Block(name, value) in `#parse`
+
+# 2.0.0.RC1
+2015-04-28 Holidays
+
+* Major version changed due to extensive renamings and removals
+* Whitespace in option names no longer stripped
+* Separate classes for options and arguments
+* `Option#argument` renamed to `Option#param`
+* `Option#eval` and `Option#env` settings removed as they aren't secure, use `Option#default`, which now may be a proc/lambda
+* `ArgParser.manifest=` added, which merges with manifest supplied through `ArgParser.new`
+* `ArgParser.new` raises `ManifestError` instead of late `exit(2)` in `ArgParser#parse` while checking manifest
+* `DefaultParser` module removed and `#parse!` method merged back into `ArgParser`
+
 # 1.0.1
 2015-04-14
 

data/README.md

@@ -1,7 +1,7 @@
 # argparser
 Yet another ruby command line argument parser library.
 
-[![Build Status](https://travis-ci.org/sinm/argparser.svg?branch=master)](https://travis-ci.org/sinm/argparser) [![Gem Version](https://badge.fury.io/rb/argparser.svg)](http://badge.fury.io/rb/argparser) [![Dependency Status](https://gemnasium.com/sinm/argparser.svg)](https://gemnasium.com/sinm/argparser) [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/sinm/argparser/master/LICENSE.txt) [![Code Climate](https://codeclimate.com/github/sinm/argparser/badges/gpa.svg)](https://codeclimate.com/github/sinm/argparser) [![Test Coverage](https://codeclimate.com/github/sinm/argparser/badges/coverage.svg)](https://codeclimate.com/github/sinm/argparser) [![Inline docs](http://inch-ci.org/github/sinm/argparser.svg?branch=master)](http://inch-ci.org/github/sinm/argparser)
+[![Build Status](https://travis-ci.org/sinm/argparser.svg?branch=master)](https://travis-ci.org/sinm/argparser) [![Gem Version](https://badge.fury.io/rb/argparser.svg)](http://badge.fury.io/rb/argparser) [![Dependency Status](https://gemnasium.com/sinm/argparser.svg)](https://gemnasium.com/sinm/argparser) [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/sinm/argparser/master/LICENSE.txt) [![Code Climate](https://codeclimate.com/github/sinm/argparser/badges/gpa.svg)](https://codeclimate.com/github/sinm/argparser) [![Test Coverage](https://codeclimate.com/github/sinm/argparser/badges/coverage.svg)](https://codeclimate.com/github/sinm/argparser) [![Inline docs](http://inch-ci.org/github/sinm/argparser.svg?branch=master)](http://inch-ci.org/github/sinm/argparser) [![security](https://hakiri.io/github/sinm/argparser/master.svg)](https://hakiri.io/github/sinm/argparser/master)
 
 ## Installation
 `gem install argparser` as usual.
@@ -86,13 +86,14 @@ Unknown option: a
 ````
 
 ## Consider more rules
-* `--help` and `--version` options provided for free unless specified
-* printed synopsis provided for free unless specified
-* `:default` used if option has :argument and no value given, lowest priority
-* `:env  => 'ENV_VAR'` to pick default value from ENV, high priority
-* `:eval => 'ruby expr'` to pick default from eval(...), useful for read defaults from config files, so it has low priority
+* `--help` and `--version` options provided unless specified explicitly
+* printed synopsis provided unless specified explicitly
+* `:default` setting assigns default option's value if value isn't specified, may be proc/lambda
 * `--` argument honored
 
+## Tests
+`bundle exec rake test`
+
 ## Documentation
 This README is all i could say in a rush. No other documentation provided at this moment, see the sources.
 

data/TODO.md

@@ -0,0 +1,13 @@
+# argparser gem TODO list
+
+5. Testing bash and rb scripts
+4. CPU Profiling
+3. + remove eval
+2. More sophisticated output of printed_help
+````ruby
+  term_width = ENV['COLUMNS'] || `tput columns` || 80
+  width = opts.reduce(0){|max, o| (sz = o.first.size) > max ? sz : max}
+  help_width = term_width - (width += 1)
+  if help_width < 32...
+````
+1. RDocs

data/argparser.gemspec

@@ -1,22 +1,26 @@
 # coding: utf-8
+require File.expand_path('../lib/argparser/version.rb', __FILE__)
+
 Gem::Specification.new do |s|
   s.name          = 'argparser'
-  s.version       = '1.0.1'
+  s.version       = ArgParser::VERSION
   s.authors       = ['sinm']
   s.email         = 'sinm.sinm@gmail.com'
   s.summary       = 'Yet another ruby command line argument parser library'
   s.description   = '== Yet another ruby command line argument parser library'
   s.homepage      = 'https://github.com/sinm/argparser'
   s.license       = 'MIT'
-  s.files         = `git ls-files -z`.split("\x0")
-  s.test_files    = `git ls-files -z spec/`.split("\0")
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/`.split("\n")
   s.require_paths = ['lib']
+  s.bindir        = 'bin'
+  s.executables   = `git ls-files -- bin/`.split("\n").map{|f| File.basename(f)}
   # s.extra_rdoc_files = 'README.md'
   # s.rdoc_options  << '--title' << 'argparser' <<
   #                      '--main' << 'README'     <<
   #                      '--markup' << 'markdown' <<
   #                      '--line-numbers'
-  s.add_development_dependency 'bundler',    '~> 1'
-  s.add_development_dependency 'rake',       '~> 10'
-  s.add_development_dependency 'minitest',   '~> 4'
+  s.add_development_dependency 'bundler',    '~> 1.7'
+  s.add_development_dependency 'rake',       '~> 10.1'
+  s.add_development_dependency 'minitest',   '~> 4.7'
 end

data/lib/argparser.rb

@@ -1,130 +1,9 @@
 # coding: utf-8
 require 'stringio'
 
+require 'argparser/version'
 require 'argparser/tools'
+require 'argparser/argument'
 require 'argparser/option'
-require 'argparser/default_parser'
-
-class ArgParser
-  include Tools
-  include DefaultParser
-
-  # Output messages used in the #terminate method
-  OUT_VERSION = '%s%s %s'
-  OUT_COPYRIGHT = 'Copyright (C) %s'
-  OUT_LICENSE = 'License: %s'
-  OUT_HOMEPAGE = '%s home page: %s'
-  OUT_BUGS = 'Report bugs to: %s'
-  OUT_MANIFEST_EXPECTED = 'Property expected through the manifest: %s'
-  OUT_MULTIPLE_INPUTS = 'Multiple input argument not allowed in the middle: %s'
-  OUT_MULTIPLE_NAMES = 'Multiple names for the input argument: %s'
-  OUT_OPTION_NULL = 'Empty name for option'
-  OUT_REQUIRED = 'Required input argument after optional one: %s'
-  OUT_REQUIRED_DEFAULT = 'Required option has default value: %s'
-  OUT_UNEXPECTED_ARGUMENT = 'Unexpected argument: %s'
-  OUT_UNKNOWN_OPTION = 'Unknown option: %s'
-  OUT_OPTION_ARGUMENT_EXPECTED = 'Expected argument for the option: %s'
-  OUT_SINGLE_OPTION = 'Multiple options not allowed: %s'
-  OUT_OPTION_EXPECTED = 'Expected option: %s'
-  OUT_ARGUMENT_EXPECTED = 'Expected argument: %s'
-  OUT_UNIQUE_NAME = 'Option name should be unique: %s'
-  OUT_INVALID_OPTION = 'Invalid value for option: %s'
-  OPT_ENOUGH  = '--'
-
-  # These options don't display their synopsis and given for free unless
-  # explicitly specified in the manifest.
-  OPT_HELP    = 'help'
-  OPT_VERSION = 'version'
-  OPTS_RESERVED = [OPT_HELP, OPT_VERSION]
-
-  attr_reader :program    # Program name, REQUIRED
-  attr_reader :package    # Set to nil if there's no package
-  attr_reader :version    # Follow semantic versioning rules, REQUIRED
-  attr_reader :copyright  # '2015 Somebody, Inc.',
-  attr_reader :license    # Give license headline
-  attr_reader :info       # Set additional lines that would follow license
-  attr_reader :bugs       # Address to post bug reports
-  attr_reader :homepage   # Package or, if absent, program's home page
-  attr_reader :synopsis   # Print this if present or construct from options
-  attr_reader :help       # Print this if present or construct from options
-  attr_reader :options    # Array of options,
-                          # see ArgParser::Option class' attr_readers
-
-  # Returns option by any of its names given
-  def [](name)
-    options.find{|o| o.names.include?(name)}
-  end
-
-  # Returns array of input args in order
-  def inputs
-    options.select{|o| o.input}
-  end
-
-  def initialize(manifest)
-    manifest = (safe_return('$config.manifest') || {}).merge(manifest)
-    hash2vars!(manifest)
-    @options = (manifest[:options] || manifest['options'] || []).
-      map {|o| o.kind_of?(Option) ? o : Option.new(o)}
-    if !self['help']
-      options << Option.new(:names    => OPT_HELP,
-                            :help     => 'Print this help and exit.',
-                            :validate => (lambda { |o, p|
-                              return true if o.count < 1
-                              p.terminate(0, p.printed_help) }))
-    end
-    if !self['version']
-      options << Option.new(:names    => OPT_VERSION,
-                            :help     => 'Print version and exit.',
-                            :validate => (lambda { |o, p|
-                              return true if o.count < 1
-                              p.terminate(0, p.printed_version) }))
-    end
-  end
-
-  def terminate(code, str)
-    s = StringIO.new
-    s.puts(printed_synopsis) if code != 0
-    s.puts(str[-1] == "\n" ? str.chop : str)
-    on_exit(code, s.string)
-  end
-
-  def on_exit(code, message)
-    (code == 0 ? $stdout : $stderr).print(message)
-    exit(code)
-  end
-
-  def printed_version
-    str = StringIO.new
-    pk = (pk = @package) ? " (#{pk})" : ''
-    str.puts(OUT_VERSION % [program, pk, version])
-    str.puts(OUT_COPYRIGHT % copyright) if copyright
-    str.puts(OUT_LICENSE % license) if license
-    str.string
-  end
-
-  def printed_help
-    str = StringIO.new
-    str.puts(printed_synopsis)
-    str.puts(info) if info
-    if help
-      str.puts(help)
-    else
-      (options.select{|o| !o.input} + inputs).each do |o|
-        str.puts(o.printed_help)
-      end
-      # term_width = ENV['COLUMNS'] || `tput columns` || 80
-      # width = opts.reduce(0){|max, o| (sz = o.first.size) > max ? sz : max}
-      # help_width = term_width - (width += 1)
-      # if help_width < 32...
-    end
-    str.puts(OUT_BUGS % bugs) if bugs
-    str.puts(OUT_HOMEPAGE % [(package||program), homepage]) if homepage
-    str.string
-  end
-
-  def printed_synopsis
-    s = synopsis ||
-      (options.select{|o| !o.input} + inputs).map{|o| o.synopsis}.join(' ')
-    "Usage: #{program} #{s}"
-  end
-end
+require 'argparser/errors'
+require 'argparser/arg_parser'

data/lib/argparser/arg_parser.rb

@@ -0,0 +1,219 @@
+# coding: utf-8
+
+class ArgParser
+  include Tools
+
+  # Output templates used for the #terminate(0) call
+  OUT_VERSION   = '%s%s %s'
+  OUT_COPYRIGHT = 'Copyright (C) %s'
+  OUT_LICENSE   = 'License: %s'
+  OUT_HOMEPAGE  = '%s home page: %s'
+  OUT_BUGS      = 'Report bugs to: %s'
+  OUT_OPTIONS   = 'OPTIONS:'
+  OUT_ARGUMENTS = 'ARGUMENTS:'
+
+  # Templates used for the terminate(2) call
+  TRM_UNEXPECTED_ARGUMENT       = 'Unexpected argument: %s'
+  TRM_UNKNOWN                   = 'Unknown option: %s'
+  TRM_OPTION_ARGUMENT_EXPECTED  = 'Expected parameter for the option: %s'
+  TRM_EXPECTED                  = 'Expected required argument/option: %s'
+  TRM_INVALID_OPTION            = 'Invalid value for the argument/option: %s'
+
+  OPT_ENOUGH  = '--'
+
+  # These options don't display their synopsis and given for free unless
+  # explicitly specified in the manifest.
+  OPTS_RESERVED = [{:func => :printed_help,
+                    :help => 'Print this help and exit.',
+                    :name => 'help'},
+                   {:func => :printed_version,
+                    :help => 'Print version and exit.',
+                    :name => 'version'}]
+
+  attr_reader :program    # Program name, REQUIRED
+  attr_reader :package    # Set to nil if there's no package
+  attr_reader :version    # Follow semantic versioning rules, REQUIRED
+  attr_reader :copyright  # Like '2015 Somebody, Inc.',
+  attr_reader :license    # Give license headline
+  attr_reader :info       # Program info string
+  attr_reader :bugs       # Address to post bug reports
+  attr_reader :homepage   # Package or, if absent, program's home page
+  attr_reader :synopsis   # Build from options if not given
+  attr_reader :help       # Build from options if not given
+  attr_reader :arguments  # Array of arguments
+  attr_reader :options    # Array of options
+                          # see ArgParser::Argument/Option classes attr_readers
+
+  class << self
+    def manifest=(manifest)
+      @@manifest = manifest
+    end
+    def manifest
+      @@manifest ||= {}
+    end
+  end
+
+  # Returns option by any of its names given
+  def [](name)
+    get_argument(name) || get_option(name)
+  end
+
+  def all
+    options + arguments
+  end
+
+  def get_argument(name)
+    arguments.find{|a| a.name == name}
+  end
+
+  def get_option(name)
+    options.find{|o| o.names.include?(name)}
+  end
+
+  def initialize(manifest)
+    hash2vars(manifest = ArgParser.manifest.merge(manifest))
+    @arguments =
+      (@arguments || []).map {|o| o.kind_of?(Argument) ? o : Argument.new(o)}
+    @options =
+      (@options || []).map   {|o| o.kind_of?(Option)   ? o : Option.new(o)}
+    _check_manifest
+  end
+
+  # Uses ARGV by default, but you may supply your own arguments
+  # It exits if bad arguments given or they aren't validated.
+  def parse(argv = ARGV)
+    all.each(&:reset)
+    _check_manifest
+
+    OPTS_RESERVED.each do |res|
+      name = res[:name]
+      next unless argv.include?("--#{name}") && !get_argument(name)
+      terminate(0, self.send(res[:func]))
+    end
+
+    args = argv.dup
+    enough = false
+    while (a = args.shift)
+      if a == OPT_ENOUGH
+        enough = true
+      elsif enough || (a =~ /^[^-]/) || (a == '-')
+        _set_argument(a)
+      elsif a =~ /^--(.+)/
+        _set_long_option($1, args)
+      elsif a =~ /^-([^-].*)/
+        _set_short_options($1, args)
+      else
+        terminate(2, TRM_UNKNOWN % a)
+      end
+    end
+
+    all.each { |o|
+      o.set_default
+      terminate(2, (TRM_EXPECTED % o.name)) if o.required && !o.value?
+    }
+
+    all.each { |o|
+      terminate(2, TRM_INVALID_OPTION % o.name) unless o.valid?(self)
+    }
+
+    all.select(&:value?).each {|o| yield(o.name, o.value)} if block_given?
+
+    self
+  end
+
+  def terminate(code, str)
+    s = StringIO.new
+    s.puts(printed_synopsis) if code != 0
+    s.puts(str[-1] == "\n" ? str.chop : str)
+    on_exit(code, s.string)
+  end
+
+  def on_exit(code, message)
+    (code == 0 ? $stdout : $stderr).print(message)
+    exit(code)
+  end
+
+  def printed_version
+    str = StringIO.new
+    pk = (pk = @package) ? " (#{pk})" : ''
+    str.puts(OUT_VERSION % [program, pk, version])
+    str.puts(OUT_COPYRIGHT % copyright) if copyright
+    str.puts(OUT_LICENSE % license) if license
+    str.string
+  end
+
+  def printed_help
+    str = StringIO.new
+    str.puts(printed_synopsis)
+    str.puts(info) if info
+    if help
+      str.puts(help)
+    else
+      unless options.empty?
+        str.puts(OUT_OPTIONS)
+        options.each {|o| str.puts(o.printed_help)}
+      end
+      OPTS_RESERVED.each do |res|
+        r = Option.new(res)
+        next if get_argument(r.name)
+        str.puts(r.printed_help)
+      end
+      unless arguments.empty?
+        str.puts(OUT_ARGUMENTS)
+        arguments.each {|a| str.puts(a.printed_help)}
+      end
+    end
+    str.puts(OUT_BUGS % bugs) if bugs
+    str.puts(OUT_HOMEPAGE % [(package||program), homepage]) if homepage
+    str.string
+  end
+
+  def printed_synopsis
+    "Usage: #{program} #{synopsis || all.map{|o| o.synopsis}.join(' ')}"
+  end
+
+  private
+
+  def _check_manifest
+    {:program => program, :version => version}.each do |k, v|
+      raise ManifestError, (ERR_MANIFEST_EXPECTED % k) if v.to_s.strip.empty?
+    end
+
+    arguments[0..-2].each do |i|
+      raise ManifestError, (ERR_MULTIPLE_INPUTS % i.name) if i.multiple
+    end
+    opt = arguments.index{|i|  !i.required} || arguments.size
+    req  = arguments.rindex{|i| i.required} || 0
+    raise ManifestError, (ERR_REQUIRED % arguments[req].name) if req > opt
+
+    names = all.map(&:names).flatten
+    raise ManifestError, ERR_UNIQUE_NAME if names.size != names.uniq.size
+  end
+
+  def _set_argument(a)
+    terminate(2, TRM_UNEXPECTED_ARGUMENT % a) unless
+     (input = arguments.find{|i| !i.value || i.multiple})
+    input.add_value(a)
+  end
+
+  def _set_long_option(a, tail)
+    terminate(2, TRM_UNKNOWN % a) unless a.size > 1 && (o = get_option(a))
+    terminate(2, TRM_OPTION_ARGUMENT_EXPECTED % a) if o.param && tail.empty?
+    o.add_value(o.param ? tail.shift : nil)
+  end
+
+  def _set_short_options(a, tail)
+    a.chars.each_with_index do |char, index|
+      terminate(2, TRM_UNKNOWN % char) unless (option = get_option(char))
+      if !option.param
+        option.add_value(nil)
+      elsif a.size-1 == index
+        terminate(2, TRM_OPTION_ARGUMENT_EXPECTED % char) if tail.empty?
+        option.add_value(tail.shift)
+      else
+        option.add_value(a[index+1..-1])
+        break
+      end
+    end
+  end
+end

data/lib/argparser/argument.rb

@@ -0,0 +1,82 @@
+# coding: utf-8
+
+class ArgParser
+  class Argument
+    include Tools
+
+    # These attrs are from the manifest that is applied through constructor
+    attr_reader   :name
+    attr_reader   :help     # Help string
+    attr_reader   :validate # Proc(this, parser) to validate a value
+    attr_reader   :default  # Value or proc to set default value
+    attr_reader   :required # Required
+    attr_reader   :multiple # May occur multiple times?
+
+    # These attrs have their meaning after parsing was done
+    attr_reader   :count    # Occucences
+    attr_reader   :value    # Value (Array if multiple)
+
+    # Just helper
+    def names
+      [name]
+    end
+
+    # Constructs from Hash of properties (see attr_readers)
+    def initialize(o_manifest)
+      hash2vars(o_manifest)
+      reset
+      raise ManifestError, ERR_OPTION_NULL if !name or name.strip.empty?
+    end
+
+    def synopsis
+      s = name.dup
+      s << '...' if multiple
+      s = "[#{s}]" if !required
+      s
+    end
+
+    # Adds value.
+    def add_value(v)
+      @count += 1
+      multiple ? (@value = @value + Array(v)) : @value = v
+      self
+    end
+
+    # Does option contain it's value?
+    def value?
+      @count > 0
+    end
+
+    # Returns value as string
+    def to_s
+      multiple ? value.map(&:to_s).join(', ') : value.to_s
+    end
+
+    def valid?(parser)
+      !validate || validate.call(self, parser)
+    end
+
+    def reset
+      @value = multiple ? [] : nil
+      @count = 0
+      self
+    end
+
+    def printed_help
+      s = help || ''
+      s << "\n\tDefaults to: #{get_default}" if default
+      "%s\n\t%s" % [synopsis, s]
+    end
+
+    # Set value to default one if no value provided
+    def set_default
+      return self if !default || value?
+      add_value(get_default)
+    end
+
+    # Get default value
+    def get_default
+      default.respond_to?(:call) ? default.call : default
+    end
+  end
+end

data/lib/argparser/errors.rb

@@ -0,0 +1,9 @@
+class ArgParser
+  ERR_OPTION_NULL       = 'Empty name for an argument'
+  ERR_MANIFEST_EXPECTED = 'Property expected through the manifest: %s'
+  ERR_MULTIPLE_INPUTS   = 'Multi-value argument allowed only if last: %s'
+  ERR_REQUIRED          = 'Required argument after optional one: %s'
+  ERR_UNIQUE_NAME       = 'All option/argument names must be unique'
+  class ManifestError < RuntimeError
+  end
+end

data/lib/argparser/option.rb

@@ -1,104 +1,25 @@
 # coding: utf-8
 
 class ArgParser
-  class Option
-    include Tools
-    attr_reader :names    # Names of an option (short, long, etc.)
-    attr_reader :argument # Name of an argument, if present
-    attr_reader :help     # Help string for an option
-    attr_reader :validate # Lambda(option, parser) to validate an option
-    attr_reader :default  # Default value for an option
-    attr_reader :input    # Option is an input argument
-    attr_reader :required # Option required
-    attr_reader :multiple # Option may occure multiple times
-    attr_reader :count    # Option occucences
-    attr_reader :env      # Default option set by this ENV VAR, if any
-    attr_reader :eval     # Default option set by this eval,
-                          # superseded by :env, if any
-                          # So, in order: value - env - eval - default
-    attr_accessor :value  # Values of an option, Array if multiple
+  class Option < Argument
 
-    # Returns most lengthy name as a 'default' name of this option
+    # These attrs are from the manifest that is applied through constructor
+    attr_reader :param  # Parameter name, if any
+    # Returns first name as a 'default' one when several names given
     def name
-      names.first
+      @name ||= names.first
     end
-
-    # Constructs option from Hash of properties (see attr_readers)
-    def initialize(o_manifest)
-      hash2vars!(o_manifest)
-      @names = Array(names).map{|n| n.to_s.strip}.
-        sort{|n1, n2| n1.size <=> n2.size}
-      reset!
-    end
-
-    # Sets value. Do not use this directly
-    def set_value(v)
-      @count += 1
-      multiple ? (@value << v).flatten! : @value = v
-    end
-
-    # Does option contain it's value?
-    def value?
-      multiple ? !value.compact.empty? : !!value
-    end
-
-    def to_s
-      if multiple
-        value.empty? ? '' : value.map(&:to_s).join(', ')
-      else
-        value.to_s
-      end
+    # Names of an option (short, long, etc.)
+    def names
+      @names ||= [@name]
     end
 
     def synopsis
-      if input
-        s = name.dup
-        s << '...' if multiple
-        s = "[#{s}]" if !required
-        s
-      else
-        s = names.map{|n| n.size == 1 ? "-#{n}" : "--#{n}"}.join(', ')
-        s << " #{argument}" if argument
-        s = "[#{s}]" if !required
-        s << '...' if multiple
-        s
-      end
-    end
-
-    def validate!(parser)
-      !validate || validate.call(self, parser)
-    end
-
-    def reset!
-      @value = multiple ? [] : nil
-      @count = 0
-    end
-
-    def printed_help
-      s = help || ''
-      s << "\n\tDefaults to: #{default}" if default
-      "%s\n\t%s" % [synopsis, s]
-    end
-
-    def set_default!
-      return self unless !value? && (argument || input)
-      # rubocop:disable Lint/Eval
-      e = ((env && ENV[env]) || (eval && safe_return(eval)) || default)
-      # rubocop:enable Lint/Eval
-      set_value(e) if e
-      self
-    end
-
-    def on_first_error
-      if !multiple && count > 1
-        yield(OUT_SINGLE_OPTION % name)
-      elsif required && count < 1
-        yield((input ? OUT_ARGUMENT_EXPECTED : OUT_OPTION_EXPECTED) % name)
-      elsif names.find(&:empty?)
-        yield(OUT_OPTION_NULL)
-      elsif required && default
-        yield(OUT_REQUIRED_DEFAULT % name)
-      end
+      s = names.map{|n| n.size == 1 ? "-#{n}" : "--#{n}"}.join(', ')
+      s << " #{param}" if param
+      s = "[#{s}]" if !required
+      s << '...' if multiple
+      s
     end
   end
 end

data/lib/argparser/tools.rb

@@ -4,7 +4,7 @@ class ArgParser
   # Aux tools intented to include into a class
   module Tools
     # Sets self state from a hash given
-    def hash2vars!(hash)
+    def hash2vars(hash)
       if hash.kind_of?(Hash) || (hash.respond_to?(:to_h) && (hash = hash.to_h))
         hash.each do |k, v|
           next unless self.respond_to?(k)
@@ -16,41 +16,11 @@ class ArgParser
       self
     end
 
-    # Returns a hash of self state, packing all objects to hashes
+    # Returns a hash of self state
     def to_hash
       instance_variables.reduce({}) { |hash, var|
         hash[var[1..-1]] = instance_variable_get(var)
         hash }
     end
-
-    # Eval ruby code.
-    # Returns result of Kernel.eval or nil if some errors occure
-    def safe_return(str)
-      # rubocop:disable Lint/Eval
-      eval(str)
-      # rubocop:enable Lint/Eval
-    rescue NameError, NoMethodError
-      nil
-    end
-
-=begin Deep pack
-    def to_hash(deep = true)
-      instance_variables.reduce({}) { |hash, var|
-        value = instance_variable_get(var)
-        hash[var[1..-1]] = deep ? value_to_hash(value) : value
-        hash }
-    end
-
-    private
-    def value_to_hash value
-      if value.respond_to?(:to_hash)
-        (v = value.to_hash).kind_of?(Hash) ? v : {}
-      elsif value.respond_to?(:to_a)
-        (v = value.to_a).kind_of?(Array) ? v.map{|v| value_to_hash(v)} : []
-      else
-        value
-      end
-    end
-=end
   end
 end

data/lib/argparser/version.rb

@@ -0,0 +1,5 @@
+# coding: utf-8
+
+class ArgParser
+  VERSION = '2.0.0.RC1'
+end

data/spec/argparser_spec.rb

@@ -2,20 +2,26 @@
 require 'spec_helper'
 
 a_manifest = {
-  :program => 'a_example',  # Use additional properties like these:
-  :version => '1.0',        #   :info, :copyright, :license,
-  :options => [{            #   :package, :bugs, :homepage
+  :program  => 'a_example',  # Use additional properties like these:
+  :version  => '1.0',        #   :info, :copyright, :license,
+  :copyright=> '2015 sinm',
+  :info => 'A Example',
+  :license  => 'MIT',
+  :package  => 'ArgParser Spec',
+  :bugs     => 'https://github.com/sinm/argparser',
+  :homepage => 'https://github.com/sinm/argparser',
+  :options  => [{            #   :package, :bugs, :homepage
     :names      => %w[m mode],
-    :argument   => 'first|second|third',
+    :param      => 'first|second|third',
     :default    => 'first',
     :multiple   => true,
     :help       => 'Example mode.',
     :validate   => (lambda {|this, _parser|  # Validating value in-line
-      possible = this.argument.split('|')
+      possible = this.param.split('|')
       this.value.select{|v| possible.include?(v)}.size == this.value.size })
-  }, {
-    :names      => 'file',
-    :input      => true,
+  }],
+  :arguments => [{
+    :name       => 'file',
     :required   => false,
     :default    => '-',
     :help       => 'Filename or - for stdin.'
@@ -29,29 +35,24 @@ describe 'manifest' do
       o.must_be_instance_of(ArgParser::Option)
       args[o.name].must_be_same_as(o)
     }
-    (a = args.parse!(%w[-])).must_be_instance_of(ArgParser)
+    (a = args.parse(%w[-])).must_be_instance_of(ArgParser)
     a.must_be_same_as(args)
   end
 
   it 'should require program' do
     b_manifest = a_manifest.merge(:program => '')
-    args = ArgParser.new(b_manifest)
-    lambda {
-      args.parse!([])
-    }.must_raise(ExitStub).status.must_equal(2)
+    lambda { ArgParser.new(b_manifest) }.must_raise(ArgParser::ManifestError)
   end
 
   it 'should require version' do
     b_manifest = a_manifest.merge(:version => nil)
-    lambda {
-      ArgParser.new(b_manifest).parse!([])
-    }.must_raise(ExitStub).status.must_equal(2)
+    lambda { ArgParser.new(b_manifest) }.must_raise(ArgParser::ManifestError)
   end
 
   it 'requires nothing but but program & version' do
     b_manifest = a_manifest.reduce({}) {|h, (k, v)|
       h[k] = v if [:program, :version].include?(k); h}
-    ArgParser.new(b_manifest).parse!([]).must_be_instance_of(ArgParser)
+    ArgParser.new(b_manifest).parse([]).must_be_instance_of(ArgParser)
   end
 end
 
@@ -59,25 +60,47 @@ describe 'Built-in options' do
   it 'prints out version and terminates' do
     a = ArgParser.new(a_manifest)
     e = lambda {
-      a.parse!(%w[any --othelp --version])
+      a.parse(%w[any --othelp --version])
     }.must_raise(ExitStub)
     e.status.must_equal(0)
     e.message.must_match(/#{a_manifest[:program]}.*#{a_manifest[:version]}/)
+    e.message.must_equal(
+      "a_example (ArgParser Spec) 1.0
+Copyright (C) 2015 sinm
+License: MIT\n")
   end
 
   it 'prints out help and terminates' do
     a = ArgParser.new(a_manifest)
     e = lambda {
-      a.parse!(%w[any --oth --help])
+      a.parse(%w[any --oth --help])
     }.must_raise(ExitStub)
     e.status.must_equal(0)
     e.message.must_match(/#{a_manifest[:options].last[:help]}/)
+    e.message.must_equal(
+      "Usage: a_example [-m, --mode first|second|third]... [file]
+A Example
+OPTIONS:
+[-m, --mode first|second|third]...
+\tExample mode.
+\tDefaults to: first
+[--help]
+\tPrint this help and exit.
+[--version]
+\tPrint version and exit.
+ARGUMENTS:
+[file]
+\tFilename or - for stdin.
+\tDefaults to: -
+Report bugs to: https://github.com/sinm/argparser
+ArgParser Spec home page: https://github.com/sinm/argparser\n")
+
   end
 
   it 'prints synopsys on argument error' do
     a = ArgParser.new(a_manifest)
     e = lambda {
-      a.parse!(%w[any --1287])
+      a.parse(%w[any --1287])
     }.must_raise(ExitStub)
     e.status.must_equal(2)
     e.message.must_match(/#{a.synopsis}/)
@@ -87,7 +110,7 @@ describe 'Built-in options' do
     b_manifest = a_manifest.merge(:help => 'User-defined help')
     a = ArgParser.new(b_manifest)
     e = lambda {
-      a.parse!(%w[--help])
+      a.parse(%w[--help])
     }.must_raise(ExitStub)
     e.status.must_equal(0)
     e.message.must_match(/#{b_manifest[:help]}/)
@@ -95,7 +118,7 @@ describe 'Built-in options' do
 
   it 'understands -- argument' do
     @args = ArgParser.new(a_manifest)
-    mode = @args.parse!(%w[-- --mode])['mode']
+    mode = @args.parse(%w[-- --mode])['mode']
     mode.count.must_equal(1)
     mode.value.first.must_equal(mode.default)
   end
@@ -107,19 +130,19 @@ describe 'Multiple argumented options w/default value' do
   end
 
   it 'reads them and gives out values in order' do
-    @args.parse!(%w[--mode second -m first -msecond -- -])
+    @args.parse(%w[--mode second -m first -msecond -- -])
     @args['mode'].value.must_equal(%w[second first second])
   end
 
   it 'doesn''t validate unknown value' do
     lambda {
-      @args.parse!(%w[--mode second -m foo -msecond -])
+      @args.parse(%w[--mode second -m foo -msecond -])
     }.must_raise(ExitStub).status.must_equal(2)
   end
 
   it 'doesn''t understand unknown options' do
     lambda {
-      @args.parse!(%w[--mode second -abm foo -m first -- -])
+      @args.parse(%w[--mode second -abm foo -m first -- -])
     }.must_raise(ExitStub).status.must_equal(2)
   end
 end
@@ -137,17 +160,17 @@ describe 'required option' do
   end
 
   it 'is really not optional' do
-    e = lambda { @args.parse!(%w[-- file]) }.must_raise(ExitStub)
+    e = lambda { @args.parse(%w[-- file]) }.must_raise(ExitStub)
     e.status.must_equal(2)
   end
 
   it 'is actually multiple too' do
-    @args.parse!(%w[-rrrrr --legacy-required --required -r -- file])
+    @args.parse(%w[-rrrrr --legacy-required --required -r -- file])
     @args['required'].count.must_equal(8)
   end
 
   it 'lives with an optional one' do
-    @args.parse!(%w[--mode first -rmsecond])
+    @args.parse(%w[--mode first -rmsecond])
     @args['required'].count.must_equal(1)
   end
 end
@@ -155,20 +178,19 @@ end
 describe 'input argument' do
   before do
     @b_manifest = a_manifest.merge({
-      :options => (a_manifest[:options] + [{
-          :names => %w[file2],
-          :input => true
+      :arguments => (a_manifest[:arguments] + [{
+          :name => 'file2'
         }])
     })
     @args = ArgParser.new(@b_manifest)
   end
 
   it 'terminates if name used as an option' do
-    lambda { @args.parse!(%w[--file2 --]) }.must_raise(ExitStub)
+    lambda { @args.parse(%w[--file2 --]) }.must_raise(ExitStub)
   end
 
   it 'survives second optional argument' do
-    @args.parse!(%w[file2])
+    @args.parse(%w[file2])
     @args['file'].value.must_equal('file2')
     @args['file2'].value.must_equal(@args['file2'].default)
   end
@@ -178,24 +200,18 @@ describe 'optional tiny features' do
   before do
     @b_manifest = a_manifest.merge({
       :options => (a_manifest[:options] + [{
-          :names => ['a', "\n aaaaa \t "],
+          :names => ['a', 'aaaaa'],
           :multiple => true,
-          :argument => 'arg'
+          :param => 'arg'
         }])
     })
     @args = ArgParser.new(@b_manifest)
   end
 
-  it 'ignores whitespace in option names' do
-    "\n aaaaa \t ".strip.must_equal('aaaaa')
-    @args.parse!(%w[--aaaaa foobar])
-    @args['aaaaa'].value.must_equal(['foobar'])
-  end
-
   it 'allows to get value as string' do
-    @args.parse!(%w[--aaaaa foo])
+    @args.parse(%w[--aaaaa foo])
     "#{@args['aaaaa']}".must_equal('foo')
-    @args.parse!(%w[--aaaaa foo -abar])
+    @args.parse(%w[--aaaaa foo -abar])
     "#{@args['aaaaa']}".must_equal('foo, bar')
   end
 end

data/spec/tools_spec.rb

@@ -17,9 +17,9 @@ describe 'hash behaviour' do
   end
 
   it 'allows to pack/unpack' do
-    obj1 = StubClass.new.hash2vars!(@hash)
+    obj1 = StubClass.new.hash2vars(@hash)
     hash = obj1.to_hash
-    obj2 = StubClass.new.hash2vars!(hash)
+    obj2 = StubClass.new.hash2vars(hash)
     obj1.hash.each{|k, v| obj2.hash[k].must_equal(v)}
     obj1.array.must_equal(obj2.array)
     obj1.value.must_equal(obj2.value)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: argparser
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0.RC1
 platform: ruby
 authors:
 - sinm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-14 00:00:00.000000000 Z
+date: 2015-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,42 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '10.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '10.1'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '4.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '4.7'
 description: "== Yet another ruby command line argument parser library"
 email: sinm.sinm@gmail.com
 executables: []
@@ -67,12 +67,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- TODO.md
 - argparser.gemspec
 - argparser.sublime-project
 - lib/argparser.rb
-- lib/argparser/default_parser.rb
+- lib/argparser/arg_parser.rb
+- lib/argparser/argument.rb
+- lib/argparser/errors.rb
 - lib/argparser/option.rb
 - lib/argparser/tools.rb
+- lib/argparser/version.rb
 - spec/argparser_spec.rb
 - spec/spec_helper.rb
 - spec/tools_spec.rb
@@ -91,9 +95,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2

data/lib/argparser/default_parser.rb

@@ -1,116 +0,0 @@
-# coding: utf-8
-#
-
-class ArgParser
-  module DefaultParser
-    # Uses ARGV by default, but you may supply your own arguments
-    # It exits if bad arguments given or they aren't validated.
-    def parse!(arguments = ARGV)
-      options.each(&:reset!)
-      _check_manifest!
-
-      OPTS_RESERVED.each { |o|
-        next unless arguments.include?("--#{o}")
-        self[o].set_value(nil)
-        self[o].validate!(self)
-        self[o].reset! # If it didn't terminate while validating
-      }
-
-      args = arguments.dup
-      enough = false
-      while (a = args.shift)
-        if a == OPT_ENOUGH
-          enough = true
-        elsif enough || (a =~ /^[^-]/) || (a == '-')
-          _set_argument!(a)
-        elsif a =~ /^--(.+)/
-          _set_long_option!(a, args)
-        elsif a =~ /^-([^-].*)/
-          _set_short_options!(a, args)
-        else
-          terminate(2, OUT_UNKNOWN_OPTION % a)
-        end
-      end
-
-      options.each { |o|
-        o.set_default!
-        o.on_first_error {|msg| terminate(2, msg)}
-      }
-
-      options.each { |o|
-        terminate(2, OUT_INVALID_OPTION % o.name) unless o.validate!(self)
-      }
-
-      self
-    end
-
-    private
-
-    def _set_argument!(a)
-      if (input = inputs.find{|i| !i.value || i.multiple})
-        input.set_value(a)
-      else
-        terminate(2, OUT_UNEXPECTED_ARGUMENT % a)
-      end
-    end
-
-    def _set_long_option!(a, tail)
-      a = a[2..-1]
-      if a.size > 1 && (option = self[a]) && !option.input
-        if option.argument
-          terminate(2, OUT_OPTION_ARGUMENT_EXPECTED % a) if tail.empty?
-          option.set_value(tail.shift)
-        else
-          option.set_value(nil)
-        end
-      else
-        terminate(2, OUT_UNKNOWN_OPTION % $1)
-      end
-    end
-
-    def _set_short_options!(a, tail)
-      (a = a[1..-1]).chars.each_with_index do |char, index|
-        unless (option = self[char]) && !option.input
-          terminate(2, OUT_UNKNOWN_OPTION % char)
-        end
-        if option.argument
-          if a.size-1 == index
-            terminate(2, OUT_OPTION_ARGUMENT_EXPECTED % char) if tail.empty?
-            option.set_value(tail.shift)
-          else
-            option.set_value(a[index+1..-1])
-            break
-          end
-        else
-          option.set_value(nil)
-        end
-      end
-    end
-
-    def _check_manifest!
-      {:program => program, :version => version}.each do |k, v|
-        terminate(2, OUT_MANIFEST_EXPECTED % k) if !v || v.to_s.strip.empty?
-      end
-
-      is = inputs
-      is.each_with_index do |i, index|
-        if index < is.length-1 && i.multiple
-          terminate(2, OUT_MULTIPLE_INPUTS % i.name)
-        elsif i.names.size > 1
-          terminate(2, OUT_MULTIPLE_NAMES % i.name)
-        end
-      end
-      opt = is.index{|i| !i.required} || is.size
-      req  = is.rindex{|i| i.required} || 0
-      terminate(2, OUT_REQUIRED % is[req].name) if req > opt
-
-      names = {}
-      options.each do |option|
-        option.names.each do |name|
-          terminate(2, OUT_UNIQUE_NAME % name) if names.has_key?(name)
-          names[name] = option
-        end
-      end
-    end
-  end
-end