Module: GLI::AppSupport

Included in:
App
Defined in:
lib/gli/app_support.rb

Overview

Internals for make App work

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(klass) ⇒ Object 



129
130
131
 
# File 'lib/gli/app_support.rb', line 129

def self.included(klass)
  @stderr = $stderr
end

Instance Method Details

#accepts ⇒ Object

:nodoc:



102
103
104
105
 
# File 'lib/gli/app_support.rb', line 102

def accepts #:nodoc:
  @accepts ||= {}

end

#around_blocks ⇒ Object 



162
163
164
 
# File 'lib/gli/app_support.rb', line 162

def around_blocks
  @around_blocks || []
end

#clear_nexts ⇒ Object

:nodoc:



118
119
120
121
122
123
 
# File 'lib/gli/app_support.rb', line 118

def clear_nexts # :nodoc:
  super
  @skips_post = false
  @skips_pre = false
  @skips_around = false
end

#commands ⇒ Object

:nodoc:



141
142
143
144
145
146
147
148
149
 
# File 'lib/gli/app_support.rb', line 141

def commands # :nodoc:
  if !@commands
    @commands = { :help => GLI::Commands::Help.new(self), :_doc => GLI::Commands::Doc.new(self) }
    @commands_declaration_order ||= []
    @commands_declaration_order << @commands[:help]
    @commands_declaration_order << @commands[:_doc]
  end
  @commands
end

#commands_declaration_order ⇒ Object

Get an array of commands, ordered by when they were declared



39
40
41
 
# File 'lib/gli/app_support.rb', line 39

def commands_declaration_order # :nodoc:
  @commands_declaration_order
end

#config_file_name ⇒ Object

Return the name of the config file; mostly useful for generating help docs



99
100
101
 
# File 'lib/gli/app_support.rb', line 99

def config_file_name #:nodoc:
  @config_file
end

#context_description ⇒ Object 



9
10
11
 
# File 'lib/gli/app_support.rb', line 9

def context_description
  "in global context"
end

#error_device=(e) ⇒ Object

Override the device of stderr; exposed only for testing



5
6
7
 
# File 'lib/gli/app_support.rb', line 5

def error_device=(e) #:nodoc:
  @stderr = e
end

#exe_name ⇒ Object 



34
35
36
 
# File 'lib/gli/app_support.rb', line 34

def exe_name
  File.basename($0)
end

#flags ⇒ Object

:nodoc:



133
134
135
 
# File 'lib/gli/app_support.rb', line 133

def flags # :nodoc:
  @flags ||= {}
end

#get_default_command ⇒ Object

Get the default command for the entire app



49
50
51
 
# File 'lib/gli/app_support.rb', line 49

def get_default_command
  @default_command
end

#help_sort_type ⇒ Object 



166
167
168
 
# File 'lib/gli/app_support.rb', line 166

def help_sort_type
  @help_sort_type || :alpha
end

#help_text_wrap_type ⇒ Object 



170
171
172
 
# File 'lib/gli/app_support.rb', line 170

def help_text_wrap_type
  @help_text_wrap_type || :to_terminal
end

#options ⇒ Object

Sets the @options instance variable if it doesn’t exist and returns it. The @options instance variable contains the options passed by the user on the command line.



212
213
214
 
# File 'lib/gli/app_support.rb', line 212

def options #:nodoc:
  @options ||= { :global => {}, "commands" => {} }
end

#options=(opts) ⇒ Object

Sets the @options instance variable, which contains the options passed by the user on the command line. If the opts parameter doesn’t have the correct format, the instance variable will be set with the correct format but the command line options will not be added to it. If the GLI Debug mode is enabled, an ArguementError exception will be raised.



223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/gli/app_support.rb', line 223

def options=(opts)
  if valid_options_hash_format_for?(opts)
    @options = opts
  else
    if ENV['GLI_DEBUG'] == 'true'
      raise ArgumentError, "The options hash is invalid"
    end

    @options = { :global => {}, "commands" => {} }
  end
end

#override_command_defaults(command_list, config) ⇒ Object 



182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/gli/app_support.rb', line 182

def override_command_defaults(command_list,config)
  command_list.each do |command_name,command|
    next if command_name == :initconfig || command.nil?
    command_config = (config['commands'] || {})[command_name] || {}

    if @subcommand_option_handling_strategy == :legacy
      override_default(command.topmost_ancestor.flags,command_config)
      override_default(command.topmost_ancestor.switches,command_config)
    else
      override_default(command.flags,command_config)
      override_default(command.switches,command_config)
    end

    override_command_defaults(command.commands,command_config)
  end
end

#override_default(tokens, config) ⇒ Object 



199
200
201
202
203
 
# File 'lib/gli/app_support.rb', line 199

def override_default(tokens,config)
  tokens.each do |name,token|
    token.default_value=config[name] if config[name]
  end
end

#override_defaults_based_on_config(config) ⇒ Object

Sets the default values for flags based on the configuration



175
176
177
178
179
180
 
# File 'lib/gli/app_support.rb', line 175

def override_defaults_based_on_config(config)
  override_default(flags,config)
  override_default(switches,config)

  override_command_defaults(commands,config)
end

#parse_config ⇒ Object

:nodoc:



107
108
109
110
111
112
113
114
115
116
 
# File 'lib/gli/app_support.rb', line 107

def parse_config # :nodoc:
  config = {
    'commands' => {},
  }
  if @config_file && File.exist?(@config_file)
    require 'yaml'
    config.merge!(File.open(@config_file) { |file| YAML::load(file) })
  end
  config
end

#post_block ⇒ Object 



157
158
159
160
 
# File 'lib/gli/app_support.rb', line 157

def post_block
  @post_block ||= Proc.new do
  end
end

#pre_block ⇒ Object 



151
152
153
154
155
 
# File 'lib/gli/app_support.rb', line 151

def pre_block
  @pre_block ||= Proc.new do
    true
  end
end

#reset ⇒ Object

Reset the GLI module internal data structures; mostly useful for testing



14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/gli/app_support.rb', line 14

def reset # :nodoc:
  switches.clear
  flags.clear
  @commands = nil
  @commands_declaration_order = []
  @flags_declaration_order = []
  @switches_declaration_order = []
  @version = nil
  @config_file = nil
  @use_openstruct = false
  @prog_desc = nil
  @error_block = false
  @pre_block = false
  @post_block = false
  @default_command = :help
  @around_block = nil
  @subcommand_option_handling_strategy = :legacy
  clear_nexts
end

#run(args) ⇒ Object

Runs whatever command is needed based on the arguments.

args

the command line ARGV array

Returns a number that would be a reasonable exit code



58
59
60
61
62
63
64
65
66
67
68
69
70
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
 
# File 'lib/gli/app_support.rb', line 58

def run(args) #:nodoc:
  args = args.dup if @preserve_argv
  the_command = nil
  begin
    override_defaults_based_on_config(parse_config)

    add_help_switch_if_needed(self)

    gli_option_parser = GLIOptionParser.new(commands,
                                            flags,
                                            switches,
                                            accepts,
                                            @default_command,
                                            self.subcommand_option_handling_strategy)

    parsing_result = gli_option_parser.parse_options(args)

    self.options = parsing_result.cli_options
    parsing_result.global_options[:cli]  = self.options[:global]
    parsing_result.command_options[:cli] = self.options["commands"][parsing_result.command.name]

    parsing_result.convert_to_openstruct! if @use_openstruct

    the_command = parsing_result.command

    if proceed?(parsing_result)
      call_command(parsing_result) 
      0
    else
      raise PreconditionFailed, "preconditions failed"
    end
  rescue Exception => ex
    if the_command.nil? && ex.respond_to?(:command_in_context)
      the_command = ex.command_in_context
    end
    handle_exception(ex,the_command)
  end
end

#stderr ⇒ Object 



125
126
127
 
# File 'lib/gli/app_support.rb', line 125

def stderr
  @stderr ||= STDERR
end

#subcommand_option_handling_strategy ⇒ Object 



205
206
207
 
# File 'lib/gli/app_support.rb', line 205

def subcommand_option_handling_strategy
  @subcommand_option_handling_strategy || :legacy
end

#switches ⇒ Object

:nodoc:



137
138
139
 
# File 'lib/gli/app_support.rb', line 137

def switches # :nodoc:
  @switches ||= {}
end

#version_string ⇒ Object

Get the version string



44
45
46
 
# File 'lib/gli/app_support.rb', line 44

def version_string #:nodoc:
  @version
end