Class: Main::Parameter::List

Inherits:

Array

• Object
• Array
• Main::Parameter::List

Defined in:

lib/main/parameter.rb

Instance Method Summary

• #<<(*a) ⇒ Object
• #[](*index) ⇒ Object
• #defaults! ⇒ Object
• #delete(name, *names) ⇒ Object
• #parse(main) ⇒ Object
• #parse_arguments(argv, params = nil) ⇒ Object
• #parse_environment(env, params = nil) ⇒ Object
• #parse_keywords(argv, params = nil) ⇒ Object
• #parse_options(argv, params = nil) ⇒ Object
• #validate! ⇒ Object

Instance Method Details

#<<(*a) ⇒ Object

# File 'lib/main/parameter.rb', line 548

def <<(*a)
  delete(*a)
  super
end

#[](*index) ⇒ Object

# File 'lib/main/parameter.rb', line 553

def [](*index)
  first = index.first
  if(index.size == 1 and (first.is_a?(String) or first.is_a?(Symbol)))
    first = first.to_s
    return detect{|param| param.name == first}
  end
  return super
end

#defaults! ⇒ Object

# File 'lib/main/parameter.rb', line 502

def defaults!
  each do |p|
    if(p.defaults? and (not p.given?)) 
      p.defaults.each do |default|
        p.values << (default.respond_to?('to_proc') ? main.instance_eval(&default) : default) # so as NOT to set 'given?'
      end
    end
  end
end

#delete(name, *names) ⇒ Object

# File 'lib/main/parameter.rb', line 537

def delete name, *names
  name, *names = name.names if Parameter === name
  names = Cast.list_of_string name, *names
  keep = []
  each do |param|
    common = Cast.list_of_string(param.names) & names 
    keep << param if common.empty?
  end
  replace keep
end

#parse(main) ⇒ Object

# File 'lib/main/parameter.rb', line 335

def parse main
  @main, @argv, @env = main, main.argv, main.env

  ignore, stop = [], argv.index('--')

  if stop
    ignore = argv[stop .. -1]
    (argv.size - stop).times{ argv.pop }
  end

  argv.push "--#{ argv.shift }" if argv.first == 'help'

  parse_options argv

  return 'help' if detect{|p| p.name.to_s == 'help' and p.given?}

  parse_keywords argv
  parse_arguments argv
  parse_environment env

  defaults!
  validate!

  argv.push(*ignore) unless ignore.empty? 

  return self
ensure
  @main, @argv, @env = nil
end

#parse_arguments(argv, params = nil) ⇒ Object

# File 'lib/main/parameter.rb', line 415

def parse_arguments argv, params=nil
  params ||= select{|p| p.type == :argument}

  params.each do |p|
    if p.arity >= 0
      p.arity.times do
        break if argv.empty?
        value = argv.shift
        p.add_value value
      end
    else
      arity = p.arity.abs - 1
      arity.times do
        break if argv.empty?
        value = argv.shift
        p.add_value value
      end
      argv.size.times do
        value = argv.shift
        p.add_value value
      end
    end
  end

=begin
  params.each do |p|
    p.setup!
  end
=end
end

#parse_environment(env, params = nil) ⇒ Object

# File 'lib/main/parameter.rb', line 484

def parse_environment env, params=nil
  params ||= select{|p| p.type == :environment}

  params.each do |p|
    names = p.names
    name = names.first
    value = env[name]
    next unless value
    p.add_value value
  end

=begin
  params.each do |p|
    p.setup!
  end
=end
end

#parse_keywords(argv, params = nil) ⇒ Object

# File 'lib/main/parameter.rb', line 446

def parse_keywords argv, params=nil
  params ||= select{|p| p.type == :keyword}

  replacements = {}

  params.each do |p|
    names = p.names
    name = names.sort_by{|n| [n.size,n]}.last

    kre = %r/^\s*(#{ names.join '|' })\s*=/
    opt = "--#{ name }"
    i = -1 

    argv.each_with_index do |a, idx|
      i += 1
      b = argv[idx + 1]
      s = "#{ a }#{ b }"
      m, key, * = kre.match(s).to_a
      if m
        replacements[i] ||= a.gsub %r/^\s*#{ key }/, opt
        next
      end
=begin
      abbrev = name.index(key) == 0
      if abbrev
        replacements[i] ||= a.gsub %r/^\s*#{ key }/, opt
      end
=end
    end
  end

  replacements.each do |i, r|
    argv[i] = r
  end

  parse_options argv, params
end

#parse_options(argv, params = nil) ⇒ Object

# File 'lib/main/parameter.rb', line 365

def parse_options argv, params = nil
  params ||= options 

  spec, h, s = [], {}, {}

  params.each do |p|
    head, *tail = p.names
    long = "--#{ head }"
    shorts = tail.map{|t| "-#{ t }"}
    type =
      if p.argument_required? then GetoptLong::REQUIRED_ARGUMENT
      elsif p.argument_optional? then GetoptLong::OPTIONAL_ARGUMENT
      else GetoptLong::NO_ARGUMENT
      end
    a = [ long, shorts, type ].flatten
    spec << a 
    h[long] = p 
    s[long] = a 
  end

  begin
    GetoptLong.new(argv, *spec).each do |long, value|
      value =
        case s[long].last
          when GetoptLong::NO_ARGUMENT
            value.empty? ? true : value
          when GetoptLong::OPTIONAL_ARGUMENT
            value.empty? ? true : value
          when GetoptLong::REQUIRED_ARGUMENT
            value
        end
      p = h[long]
      p.add_value value
    end
  rescue GetoptLong::AmbigousOption, GetoptLong::NeedlessArgument,
         GetoptLong::MissingArgument, GetoptLong::InvalidOption => e
    c = Parameter.const_get e.class.name.split(/::/).last
    ex = c.new e.message
    ex.set_backtrace e.backtrace
    ex.extend Softspoken
    raise ex
  end

=begin
  params.each do |p|
    p.setup!
  end
=end
end

#validate! ⇒ Object

# File 'lib/main/parameter.rb', line 512

def validate!
  each do |p|
    #p.adding_handlers do
      #next if p.arity == -1
      #raise NotGiven, "#{ p.typename } not given" if(p.required? and (not p.given?))
    #end
    p.setup!
  end
end