pdk 1.14.1 → 1.18.1

data/lib/pdk/cli/remove.rb

@@ -0,0 +1,20 @@
+module PDK::CLI
+  @remove_cmd = @base_cmd.define_command do
+    name 'remove'
+    usage _('remove [subcommand] [options]')
+    summary _('Remove or delete information about the PDK or current project.')
+    default_subcommand 'help'
+
+    run do |_opts, args, _cmd|
+      if args == ['help']
+        PDK::CLI.run(%w[remove --help])
+        exit 0
+      end
+
+      PDK::CLI.run(%w[remove help]) if args.empty?
+    end
+  end
+  @remove_cmd.add_command Cri::Command.new_basic_help
+end
+
+require 'pdk/cli/remove/config'

data/lib/pdk/cli/remove/config.rb

@@ -0,0 +1,80 @@
+module PDK::CLI
+  module Remove
+    module Config
+      def self.run(opts, args)
+        item_name = (args.count > 0) ? args[0] : nil
+        item_value = (args.count > 1) ? args[1].strip : nil
+        item_value = nil if !item_value.nil? && item_value.empty?
+
+        force = opts[:force] || false
+
+        raise PDK::CLI::ExitWithError, _('Configuration name is required') if item_name.nil?
+
+        current_value = PDK.config.get(item_name)
+        raise PDK::CLI::ExitWithError, _("The configuration item '%{name}' can not be removed.") % { name: item_name } if current_value.is_a?(PDK::Config::Namespace)
+        if current_value.nil?
+          PDK.logger.info(_("Could not remove '%{name}' as it has not been set") % { name: item_name })
+          return 0
+        end
+
+        PDK.logger.info(_("Ignoring the item value '%{value}' as --force has been set") % { value: item_value }) if current_value.is_a?(Array) && !item_value.nil? && force
+        PDK.logger.info(_('Ignoring --force as the setting is not multi-valued')) if !current_value.is_a?(Array) && force
+
+        # FIXME: It'd be nice to shortcircuit deleting default values.  This causes the configuration file
+        # to be saved, even though nothing actually changes
+
+        # For most value types, just changing the value to nil is enough, however Arrays are a special case.
+        # Unless they're forced, array removal with either remove a single entry (matched by .to_s) or clear the
+        # array.  When forced, the array is completed removed just like a string or number.
+        if current_value.is_a?(Array) && !force
+          # If the user didn't set a value then set the array as empty, otherwise remove that one item
+          new_value = item_value.nil? ? [] : current_value.reject { |item| item.to_s == item_value }
+          if current_value.count == new_value.count
+            if item_value.nil?
+              PDK.logger.info(_("Could not remove '%{name}' as it is already empty") % { name: item_name })
+            else
+              PDK.logger.info(_("Could not remove '%{value}' from '%{name}' as it has not been set") % { value: item_value, name: item_name })
+            end
+            return 0
+          end
+          PDK.config.set(item_name, new_value, force: true)
+        else
+          # Set the value to nil for deleting.
+          PDK.config.set(item_name, nil, force: true)
+        end
+
+        # Output the result to the user
+        new_value = PDK.config.get(item_name)
+        if current_value.is_a?(Array) && !force
+          # Arrays have a special output format. If item_value is nil then the user wanted to empty/clear
+          # the array otherwise they just wanted to remove a single entry.
+          if item_value.nil?
+            PDK.logger.info(_("Cleared '%{name}' which had a value of '%{from}'") % { name: item_name, from: current_value })
+          else
+            PDK.logger.info(_("Removed '%{value}' from '%{name}'") % { value: item_value, name: item_name })
+          end
+        elsif !new_value.nil?
+          PDK.logger.info(_("Could not remove '%{name}' as it using a default value of '%{to}'") % { name: item_name, to: new_value })
+        else
+          PDK.logger.info(_("Removed '%{name}' which had a value of '%{from}'") % { name: item_name, from: current_value })
+        end
+
+        # Same output as `get config`
+        $stdout.puts _('%{name}=%{value}') % { name: item_name, value: new_value }
+        0
+      end
+    end
+  end
+
+  @remove_config_cmd = @remove_cmd.define_command do
+    name 'config'
+    usage _('config [name] [value]')
+    summary _('Remove or delete the configuration for <name>')
+
+    option :f, :force, _('Force multi-value configuration settings to be removed instead of emptied.'), argument: :forbidden
+
+    run do |opts, args, _cmd|
+      exit PDK::CLI::Remove::Config.run(opts, args)
+    end
+  end
+end

data/lib/pdk/cli/set.rb

@@ -0,0 +1,20 @@
+module PDK::CLI
+  @set_cmd = @base_cmd.define_command do
+    name 'set'
+    usage _('set [subcommand] [options]')
+    summary _('Set or update information about the PDK or current project.')
+    default_subcommand 'help'
+
+    run do |_opts, args, _cmd|
+      if args == ['help']
+        PDK::CLI.run(%w[set --help])
+        exit 0
+      end
+
+      PDK::CLI.run(%w[set help]) if args.empty?
+    end
+  end
+  @set_cmd.add_command Cri::Command.new_basic_help
+end
+
+require 'pdk/cli/set/config'

data/lib/pdk/cli/set/config.rb

@@ -0,0 +1,119 @@
+module PDK::CLI
+  module Set
+    module Config
+      ALLOWED_TYPE_NAMES = %w[array boolean number string].freeze
+
+      # :nocov:
+      def self.pretty_allowed_names
+        ALLOWED_TYPE_NAMES.map { |name| "'#{name}'" }.join(', ')
+      end
+      # :nocov:
+
+      def self.transform_value(type_name, value)
+        normalized_name = type_name.downcase.strip
+        unless ALLOWED_TYPE_NAMES.include?(normalized_name)
+          raise PDK::CLI::ExitWithError, _('Unknown type %{type_name}. Expected one of %{allowed}') % { type_name: type_name, allowed: pretty_allowed_names }
+        end
+
+        # Short circuit string conversions as it's trivial
+        if normalized_name == 'string'
+          raise PDK::CLI::ExitWithError, _('An error occured converting \'%{value}\' into a %{type_name}') % { value: value.nil? ? 'nil' : value, type_name: type_name } unless value.is_a?(String)
+          return value
+        end
+
+        begin
+          case normalized_name
+          when 'array'
+            convert_to_array(value)
+          when 'boolean'
+            convert_to_boolean(value)
+          when 'number'
+            convert_to_number(value)
+          else
+            value
+          end
+        rescue ArgumentError, TypeError
+          raise PDK::CLI::ExitWithError, _('An error occured converting \'%{value}\' into a %{type_name}') % { value: value.nil? ? 'nil' : value, type_name: type_name }
+        end
+      end
+
+      def self.convert_to_array(value)
+        return [] if value.nil?
+        value.is_a?(Array) ? value : [value]
+      end
+      private_class_method :convert_to_array
+
+      def self.convert_to_boolean(value)
+        string_val = value.to_s.strip.downcase
+
+        return true  if %w[yes true -1 1].include?(string_val)
+        return false if %w[no false 0].include?(string_val)
+
+        raise ArgumentError
+      end
+      private_class_method :convert_to_boolean
+
+      def self.convert_to_number(value)
+        float_val = Float(value)
+        # Return an Integer if this is actually and Integer, otherwise return the float
+        (float_val.truncate == float_val) ? float_val.truncate : float_val
+      end
+      private_class_method :convert_to_number
+
+      def self.run(opts, args)
+        item_name = (args.count > 0) ? args[0] : nil
+        item_value = (args.count > 1) ? args[1] : nil
+
+        opts[:type] = opts[:as] if opts[:type].nil? && !opts[:as].nil?
+        force = opts[:force] || false
+
+        # Transform the value if we need to
+        item_value = PDK::CLI::Set::Config.transform_value(opts[:type], item_value) unless opts[:type].nil?
+
+        raise PDK::CLI::ExitWithError, _('Configuration name is required') if item_name.nil?
+        raise PDK::CLI::ExitWithError, _('Configuration value is required. If you wish to remove a value use \'pdk remove config\'') if item_value.nil?
+
+        current_value = PDK.config.get(item_name)
+        raise PDK::CLI::ExitWithError, _("The configuration item '%{name}' can not have a value set.") % { name: item_name } if current_value.is_a?(PDK::Config::Namespace)
+
+        # If we're forcing the value, don't do any munging
+        unless force
+          # Check if the setting already exists
+          if current_value.is_a?(Array) && current_value.include?(item_value)
+            PDK.logger.info(_("No changes made to '%{name}' as it already contains value '%{to}'") % { name: item_name, to: item_value })
+            return 0
+          end
+        end
+
+        new_value = PDK.config.set(item_name, item_value, force: opts[:force])
+        if current_value.nil? || force
+          PDK.logger.info(_("Set initial value of '%{name}' to '%{to}'") % { name: item_name, to: new_value })
+        elsif current_value.is_a?(Array)
+          # Arrays have a special output format
+          PDK.logger.info(_("Added new value '%{to}' to '%{name}'") % { name: item_name, to: item_value })
+        else
+          PDK.logger.info(_("Changed existing value of '%{name}' from '%{from}' to '%{to}'") % { name: item_name, from: current_value, to: new_value })
+        end
+
+        # Same output as `get config`
+        $stdout.puts _('%{name}=%{value}') % { name: item_name, value: PDK.config.get(item_name) }
+        0
+      end
+    end
+  end
+
+  @set_config_cmd = @set_cmd.define_command do
+    name 'config'
+    usage _('config [name] [value]')
+    summary _('Set or update the configuration for <name>')
+
+    option :f, :force, _('Force the configuration setting to be overwitten.'), argument: :forbidden
+
+    option :t, :type, _('The type of value to set. Acceptable values: %{values}') % { values: PDK::CLI::Set::Config.pretty_allowed_names }, argument: :required
+    option nil, :as, _('Alias of --type'), argument: :required
+
+    run do |opts, args, _cmd|
+      exit PDK::CLI::Set::Config.run(opts, args)
+    end
+  end
+end

data/lib/pdk/cli/update.rb

@@ -10,14 +10,12 @@ module PDK::CLI
     PDK::CLI.template_ref_option(self)
 
     run do |opts, _args, _cmd|
-      require 'pdk/cli/util'
-      require 'pdk/util'
-      require 'pdk/module/update'
+      # Write the context information to the debug log
+      PDK.context.to_debug_log
 
-      PDK::CLI::Util.ensure_in_module!(
-        message:   _('`pdk update` can only be run from inside a valid module directory.'),
-        log_level: :info,
-      )
+      unless PDK.context.is_a?(PDK::Context::Module)
+        raise PDK::CLI::ExitWithError, _('`pdk update` can only be run from inside a valid module directory.')
+      end
 
       raise PDK::CLI::ExitWithError, _('This module does not appear to be PDK compatible. To make the module compatible with PDK, run `pdk convert`.') unless PDK::Util.module_pdk_compatible?
 
@@ -46,7 +44,19 @@ module PDK::CLI
 
       PDK::CLI::Util.analytics_screen_view('update', opts)
 
-      updater = PDK::Module::Update.new(opts)
+      updater = PDK::Module::Update.new(PDK.context.root_path, opts)
+
+      if updater.pinned_to_puppetlabs_template_tag?
+        PDK.logger.info _(
+          'This module is currently pinned to version %{current_version} ' \
+          'of the default template. If you would like to update your ' \
+          'module to the latest version of the template, please run `pdk ' \
+          'update --template-ref %{new_version}`.',
+        ) % {
+          current_version: updater.template_uri.uri_fragment,
+          new_version:     PDK::TEMPLATE_REF,
+        }
+      end
 
       updater.run
     end

data/lib/pdk/cli/util.rb

@@ -8,6 +8,7 @@ module PDK
       autoload :OptionValidator, 'pdk/cli/util/option_validator'
       autoload :Interview, 'pdk/cli/util/interview'
       autoload :Spinner, 'pdk/cli/util/spinner'
+      autoload :UpdateManagerPrinter, 'pdk/cli/util/update_manager_printer'
 
       # Ensures the calling code is being run from inside a module directory.
       #
@@ -129,13 +130,14 @@ module PDK
       end
       module_function :check_for_deprecated_puppet
 
-      # @param opts [Hash] - the pdk options ot use, defaults to empty hash
+      # @param opts [Hash] - the pdk options to use, defaults to empty hash
       # @option opts [String] :'puppet-dev' Use the puppet development version, default to PDK_PUPPET_DEV env
       # @option opts [String] :'puppet-version' Puppet version to use, default to PDK_PUPPET_VERSION env
       # @option opts [String] :'pe-version' PE Puppet version to use, default to PDK_PE_VERSION env
       # @param logging_disabled [Boolean] - disable logging of PDK info
+      # @param context [PDK::Context::AbstractContext] - The context the PDK is running in
       # @return [Hash] - return hash of { gemset: <>, ruby_version: 2.x.x }
-      def puppet_from_opts_or_env(opts, logging_disabled = false)
+      def puppet_from_opts_or_env(opts, logging_disabled = false, context = PDK.context)
         opts ||= {}
         use_puppet_dev = opts.fetch(:'puppet-dev', PDK::Util::Env['PDK_PUPPET_DEV'])
         desired_puppet_version = opts.fetch(:'puppet-version', PDK::Util::Env['PDK_PUPPET_VERSION'])
@@ -150,8 +152,10 @@ module PDK
               PDK::Util::PuppetVersion.find_gem_for(desired_puppet_version)
             elsif desired_pe_version
               PDK::Util::PuppetVersion.from_pe_version(desired_pe_version)
-            else
+            elsif context.is_a?(PDK::Context::Module)
               PDK::Util::PuppetVersion.from_module_metadata || PDK::Util::PuppetVersion.latest_available
+            else
+              PDK::Util::PuppetVersion.latest_available
             end
         rescue ArgumentError => e
           raise PDK::CLI::ExitWithError, e.message

data/lib/pdk/cli/util/update_manager_printer.rb

@@ -0,0 +1,82 @@
+require 'pdk'
+
+module PDK
+  module CLI
+    module Util
+      module UpdateManagerPrinter
+        # Prints the summary for a PDK::Module::UpdateManager Object
+        # @param update_manager [PDK::Module::UpdateManager] The object to print a summary of
+        # @param options [Hash{Object => Object}] A list of options when printing
+        # @option options [Boolean] :tense Whether to use future (:future) or past (:past) tense when printing the summary ("Files to be added" versus "Files added"). Default is :future
+        #
+        # @return [void]
+        def self.print_summary(update_manager, options = {})
+          require 'pdk/report'
+
+          options = {
+            tense: :future,
+          }.merge(options)
+
+          footer = false
+
+          summary(update_manager).each do |category, files|
+            next if files.empty?
+
+            PDK::Report.default_target.puts('')
+            PDK::Report.default_target.puts(generate_banner("Files #{(options[:tense] == :future) ? 'to be ' : ''}#{category}", 40))
+            PDK::Report.default_target.puts(files.map(&:to_s).join("\n"))
+            footer = true
+          end
+
+          if footer # rubocop:disable Style/GuardClause No.
+            PDK::Report.default_target.puts('')
+            PDK::Report.default_target.puts(generate_banner('', 40))
+          end
+        end
+
+        #:nocov: Tested as part of the public methods
+        # Returns a hash, summarizing the contents of the Update Manager object
+        # @param update_manager [PDK::Module::UpdateManager] The object to create a summary of
+        #
+        # @return [Hash{Symbol => Array[String]}] A hash of each category and the file paths in each category
+        def self.summary(update_manager)
+          summary = {}
+          update_manager.changes.each do |category, update_category|
+            if update_category.respond_to?(:keys)
+              updated_files = update_category.keys
+            else
+              begin
+                updated_files = update_category.map { |file| file[:path] }
+              rescue TypeError
+                updated_files = update_category.to_a
+              end
+            end
+
+            summary[category] = updated_files
+          end
+
+          summary
+        end
+        private_class_method :summary
+
+        # Creates a line of text, with `text` centered in the middle
+        # @param text [String] The text to put in the middle of the banner
+        # @param width [Integer] The width of the banner in characters. Default is 80
+        # @return [String] The generated banner
+        def self.generate_banner(text, width = 80)
+          padding = width - text.length
+          banner = ''
+          padding_char = '-'
+
+          (padding / 2.0).ceil.times { banner << padding_char }
+          banner << text
+          (padding / 2.0).floor.times { banner << padding_char }
+
+          banner
+        end
+        private_class_method :generate_banner
+        #:nocov:
+      end
+    end
+  end
+end

data/lib/pdk/cli/validate.rb

@@ -19,6 +19,9 @@ module PDK::CLI
     flag nil, :parallel, _('Run validations in parallel.')
 
     run do |opts, args, _cmd|
+      # Write the context information to the debug log
+      PDK.context.to_debug_log
+
       if args == ['help']
         PDK::CLI.run(['validate', '--help'])
         exit 0
@@ -26,42 +29,42 @@ module PDK::CLI
 
       require 'pdk/validate'
 
-      validator_names = PDK::Validate.validators.map { |v| v.name }
-      validators = PDK::Validate.validators
-      targets = []
-
       if opts[:list]
         PDK::CLI::Util.analytics_screen_view('validate', opts)
-        PDK.logger.info(_('Available validators: %{validator_names}') % { validator_names: validator_names.join(', ') })
+        PDK.logger.info(_('Available validators: %{validator_names}') % { validator_names: PDK::Validate.validator_names.join(', ') })
         exit 0
       end
 
       PDK::CLI::Util.validate_puppet_version_opts(opts)
+      unless PDK.feature_flag?('controlrepo') || PDK.context.is_a?(PDK::Context::Module)
+        raise PDK::CLI::ExitWithError.new(_('Code validation can only be run from inside a valid module directory'), log_level: :error)
+      end
 
-      PDK::CLI::Util.ensure_in_module!(
-        message:   _('Code validation can only be run from inside a valid module directory'),
-        log_level: :info,
-      )
+      PDK::CLI::Util.module_version_check if PDK.context.is_a?(PDK::Context::Module)
 
-      PDK::CLI::Util.module_version_check
+      # Set the ruby version we're going to use early. Must be set before the validators are created.
+      # Note that this is a bit of code-smell and should be fixed
+      puppet_env = PDK::CLI::Util.puppet_from_opts_or_env(opts)
+      PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
 
+      targets = []
+      validators_to_run = nil
       if args[0]
         # This may be a single validator, a list of validators, or a target.
         if Util::OptionValidator.comma_separated_list?(args[0])
           # This is a comma separated list. Treat each item as a validator.
-
           vals = Util::OptionNormalizer.comma_separated_list_to_array(args[0])
-          validators = PDK::Validate.validators.select { |v| vals.include?(v.name) }
+          validators_to_run = PDK::Validate.validator_names.select { |name| vals.include?(name) }
 
-          invalid = vals.reject { |v| validator_names.include?(v) }
-          invalid.each do |v|
-            PDK.logger.warn(_("Unknown validator '%{v}'. Available validators: %{validators}.") % { v: v, validators: validator_names.join(', ') })
+          vals.reject { |v| PDK::Validate.validator_names.include?(v) }
+              .each do |v|
+            PDK.logger.warn(_("Unknown validator '%{v}'. Available validators: %{validators}.") % { v: v, validators: PDK::Validate.validator_names.join(', ') })
           end
         else
           # This is a single item. Check if it's a known validator, or otherwise treat it as a target.
-          val = PDK::Validate.validators.find { |v| args[0] == v.name }
+          val = PDK::Validate.validator_names.find { |name| args[0] == name }
           if val
-            validators = [val]
+            validators_to_run = [val]
           else
             targets = [args[0]]
             # We now know that no validators were passed, so let the user know we're using all of them by default.
@@ -71,11 +74,12 @@ module PDK::CLI
       else
         PDK.logger.info(_('Running all available validators...'))
       end
+      validators_to_run = PDK::Validate.validator_names if validators_to_run.nil?
 
-      if validators == PDK::Validate.validators
+      if validators_to_run.sort == PDK::Validate.validator_names.sort
         PDK::CLI::Util.analytics_screen_view('validate', opts)
       else
-        PDK::CLI::Util.analytics_screen_view(['validate', validators.map(&:name).sort].flatten.join('_'), opts)
+        PDK::CLI::Util.analytics_screen_view(['validate', validators_to_run.sort].flatten.join('_'), opts)
       end
 
       # Subsequent arguments are targets.
@@ -93,36 +97,14 @@ module PDK::CLI
 
       options = targets.empty? ? {} : { targets: targets }
       options[:auto_correct] = true if opts[:'auto-correct']
-
-      # Ensure that the bundled gems are up to date and correct Ruby is activated before running any validations.
-      puppet_env = PDK::CLI::Util.puppet_from_opts_or_env(opts)
-      PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
-
       options.merge!(puppet_env[:gemset])
 
+      # Ensure that the bundled gems are up to date and correct Ruby is activated before running any validations.
+      # Note that if no Gemfile exists, then ensure_bundle! will log a debug message and exit gracefully
       require 'pdk/util/bundler'
-
       PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
 
-      exit_code = 0
-      if opts[:parallel]
-        require 'pdk/cli/exec_group'
-
-        exec_group = PDK::CLI::ExecGroup.new(_('Validating module using %{num_of_threads} threads' % { num_of_threads: validators.count }), opts)
-
-        validators.each do |validator|
-          exec_group.register do
-            validator.invoke(report, options.merge(exec_group: exec_group))
-          end
-        end
-
-        exit_code = exec_group.exit_code
-      else
-        validators.each do |validator|
-          validator_exit_code = validator.invoke(report, options.dup)
-          exit_code = validator_exit_code if validator_exit_code != 0
-        end
-      end
+      exit_code, report = PDK::Validate.invoke_validators_by_name(PDK.context, validators_to_run, opts.fetch(:parallel, false), options)
 
       report_formats.each do |format|
         report.send(format[:method], format[:target])