Class: OptionParser::Switch (Ruby 2.2.2)
Description: Class : OptionParser::Switch - Ruby 2.2.2

- Home
- Core 2.2.2
- Std-lib 2.2.2
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- optparse.rb

### Parent

Object

### Namespace

- CLASS OptionParser::Switch::NoArgument
- CLASS OptionParser::Switch::OptionalArgument
- CLASS OptionParser::Switch::PlacedArgument
- CLASS OptionParser::Switch::RequiredArgument

### Methods

- ::guess
- ::incompatible_argument_styles
- ::new
- ::pattern
- #summarize
- #switch_name

### Class/Module Index

Quicksearch

- Object
- OptParse
- OptionParser
- OptionParser::AC
- OptionParser::Acceptables
- OptionParser::AmbiguousArgument
- OptionParser::AmbiguousOption
- OptionParser::Arguable
- OptionParser::CompletingHash
- OptionParser::Completion
- OptionParser::InvalidArgument
- OptionParser::InvalidOption
- OptionParser::List
- OptionParser::MissingArgument
- OptionParser::NeedlessArgument
- OptionParser::OptionMap
- OptionParser::ParseError
- OptionParser::Regexp
- OptionParser::Switch
- OptionParser::Switch::NoArgument
- OptionParser::Switch::OptionalArgument
- OptionParser::Switch::PlacedArgument
- OptionParser::Switch::RequiredArgument

No matching classes.

# 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 340
    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 355
    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 = Proc.new) click to toggle source

                   # File optparse.rb, line 364
    def initialize(pattern = nil, conv = nil,
                   short = nil, long = nil, arg = nil,
                   desc = ([] if short or long), block = Proc.new)
      raise if Array === pattern
      @pattern, @conv, @short, @long, @arg, @desc, @block =
        pattern, conv, short, long, arg, desc, block
    end

pattern() click to toggle source

                   # File optparse.rb, line 360
    def self.pattern
      NilClass
    end

### Public Instance Methods

summarize(sdone = [], ldone = [], width = 1, max = width - 1, 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 423
    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] << if left[-1].empty? then ' ' * 4 else ', ' end << 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 475
    def switch_name
      (long.first || short.first).sub(/\A-+(?:\[no-\])?/, '')
    end