Class: Slop::Option

### Home Classes Methods

### In Files

- lib/slop/option.rb

### Parent

Object

### Methods

- ::new
- #accepts_optional_argument?
- #call
- #expects_argument?
- #help
- #inspect
- #key
- #to_s
- #value
- #value=

### Class/Module Index

Quicksearch

- Slop
- Slop::Commands
- Slop::Error
- Slop::InvalidArgumentError
- Slop::InvalidCommandError
- Slop::InvalidOptionError
- Slop::MissingArgumentError
- Slop::MissingOptionError
- Slop::Option

No matching classes.

# Slop::Option

### Constants

DEFAULT_OPTIONS

  The default Hash of configuration options this class uses.

### Attributes

argument_in_value[RW]
config[R]
count[RW]
description[R]
long[R]
short[R]
types[R]

### Public Class Methods

new(slop, short, long, description, config = {}, &block) click to toggle source

Incapsulate internal option information, mainly used to store option specific configuration data, most of the meat of this class is found in the value method.

slop - The instance of Slop tied to this Option. short - The String or Symbol short flag. long - The String or Symbol long flag. description - The String description text. config - A Hash of configuration options. block - An optional block used as a callback.

    # File lib/slop/option.rb, line 33
    def initialize(slop, short, long, description, config = {}, &block)
      @slop = slop
      @short = short
      @long = long
      @description = description
      @config = DEFAULT_OPTIONS.merge(config)
      @count = 0
      @callback = block_given? ? block : config[:callback]
      @value = nil

      @types = {
        :string  => proc { |v| v.to_s },
        :symbol  => proc { |v| v.to_sym },
        :integer => proc { |v| value_to_integer(v) },
        :float   => proc { |v| value_to_float(v) },
        :range   => proc { |v| value_to_range(v) },
        :regexp  => proc { |v| Regexp.new(v) },
        :count   => proc { |v| @count }
      }

      if long && long.size > @slop.config[:longest_flag]
        @slop.config[:longest_flag] = long.size
      end

      @config.each_key do |key|
        predicate = :"#{key}?"
        unless self.class.method_defined? predicate
          self.class.__send__(:define_method, predicate) { !!@config[key] }
        end
      end
    end

### Public Instance Methods

accepts_optional_argument?() click to toggle source

Returns true if this option accepts an optional argument.

    # File lib/slop/option.rb, line 71
    def accepts_optional_argument?
      config[:optional_argument] || config[:argument] == :optional
    end

call(*objects) click to toggle source

Call this options callback if one exists, and it responds to call().

Returns nothing.

    # File lib/slop/option.rb, line 83
    def call(*objects)
      @callback.call(*objects) if @callback.respond_to?(:call)
    end

expects_argument?() click to toggle source

Returns true if this option expects an argument.

    # File lib/slop/option.rb, line 66
    def expects_argument?
      config[:argument] && config[:argument] != :optional
    end

help() click to toggle source
Alias for: to_s
inspect() click to toggle source

Returns the String inspection text.

    # File lib/slop/option.rb, line 151
    def inspect
      "#<Slop::Option [-#{short} | --#{long}" +
      "#{'=' if expects_argument?}#{'=?' if accepts_optional_argument?}]" +
      " (#{description}) #{config.inspect}"
    end

key() click to toggle source

Returns the String flag of this option. Preferring the long flag.

    # File lib/slop/option.rb, line 76
    def key
      long || short
    end

to_s() click to toggle source

Returns the help String for this option.

    # File lib/slop/option.rb, line 127
    def to_s
      return config[:help] if config[:help].respond_to?(:to_str)

      out = "    #{short ? "-#{short}, " : ' ' * 4}"

      if long
        out << "--#{long}"
        size = long.size
        diff = @slop.config[:longest_flag] - size
        out << (' ' * (diff + 6))
      else
        out << (' ' * (@slop.config[:longest_flag] + 8))
      end

      if config[:default]
        default = config[:default]
        "#{out}#{description} (default: #{default})"
      else
        "#{out}#{description}"
      end
    end

Also aliased as: help
value() click to toggle source

Fetch the argument value for this option.

Returns the Object once any type conversions have taken place.

    # File lib/slop/option.rb, line 107
    def value
      value = @value.nil? ? config[:default] : @value

      if [true, false, nil].include?(value) && config[:as].to_s != 'count'
        return value
      end

      type = config[:as]
      if type.respond_to?(:call)
        type.call(value)
      else
        if callable = types[type.to_s.downcase.to_sym]
          callable.call(value)
        else
          value
        end
      end
    end

value=(new_value) click to toggle source

Set the new argument value for this option.

We use this setter method to handle concatenating lists. That is, when an array type is specified and used more than once, values from both options will be grouped together and flattened into a single array.

    # File lib/slop/option.rb, line 92
    def value=(new_value)
      if config[:as].to_s.downcase == 'array'
        @value ||= []

        if new_value.respond_to?(:split)
          @value.concat new_value.split(config[:delimiter], config[:limit])
        end
      else
        @value = new_value
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.