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 



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

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

Instance Method Details

#accepts ⇒ Object

:nodoc:



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

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

end

#around_blocks ⇒ Object 



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

def around_blocks
  @around_blocks || []
end

#clear_nexts ⇒ Object

:nodoc:



113
114
115
116
117
118
 
# File 'lib/gli/app_support.rb', line 113

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

#commands ⇒ Object

:nodoc:



136
137
138
139
140
141
142
143
144
 
# File 'lib/gli/app_support.rb', line 136

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



94
95
96
 
# File 'lib/gli/app_support.rb', line 94

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:



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

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 



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

def help_sort_type
  @help_sort_type || :alpha
end

#help_text_wrap_type ⇒ Object 



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

def help_text_wrap_type
  @help_text_wrap_type || :to_terminal
end

#override_command_defaults(command_list, config) ⇒ Object 



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/gli/app_support.rb', line 177

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 



194
195
196
197
198
 
# File 'lib/gli/app_support.rb', line 194

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



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

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:



102
103
104
105
106
107
108
109
110
111
 
# File 'lib/gli/app_support.rb', line 102

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 



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

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

#pre_block ⇒ Object 



146
147
148
149
150
 
# File 'lib/gli/app_support.rb', line 146

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
 
# 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)
    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 



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

def stderr
  @stderr ||= STDERR
end

#subcommand_option_handling_strategy ⇒ Object 



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

def subcommand_option_handling_strategy
  @subcommand_option_handling_strategy || :legacy
end

#switches ⇒ Object

:nodoc:



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

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