Class: Thor::Options

Inherits:
Arguments show all
Defined in:
lib/thor/parser/options.rb

Overview

:nodoc:

Constant Summary

LONG_RE =
/^(--\w+(?:-\w+)*)$/
SHORT_RE =
/^(-[a-z])$/i
EQ_RE =
/^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
SHORT_SQ_RE =

Allow either -x -v or -xv style for single char args

/^-([a-z]{2,})$/i
SHORT_NUM =
/^(-[a-z])#{NUMERIC}$/i
OPTS_END =
'--'.freeze

Constants inherited from Arguments

Arguments::NUMERIC

Class Method Summary (collapse)

Instance Method Summary (collapse)

Methods inherited from Arguments

parse, split

Constructor Details

- (Options) initialize(hash_options = {}, defaults = {}, stop_on_unknown = false)

Takes a hash of Thor::Option and a hash with defaults.

If stop_on_unknown is true, #parse will stop as soon as it encounters an unknown option or a regular argument.



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# File 'lib/thor/parser/options.rb', line 32

def initialize(hash_options={}, defaults={}, stop_on_unknown=false)
  @stop_on_unknown = stop_on_unknown
  options = hash_options.values
  super(options)

  # Add defaults
  defaults.each do |key, value|
    @assigns[key.to_s] = value
    @non_assigned_required.delete(hash_options[key])
  end

  @shorts, @switches, @extra = {}, {}, []

  options.each do |option|
    @switches[option.switch_name] = option

    option.aliases.each do |short|
      @shorts[short.to_s] ||= option.switch_name
    end
  end
end

Class Method Details

+ (Object) to_switches(options)

Receives a hash and makes it switches.



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# File 'lib/thor/parser/options.rb', line 11

def self.to_switches(options)
  options.map do |key, value|
    case value
      when true
        "--#{key}"
      when Array
        "--#{key} #{value.map{ |v| v.inspect }.join(' ')}"
      when Hash
        "--#{key} #{value.map{ |k,v| "#{k}:#{v}" }.join(' ')}"
      when nil, false
        ""
      else
        "--#{key} #{value.inspect}"
    end
  end.join(" ")
end

Instance Method Details

- (Object) check_unknown!



117
118
119
120
121
# File 'lib/thor/parser/options.rb', line 117

def check_unknown!
  # an unknown option starts with - or -- and has no more --'s afterward.
  unknown = @extra.select { |str| str =~ /^--?(?:(?!--).)*$/ }
  raise UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
end

- (Object) parse(args)



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
# File 'lib/thor/parser/options.rb', line 71

def parse(args)
  @pile = args.dup
  @parsing_options = true

  while peek
    if parsing_options?
      match, is_switch = current_is_switch?
      shifted = shift

      if is_switch
        case shifted
          when SHORT_SQ_RE
            unshift($1.split('').map { |f| "-#{f}" })
            next
          when EQ_RE, SHORT_NUM
            unshift($2)
            switch = $1
          when LONG_RE, SHORT_RE
            switch = $1
        end

        switch = normalize_switch(switch)
        option = switch_option(switch)
        @assigns[option.human_name] = parse_peek(switch, option)
      elsif @stop_on_unknown
        @extra << shifted
        @extra << shift while peek
        break
      elsif match
        @extra << shifted
        @extra << shift while peek && peek !~ /^-/
      else
        @extra << shifted
      end
    else
      @extra << shift
    end
  end

  check_requirement!

  assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
  assigns.freeze
  assigns
end

- (Object) peek



58
59
60
61
62
63
64
65
66
67
68
69
# File 'lib/thor/parser/options.rb', line 58

def peek
  return super unless @parsing_options

  result = super
  if result == OPTS_END
    shift
    @parsing_options = false
    super
  else
    result
  end
end

- (Object) remaining



54
55
56
# File 'lib/thor/parser/options.rb', line 54

def remaining
  @extra
end