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.



114
115
116
117
118
 
# File 'lib/hammer_cli/abstract.rb', line 114

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

Class Attribute Details

.validation_blocks ⇒ Object

Returns the value of attribute validation_blocks.



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

def validation_blocks
  @validation_blocks
end

Class Method Details

.add_sets_help(help) ⇒ Object 



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

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 



188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/hammer_cli/abstract.rb', line 188

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

    if option.respond_to?(:referenced_resource)
      # Collect options that don't have family, but related to this parent.
      children = find_options(
        referenced_resource: option.referenced_resource.to_s,
        aliased_resource: option.aliased_resource.to_s
      ).select { |o| o.family.nil? || o.family.head.nil? }
      children.each do |child|
        option.family.adopt(child) if option.family
      end
    end
    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)
    completion_type_for(option)
  end
end

.command_extensions ⇒ Object 



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

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

.extend_help(&block) ⇒ Object 



147
148
149
150
 
# File 'lib/hammer_cli/abstract.rb', line 147

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 



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

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 



152
153
154
155
156
157
 
# File 'lib/hammer_cli/abstract.rb', line 152

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 



213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/hammer_cli/abstract.rb', line 213

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_option_family(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 



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

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 



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

def help_extension_blocks
  @help_extension_blocks ||= []
end

.inherited_command_extensions ⇒ Object 



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

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 



183
184
185
186
 
# File 'lib/hammer_cli/abstract.rb', line 183

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

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



159
160
161
162
163
164
 
# File 'lib/hammer_cli/abstract.rb', line 159

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 



174
175
176
177
 
# File 'lib/hammer_cli/abstract.rb', line 174

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

.use_option(*names) ⇒ Object 



229
230
231
232
233
 
# File 'lib/hammer_cli/abstract.rb', line 229

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 



100
101
102
103
104
 
# File 'lib/hammer_cli/abstract.rb', line 100

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 



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

def adapter
  :base
end

#exception_handler ⇒ Object 



110
111
112
 
# File 'lib/hammer_cli/abstract.rb', line 110

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

#execute ⇒ Object 



96
97
98
 
# File 'lib/hammer_cli/abstract.rb', line 96

def execute
  HammerCLI::EX_OK
end

#help ⇒ Object 



124
125
126
 
# File 'lib/hammer_cli/abstract.rb', line 124

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

#interactive? ⇒ Boolean

Returns:

  • (Boolean) 


179
180
181
 
# File 'lib/hammer_cli/abstract.rb', line 179

def interactive?
  HammerCLI.interactive?
end

#output ⇒ Object 



166
167
168
 
# File 'lib/hammer_cli/abstract.rb', line 166

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

#output_definition ⇒ Object 



170
171
172
 
# File 'lib/hammer_cli/abstract.rb', line 170

def output_definition
  self.class.output_definition
end

#parent_command ⇒ Object 



120
121
122
 
# File 'lib/hammer_cli/abstract.rb', line 120

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

#parse(arguments) ⇒ Object 



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

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 



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

def run(arguments)
  begin
    begin
      exit_code = super
      context.delete(:fields)
      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 



106
107
108
 
# File 'lib/hammer_cli/abstract.rb', line 106

def validate_options
  # keep the method for legacy reasons
end