Class: HammerCLI::AbstractCommand

Inherits:
Clamp::Command
  • Object
show all
Includes:
Subcommand
Defined in:
lib/hammer_cli/abstract.rb

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Subcommand

included

Constructor Details

#initialize(*args) ⇒ AbstractCommand

Returns a new instance of AbstractCommand.



112
113
114
115
116
 
# File 'lib/hammer_cli/abstract.rb', line 112

def initialize(*args)
  super
  context[:path] ||= []
  context[:path] << self
end

Class Attribute Details

.validation_blocks ⇒ Object

Returns the value of attribute validation_blocks.



23
24
25
 
# File 'lib/hammer_cli/abstract.rb', line 23

def validation_blocks
  @validation_blocks
end

Class Method Details

.add_sets_help(help) ⇒ Object 



62
63
64
65
66
 
# File 'lib/hammer_cli/abstract.rb', line 62

def add_sets_help(help)
  sets_details = HammerCLI::Help::Section.new(_('Predefined field sets'), nil, id: :s_sets_details, richtext: true)
  sets_details.definition << HammerCLI::Help::Text.new(output_definition.sets_table)
  help.definition.unshift(sets_details)
end

.build_options(builder_params = {}) ⇒ Object 



186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/hammer_cli/abstract.rb', line 186

def self.build_options(builder_params={})
  builder_params = yield(builder_params) if block_given?

  option_builder.build(builder_params).each do |option|
    # skip switches that are already defined
    next if option.nil? or option.switches.any? {|s| find_option(s) }

    declared_options << option
    block ||= option.default_conversion_block
    define_accessors_for(option, &block)
    extend_options_help(option) if option.value_formatter.is_a?(HammerCLI::Options::Normalizers::ListNested)
  end
end

.command_extensions ⇒ Object 



29
30
31
32
 
# File 'lib/hammer_cli/abstract.rb', line 29

def command_extensions
  @command_extensions = @command_extensions || inherited_command_extensions || []
  @command_extensions
end

.extend_help(&block) ⇒ Object 



145
146
147
148
 
# File 'lib/hammer_cli/abstract.rb', line 145

def self.extend_help(&block)
  # We save the block for execution on object level, where we can access command's context and check :is_tty? flag
  self.help_extension_blocks << block
end

.extend_options_help(option) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/hammer_cli/abstract.rb', line 43

def extend_options_help(option)
  extend_help do |h|
    begin
      h.find_item(:s_option_details)
    rescue ArgumentError
      option_details = HammerCLI::Help::Section.new(_('Option details'), nil, id: :s_option_details, richtext: true)
      option_details.definition << HammerCLI::Help::Text.new(
        _('Following parameters accept format defined by its schema ' \
          '(bold are required; <> contain acceptable type; [] contain acceptable value):')
      )
      h.definition.unshift(option_details)
    ensure
      h.find_item(:s_option_details).definition << HammerCLI::Help::List.new([
        [option.switches.last, option.value_formatter.schema.description]
      ])
    end
  end
end

.extend_output_definition(&block) ⇒ Object 



150
151
152
153
154
155
 
# File 'lib/hammer_cli/abstract.rb', line 150

def self.extend_output_definition(&block)
  block.call(output_definition)
rescue ArgumentError => e
  handler = HammerCLI::ExceptionHandler.new
  handler.handle_exception(e)
end

.extend_with(*extensions) ⇒ Object 



200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/hammer_cli/abstract.rb', line 200

def self.extend_with(*extensions)
  extensions.each do |extension|
    unless extension.is_a?(HammerCLI::CommandExtensions)
      raise ArgumentError, _('Command extensions should be inherited from %s.') % HammerCLI::CommandExtensions
    end
    extension.delegatee(self)
    extension.extend_predefined_options(self)
    extension.extend_options(self)
    extension.extend_output(self)
    extension.extend_help(self)
    logger('Extensions').info "Applied #{extension.details} on #{self}."
    command_extensions << extension
  end
end

.help(invocation_path, builder = HammerCLI::Help::Builder.new) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/hammer_cli/abstract.rb', line 126

def self.help(invocation_path, builder = HammerCLI::Help::Builder.new)
  super(invocation_path, builder)
  help_extension = HammerCLI::Help::TextBuilder.new(builder.richtext)
  fields_switch = HammerCLI::Options::Predefined::OPTIONS[:fields].first[0]
  add_sets_help(help_extension) if find_option(fields_switch)
  unless help_extension_blocks.empty?
    help_extension_blocks.each do |extension_block|
      begin
        extension_block.call(help_extension)
      rescue ArgumentError => e
        handler = HammerCLI::ExceptionHandler.new
        handler.handle_exception(e)
      end
    end
  end
  builder.add_text(help_extension.string)
  builder.string
end

.help_extension_blocks ⇒ Object 



25
26
27
 
# File 'lib/hammer_cli/abstract.rb', line 25

def help_extension_blocks
  @help_extension_blocks ||= []
end

.inherited_command_extensions ⇒ Object 



34
35
36
37
38
39
40
41
 
# File 'lib/hammer_cli/abstract.rb', line 34

def inherited_command_extensions
  extensions = nil
  if superclass.respond_to?(:command_extensions)
    parent_extensions = superclass.command_extensions.select(&:inheritable?)
    extensions = parent_extensions.dup unless parent_extensions.empty?
  end
  extensions
end

.option_builder ⇒ Object 



181
182
183
184
 
# File 'lib/hammer_cli/abstract.rb', line 181

def self.option_builder
  @option_builder ||= create_option_builder
  @option_builder
end

.output(definition = nil, &block) ⇒ Object 



157
158
159
160
161
162
 
# File 'lib/hammer_cli/abstract.rb', line 157

def self.output(definition=nil, &block)
  dsl = HammerCLI::Output::Dsl.new
  dsl.build &block if block_given?
  output_definition.append definition.fields unless definition.nil?
  output_definition.append dsl.fields
end

.output_definition ⇒ Object 



172
173
174
175
 
# File 'lib/hammer_cli/abstract.rb', line 172

def self.output_definition
  @output_definition = @output_definition || inherited_output_definition || HammerCLI::Output::Definition.new
  @output_definition
end

.use_option(*names) ⇒ Object 



215
216
217
218
219
 
# File 'lib/hammer_cli/abstract.rb', line 215

def self.use_option(*names)
  names.each do |name|
    HammerCLI::Options::Predefined.use(name, self)
  end
end

.validate_options(mode = :append, target_name = nil, validator: nil, &block) ⇒ Object 



98
99
100
101
102
 
# File 'lib/hammer_cli/abstract.rb', line 98

def self.validate_options(mode=:append, target_name=nil, validator: nil, &block)
  validator ||= HammerCLI::Options::Validators::DSLBlockValidator.new(&block)
  self.validation_blocks ||= []
  self.validation_blocks << [mode, target_name, validator]
end

Instance Method Details

#adapter ⇒ Object 



69
70
71
 
# File 'lib/hammer_cli/abstract.rb', line 69

def adapter
  :base
end

#exception_handler ⇒ Object 



108
109
110
 
# File 'lib/hammer_cli/abstract.rb', line 108

def exception_handler
  @exception_handler ||= exception_handler_class.new(:output => output)
end

#execute ⇒ Object 



94
95
96
 
# File 'lib/hammer_cli/abstract.rb', line 94

def execute
  HammerCLI::EX_OK
end

#help ⇒ Object 



122
123
124
 
# File 'lib/hammer_cli/abstract.rb', line 122

def help
  self.class.help(invocation_path, HammerCLI::Help::Builder.new(context[:is_tty?]))
end

#interactive? ⇒ Boolean

Returns:

  • (Boolean) 


177
178
179
 
# File 'lib/hammer_cli/abstract.rb', line 177

def interactive?
  HammerCLI.interactive?
end

#output ⇒ Object 



164
165
166
 
# File 'lib/hammer_cli/abstract.rb', line 164

def output
  @output ||= HammerCLI::Output::Output.new(context, :default_adapter => adapter)
end

#output_definition ⇒ Object 



168
169
170
 
# File 'lib/hammer_cli/abstract.rb', line 168

def output_definition
  self.class.output_definition
end

#parent_command ⇒ Object 



118
119
120
 
# File 'lib/hammer_cli/abstract.rb', line 118

def parent_command
  context[:path][-2]
end

#parse(arguments) ⇒ Object 



86
87
88
89
90
91
92
 
# File 'lib/hammer_cli/abstract.rb', line 86

def parse(arguments)
  super
  validate_options
  logger.info "Called with options: %s" % options.inspect
rescue HammerCLI::Options::Validators::ValidationError => e
  signal_usage_error e.message
end

#run(arguments) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/hammer_cli/abstract.rb', line 73

def run(arguments)
  begin
    begin
      exit_code = super
      raise "exit code must be integer" unless exit_code.is_a? Integer
    rescue => e
      exit_code = handle_exception(e)
    end
    logger.debug 'Retrying the command' if (exit_code == HammerCLI::EX_RETRY)
  end while (exit_code == HammerCLI::EX_RETRY)
  return exit_code
end

#validate_options ⇒ Object 



104
105
106
 
# File 'lib/hammer_cli/abstract.rb', line 104

def validate_options
  # keep the method for legacy reasons
end