hammer_cli 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 836795c65ef362f852b3eed29126508d0bf23927
-  data.tar.gz: 8300578ae0b731724817506ee20bda1ea458b71b
+SHA256:
+  metadata.gz: 025b01a30fd003ed027068563ad6971163cdfaea6a65749d775837df3552ea5e
+  data.tar.gz: 99177e6377a8fecf639cfe80fd6c79868a2ef24b6638c692d54da3ed8297c9d6
 SHA512:
-  metadata.gz: 848a8e9636cb5c8e8dea817de554d943f73db10399d897d770d71a7df5cfc66d5c843b351c64587781dd93ae5be81ecd17afe0e2ffa4e0ce7192d55e4d5fd732
-  data.tar.gz: aa6bbeb277ae28f0d1c1626f78773dcfbd64a4b81de89609a5fa64eff4a7a607e582f464fb2b58bc7df30b3770c877b2188b62ed14030992630a21932e0b9cf8
+  metadata.gz: b9d259322165498e492bed10e91e8a73b200b8ca78a72fd3011af3cb7fec4d73861274f9a6c23d597c3b4294a25facc7cec1bb4e02c719856a6ecc1de4c15387
+  data.tar.gz: 8e09c9a846262861b6a86f9ea4dc4dbaeb9bde089f35fe6f8f30b2066ab4e611ed9a8557b25d063bd2158a9811d5f73f4541f65b57e4104072551055015928b4

data/doc/commands_extension.md

@@ -0,0 +1,115 @@
+Extend an existing command
+-------------------------
+
+Each command can be easily extended with one ore more `HammerCLI::CommandExtensions`:
+- Define the extension
+  ```ruby
+  class Extensions < HammerCLI::CommandExtensions
+    # Tells if those extensions are inherited by subcommands (false by default)
+    # Can be changed for specific object, e.g. MyExtensions.new(inheritable: false)
+    inheritable true
+    # Simply add a new option to a command is being extended
+    option(option_params)
+    # Extend hash with data returned from server before it is printed
+    before_print do |data|
+      # data modifications
+    end
+    # Extend command's output definition
+    output do |definition|
+      # output definition modifications
+    end
+    # Extend command's help definition
+    help do |h|
+      # help modifications
+    end
+    # Extend hash with headers before request is sent
+    request_headers do |headers|
+      # headers modifications
+    end
+    # Extend hash with options before request is sent
+    request_options do |options|
+      # options modifications
+    end
+    # Extend hash with params before request is sent
+    request_params do |params|
+      # params modifications
+    end
+    # Extend option sources
+    option_sources do |sources, command|
+      # no need to call super method
+      # simply add your sources to sources variable
+    end
+  end
+  ```
+- Extend the command
+  ```ruby
+  MyCommand.extend_with(Extensions.new)
+  # Also it is possible to specify exact extensions you want to apply
+  # This can be useful when you want to use several extensions
+  MyCommand.extend_with(
+    # Apply only the output extensions from Extensions
+    Extensions.new(only: :output),
+    # Apply all except output and help extensions from OtherExtensions
+    OtherExtensions.new(except: [:output, :help])
+  )
+  ```
+
+__NOTE:__
+  - `request_*` extensions are applied before sending a request to the server
+  - `option`, `output`, `help` extensions are applied right away after the command is extended with `extend_with`
+  - `before_print` extensions are applied right away after the server returns the data
+
+#### Example
+```ruby
+class MyCommandExtensions < HammerCLI::CommandExtensions
+
+  option ['--new-option'], 'TYPE', _('Option description')
+
+  before_print do |data|
+    data['results'].each do |result|
+      result['status'] = process_errors(result['errors'])
+    end
+  end
+  # To use your custom helpers define them as class methods
+  def self.process_errors(errors)
+    errors.empty? ? 'ok' : 'fail'
+  end
+
+  output do |definition|
+    definition.append do
+      field nil, 'Statuses', Fields::Label do
+        from 'results' do
+          field 'status', _('Status')
+        end
+      end
+    end
+  end
+
+  help do |h|
+    h.text('Something useful')
+  end
+
+  request_headers do |headers|
+    headers[:ssl] = true
+  end
+
+  request_options do |options|
+    options[:with_authentication] = true
+  end
+
+  request_params do |params|
+    params[:thin] = false
+  end
+
+  option_sources do |sources, command|
+    sources.find_by_name('IdResolution').insert_relative(
+      :after,
+      'IdParams',
+      HammerCLIForeman::OptionSources::PuppetEnvironmentParams.new(command)
+    )
+    sources
+  end
+end
+
+MyCommand.extend_with(MyCommandExtensions.new)
+```

data/doc/creating_commands.md

@@ -435,7 +435,34 @@ HammerCLI::MainCommand.lazy_subcommand(
 )
 ```
 
+### Deprecated commands
+To mark a command as deprecated use the `:warning` option as follows:
 
+```ruby
+HammerCLI::MainCommand.lazy_subcommand(
+  'say',                        # command's name
+  'Say something',              # description
+  'HammerCLIHello::SayCommand', # command's class in a string
+  'hammer_cli_hello/say',       # require path of the file
+  warning: _('This command is deprecated and will be removed.')
+)
+```
+Or you can mark a command in its definition:
+
+```ruby
+class SayCommand < HammerCLI::AbstractCommand
+
+  class HelloCommand < HammerCLI::AbstractCommand
+    warning 'This command is deprecated and will be removed.'
+    command_name 'hello'
+    desc 'Say Hello World!'
+    # ...
+  end
+  # ...
+
+  autoload_subcommands
+end
+```
 ### Printing some output
 We've mentioned above that it's not recommended practice to print output
 directly with `puts` in Hammer. The reason is we separate definition

data/doc/developer_docs.md

@@ -10,6 +10,7 @@ Contents:
  - [Creating commands](creating_commands.md#create-your-first-command)
  - [Help modification](help_modification.md#modify-an-existing-help)
  - [Commands modification](commands_modification.md#modify-an-existing-command)
+ - [Command extensions](commands_extension.md#extend-an-existing-command)
  - [Option builders](option_builders.md#option-builders)
  - [Creating ApiPie commands](creating_apipie_commands.md#creating-commands-for-restful-api-with-apipie)
  - [Development tips](development_tips.md#development-tips)

data/doc/release_notes.md

@@ -1,5 +1,11 @@
 Release notes
 =============
+### 0.17.0 (2019-04-24)
+* Extended capabilities for list type options ([#26120](http://projects.theforeman.org/issues/26120))
+* Document how to deprecate commands ([PR #301](https://github.com/theforeman/hammer-cli/pull/301)) ([#24964](http://projects.theforeman.org/issues/24964))
+* Extensible commands in hammer ([#21635](http://projects.theforeman.org/issues/21635))
+* Table output allows to hide fields with no error ([#26453](http://projects.theforeman.org/issues/26453))
+
 ### 0.16.0 (2019-01-16)
 * Fixed instructions in i18n docs ([#25724](http://projects.theforeman.org/issues/25724))
 * Option validators can be mixed with sources ([#22253](http://projects.theforeman.org/issues/22253))

data/lib/hammer_cli/abstract.rb

@@ -11,6 +11,7 @@ require 'hammer_cli/subcommand'
 require 'hammer_cli/options/matcher'
 require 'hammer_cli/help/builder'
 require 'hammer_cli/help/text_builder'
+require 'hammer_cli/command_extensions'
 require 'logging'
 
 module HammerCLI
@@ -24,6 +25,38 @@ module HammerCLI
       def help_extension_blocks
         @help_extension_blocks ||= []
       end
+
+      def command_extensions
+        @command_extensions = @command_extensions || inherited_command_extensions || []
+        @command_extensions
+      end
+
+      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
+
+      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):')
+            )
+            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
     end
 
     def adapter
@@ -154,6 +187,21 @@ module HammerCLI
         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
+
+    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_options(self)
+        extension.extend_output(self)
+        extension.extend_help(self)
+        logger('Extensions').info "Applied #{extension.details} on #{self}."
+        command_extensions << extension
       end
     end
 
@@ -226,10 +274,15 @@ module HammerCLI
       @name || (superclass.respond_to?(:command_name) ? superclass.command_name : nil)
     end
 
+    def self.warning(message = nil)
+      @warning_msg = message if message
+      @warning_msg
+    end
+
     def self.autoload_subcommands
       commands = constants.map { |c| const_get(c) }.select { |c| c <= HammerCLI::AbstractCommand }
       commands.each do |cls|
-        subcommand cls.command_name, cls.desc, cls
+        subcommand(cls.command_name, cls.desc, cls, warning: cls.warning)
       end
     end
 
@@ -269,7 +322,11 @@ module HammerCLI
       sources << HammerCLI::Options::Sources::CommandLine.new(self)
       sources << HammerCLI::Options::Sources::SavedDefaults.new(context[:defaults], logger) if context[:use_defaults]
 
-      HammerCLI::Options::ProcessorList.new([sources])
+      sources = HammerCLI::Options::ProcessorList.new([sources])
+      self.class.command_extensions.each do |extension|
+        extension.extend_option_sources(sources, self)
+      end
+      sources
     end
 
     def add_validators(sources)

data/lib/hammer_cli/apipie/command.rb

@@ -47,11 +47,10 @@ module HammerCLI::Apipie
     protected
 
     def send_request
-      if resource && resource.has_action?(action)
-        resource.call(action, request_params, request_headers, request_options)
-      else
-        raise HammerCLI::OperationNotSupportedError, "The server does not support such operation."
+      unless resource && resource.has_action?(action)
+        raise HammerCLI::OperationNotSupportedError, _('The server does not support such operation.')
       end
+      extended_data(resource.call(action, *extended_request))
     end
 
     def request_headers
@@ -90,5 +89,25 @@ module HammerCLI::Apipie
       end
     end
 
+    private
+
+    def extended_request
+      params = request_params
+      headers = request_headers
+      options = request_options
+      self.class.command_extensions.each do |extension|
+        extension.extend_request_headers(headers)
+        extension.extend_request_options(options)
+        extension.extend_request_params(params)
+      end
+      [params, headers, options]
+    end
+
+    def extended_data(data)
+      self.class.command_extensions.each do |extension|
+        extension.extend_before_print(data)
+      end
+      data
+    end
   end
 end

data/lib/hammer_cli/apipie/option_builder.rb

@@ -65,7 +65,11 @@ module HammerCLI::Apipie
       opts = {}
       opts[:required] = true if (param.required? and require_options?)
       if param.expected_type.to_s == 'array'
-        opts[:format] = HammerCLI::Options::Normalizers::List.new
+        if param.params.empty?
+          opts[:format] = HammerCLI::Options::Normalizers::List.new
+        else
+          opts[:format] = HammerCLI::Options::Normalizers::ListNested.new(param.params)
+        end
       elsif param.expected_type.to_s == 'boolean' || param.validator.to_s == 'boolean'
         opts[:format] = HammerCLI::Options::Normalizers::Bool.new
       elsif param.expected_type.to_s == 'string' && param.validator =~ /Must be one of: (.*)\./

data/lib/hammer_cli/command_extensions.rb

@@ -0,0 +1,222 @@
+module HammerCLI
+  class CommandExtensions
+    class << self
+      attr_accessor :delegatee
+
+      def logger
+        Logging.logger[to_s]
+      end
+
+      def inheritable?
+        @inheritable
+      end
+    end
+
+    ALLOWED_EXTENSIONS = %i[
+      option command_options before_print data output help request
+      request_headers headers request_options options request_params params
+      option_sources
+    ].freeze
+
+    def initialize(options = {})
+      @only = options[:only] || ALLOWED_EXTENSIONS
+      @only = [@only] unless @only.is_a?(Array)
+      @except = options[:except] || []
+      @except = [@except] unless @except.is_a?(Array)
+      @inheritable = options[:inheritable]
+    end
+
+    def inheritable?
+      return @inheritable unless @inheritable.nil?
+
+      self.class.inheritable? || false
+    end
+
+    def self.method_missing(message, *args, &block)
+      if @delegatee
+        @delegatee.send(message, *args, &block)
+      else
+        super
+      end
+    end
+
+    # DSL
+
+    def self.inheritable(boolean)
+      @inheritable = boolean
+    end
+
+    def self.option(switches, type, description, opts = {}, &block)
+      @options ||= []
+      @options << { switches: switches,
+                    type: type,
+                    description: description,
+                    opts: opts, block: block }
+    end
+
+    def self.before_print(&block)
+      @before_print_block = block
+    end
+
+    def self.output(&block)
+      @output_extension_block = block
+    end
+
+    def self.help(&block)
+      @help_extension_block = block
+    end
+
+    def self.request_headers(&block)
+      @request_headers_block = block
+    end
+
+    def self.request_options(&block)
+      @request_options_block = block
+    end
+
+    def self.request_params(&block)
+      @request_params_block = block
+    end
+
+    def self.option_sources(&block)
+      @option_sources_block = block
+    end
+
+    # Object
+
+    def extend_options(command_class)
+      allowed = @only & %i[command_options option]
+      return if allowed.empty? || (allowed & @except).any?
+
+      self.class.extend_options(command_class)
+    end
+
+    def extend_before_print(data)
+      allowed = @only & %i[before_print data]
+      return if allowed.empty? || (allowed & @except).any?
+
+      self.class.extend_before_print(data)
+    end
+
+    def extend_output(command_class)
+      allowed = @only & %i[output]
+      return if allowed.empty? || (allowed & @except).any?
+
+      self.class.extend_output(command_class)
+    end
+
+    def extend_help(command_class)
+      allowed = @only & %i[help]
+      return if allowed.empty? || (allowed & @except).any?
+
+      self.class.extend_help(command_class)
+    end
+
+    def extend_request_headers(headers)
+      allowed = @only & %i[request_headers headers request]
+      return if allowed.empty? || (allowed & @except).any?
+
+      self.class.extend_request_headers(headers)
+    end
+
+    def extend_request_options(options)
+      allowed = @only & %i[request_options options request]
+      return if allowed.empty? || (allowed & @except).any?
+
+      self.class.extend_request_options(options)
+    end
+
+    def extend_request_params(params)
+      allowed = @only & %i[request_params params request]
+      return if allowed.empty? || (allowed & @except).any?
+
+      self.class.extend_request_params(params)
+    end
+
+    def extend_option_sources(sources, command = nil)
+      allowed = @only & %i[option_sources]
+      return if allowed.empty? || (allowed & @except).any?
+
+      self.class.extend_option_sources(sources, command)
+    end
+
+    def delegatee(command_class)
+      self.class.delegatee = command_class
+    end
+
+    def details
+      except = @except.empty? ? '*nothing*' : @except
+      details = if @only == ALLOWED_EXTENSIONS
+                  "*all* except #{except}"
+                else
+                  "#{@only} only"
+                end
+      "#{self.class} for #{details}"
+    end
+
+    # Class
+
+    def self.extend_options(command_class)
+      return if @options.nil?
+
+      @options.each do |option|
+        command_class.send(:option,
+                           option[:switches],
+                           option[:type],
+                           option[:description],
+                           option[:opts],
+                           &option[:block])
+        logger.debug("Added option for #{command_class}: #{option}")
+      end
+    end
+
+    def self.extend_before_print(data)
+      return if @before_print_block.nil?
+
+      @before_print_block.call(data)
+      logger.debug("Called block for #{@delegatee} data:\n\t#{@before_print_block}")
+    end
+
+    def self.extend_output(command_class)
+      return if @output_extension_block.nil?
+
+      @output_extension_block.call(command_class.output_definition)
+      logger.debug("Called block for #{@delegatee} output definition:\n\t#{@output_extension_block}")
+    end
+
+    def self.extend_help(command_class)
+      return if @help_extension_block.nil?
+
+      command_class.help_extension_blocks << @help_extension_block
+      logger.debug("Saved block for #{@delegatee} help definition:\n\t#{@help_extension_block}")
+    end
+
+    def self.extend_request_headers(headers)
+      return if @request_headers_block.nil?
+
+      @request_headers_block.call(headers)
+      logger.debug("Called block for #{@delegatee} request headers:\n\t#{@request_headers_block}")
+    end
+
+    def self.extend_request_options(options)
+      return if @request_options_block.nil?
+
+      @request_options_block.call(options)
+      logger.debug("Called block for #{@delegatee} request options:\n\t#{@request_options_block}")
+    end
+
+    def self.extend_request_params(params)
+      return if @request_params_block.nil?
+
+      @request_params_block.call(params)
+      logger.debug("Called block for #{@delegatee} request params:\n\t#{@request_params_block}")
+    end
+
+    def self.extend_option_sources(sources, command = nil)
+      return if @option_sources_block.nil?
+
+      @option_sources_block.call(sources, command)
+      logger.debug("Called block for #{@delegatee} option sources:\n\t#{@option_sources_block}")
+    end
+  end
+end

data/lib/hammer_cli/options/normalizers.rb

@@ -27,11 +27,12 @@ module HammerCLI
 
       class KeyValueList < AbstractNormalizer
 
-        PAIR_RE = '([^,=]+)=([^,\[]+|\[[^\[\]]*\])'
+        PAIR_RE = '([^,=]+)=([^,\{\[]+|[\{\[][^\{\}\[\]]*[\}\]])'
         FULL_RE = "^((%s)[,]?)+$" % PAIR_RE
 
         def description
-          _("Comma-separated list of key=value")
+          _("Comma-separated list of key=value.") + "\n" +
+          _("JSON is acceptable and preferred way for complex parameters")
         end
 
         def format(val)
@@ -60,7 +61,11 @@ module HammerCLI
           result = {}
           val.scan(Regexp.new(PAIR_RE)) do |key, value|
             value = value.strip
-            value = value.scan(/[^,\[\]]+/) if value.start_with?('[')
+            if value.start_with?('[')
+              value = value.scan(/[^,\[\]]+/)
+            elsif value.start_with?('{')
+              value = parse_key_value(value[1...-1])
+            end
 
             result[key.strip] = strip_value(value)
           end
@@ -72,6 +77,10 @@ module HammerCLI
             value.map do |item|
               strip_chars(item.strip, '"\'')
             end
+          elsif value.is_a? Hash
+            value.map do |key, val|
+              [strip_chars(key.strip, '"\''), strip_chars(val.strip, '"\'')]
+            end.to_h
           else
             strip_chars(value.strip, '"\'')
           end
@@ -86,14 +95,55 @@ module HammerCLI
 
       class List < AbstractNormalizer
         def description
-          _("Comma separated list of values. Values containing comma should be quoted or escaped with backslash")
+          _("Comma separated list of values. Values containing comma should be quoted or escaped with backslash.") + "\n" +
+          _("JSON is acceptable and preferred way for complex parameters")
         end
 
         def format(val)
-          (val.is_a?(String) && !val.empty?) ? HammerCLI::CSVParser.new.parse(val) : []
+          return [] unless val.is_a?(String) && !val.empty?
+          begin
+            JSON.parse(val)
+          rescue JSON::ParserError
+            HammerCLI::CSVParser.new.parse(val)
+          end
         end
       end
 
+      class ListNested < AbstractNormalizer
+        class Schema < Array
+          def description
+            '"' + reduce([]) do |schema, nested_param|
+              name = nested_param.name
+              name = HighLine.color(name, :bold) if nested_param.required?
+              schema << "#{name}=#{nested_param.expected_type}"
+            end.join('\,').concat(', ... "')
+          end
+        end
+
+        attr_reader :schema
+
+        def initialize(schema)
+          @schema = Schema.new(schema)
+        end
+
+        def description
+          _("Comma separated list of values defined by a schema. See Option details section below.") + "\n" +
+          _("JSON is acceptable and preferred way for complex parameters")
+        end
+
+        def format(val)
+          return [] unless val.is_a?(String) && !val.empty?
+          begin
+            JSON.parse(val)
+          rescue JSON::ParserError
+            HammerCLI::CSVParser.new.parse(val).inject([]) do |results, item|
+              next if item.empty?
+
+              results << KeyValueList.new.format(item)
+            end
+          end
+        end
+      end
 
       class Number < AbstractNormalizer
 

data/lib/hammer_cli/options/option_definition.rb

@@ -27,9 +27,9 @@ module HammerCLI
       attr_accessor :deprecated_switches
 
       def initialize(switches, type, description, options = {})
-        self.value_formatter = options.delete(:format) || HammerCLI::Options::Normalizers::Default.new
-        self.context_target = options.delete(:context_target)
-        self.deprecated_switches = options.delete(:deprecated)
+        self.value_formatter = options[:format] || HammerCLI::Options::Normalizers::Default.new
+        self.context_target = options[:context_target]
+        self.deprecated_switches = options[:deprecated]
         super
       end
 

data/lib/hammer_cli/output/adapter/table.rb

@@ -53,8 +53,8 @@ module HammerCLI::Output::Adapter
       # and there is no --no-headers option
       output_stream.puts line unless formatted_collection.empty? || @context[:no_headers]
 
-      if @context[:verbosity] >= collection.meta.pagination_verbosity &&
-         collection.respond_to?(:meta) && collection.meta.pagination_set? &&
+      if collection.respond_to?(:meta) && collection.meta.pagination_set? &&
+         @context[:verbosity] >= collection.meta.pagination_verbosity &&
          collection.count < collection.meta.subtotal
         pages = (collection.meta.subtotal.to_f / collection.meta.per_page).ceil
         puts _("Page %{page} of %{total} (use --page and --per-page for navigation).") % {:page => collection.meta.page, :total => pages}

data/lib/hammer_cli/subcommand.rb

@@ -18,6 +18,7 @@ module HammerCLI
       end
 
       def subcommand_class
+        @warning ||= @subcommand_class.warning
         warn(@warning) if @warning
         @subcommand_class
       end
@@ -38,12 +39,13 @@ module HammerCLI
       end
 
       def subcommand_class
-        warn(@warning) if @warning
-        if !@loaded
+        unless @loaded
           require @path
           @loaded = true
           @constantized_class = @subcommand_class.constantize
         end
+        @warning ||= @constantized_class.warning
+        warn(@warning) if @warning
         @constantized_class
       end
     end

data/lib/hammer_cli/version.rb

@@ -1,5 +1,5 @@
 module HammerCLI
   def self.version
-    @version ||= Gem::Version.new '0.16.0'
+    @version ||= Gem::Version.new '0.17.0'
   end
 end

data/test/unit/abstract_test.rb

@@ -499,5 +499,33 @@ describe HammerCLI::AbstractCommand do
       assert_equal ['Validator1'], result.map(&:name)
     end
   end
-end
 
+  describe '#extend_with' do
+    class Extensions < HammerCLI::CommandExtensions
+      option '--flag', 'FLAG', 'flag'
+      output { |definition| definition.append(Fields::Field.new) }
+      help { |h| h.text('text') }
+    end
+    class Cmd < HammerCLI::AbstractCommand
+      def execute
+        HammerCLI::EX_OK
+      end
+    end
+    let(:extension) { Extensions.new }
+    let(:output_extension) { Extensions.new(only: :output) }
+    let(:cmd) { Class.new(Cmd) }
+
+    it 'should extend command with option, output, help right away' do
+      cmd.extend_with(extension)
+      opt = cmd.find_option('--flag')
+      opt.is_a?(HammerCLI::Options::OptionDefinition).must_equal true
+      cmd.output_definition.empty?.must_equal false
+      cmd.new({}).help.must_match(/.*text.*/)
+    end
+
+    it 'should store more than one extension' do
+      cmd.extend_with(extension, output_extension)
+      cmd.command_extensions.size.must_equal 2
+    end
+  end
+end

data/test/unit/command_extensions_test.rb

@@ -0,0 +1,189 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe HammerCLI::CommandExtensions do
+  class CustomCmd < HammerCLI::Apipie::Command
+    def execute
+      HammerCLI::EX_OK
+    end
+
+    def request_headers
+      {}
+    end
+
+    def request_options
+      {}
+    end
+
+    def request_params
+      {}
+    end
+
+    public :extended_request, :extended_data
+  end
+
+  class CmdExtensions < HammerCLI::CommandExtensions
+    option '--ext', 'EXT', 'ext'
+    before_print do |data|
+      data['key'] = 'value'
+    end
+    output do |definition|
+      definition.append(Fields::Field.new)
+      definition.append(Fields::Field.new)
+    end
+    help do |h|
+      h.section('Section')
+      h.text('text')
+    end
+    request_headers do |headers|
+      headers[:ssl] = true
+    end
+    request_options do |options|
+      options[:with_authentication] = true
+    end
+    request_params do |params|
+      params[:thin] = true
+    end
+  end
+
+  let(:cmd) { Class.new(CustomCmd) }
+
+  context 'only' do
+    it 'should extend options only' do
+      cmd.extend_with(CmdExtensions.new(only: :option))
+      opt = cmd.find_option('--ext')
+      opt.is_a?(HammerCLI::Options::OptionDefinition).must_equal true
+      cmd.output_definition.empty?.must_equal true
+    end
+
+    it 'should extend output only' do
+      cmd.extend_with(CmdExtensions.new(only: :output))
+      cmd.output_definition.empty?.must_equal false
+      opt = cmd.find_option('--ext')
+      opt.is_a?(HammerCLI::Options::OptionDefinition).must_equal false
+    end
+
+    it 'should extend help only' do
+      cmd.extend_with(CmdExtensions.new(only: :help))
+      cmd.new({}).help.must_match(/.*Section.*/)
+      cmd.new({}).help.must_match(/.*text.*/)
+    end
+
+    it 'should extend params only' do
+      cmd.extend_with(CmdExtensions.new(only: :request_params))
+      cmd.new({}).extended_request[0].must_equal(thin: true)
+      cmd.new({}).extended_request[1].must_equal({})
+      cmd.new({}).extended_request[2].must_equal({})
+    end
+
+    it 'should extend headers only' do
+      cmd.extend_with(CmdExtensions.new(only: :request_headers))
+      cmd.new({}).extended_request[0].must_equal({})
+      cmd.new({}).extended_request[1].must_equal(ssl: true)
+      cmd.new({}).extended_request[2].must_equal({})
+    end
+
+    it 'should extend options only' do
+      cmd.extend_with(CmdExtensions.new(only: :request_options))
+      cmd.new({}).extended_request[0].must_equal({})
+      cmd.new({}).extended_request[1].must_equal({})
+      cmd.new({}).extended_request[2].must_equal(with_authentication: true)
+    end
+
+    it 'should extend params and options and headers' do
+      cmd.extend_with(CmdExtensions.new(only: :request))
+      cmd.new({}).extended_request[0].must_equal(thin: true)
+      cmd.new({}).extended_request[1].must_equal(ssl: true)
+      cmd.new({}).extended_request[2].must_equal(with_authentication: true)
+    end
+
+    it 'should extend data only' do
+      cmd.extend_with(CmdExtensions.new(only: :data))
+      cmd.new({}).help.wont_match(/.*Section.*/)
+      cmd.new({}).help.wont_match(/.*text.*/)
+      cmd.output_definition.empty?.must_equal true
+      opt = cmd.find_option('--ext')
+      opt.is_a?(HammerCLI::Options::OptionDefinition).must_equal false
+      cmd.new({}).extended_request[0].must_equal({})
+      cmd.new({}).extended_request[1].must_equal({})
+      cmd.new({}).extended_request[2].must_equal({})
+      cmd.new({}).extended_data({}).must_equal('key' => 'value')
+    end
+  end
+
+  context 'except' do
+    it 'should extend all except options' do
+      cmd.extend_with(CmdExtensions.new(except: :option))
+      opt = cmd.find_option('--ext')
+      opt.is_a?(HammerCLI::Options::OptionDefinition).must_equal false
+      cmd.output_definition.empty?.must_equal false
+      cmd.new({}).extended_request[0].must_equal(thin: true)
+      cmd.new({}).extended_request[1].must_equal(ssl: true)
+      cmd.new({}).extended_request[2].must_equal(with_authentication: true)
+    end
+
+    it 'should extend all except output' do
+      cmd.extend_with(CmdExtensions.new(except: :output))
+      cmd.output_definition.empty?.must_equal true
+      opt = cmd.find_option('--ext')
+      opt.is_a?(HammerCLI::Options::OptionDefinition).must_equal true
+      cmd.new({}).extended_request[0].must_equal(thin: true)
+      cmd.new({}).extended_request[1].must_equal(ssl: true)
+      cmd.new({}).extended_request[2].must_equal(with_authentication: true)
+    end
+
+    it 'should extend all except help' do
+      cmd.extend_with(CmdExtensions.new(except: :help))
+      cmd.new({}).help.wont_match(/.*Section.*/)
+      cmd.new({}).help.wont_match(/.*text.*/)
+      cmd.output_definition.empty?.must_equal false
+      opt = cmd.find_option('--ext')
+      opt.is_a?(HammerCLI::Options::OptionDefinition).must_equal true
+      cmd.new({}).extended_request[0].must_equal(thin: true)
+      cmd.new({}).extended_request[1].must_equal(ssl: true)
+      cmd.new({}).extended_request[2].must_equal(with_authentication: true)
+    end
+
+    it 'should extend all except params' do
+      cmd.extend_with(CmdExtensions.new(except: :request_params))
+      cmd.new({}).extended_request[0].must_equal({})
+      cmd.new({}).extended_request[1].must_equal(ssl: true)
+      cmd.new({}).extended_request[2].must_equal(with_authentication: true)
+    end
+
+    it 'should extend all except headers' do
+      cmd.extend_with(CmdExtensions.new(except: :request_headers))
+      cmd.new({}).extended_request[0].must_equal(thin: true)
+      cmd.new({}).extended_request[1].must_equal({})
+      cmd.new({}).extended_request[2].must_equal(with_authentication: true)
+    end
+
+    it 'should extend all except options' do
+      cmd.extend_with(CmdExtensions.new(except: :request_options))
+      cmd.new({}).extended_request[0].must_equal(thin: true)
+      cmd.new({}).extended_request[1].must_equal(ssl: true)
+      cmd.new({}).extended_request[2].must_equal({})
+    end
+
+    it 'should extend all except params and options and headers' do
+      cmd.extend_with(CmdExtensions.new(except: :request))
+      cmd.new({}).extended_request[0].must_equal({})
+      cmd.new({}).extended_request[1].must_equal({})
+      cmd.new({}).extended_request[2].must_equal({})
+    end
+
+    it 'should extend all except data' do
+      cmd.extend_with(CmdExtensions.new(except: :data))
+      cmd.new({}).help.must_match(/.*Section.*/)
+      cmd.new({}).help.must_match(/.*text.*/)
+      cmd.output_definition.empty?.must_equal false
+      opt = cmd.find_option('--ext')
+      opt.is_a?(HammerCLI::Options::OptionDefinition).must_equal true
+      cmd.new({}).extended_request[0].must_equal(thin: true)
+      cmd.new({}).extended_request[1].must_equal(ssl: true)
+      cmd.new({}).extended_request[2].must_equal(with_authentication: true)
+      cmd.new({}).extended_data({}).must_equal({})
+    end
+  end
+
+
+end

data/test/unit/options/normalizers_test.rb

@@ -14,21 +14,21 @@ describe HammerCLI::Options::Normalizers do
   end
 
   describe 'default' do
-  
+
     let(:formatter) { HammerCLI::Options::Normalizers::Default.new }
-  
+
     it "should not change any value" do
       formatter.format('value').must_equal 'value'
     end
-  
+
     it "should not change nil value" do
       formatter.format(nil).must_be_nil
       end
-    
+
     it "has empty description" do
       formatter.description.must_equal ''
     end
- 
+
     it "has empty completion" do
       formatter.complete('test').must_equal []
     end
@@ -69,8 +69,85 @@ describe HammerCLI::Options::Normalizers do
     it "should catch quoting errors" do
       proc { formatter.format('1,"3,4""s') }.must_raise ArgumentError
     end
+
+    it "should accept and parse JSON" do
+      formatter.format("{\"name\":\"bla\", \"value\":1}").must_equal(
+        JSON.parse("{\"name\":\"bla\", \"value\":1}")
+      )
+    end
   end
 
+  describe 'list_nested' do
+    let(:params_raw) do
+      [
+        {name: 'name', expected_type: :string, validator: 'string', description: ''},
+        {name: 'value', expected_type: :string, validator: 'string', description: ''}
+      ]
+    end
+    let(:params) do
+      [
+        ApipieBindings::Param.new(params_raw.first),
+        ApipieBindings::Param.new(params_raw.last)
+      ]
+    end
+    let(:param) do
+      ApipieBindings::Param.new({
+        name: 'array', expected_type: :array, validator: 'nested', description: '',
+        params: params_raw
+      })
+    end
+    let(:formatter) { HammerCLI::Options::Normalizers::ListNested.new(param.params) }
+
+    it "should accept and parse JSON" do
+      formatter.format("{\"name\":\"bla\", \"value\":1}").must_equal(
+        JSON.parse("{\"name\":\"bla\", \"value\":1}")
+      )
+    end
+
+    it "should parse simple input" do
+      formatter.format("name=test\\,value=1,name=other\\,value=2").must_equal(
+        [{'name' => 'test', 'value' => '1'}, {'name' => 'other', 'value' => '2'}]
+      )
+    end
+
+    it "should parse unexpected input" do
+      formatter.format("name=test\\,value=1,name=other\\,value=2,unexp=doe").must_equal(
+        [
+          {'name' => 'test', 'value' => '1'}, {'name' => 'other', 'value' => '2'},
+          {'unexp' => 'doe'}
+        ]
+      )
+    end
+
+    it "should accept arrays" do
+      formatter.format("name=test\\,value=1,name=other\\,value=[1\\,2\\,3]").must_equal(
+        [{'name' => 'test', 'value' => '1'}, {'name' => 'other', 'value' => ['1', '2', '3']}]
+      )
+    end
+
+    it "should accept hashes" do
+      formatter.format(
+        "name=test\\,value={key=key1\\,value=1},name=other\\,value={key=key2\\,value=2}"
+      ).must_equal(
+        [
+          {'name' => 'test', 'value' => {'key' => 'key1', 'value' => '1'}},
+          {'name' => 'other', 'value' => {'key' => 'key2', 'value' => '2'}},
+        ]
+      )
+    end
+
+    it "should accept combined input" do
+      formatter.format(
+        "name=foo\\,value=1\\,adds=[1\\,2\\,3]\\,cpu={name=ddd\\,type=abc}," \
+        "name=bar\\,value=2\\,adds=[2\\,2\\,2]\\,cpu={name=ccc\\,type=cba}"
+      ).must_equal(
+        [
+          {'name' => 'foo', 'value' => '1', 'adds' => ['1','2','3'], 'cpu' => {'name' => 'ddd', 'type' => 'abc'}},
+          {'name' => 'bar', 'value' => '2', 'adds' => ['2','2','2'], 'cpu' => {'name' => 'ccc', 'type' => 'cba'}}
+        ]
+      )
+    end
+  end
 
   describe 'key_value_list' do
 
@@ -133,6 +210,16 @@ describe HammerCLI::Options::Normalizers do
         formatter.format("a=1,b=[],c=3").must_equal({'a' => '1', 'b' => [], 'c' => '3'})
       end
 
+      it "should parse hash with one item" do
+        formatter.format("a=1,b={key=abc,value=abc},c=3").must_equal(
+          {'a' => '1', 'b' => {'key' => 'abc', 'value' => 'abc'}, 'c' => '3'}
+        )
+      end
+
+      it "should parse empty hash" do
+        formatter.format("a=1,b={},c=3").must_equal({'a' => '1', 'b' => {}, 'c' => '3'})
+      end
+
       it "should parse a comma separated string 2" do
         proc { formatter.format("a=1,b,c=3") }.must_raise ArgumentError
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hammer_cli
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Martin Bačovský
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-16 00:00:00.000000000 Z
+date: 2019-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clamp
@@ -156,6 +156,7 @@ extra_rdoc_files:
 - doc/release_notes.md
 - doc/commands_modification.md
 - doc/creating_commands.md
+- doc/commands_extension.md
 - doc/development_tips.md
 - doc/developer_docs.md
 - doc/writing_a_plugin.md
@@ -178,6 +179,7 @@ files:
 - bin/hammer
 - config/cli.modules.d/module_config_template.yml
 - config/cli_config.template.yml
+- doc/commands_extension.md
 - doc/commands_modification.md
 - doc/creating_apipie_commands.md
 - doc/creating_commands.md
@@ -209,6 +211,7 @@ files:
 - lib/hammer_cli/ca_cert_fetcher.rb
 - lib/hammer_cli/ca_cert_manager.rb
 - lib/hammer_cli/clamp.rb
+- lib/hammer_cli/command_extensions.rb
 - lib/hammer_cli/completer.rb
 - lib/hammer_cli/connection.rb
 - lib/hammer_cli/context.rb
@@ -439,6 +442,7 @@ files:
 - test/unit/apipie/option_definition_test.rb
 - test/unit/apipie/test_helper.rb
 - test/unit/ca_cert_manager_test.rb
+- test/unit/command_extensions_test.rb
 - test/unit/completer_test.rb
 - test/unit/connection_test.rb
 - test/unit/csv_parser_test.rb
@@ -510,7 +514,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14.1
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
 summary: Universal command-line interface
@@ -708,6 +712,7 @@ test_files:
 - test/unit/fixtures/defaults/defaults_dashed.yml
 - test/unit/defaults_test.rb
 - test/unit/messages_test.rb
+- test/unit/command_extensions_test.rb
 - test/unit/ca_cert_manager_test.rb
 - test/unit/test_helper.rb
 - test/functional/help_test.rb