hammer_cli_foreman 2.4.0 → 3.1.0

data/lib/hammer_cli_foreman/option_builders.rb

@@ -170,15 +170,33 @@ module HammerCLIForeman
     attr_reader :resource
 
     def build(builder_params={})
+      resource_name_map = builder_params[:resource_mapping] || {}
       @searchables.for(@resource).collect do |s|
         option(
           optionamize("--#{s.name}"),
           s.name.upcase,
           s.description,
-          :referenced_resource => @resource.singular_name
+          referenced_resource: @resource.singular_name,
+          aliased_resource: aliased_name(resource_name(s.name), resource_name_map)
         )
       end
     end
+
+    def aliased_name(name, resource_name_map)
+      return if name.nil?
+
+      resource_name_map[name.to_s] || resource_name_map[name.to_sym] || name
+    end
+
+    def resource_name(param)
+      if param =~ /^id[s]?$/
+        @resource.singular_name
+      elsif param =~ /_id[s]?$/
+        param.gsub(/_id[s]?$/, '')
+      else
+        nil
+      end
+    end
   end
 
 
@@ -194,23 +212,43 @@ module HammerCLIForeman
 
     def build(builder_params={})
       resource_name_map = builder_params[:resource_mapping] || {}
-      dependent_options(@resource, resource_name_map)
+      command = builder_params[:command]
+      dependent_options(@resource, resource_name_map, command)
     end
 
     protected
 
-    def dependent_options(resource, resource_name_map)
+    def dependent_options(resource, resource_name_map, command)
       options = []
       searchables = @searchables.for(resource)
       resource_name = resource.singular_name
       aliased_name = aliased(resource_name, resource_name_map)
       types = searchables.map(&:name).push('id').map(&:capitalize).join('/')
-      associated_resource = resource.singular_name.to_s.tr('_', ' ')
-      family = HammerCLI::Options::OptionFamily.new(
-        referenced_resource: resource_name,
-        aliased_resource: aliased_name,
-        description: _('Set the current %{resource} context for the request. %{types} can be used') % { types: types, resource: associated_resource }
-      )
+      associated_resource = aliased_name.to_s.tr('_', ' ')
+      family = command.option_families.find do |f|
+        f.head.referenced_resource == resource_name
+      end
+      unless family
+        # If there is no family it probably means that we explicitly want to
+        # expand options via
+        # build_options do |o|
+        #   o.expand.including(:resource)
+        # end
+        # instead of generating it from API docs (it may not be even present there)
+        family = HammerCLI::Options::OptionFamily.new(
+          description: _('%{types} of associated %{resource}') % { types: types, resource: associated_resource },
+          creator: command
+        )
+        options << family.parent(
+          optionamize("--#{aliased_name}-id"),
+          "#{aliased_name}_id".upcase,
+          description("#{aliased_name}_id", @context[:action]),
+          attribute_name: HammerCLI.option_accessor_name("#{resource_name}_id"),
+          referenced_resource: resource_name,
+          aliased_resource: aliased_name,
+          format: HammerCLI::Options::Normalizers::Number.new
+        )
+      end
 
       unless searchables.empty?
         first = searchables[0]
@@ -221,31 +259,25 @@ module HammerCLIForeman
         options << family.child(
           optionamize("--#{aliased_name}"),
           "#{aliased_name}_#{first.name}".upcase,
-          first.description || " ",
-          attribute_name: HammerCLI.option_accessor_name("#{resource_name}_#{first.name}")
+          first.description || ' ',
+          attribute_name: HammerCLI.option_accessor_name("#{resource_name}_#{first.name}"),
+          referenced_resource: resource_name,
+          aliased_resource: aliased_name
         )
         # Other options are named by the resource plus the searchable name
         # Eg. --organization-label with accessor option_organization_label
         remaining.each do |s|
-          options << family.send(s.parent? ? :parent : :child,
+          options << family.child(
             optionamize("--#{aliased_name}-#{s.name}"),
             "#{aliased_name}_#{s.name}".upcase,
-            s.description || " ",
+            s.description || ' ',
             attribute_name: HammerCLI.option_accessor_name("#{resource_name}_#{s.name}"),
-            format: s.format
+            referenced_resource: resource_name,
+            aliased_resource: aliased_name
           )
         end
       end
 
-      unless options.any? { |o| o.handles?("--#{aliased_name}-id") }
-        options << family.parent(
-          optionamize("--#{aliased_name}-id"),
-          "#{aliased_name}_id".upcase,
-          description("#{aliased_name}_id", @context[:action]),
-          attribute_name: HammerCLI.option_accessor_name("#{resource_name}_id"),
-          format: HammerCLI::Options::Normalizers::Number.new
-        )
-      end
       options
     end
 
@@ -266,15 +298,25 @@ module HammerCLIForeman
   class UpdateDependentSearchablesOptionBuilder < DependentSearchablesOptionBuilder
     protected
 
-    def dependent_options(resource, resource_name_map)
+    def dependent_options(resource, resource_name_map, command)
       options = []
       searchables = @searchables.for(resource)
       resource_name = resource.singular_name
       aliased_name = aliased(resource_name, resource_name_map)
+      # Those options are not coming from API docs, thus create a new family only
       family = HammerCLI::Options::OptionFamily.new(
         prefix: 'new-',
         aliased_resource: aliased_name,
-        referenced_resource: resource_name
+        referenced_resource: resource_name,
+        creator: command
+      )
+
+      options << family.parent(
+        optionamize("--new-#{aliased_name}-id"),
+        "new_#{aliased_name}_id".upcase,
+        _('Use to update associated %s') % aliased_name,
+        attribute_name: HammerCLI.option_accessor_name("new_#{resource_name}_id"),
+        format: HammerCLI::Options::Normalizers::Number.new
       )
       unless searchables.empty?
         first = searchables[0]
@@ -285,73 +327,63 @@ module HammerCLIForeman
         options << family.child(
           optionamize("--new-#{aliased_name}"),
           "new_#{aliased_name}_#{first.name}".upcase,
-          _('Use to update'),
+          _('Use to update associated %s') % aliased_name,
           attribute_name: HammerCLI.option_accessor_name("new_#{resource_name}_#{first.name}")
         )
         # Other options are named by the resource plus the searchable name
         # Eg. --new-organization-label with accessor option_new_organization_label
         remaining.each do |s|
-          options << family.send(s.parent? ? :parent : :child,
+          options << family.child(
             optionamize("--new-#{aliased_name}-#{s.name}"),
             "new_#{aliased_name}_#{s.name}".upcase,
-            _('Use to update'),
+            _('Use to update associated %s') % aliased_name,
             attribute_name: HammerCLI.option_accessor_name("new_#{resource_name}_#{s.name}")
           )
         end
       end
 
-      unless options.any? { |o| o.handles?("--new-#{aliased_name}-id") }
-        options << family.parent(
-          optionamize("--new-#{aliased_name}-id"),
-          "new_#{aliased_name}_id".upcase,
-          _('Use to update'),
-          attribute_name: HammerCLI.option_accessor_name("new_#{resource_name}_id"),
-          format: HammerCLI::Options::Normalizers::Number.new
-        )
-      end
       options
     end
   end
 
   class DependentSearchablesArrayOptionBuilder < DependentSearchablesOptionBuilder
-
-
-    def dependent_options(resource, resource_name_map)
+    def dependent_options(resource, resource_name_map, command)
       options = []
       searchables = @searchables.for(resource)
       resource_name = resource.singular_name
 
       aliased_name = aliased(resource_name, resource_name_map)
       aliased_plural_name = aliased(resource.name, resource_name_map)
-
       unless searchables.empty?
         first = searchables[0]
         remaining = searchables[1..-1] || []
-        types = searchables.map(&:plural_name).map(&:capitalize).join('/')
-        associated_resource = resource.name.to_s.tr('_', ' ')
-        family = HammerCLI::Options::OptionFamily.new(
-          format: HammerCLI::Options::Normalizers::List.new,
-          referenced_resource: resource_name,
-          aliased_resource: aliased_name,
-          description: _('%{types} of associated %{resource}') % { types: types, resource: associated_resource }
-        )
+        # Find family created by HammerCLI::Apipie::OptionBuilder for *_ids options
+        family = command.option_families.find do |f|
+          f.head.referenced_resource == resource_name && f.formats.include?(HammerCLI::Options::Normalizers::List)
+        end
         # First option is named by the resource
         # Eg. --organizations with accessor option_organization_names
         options << family.child(
           optionamize("--#{aliased_plural_name}"),
           "#{aliased_name}_#{first.plural_name}".upcase,
           ' ',
-          attribute_name: HammerCLI.option_accessor_name("#{resource_name}_#{first.plural_name}")
+          attribute_name: HammerCLI.option_accessor_name("#{resource_name}_#{first.plural_name}"),
+          format: HammerCLI::Options::Normalizers::List.new,
+          referenced_resource: resource_name,
+          aliased_resource: aliased_name
         )
 
         # Other options are named by the resource plus the searchable name
         # Eg. --organization-labels with accessor option_organization_labels
         remaining.each do |s|
-          options << family.send(s.parent? ? :parent : :child,
+          options << family.child(
             optionamize("--#{aliased_name}-#{s.plural_name}"),
             "#{aliased_name}_#{s.plural_name}".upcase,
             ' ',
-            attribute_name: HammerCLI.option_accessor_name("#{resource_name}_#{s.plural_name}")
+            attribute_name: HammerCLI.option_accessor_name("#{resource_name}_#{s.plural_name}"),
+            format: HammerCLI::Options::Normalizers::List.new,
+            referenced_resource: resource_name,
+            aliased_resource: aliased_name
           )
         end
       end

data/lib/hammer_cli_foreman/option_sources/id_params.rb

@@ -6,29 +6,53 @@ module HammerCLIForeman
       end
 
       def param_updatable?(param_resource)
-        param_resource && @command.respond_to?(HammerCLI.option_accessor_name("#{param_resource.singular_name}_id"))
+        param_resource && @command.respond_to?(cli_option_resource_id(param_resource))
       end
 
       def available_id_params
         IdParamsFilter.new(:only_required => false).for_action(@command.resource.action(@command.action))
       end
 
-      def get_options(defined_options, result)
+      def needs_resolving?(param_option, param_resource, all_opts)
+        return false unless param_updatable?(param_resource)
+
+        cli_searchables_set = @command.searchables.for(param_resource).any? do |s|
+          option = HammerCLI.option_accessor_name("#{param_resource.singular_name}_#{s.name}")
+          next false unless @command.respond_to?(option)
+
+          !@command.send(option).nil?
+        end
+        if cli_searchables_set
+          # Remove set '<resource_name>_id' option to force resolving in case of
+          # '<resource_name>_[name|title]' was set from CLI
+          all_opts.delete(param_option)
+          true
+        else
+          # Don't resolve if resource id was set via CLI
+          return false if @command.send(cli_option_resource_id(param_resource))
+
+          all_opts[param_option].nil?
+        end
+      end
+
+      def get_options(_defined_options, result)
         # resolve all '<resource_name>_id' parameters if they are defined as options
         # (they can be skipped using .without or .expand.except)
         return result if @command.action.nil?
+
         available_id_params.each do |api_param|
           param_resource = HammerCLIForeman.param_to_resource(api_param.name)
-          if result[HammerCLI.option_accessor_name(api_param.name)].nil? && param_updatable?(param_resource)
-            resource_id = @command.get_resource_id(param_resource, :scoped => true, :required => api_param.required?, :all_options => result)
-            result[HammerCLI.option_accessor_name(api_param.name)] = resource_id if resource_id
-          end
+          param_option = HammerCLI.option_accessor_name(api_param.name)
+          next unless needs_resolving?(param_option, param_resource, result)
+
+          resource_id = @command.get_resource_id(
+            param_resource, scoped: true, required: api_param.required?, all_options: result
+          )
+          result[param_option] = resource_id if resource_id
         end
         result
-
       rescue HammerCLIForeman::MissingSearchOptions => e
-
-        switches = @command.class.find_options(:referenced_resource => e.resource.singular_name).map(&:long_switch)
+        switches = @command.class.find_options(referenced_resource: e.resource.singular_name).map(&:long_switch)
 
         if switches.empty?
           error_message = _("Could not find %{resource}. Some search options were missing, please see --help.")
@@ -40,12 +64,18 @@ module HammerCLIForeman
 
         raise MissingSearchOptions.new(
           error_message % {
-            :resource => e.resource.singular_name,
-            :switches => switches.join(", ")
+            resource: e.resource.singular_name,
+            switches: switches.join(', ')
           },
           e.resource
         )
       end
+
+      private
+
+      def cli_option_resource_id(resource)
+        HammerCLI.option_accessor_name("#{resource.singular_name}_id")
+      end
     end
   end
 end

data/lib/hammer_cli_foreman/option_sources/ids_params.rb

@@ -6,25 +6,57 @@ module HammerCLIForeman
       end
 
       def param_updatable?(param_resource)
-        param_resource && @command.respond_to?(HammerCLI.option_accessor_name("#{param_resource.singular_name}_ids"))
+        param_resource && @command.respond_to?(cli_option_resource_ids(param_resource))
       end
 
       def available_ids_params
         IdArrayParamsFilter.new(:only_required => false).for_action(@command.resource.action(@command.action))
       end
 
-      def get_options(defined_options, result)
-        return result if @command.action.nil?
+      def needs_resolving?(param_option, param_resource, all_opts)
+        return false unless param_updatable?(param_resource)
+
+        cli_searchables_set = @command.searchables.for(param_resource).any? do |s|
+          option = HammerCLI.option_accessor_name("#{param_resource.singular_name}_#{s.plural_name}")
+          next false unless @command.respond_to?(option)
+
+          !@command.send(option).nil?
+        end
+        if cli_searchables_set
+          # Remove set '<resource_name>_ids' option to force resolving in case of
+          # '<resource_name>_[names|titles]' were set from CLI
+          all_opts.delete(param_option)
+          true
+        else
+          # Don't resolve if resource ids were set via CLI
+          return false if @command.send(cli_option_resource_ids(param_resource))
+
+          all_opts[param_option].nil?
+        end
+      end
+
+      def get_options(_defined_options, result)
         # resolve all '<resource_name>_ids' parameters if they are defined as options
+        return result if @command.action.nil?
+
         available_ids_params.each do |api_param|
           param_resource = HammerCLIForeman.param_to_resource(api_param.name)
-          if result[HammerCLI.option_accessor_name(api_param.name)].nil? && param_updatable?(param_resource)
-            resource_ids = @command.get_resource_ids(param_resource, :scoped => true, :required => api_param.required?, :all_options => result)
-            result[HammerCLI.option_accessor_name(api_param.name)] = resource_ids if resource_ids
-          end
+          param_option = HammerCLI.option_accessor_name(api_param.name)
+          next unless needs_resolving?(param_option, param_resource, result)
+
+          resource_ids = @command.get_resource_ids(
+            param_resource, scoped: true, required: api_param.required?, all_options: result
+          )
+          result[param_option] = resource_ids if resource_ids
         end
         result
       end
+
+      private
+
+      def cli_option_resource_ids(resource)
+        HammerCLI.option_accessor_name("#{resource.singular_name}_ids")
+      end
     end
   end
 end

data/lib/hammer_cli_foreman/option_sources.rb

@@ -3,6 +3,5 @@ require 'hammer_cli_foreman/option_sources/ids_params'
 require 'hammer_cli_foreman/option_sources/self_param'
 require 'hammer_cli_foreman/option_sources/user_params'
 require 'hammer_cli_foreman/option_sources/fields_params'
-require 'hammer_cli_foreman/option_sources/puppet_environment_params'
 require 'hammer_cli_foreman/option_sources/new_params'
 require 'hammer_cli_foreman/option_sources/referenced_resource_id_params'

data/lib/hammer_cli_foreman/organization.rb

@@ -36,7 +36,6 @@ module HammerCLIForeman
         HammerCLIForeman::References.partition_tables(self)
         HammerCLIForeman::References.domains(self)
         HammerCLIForeman::References.realms(self)
-        HammerCLIForeman::References.environments(self)
         HammerCLIForeman::References.hostgroups(self)
         HammerCLIForeman::References.parameters(self)
         collection :locations, _("Locations"), :numbered => false, :hide_blank => true do
@@ -59,8 +58,6 @@ module HammerCLIForeman
       failure_message _("Could not create the organization")
 
       build_options
-
-      extend_with(HammerCLIForeman::CommandExtensions::PuppetEnvironments.new)
     end
 
 
@@ -73,8 +70,6 @@ module HammerCLIForeman
       failure_message _("Could not update the organization")
 
       build_options
-
-      extend_with(HammerCLIForeman::CommandExtensions::PuppetEnvironments.new)
     end
 
 
@@ -114,7 +109,6 @@ module HammerCLIForeman
 
 
     HammerCLIForeman::AssociatingCommands::Hostgroup.extend_command(self)
-    HammerCLIForeman::AssociatingCommands::PuppetEnvironment.extend_command(self)
     HammerCLIForeman::AssociatingCommands::Domain.extend_command(self)
     HammerCLIForeman::AssociatingCommands::Medium.extend_command(self)
     HammerCLIForeman::AssociatingCommands::Subnet.extend_command(self)

data/lib/hammer_cli_foreman/ping.rb

@@ -19,7 +19,12 @@ module HammerCLIForeman
         response = send_request
         print_data(response)
 
-        return 1 if HammerCLIForeman::CommandExtensions::Ping.failed?(response)
+        if HammerCLIForeman::CommandExtensions::Ping.failed?(response)
+          HammerCLIForeman::CommandExtensions::Ping.check_for_unrecognized(
+            response, output_definition
+          )
+          return 1
+        end
 
         HammerCLI::EX_OK
       end

data/lib/hammer_cli_foreman/references.rb

@@ -112,14 +112,6 @@ module HammerCLIForeman
       end
     end
 
-    def self.environments(dsl)
-      dsl.build do
-        collection :environments, _("Environments"), :numbered => false do
-          custom_field Fields::Reference
-        end
-      end
-    end
-
     def self.hostgroups(dsl)
       dsl.build do
         collection :hostgroups, _("Hostgroups"), :numbered => false do
@@ -153,14 +145,6 @@ module HammerCLIForeman
       end
     end
 
-    def self.puppetclasses(dsl)
-      dsl.build do
-        collection :puppetclasses, _("Puppetclasses"), :numbered => false do
-          custom_field Fields::Reference
-        end
-      end
-    end
-
     def self.operating_systems(dsl)
       dsl.build do
         collection :operatingsystems, _("Operating systems"), :numbered => false do

data/lib/hammer_cli_foreman/registration.rb

@@ -0,0 +1,18 @@
+module HammerCLIForeman
+  class Registration < HammerCLIForeman::Command
+    resource :registration_commands
+
+    class GenerateCommand < HammerCLIForeman::CreateCommand
+      command_name 'generate-command'
+      failure_message _("Failed to generate registration command")
+
+      def print_data(registration_command)
+        puts registration_command
+      end
+
+      build_options
+    end
+
+    autoload_subcommands
+  end
+end

data/lib/hammer_cli_foreman/settings.rb

@@ -20,7 +20,7 @@ module HammerCLIForeman
         data
       end
 
-      build_options expand: { except: %i[organizations locations] }, without: %i[organization_id location_id]
+      build_options
     end
 
     class UpdateCommand < HammerCLIForeman::UpdateCommand
@@ -29,7 +29,7 @@ module HammerCLIForeman
       success_message _("Setting [%{name}] updated to [%{value}].")
       failure_message _("Could not update the setting")
 
-      build_options expand: { except: %i[organizations locations] }, without: %i[organization_id location_id]
+      build_options
     end
 
     class InfoCommand < HammerCLIForeman::InfoCommand
@@ -42,7 +42,7 @@ module HammerCLIForeman
         field :value, _("Value")
       end
 
-      build_options expand: { except: %i[organizations locations] }, without: %i[organization_id location_id]
+      build_options
     end
 
 

data/lib/hammer_cli_foreman/smart_proxy.rb

@@ -10,8 +10,9 @@ module HammerCLIForeman
       output do
         field :id, _("Id")
         field :name, _("Name")
+        field :status, _("Status")
         field :url, _("URL")
-        field :_features, _( "Features"), Fields::List, :width => 25, :hide_blank => true
+        field :_features, _( "Features"), Fields::List, :hide_blank => true
       end
 
       def extend_data(proxy)
@@ -22,12 +23,13 @@ module HammerCLIForeman
       build_options
     end
 
-
     class InfoCommand < HammerCLIForeman::InfoCommand
-
       output ListCommand.output_definition do
-        collection :features,  _("Features"), :numbered => false do
-          custom_field Fields::Reference
+        field :version, _("Version")
+        field :hosts_count, _("Host_count")
+        collection :features, _("Features") do
+          field :name, _('Name')
+          field :version, _('Version')
         end
         HammerCLIForeman::References.taxonomies(self)
         HammerCLIForeman::References.timestamps(self)
@@ -60,58 +62,6 @@ module HammerCLIForeman
       build_options
     end
 
-
-    class ImportPuppetClassesCommand < HammerCLIForeman::Command
-      action :import_puppetclasses
-
-      command_name    "import-classes"
-
-      option "--dryrun", :flag, _("Do not run the import")
-
-      output do
-        field :message, _("Result"), Fields::LongText
-        collection :results, _("Changed environments"), :hide_blank => true do
-          field :name, nil
-          collection :new_puppetclasses, _("New classes"), :hide_blank => true, :numbered => false do
-            field nil, nil
-          end
-          collection :updated_puppetclasses, _("Updated classes"), :hide_blank => true, :numbered => false do
-            field nil, nil
-          end
-          collection :obsolete_puppetclasses, _("Removed classes"), :hide_blank => true, :numbered => false do
-            field nil, nil
-          end
-          collection :ignored_puppetclasses, _("Ignored classes"), :hide_blank => true, :numbered => false do
-            field nil, nil
-          end
-        end
-      end
-
-      build_options do |o|
-        o.without(:smart_proxy_id, :dryrun)
-        o.expand.except(:smart_proxies)
-      end
-
-      def request_params
-        opts = super
-        opts['dryrun'] = option_dryrun? || false
-        opts
-      end
-
-      def transform_format(data)
-        # Overriding the default behavior that tries to remove nesting
-        # when there's only {"message": "..."}
-        data
-      end
-
-      def print_data(record)
-        print_record(output_definition, record)
-      end
-
-      extend_with(HammerCLIForeman::CommandExtensions::PuppetEnvironment.new)
-    end
-
-
     class RefreshFeaturesCommand < HammerCLIForeman::Command
 
       action :refresh

data/lib/hammer_cli_foreman/template.rb

@@ -5,25 +5,13 @@ module HammerCLIForeman
     resource :provisioning_templates
 
     module TemplateCreateUpdateCommons
-
       def option_snippet
         option_type && (option_type == "snippet")
       end
 
-      def option_template_kind_id
-        table = kinds.inject({}){ |result, k| result.update(k["name"] => k["id"]) }
-        if option_snippet == false && table[option_type].nil?
-          signal_usage_error _("unknown template kind")
-        else
-          table[option_type]
-        end
-      end
-
-      def kinds
-        HammerCLIForeman.collection_to_common_format(
-          HammerCLIForeman.foreman_resource!(:template_kinds).call(:index))
-      end
-
+      # This method is for IdParams option source to make resolver work for
+      # --type option
+      def option_template_kind_id; end
     end
 
     class ListCommand < HammerCLIForeman::ListCommand

data/lib/hammer_cli_foreman/user.rb

@@ -56,9 +56,9 @@ module HammerCLIForeman
       success_message _("User [%{login}] created.")
       failure_message _("Could not create the user")
 
-      extend_with(HammerCLIForeman::CommandExtensions::User.new)
-
       build_options
+
+      extend_with(HammerCLIForeman::CommandExtensions::User.new)
     end
 
 
@@ -66,9 +66,9 @@ module HammerCLIForeman
       success_message _("User [%{login}] updated.")
       failure_message _("Could not update the user")
 
-      extend_with(HammerCLIForeman::CommandExtensions::User.new)
-
       build_options
+
+      extend_with(HammerCLIForeman::CommandExtensions::User.new)
     end