argparser 1.0.0 → 1.0.1

data/lib/argparser/default_parser.rb

@@ -0,0 +1,116 @@
+# 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

data/lib/argparser/option.rb

@@ -0,0 +1,104 @@
+# 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
+
+    # Returns most lengthy name as a 'default' name of this option
+    def 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
+    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
+    end
+  end
+end

data/lib/argparser/tools.rb

@@ -0,0 +1,56 @@
+# coding: utf-8
+
+class ArgParser
+  # Aux tools intented to include into a class
+  module Tools
+    # Sets self state from a hash given
+    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)
+          instance_variable_set("@#{k}", v)
+        end
+      else
+        raise 'Hash expected'
+      end
+      self
+    end
+
+    # Returns a hash of self state, packing all objects to hashes
+    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/spec/argparser_spec.rb

@@ -0,0 +1,201 @@
+# coding: utf-8
+require 'spec_helper'
+
+a_manifest = {
+  :program => 'a_example',  # Use additional properties like these:
+  :version => '1.0',        #   :info, :copyright, :license,
+  :options => [{            #   :package, :bugs, :homepage
+    :names      => %w[m mode],
+    :argument   => 'first|second|third',
+    :default    => 'first',
+    :multiple   => true,
+    :help       => 'Example mode.',
+    :validate   => (lambda {|this, _parser|  # Validating value in-line
+      possible = this.argument.split('|')
+      this.value.select{|v| possible.include?(v)}.size == this.value.size })
+  }, {
+    :names      => 'file',
+    :input      => true,
+    :required   => false,
+    :default    => '-',
+    :help       => 'Filename or - for stdin.'
+  }]
+}
+
+describe 'manifest' do
+  it 'should compile option objects' do
+    args = ArgParser.new(a_manifest)
+    args.options.each {|o|
+      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.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)
+  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)
+  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)
+  end
+end
+
+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])
+    }.must_raise(ExitStub)
+    e.status.must_equal(0)
+    e.message.must_match(/#{a_manifest[:program]}.*#{a_manifest[:version]}/)
+  end
+
+  it 'prints out help and terminates' do
+    a = ArgParser.new(a_manifest)
+    e = lambda {
+      a.parse!(%w[any --oth --help])
+    }.must_raise(ExitStub)
+    e.status.must_equal(0)
+    e.message.must_match(/#{a_manifest[:options].last[:help]}/)
+  end
+
+  it 'prints synopsys on argument error' do
+    a = ArgParser.new(a_manifest)
+    e = lambda {
+      a.parse!(%w[any --1287])
+    }.must_raise(ExitStub)
+    e.status.must_equal(2)
+    e.message.must_match(/#{a.synopsis}/)
+  end
+
+  it 'prints user-defined help if specified' do
+    b_manifest = a_manifest.merge(:help => 'User-defined help')
+    a = ArgParser.new(b_manifest)
+    e = lambda {
+      a.parse!(%w[--help])
+    }.must_raise(ExitStub)
+    e.status.must_equal(0)
+    e.message.must_match(/#{b_manifest[:help]}/)
+  end
+
+  it 'understands -- argument' do
+    @args = ArgParser.new(a_manifest)
+    mode = @args.parse!(%w[-- --mode])['mode']
+    mode.count.must_equal(1)
+    mode.value.first.must_equal(mode.default)
+  end
+end
+
+describe 'Multiple argumented options w/default value' do
+  before do
+    @args = ArgParser.new(a_manifest)
+  end
+
+  it 'reads them and gives out values in order' do
+    @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 -])
+    }.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 -- -])
+    }.must_raise(ExitStub).status.must_equal(2)
+  end
+end
+
+describe 'required option' do
+  before do
+    @b_manifest = a_manifest.merge({
+      :options => (a_manifest[:options] + [{
+          :names => %w[r required legacy-required],
+          :required => true,
+          :multiple => true
+        }])
+    })
+    @args = ArgParser.new(@b_manifest)
+  end
+
+  it 'is really not optional' do
+    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['required'].count.must_equal(8)
+  end
+
+  it 'lives with an optional one' do
+    @args.parse!(%w[--mode first -rmsecond])
+    @args['required'].count.must_equal(1)
+  end
+end
+
+describe 'input argument' do
+  before do
+    @b_manifest = a_manifest.merge({
+      :options => (a_manifest[:options] + [{
+          :names => %w[file2],
+          :input => true
+        }])
+    })
+    @args = ArgParser.new(@b_manifest)
+  end
+
+  it 'terminates if name used as an option' do
+    lambda { @args.parse!(%w[--file2 --]) }.must_raise(ExitStub)
+  end
+
+  it 'survives second optional argument' do
+    @args.parse!(%w[file2])
+    @args['file'].value.must_equal('file2')
+    @args['file2'].value.must_equal(@args['file2'].default)
+  end
+end
+
+describe 'optional tiny features' do
+  before do
+    @b_manifest = a_manifest.merge({
+      :options => (a_manifest[:options] + [{
+          :names => ['a', "\n aaaaa \t "],
+          :multiple => true,
+          :argument => '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['aaaaa']}".must_equal('foo')
+    @args.parse!(%w[--aaaaa foo -abar])
+    "#{@args['aaaaa']}".must_equal('foo, bar')
+  end
+end