class Gem::OptionParser::Switch


RequiredArgument, etc.
Defined within Switch are several Switch-derived classes: NoArgument,
Individual switch class. Not important to the user.

def self.guess(arg)


Gem::OptionParser::Switch class (OptionalArgument, etc.).
Guesses argument style from +arg+. Returns corresponding
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

def self.incompatible_argument_styles(arg, t) 

def self.incompatible_argument_styles(arg, t)
  raise(ArgumentError, "#{arg}: incompatible argument styles\n  #{self}, #{t}",
        ParseError.filter_backtrace(caller(2)))
end

def self.pattern 

def self.pattern
  NilClass
end

def add_banner(to) # :nodoc:

:nodoc: 
def add_banner(to)  # :nodoc:
  unless @short or @long
    s = desc.join
    to << " [" + s + "]..." unless s.empty?
  end
  to
end

def compsys(sdone, ldone) # :nodoc:

:nodoc: 
def compsys(sdone, ldone)   # :nodoc:
  sopts, lopts = [], []
  @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
  (sopts+lopts).each do |opt|
    # "(-x -c -r)-l[left justify]"
    if /^--\[no-\](.+)$/ =~ opt
      o = $1
      yield("--#{o}", desc.join(""))
      yield("--no-#{o}", desc.join(""))
    else
      yield("#{opt}", desc.join(""))
    end
  end
end

def conv_arg(arg, val = []) # :nodoc:

:nodoc:

exception.
conversion. Yields at semi-error condition instead of raising an
Parses argument, converts and returns +arg+, +block+ and result of
def conv_arg(arg, val = []) # :nodoc:
  if conv
    val = conv.call(*val)
  else
    val = proc {|v| v}.call(*val)
  end
  return arg, block, val
end

def initialize(pattern = nil, conv = nil, 

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

def match_nonswitch?(str) # :nodoc:

:nodoc: 
def match_nonswitch?(str)  # :nodoc:
  @pattern =~ str unless @short or @long
end

def omitted_argument(val) # :nodoc:

:nodoc: 
def omitted_argument(val)   # :nodoc:
  val.pop if val.size == 3 and val.last.nil?
  val
end

def parse_arg(arg) # :nodoc:

:nodoc:

argument pattern. Yields when the pattern doesn't match substring.
Parses +arg+ and returns rest of +arg+ and matched portion to the
def parse_arg(arg) # :nodoc:
  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

def pretty_print(q) # :nodoc:

:nodoc: 
def pretty_print(q)         # :nodoc:
  q.object_group(self) {pretty_print_contents(q)}
end

def pretty_print_contents(q) # :nodoc:

:nodoc: 
def pretty_print_contents(q) # :nodoc:
  if @block
    q.text ":" + @block.source_location.join(":") + ":"
    first = false
  else
    first = true
  end
  [@short, @long].each do |list|
    list.each do |opt|
      if first
        q.text ":"
        first = false
      end
      q.breakable
      q.text opt
    end
  end
end

def summarize(sdone = {}, ldone = {}, width = 1, max = width - 1, indent = "")


+indent+:: Prefix string indents all summarized lines.
+max+ columns.
+max+:: Maximum width of left side -> the options are filled within
side (description part) starts after +width+ columns.
+width+:: Width of left side (option part). In other words, the right
+ldone+:: Already summarized long style options keyed hash.
+sdone+:: Already summarized short style options keyed hash.

block (without newline).
Produces the summary text. Each line of the summary is yielded to the
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

def switch_name


Main name of the switch.
def switch_name
  (long.first || short.first).sub(/\A-+(?:\[no-\])?/, '')
end