hammer_cli 2.5.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a632fb8b3ddc1914f0110af4371d152d31e0efe042453512c55dd1384b8bafc
-  data.tar.gz: 76029ef771f18e0096ffdc18f897b1758d09c58277065dce55907f625f13d77e
+  metadata.gz: 510f07df29c39c069ae58e923507361a276e12ef50cc38628868361794a7754c
+  data.tar.gz: 13790a4114574688531978c11a9bb479062381d1b5196168f6d0e70deddc6a43
 SHA512:
-  metadata.gz: 6777ff43f35fb9b29332e3f02ed68320a5a0f526da5c1a0256f714223ceed72c6d09f3982d0df252be82e2e7ea754fd6105d202f68eebac030d9e6fc6a3db6b6
-  data.tar.gz: 0e7ddb3ea2aaf2080ab8b796c9eb0f68d747a0d290a57bb84e53386de86e17cb51dfbf266fccce3bee71c38123ce0aa67773aaca963fa8001840a56a8a03d467
+  metadata.gz: a8bd5241448ccae9b7bd27f4260ebe5cbc8d75f2a79dcf76fb710c13e7bba42275cda6332acd6b67c33125572393b17e1f2d1575166ce8edfc76c7a81cdb9854
+  data.tar.gz: 9656ed10f1c8d44f35f0d321e1568d82a9607dc82b5ecf3e03999ec471eb67aa5dc119fcc31c90b1f540bab4a3d5abc5eff444d498eb275a7e0b061c61426fcf

data/bin/hammer

@@ -1,4 +1,4 @@
-#! /usr/bin/env ruby
+#!/usr/bin/env ruby
 
 require 'rubygems'
 require 'clamp'

data/doc/commands_extension.md

@@ -16,11 +16,11 @@ Each command can be easily extended with one ore more `HammerCLI::CommandExtensi
       child option_params
     end
     # Extend hash with data returned from server before it is printed
-    before_print do |data|
+    before_print do |data, command_object, command_class|
       # data modifications
     end
     # Extend command's output definition
-    output do |definition|
+    output do |definition, command_object, command_class|
       # output definition modifications
     end
     # Extend command's help definition
@@ -28,19 +28,19 @@ Each command can be easily extended with one ore more `HammerCLI::CommandExtensi
       # help modifications
     end
     # Extend hash with headers before request is sent
-    request_headers do |headers|
+    request_headers do |headers, command_object, command_class|
       # headers modifications
     end
     # Extend hash with options before request is sent
-    request_options do |options|
+    request_options do |options, command_object, command_class|
       # options modifications
     end
     # Extend hash with params before request is sent
-    request_params do |params|
+    request_params do |params, command_object, command_class|
       # params modifications
     end
     # Extend option sources
-    option_sources do |sources, command|
+    option_sources do |sources, command_object, command_class|
       # no need to call super method
       # simply add your sources to sources variable
     end
@@ -63,6 +63,8 @@ __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
+  - `request_*`, `output`, `before_print` extensions have access to the command object
+    after the command with the extension was initialized
 
 #### Example
 ```ruby

data/doc/creating_commands.md

@@ -190,6 +190,23 @@ To define an option family, use the following DSL:
   end
 ```
 
+You can also add additional options for automatically built ones:
+```ruby
+  # ...
+  build_options
+  # If --resource-id option comes from the API params and you want to add options
+  # with searchables such as --resource-name, --resource-label
+  option_family(associate: 'resource') do
+    child '--resource-name', 'RESOURCE', _('Resource desc'), attribute_name: :option_resource_name
+    child '--resource-label', 'RESOURCE', _('Resource desc'), attribute_name: :option_resource_label
+  end
+  # $ hammer command --help:
+  # ...
+  #  Options:
+  #    --resource[-id|-name|-label]               Resource desc
+  # ...
+```
+
 ##### Example
 
 ```ruby

data/doc/release_notes.md

@@ -1,5 +1,28 @@
 Release notes
 =============
+### 3.1.0 (2021-11-10)
+* Remove a space in hammer's shebang, [#33810](http://projects.theforeman.org/issues/33810)
+* Revert fix rake version
+* Fix rake version
+* Wrap option descriptions to 80 chars, [#33129](http://projects.theforeman.org/issues/33129)
+* Don't store @context in field params, [#33259](http://projects.theforeman.org/issues/33259)
+* Change from superficial copy to deep copy of fields ([PR #348](https://github.com/theforeman/hammer-cli/pull/348)), [#29093](http://projects.theforeman.org/issues/29093)
+* Make api docs params to be the main options, [#33226](http://projects.theforeman.org/issues/33226)
+* Show depr warning only on option usage, [#33225](http://projects.theforeman.org/issues/33225)
+* Extract descs to option details section, [#32783](http://projects.theforeman.org/issues/32783)
+* Bump to 3.1.0-develop
+
+### 3.0.0 (2021-08-04)
+* Update rel-eng notebook ([PR #347](https://github.com/theforeman/hammer-cli/pull/347))
+* Bump version to 3.0-develop
+* Revert "change from superficial copy to deep copy of fields", [#29093](http://projects.theforeman.org/issues/29093)
+* Change from superficial copy to deep copy of fields, [#29093](http://projects.theforeman.org/issues/29093)
+* Add full comparison for fields option, [#31984](http://projects.theforeman.org/issues/31984)
+* Force capitalized field names in help, [#32444](http://projects.theforeman.org/issues/32444)
+* Unescape enum validator description, [#32570](http://projects.theforeman.org/issues/32570)
+* Make cmd object be available in command extensions, [#32568](http://projects.theforeman.org/issues/32568)
+* Bump to 2.6.0-develop
+
 ### 2.5.0 (2021-05-04)
 * Better family assignment for options, [#30996](http://projects.theforeman.org/issues/30996)
 * Bump to 2.5.0-develop

data/lib/hammer_cli/abstract.rb

@@ -20,9 +20,23 @@ module HammerCLI
   class AbstractCommand < Clamp::Command
     include HammerCLI::Subcommand
 
+    attr_reader :context
+
     class << self
       attr_accessor :validation_blocks
 
+      def family_registry
+        @family_registry ||= HammerCLI::Options::OptionFamilyRegistry.new
+      end
+
+      def option_families
+        ancestors.inject([]) do |registry, ancestor|
+          next registry unless ancestor <= HammerCLI::AbstractCommand
+
+          registry + ancestor.family_registry
+        end
+      end
+
       def help_extension_blocks
         @help_extension_blocks ||= []
       end
@@ -41,25 +55,37 @@ module HammerCLI
         extensions
       end
 
-      def extend_options_help(option)
+      def add_option_schema(option)
         extend_help do |h|
+          option_details = h.find_item(:s_option_details)
           begin
-            h.find_item(:s_option_details)
+            option_details.definition.find_item(:t_schema_help)
           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):')
+                '(bold are required; <> contains acceptable type; [] contains acceptable value):'),
+              id: :t_schema_help
             )
-            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
+          option_details.definition << HammerCLI::Help::List.new([
+            [option.switches.last, option.value_formatter.schema.description]
+          ])
         end
       end
 
+      def add_option_details_section(help)
+        option_details = HammerCLI::Help::Section.new(_('Option details'), nil, id: :s_option_details, richtext: true)
+        option_details.definition << HammerCLI::Help::Text.new(
+          _('Here you can find option types and the value an option can accept:')
+        )
+        type_list = HammerCLI::Options::Normalizers.available.each_with_object([]) do |n, l|
+          l << [n.completion_type.to_s.upcase, n.common_description]
+        end.uniq(&:first).sort
+
+        option_details.definition << HammerCLI::Help::List.new(type_list)
+        help.definition.unshift(option_details)
+      end
+
       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)
@@ -75,7 +101,7 @@ module HammerCLI
       begin
         begin
           exit_code = super
-          context.delete(:fields)
+          clean_up_context
           raise "exit code must be integer" unless exit_code.is_a? Integer
         rescue => e
           exit_code = handle_exception(e)
@@ -97,6 +123,10 @@ module HammerCLI
       HammerCLI::EX_OK
     end
 
+    def clean_up_context
+      context.delete(:fields)
+    end
+
     def self.validate_options(mode=:append, target_name=nil, validator: nil, &block)
       validator ||= HammerCLI::Options::Validators::DSLBlockValidator.new(&block)
       self.validation_blocks ||= []
@@ -115,6 +145,9 @@ module HammerCLI
       super
       context[:path] ||= []
       context[:path] << self
+      self.class.command_extensions.each do |extension|
+        extension.command_object(self)
+      end
     end
 
     def parent_command
@@ -129,6 +162,7 @@ module HammerCLI
       super(invocation_path, builder)
       help_extension = HammerCLI::Help::TextBuilder.new(builder.richtext)
       fields_switch = HammerCLI::Options::Predefined::OPTIONS[:fields].first[0]
+      add_option_details_section(help_extension) if recognised_options.size > 1
       add_sets_help(help_extension) if find_option(fields_switch)
       unless help_extension_blocks.empty?
         help_extension_blocks.each do |extension_block|
@@ -185,18 +219,29 @@ module HammerCLI
       @option_builder
     end
 
+    def self.option(switches, type, description, opts = {}, &block)
+      option = HammerCLI::Options::OptionDefinition.new(switches, type, description, opts).tap do |option|
+        declared_options << option
+        block ||= option.default_conversion_block
+        define_accessors_for(option, &block)
+        add_option_schema(option) if option.value_formatter.is_a?(HammerCLI::Options::Normalizers::ListNested)
+        completion_type_for(option, opts)
+      end
+      option
+    end
+
     def self.build_options(builder_params={})
       builder_params = yield(builder_params) if block_given?
+      builder_params[:command] = self
 
       option_builder.build(builder_params).each do |option|
         # skip switches that are already defined
-        next if option.nil? || option.switches.any? { |s| find_option(s) }
+        next if option.nil? || option.family || option.switches.any? { |s| find_option(s) }
 
-        adjust_family(option) if option.respond_to?(:family)
         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)
+        add_option_schema(option) if option.value_formatter.is_a?(HammerCLI::Options::Normalizers::ListNested)
         completion_type_for(option)
       end
     end
@@ -207,11 +252,12 @@ module HammerCLI
           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)
+        extension.command_class(self)
+        extension.extend_predefined_options
+        extension.extend_options
+        extension.extend_option_family
+        extension.extend_output
+        extension.extend_help
         logger('Extensions').info "Applied #{extension.details} on #{self}."
         command_extensions << extension
       end
@@ -223,14 +269,20 @@ module HammerCLI
       end
     end
 
-    protected
-
     def self.option_family(options = {}, &block)
       options[:creator] ||= self
-      family = HammerCLI::Options::OptionFamily.new(options)
-      family.instance_eval(&block)
+      family = if options[:associate]
+                 option_families.find { |f| f.root.to_s == options[:associate].to_s }
+               else
+                 HammerCLI::Options::OptionFamily.new(options)
+               end
+      return family.instance_eval(&block) if family
+
+      logger('Option Family').debug "No family found for #{options[:associate]}, skipping"
     end
 
+    protected
+
     def self.find_options(switch_filter, other_filters={})
       filters = other_filters
       if switch_filter.is_a? Hash
@@ -329,17 +381,6 @@ module HammerCLI
       end
     end
 
-    def self.option(switches, type, description, opts = {}, &block)
-      option = HammerCLI::Options::OptionDefinition.new(switches, type, description, opts).tap do |option|
-        declared_options << option
-        block ||= option.default_conversion_block
-        define_accessors_for(option, &block)
-        completion_type_for(option, opts)
-      end
-      extend_options_help(option) if option.value_formatter.is_a?(HammerCLI::Options::Normalizers::ListNested)
-      option
-    end
-
     def all_options
       option_collector.all_options
     end
@@ -359,7 +400,7 @@ module HammerCLI
 
       sources = HammerCLI::Options::ProcessorList.new([sources])
       self.class.command_extensions.each do |extension|
-        extension.extend_option_sources(sources, self)
+        extension.extend_option_sources(sources)
       end
       sources
     end
@@ -402,32 +443,6 @@ module HammerCLI
 
     private
 
-    def self.adjust_family(option)
-      # Collect options that should share the same family
-      # If those options have family, adopt the current one
-      # Else adopt those options to the family of the current option
-      # NOTE: this shouldn't rewrite any options,
-      # although options from similar family could be adopted (appended)
-      options = find_options(
-        aliased_resource: option.aliased_resource.to_s
-      ).select { |o| o.family.nil? || o.family.formats.include?(option.value_formatter.class) }.group_by do |o|
-        next :to_skip if option.family.children.include?(o)
-        next :to_adopt if o.family.nil? || o.family.head.nil?
-        next :to_skip if o.family.children.include?(option)
-        # If both family heads handle the same switch
-        # then `option` is probably from similar family and can be adopted
-        next :adopt_by if option.family.head.nil? || o.family.head.handles?(option.family.head.long_switch)
-
-        :to_skip
-      end
-      options[:to_adopt]&.each do |child|
-        option.family&.adopt(child)
-      end
-      options[:adopt_by]&.map(&:family)&.uniq&.each do |family|
-        family.adopt(option)
-      end
-    end
-
     def self.inherited_output_definition
       od = nil
       if superclass.respond_to? :output_definition

data/lib/hammer_cli/apipie/command.rb

@@ -86,9 +86,9 @@ module HammerCLI::Apipie
         declared_options << option
         block ||= option.default_conversion_block
         define_accessors_for(option, &block)
+        add_option_schema(option) if option.value_formatter.is_a?(HammerCLI::Options::Normalizers::ListNested)
         completion_type_for(option, opts)
       end
-      extend_options_help(option) if option.value_formatter.is_a?(HammerCLI::Options::Normalizers::ListNested)
       option
     end
 

data/lib/hammer_cli/apipie/option_builder.rb

@@ -9,11 +9,11 @@ module HammerCLI::Apipie
       @require_options = options[:require_options].nil? ? true : options[:require_options]
     end
 
-    def build(builder_params={})
+    def build(builder_params = {})
       filter = Array(builder_params[:without])
       resource_name_map = builder_params[:resource_mapping] || {}
 
-      options_for_params(@action.params, filter, resource_name_map)
+      options_for_params(@action.params, filter, resource_name_map, command: builder_params[:command])
     end
 
     attr_writer :require_options
@@ -27,21 +27,24 @@ module HammerCLI::Apipie
       HammerCLI::Apipie::OptionDefinition.new(*args)
     end
 
-    def options_for_params(params, filter, resource_name_map)
-      opts = []
+    def options_for_params(params, filter, resource_name_map, opts = {})
+      options = []
       params.each do |p|
-        next if filter.include?(p.name) || filter.include?(p.name.to_sym)
+        exists = opts[:command].find_option(option_switch(p, resource_name_map))
+        next if filter.include?(p.name) || filter.include?(p.name.to_sym) || exists
+
         if p.expected_type == :hash
-          opts += options_for_params(p.params, filter, resource_name_map)
+          options += options_for_params(p.params, filter, resource_name_map, opts)
         else
-          opts << create_option(p, resource_name_map)
+          options << create_option(p, resource_name_map, opts)
         end
       end
-      opts
+      options
     end
 
-    def create_option(param, resource_name_map)
-      family = HammerCLI::Options::OptionFamily.new
+    def create_option(param, resource_name_map, opts = {})
+      family = HammerCLI::Options::OptionFamily.new(creator: opts[:command])
+      # APIdoc params are considered to be the main options (parent) by default
       family.parent(option_switch(param, resource_name_map),
                     option_type(param, resource_name_map),
                     option_desc(param),
@@ -72,7 +75,9 @@ module HammerCLI::Apipie
       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: (.*)\./
-        allowed = $1.split(/,\ ?/).map { |val| val.gsub(/<[^>]*>/i,'') }
+        allowed = $1.split(/,\ ?/).map { |val| val.gsub(/<[^>]*>/i, '') }.map do |item|
+          CGI.unescapeHTML(item)
+        end
         opts[:format] = HammerCLI::Options::Normalizers::Enum.new(allowed)
       elsif param.expected_type.to_s == 'numeric'
         opts[:format] = HammerCLI::Options::Normalizers::Number.new

data/lib/hammer_cli/apipie/option_definition.rb

@@ -2,22 +2,15 @@ require File.join(File.dirname(__FILE__), 'options')
 
 module HammerCLI::Apipie
   class OptionDefinition < HammerCLI::Options::OptionDefinition
-    attr_accessor :referenced_resource, :aliased_resource, :family
+    attr_accessor :referenced_resource, :aliased_resource
 
     def initialize(switches, type, description, options = {})
       @referenced_resource = options[:referenced_resource].to_s if options[:referenced_resource]
       @aliased_resource = options[:aliased_resource].to_s if options[:aliased_resource]
-      @family = options[:family]
       super
       # Apipie currently sends descriptions as escaped HTML once this is changed this should be removed.
       # See #15198 on Redmine.
       @description = CGI::unescapeHTML(description)
     end
-
-    def child?
-      return unless @family
-
-      @family.children.include?(self)
-    end
   end
 end

data/lib/hammer_cli/command_extensions.rb

@@ -87,86 +87,97 @@ module HammerCLI
     end
 
     def self.option_family(options = {}, &block)
-      @option_family_opts = options
-      @option_family_block = block
+      @option_family_extensions ||= []
+      @option_family_extensions << {
+        options: options,
+        block: block
+      }
     end
 
     # Object
 
-    def extend_options(command_class)
+    def extend_options
       allowed = @only & %i[command_options option]
       return if allowed.empty? || (allowed & @except).any?
 
-      self.class.extend_options(command_class)
+      self.class.extend_options(@command_class)
     end
 
-    def extend_predefined_options(command_class)
+    def extend_predefined_options
       allowed = @only & %i[predefined_options use_option]
       return if allowed.empty? || (allowed & @except).any?
 
-      self.class.extend_predefined_options(command_class)
+      self.class.extend_predefined_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)
+      self.class.extend_before_print(data, @command_object, @command_class)
     end
 
-    def extend_output(command_class)
+    def extend_output
       allowed = @only & %i[output]
       return if allowed.empty? || (allowed & @except).any?
 
-      self.class.extend_output(command_class)
+      self.class.extend_output(@command_class, @command_object)
     end
 
-    def extend_help(command_class)
+    def extend_help
       allowed = @only & %i[help]
       return if allowed.empty? || (allowed & @except).any?
 
-      self.class.extend_help(command_class)
+      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)
+      self.class.extend_request_headers(headers, @command_object, @command_class)
     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)
+      self.class.extend_request_options(options, @command_object, @command_class)
     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)
+      self.class.extend_request_params(params, @command_object, @command_class)
     end
 
-    def extend_option_sources(sources, command = nil)
+    def extend_option_sources(sources)
       allowed = @only & %i[option_sources]
       return if allowed.empty? || (allowed & @except).any?
 
-      self.class.extend_option_sources(sources, command)
+      self.class.extend_option_sources(sources, @command_object, @command_class)
     end
 
-    def extend_option_family(command_class)
+    def extend_option_family
       allowed = @only & %i[option_family]
       return if allowed.empty? || (allowed & @except).any?
 
-      self.class.extend_option_family(command_class)
+      self.class.extend_option_family(@command_class)
     end
 
     def delegatee(command_class)
       self.class.delegatee = command_class
     end
 
+    def command_class(command_class)
+      @command_class = command_class
+    end
+
+    def command_object(command_object)
+      @command_object = command_object
+    end
+
     def details
       except = @except.empty? ? '*nothing*' : @except
       details = if @only == ALLOWED_EXTENSIONS
@@ -198,17 +209,17 @@ module HammerCLI
       logger.debug("Added predefined options for #{command_class}: #{@predefined_option_names}")
     end
 
-    def self.extend_before_print(data)
+    def self.extend_before_print(data, command_object, command_class)
       return if @before_print_block.nil?
 
-      @before_print_block.call(data)
+      @before_print_block.call(data, command_object, command_class)
       logger.debug("Called block for #{@delegatee} data:\n\t#{@before_print_block}")
     end
 
-    def self.extend_output(command_class)
+    def self.extend_output(command_class, command_object)
       return if @output_extension_block.nil?
 
-      @output_extension_block.call(command_class.output_definition)
+      @output_extension_block.call(command_class.output_definition, command_object, command_class)
       logger.debug("Called block for #{@delegatee} output definition:\n\t#{@output_extension_block}")
     end
 
@@ -219,40 +230,42 @@ module HammerCLI
       logger.debug("Saved block for #{@delegatee} help definition:\n\t#{@help_extension_block}")
     end
 
-    def self.extend_request_headers(headers)
+    def self.extend_request_headers(headers, command_object, command_class)
       return if @request_headers_block.nil?
 
-      @request_headers_block.call(headers)
+      @request_headers_block.call(headers, command_object, command_class)
       logger.debug("Called block for #{@delegatee} request headers:\n\t#{@request_headers_block}")
     end
 
-    def self.extend_request_options(options)
+    def self.extend_request_options(options, command_object, command_class)
       return if @request_options_block.nil?
 
-      @request_options_block.call(options)
+      @request_options_block.call(options, command_object, command_class)
       logger.debug("Called block for #{@delegatee} request options:\n\t#{@request_options_block}")
     end
 
-    def self.extend_request_params(params)
+    def self.extend_request_params(params, command_object, command_class)
       return if @request_params_block.nil?
 
-      @request_params_block.call(params)
+      @request_params_block.call(params, command_object, command_class)
       logger.debug("Called block for #{@delegatee} request params:\n\t#{@request_params_block}")
     end
 
-    def self.extend_option_sources(sources, command = nil)
+    def self.extend_option_sources(sources, command_object, command_class)
       return if @option_sources_block.nil?
 
-      @option_sources_block.call(sources, command)
+      @option_sources_block.call(sources, command_object, command_class)
       logger.debug("Called block for #{@delegatee} option sources:\n\t#{@option_sources_block}")
     end
 
     def self.extend_option_family(command_class)
-      return if @option_family_block.nil?
+      return if @option_family_extensions.nil?
 
-      @option_family_opts[:creator] = command_class
-      command_class.send(:option_family, @option_family_opts, &@option_family_block)
-      logger.debug("Called option family block for #{command_class}:\n\t#{@option_family_block}")
+      @option_family_extensions.each do |extension|
+        extension[:options][:creator] = command_class
+        command_class.send(:option_family, extension[:options], &extension[:block])
+        logger.debug("Called option family block for #{command_class}:\n\t#{extension[:block]}")
+      end
     end
   end
 end