class OptionParser::Switch

Individual switch class. Not important to the user.

Defined within Switch are several Switch-derived classes: NoArgument, RequiredArgument, etc.

Attributes

arg[R]
block[R]
conv[R]
desc[R]
long[R]
pattern[R]
short[R]

Public Class Methods

guess(arg) click to toggle source

Guesses argument style from arg. Returns corresponding OptionParser::Switch class (OptionalArgument, etc.).

# File optparse.rb, line 513
def self.guess(arg)
  case arg
  when ""
    t = self
  when /\A=?\[/
    t = Switch::OptionalArgument
  when /\A\s+\[/
    t = Switch::PlacedArgument
  else
    t = Switch::RequiredArgument
  end
  self >= t or incompatible_argument_styles(arg, t)
  t
end
incompatible_argument_styles(arg, t) click to toggle source
# File optparse.rb, line 528
def self.incompatible_argument_styles(arg, t)
  raise(ArgumentError, "#{arg}: incompatible argument styles\n  #{self}, #{t}",
        ParseError.filter_backtrace(caller(2)))
end
new(pattern = nil, conv = nil, short = nil, long = nil, arg = nil, desc = ([] if short or long), block = nil, &_block) click to toggle source
# File optparse.rb, line 537
def initialize(pattern = nil, conv = nil,
               short = nil, long = nil, arg = nil,
               desc = ([] if short or long), block = nil, &_block)
  raise if Array === pattern
  block ||= _block
  @pattern, @conv, @short, @long, @arg, @desc, @block =
    pattern, conv, short, long, arg, desc, block
end
pattern() click to toggle source
# File optparse.rb, line 533
def self.pattern
  NilClass
end

Public Instance Methods

summarize(sdone = {}, ldone = {}, width = 1, max = width - 1, indent = "") { |indent| ... } click to toggle source

Produces the summary text. Each line of the summary is yielded to the block (without newline).

sdone

Already summarized short style options keyed hash.

ldone

Already summarized long style options keyed hash.

width

Width of left side (option part). In other words, the right side (description part) starts after width columns.

max

Maximum width of left side -> the options are filled within max columns.

indent

Prefix string indents all summarized lines.

# File optparse.rb, line 597
def summarize(sdone = {}, ldone = {}, width = 1, max = width - 1, indent = "")
  sopts, lopts = [], [], nil
  @short.each {|s| sdone.fetch(s) {sopts << s}; sdone[s] = true} if @short
  @long.each {|s| ldone.fetch(s) {lopts << s}; ldone[s] = true} if @long
  return if sopts.empty? and lopts.empty? # completely hidden

  left = [sopts.join(', ')]
  right = desc.dup

  while s = lopts.shift
    l = left[-1].length + s.length
    l += arg.length if left.size == 1 && arg
    l < max or sopts.empty? or left << +''
    left[-1] << (left[-1].empty? ? ' ' * 4 : ', ') << s
  end

  if arg
    left[0] << (left[1] ? arg.sub(/\A(\[?)=/, '\1') + ',' : arg)
  end
  mlen = left.collect {|ss| ss.length}.max.to_i
  while mlen > width and l = left.shift
    mlen = left.collect {|ss| ss.length}.max.to_i if l.length == mlen
    if l.length < width and (r = right[0]) and !r.empty?
      l = l.to_s.ljust(width) + ' ' + r
      right.shift
    end
    yield(indent + l)
  end

  while begin l = left.shift; r = right.shift; l or r end
    l = l.to_s.ljust(width) + ' ' + r if r and !r.empty?
    yield(indent + l)
  end

  self
end
switch_name() click to toggle source

Main name of the switch.

# File optparse.rb, line 649
def switch_name
  (long.first || short.first).sub(/\A-+(?:\[no-\])?/, '')
end

Private Instance Methods

conv_arg(arg, val = []) click to toggle source

Parses argument, converts and returns arg, block and result of conversion. Yields at semi-error condition instead of raising an exception.

# File optparse.rb, line 575
def conv_arg(arg, val = [])
  if conv
    val = conv.call(*val)
  else
    val = proc {|v| v}.call(*val)
  end
  return arg, block, val
end
parse_arg(arg) { |InvalidArgument, arg| ... } click to toggle source

Parses arg and returns rest of arg and matched portion to the argument pattern. Yields when the pattern doesn’t match substring.

# File optparse.rb, line 550
def parse_arg(arg)
  pattern or return nil, [arg]
  unless m = pattern.match(arg)
    yield(InvalidArgument, arg)
    return arg, []
  end
  if String === m
    m = [s = m]
  else
    m = m.to_a
    s = m[0]
    return nil, m unless String === s
  end
  raise InvalidArgument, arg unless arg.rindex(s, 0)
  return nil, m if s.length == arg.length
  yield(InvalidArgument, arg) # didn't match whole arg
  return arg[s.length..-1], m
end