pdk 1.9.0 → 3.2.0

data/lib/pdk/cli/remove.rb

@@ -0,0 +1,22 @@
+module PDK
+  module 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(['remove', '--help'])
+          exit 0
+        end
+
+        PDK::CLI.run(['remove', 'help']) if args.empty?
+      end
+    end
+    @remove_cmd.add_command Cri::Command.new_basic_help
+  end
+end
+
+require 'pdk/cli/remove/config'

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

@@ -0,0 +1,121 @@
+module PDK
+  module CLI
+    module Set
+      module Config
+        ALLOWED_TYPE_NAMES = ['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, format('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, format('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, format('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 ['yes', 'true', '-1', '1'].include?(string_val)
+          return false if ['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.positive? ? 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, format("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
+          # Check if the setting already exists
+          if !force && (current_value.is_a?(Array) && current_value.include?(item_value))
+            PDK.logger.info(format("No changes made to '%{name}' as it already contains value '%{to}'", name: item_name, to: item_value))
+            return 0
+          end
+
+          new_value = PDK.config.set(item_name, item_value, force: opts[:force])
+          if current_value.nil? || force
+            PDK.logger.info(format("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(format("Added new value '%{to}' to '%{name}'", name: item_name, to: item_value))
+          else
+            PDK.logger.info(format("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 format('%{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, format('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
+end

data/lib/pdk/cli/set.rb

@@ -0,0 +1,22 @@
+module PDK
+  module 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(['set', '--help'])
+          exit 0
+        end
+
+        PDK::CLI.run(['set', 'help']) if args.empty?
+      end
+    end
+    @set_cmd.add_command Cri::Command.new_basic_help
+  end
+end
+
+require 'pdk/cli/set/config'

data/lib/pdk/cli/test/unit.rb

@@ -1,87 +1,89 @@
-require 'pdk/cli/util/option_validator'
-require 'pdk/report'
-
-module PDK::CLI
-  @test_unit_cmd = @test_cmd.define_command do
-    name 'unit'
-    usage _('unit [options]')
-    summary _('Run unit tests.')
-
-    PDK::CLI.puppet_version_options(self)
-    PDK::CLI.puppet_dev_option(self)
-    flag nil, :list, _('List all available unit test files.')
-    flag nil, :parallel, _('Run unit tests in parallel.')
-    flag :v, :verbose, _('More verbose --list output. Displays a list of examples in each unit test file.')
-    flag :c, 'clean-fixtures', _('Clean up downloaded fixtures after the test run.')
-
-    option nil, :tests, _('Specify a comma-separated list of unit test files to run.'), argument: :required, default: '' do |values|
-      PDK::CLI::Util::OptionValidator.comma_separated_list?(values)
-    end
-
-    # TODO
-    # option nil, :runner_options, _("options to pass through to the actual test-runner"), argument: :required
-
-    run do |opts, _args, _cmd|
-      require 'pdk/tests/unit'
+module PDK
+  module CLI
+    @test_unit_cmd = @test_cmd.define_command do
+      name 'unit'
+      usage 'unit [options]'
+      summary 'Run unit tests.'
+
+      PDK::CLI.puppet_version_options(self)
+      PDK::CLI.puppet_dev_option(self)
+      flag nil, :list, 'List all available unit test files.'
+      flag nil, :parallel, 'Run unit tests in parallel.'
+      flag :v, :verbose, 'More verbose --list output. Displays a list of examples in each unit test file.'
+      flag :c, 'clean-fixtures', 'Clean up downloaded fixtures after the test run.'
+
+      option nil, :tests, 'Specify a comma-separated list of unit test files to run.', argument: :required, default: '' do |values|
+        require 'pdk/cli/util/option_validator'
+        PDK::CLI::Util::OptionValidator.comma_separated_list?(values)
+      end
 
-      PDK::CLI::Util.validate_puppet_version_opts(opts)
+      # TODO
+      # option nil, :runner_options, "options to pass through to the actual test-runner", argument: :required
 
-      PDK::CLI::Util.ensure_in_module!(
-        message:   _('Unit tests can only be run from inside a valid module directory.'),
-        log_level: :info,
-      )
+      run do |opts, _args, _cmd|
+        require 'pdk/tests/unit'
+        require 'pdk/report'
+        require 'pdk/util/bundler'
 
-      PDK::CLI::Util.module_version_check
+        PDK::CLI::Util.validate_puppet_version_opts(opts)
 
-      report = nil
+        PDK::CLI::Util.ensure_in_module!(
+          message: 'Unit tests can only be run from inside a valid module directory.',
+          log_level: :info
+        )
 
-      if opts[:list]
-        examples = PDK::Test::Unit.list
-        if examples.empty?
-          puts _('No unit test files with examples were found.')
-        else
-          puts _('Unit Test Files:')
-          files = examples.map { |example| example[:file_path] }
-          files.uniq.each do |file|
-            puts _(file)
+        PDK::CLI::Util.module_version_check
 
-            next unless opts[:verbose]
-
-            file_examples = examples.select { |example| example[:file_path] == file }
-            file_examples.each do |file_example|
-              puts _("\t%{id}\t%{description}" % { id: file_example[:id], description: file_example[:full_description] })
-            end
-          end
-        end
-      else
-        PDK.logger.info _('--verbose has no effect when not used with --list') if opts[:verbose]
-
-        report = PDK::Report.new
-        report_formats = if opts[:format]
-                           PDK::CLI::Util::OptionNormalizer.report_formats(opts[:format])
-                         else
-                           [{
-                             method: PDK::Report.default_format,
-                             target: PDK::Report.default_target,
-                           }]
-                         end
-
-        # Ensure that the bundled gems are up to date and correct Ruby is activated before running tests.
+        # Ensure that the bundled gems are up to date and correct Ruby is activated before running or listing tests.
         puppet_env = PDK::CLI::Util.puppet_from_opts_or_env(opts)
-        PDK::Util::PuppetVersion.fetch_puppet_dev if opts.key?(:'puppet-dev')
         PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
 
         opts.merge!(puppet_env[:gemset])
 
         PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
 
-        exit_code = PDK::Test::Unit.invoke(report, opts)
+        report = nil
 
-        report_formats.each do |format|
-          report.send(format[:method], format[:target])
-        end
+        if opts[:list]
+          examples = PDK::Test::Unit.list(opts)
+
+          if examples.empty?
+            puts 'No unit test files with examples were found.'
+          else
+            puts 'Unit Test Files:'
+            files = examples.map { |example| example[:file_path] }
+            files.uniq.each do |file|
+              puts file
+
+              next unless opts[:verbose]
 
-        exit exit_code
+              file_examples = examples.select { |example| example[:file_path] == file }
+              file_examples.each do |file_example|
+                puts format("\t%{id}\t%{description}", id: file_example[:id], description: file_example[:full_description])
+              end
+            end
+          end
+        else
+          report = PDK::Report.new
+          report_formats = if opts[:format]
+                             opts[:interactive] = false
+                             PDK::CLI::Util::OptionNormalizer.report_formats(opts[:format])
+                           else
+                             opts[:interactive] = true
+                             [{
+                               method: PDK::Report.default_format,
+                               target: PDK::Report.default_target
+                             }]
+                           end
+
+          exit_code = PDK::Test::Unit.invoke(report, opts)
+
+          report_formats.each do |format|
+            report.send(format[:method], format[:target])
+          end
+
+          exit exit_code
+        end
       end
     end
   end

data/lib/pdk/cli/test.rb

@@ -1,12 +1,13 @@
-
-module PDK::CLI
-  @test_cmd = @base_cmd.define_command do
-    name 'test'
-    usage _('test [subcommand] [options]')
-    summary _('Run tests.')
-    default_subcommand 'help'
+module PDK
+  module CLI
+    @test_cmd = @base_cmd.define_command do
+      name 'test'
+      usage 'test [subcommand] [options]'
+      summary 'Run tests.'
+      default_subcommand 'help'
+    end
+    @test_cmd.add_command Cri::Command.new_basic_help
   end
-  @test_cmd.add_command Cri::Command.new_basic_help
 end
 
 require 'pdk/cli/test/unit'

data/lib/pdk/cli/update.rb

@@ -1,32 +1,49 @@
-require 'pdk/cli/util'
-require 'pdk/util'
+module PDK
+  module CLI
+    @update_cmd = @base_cmd.define_command do
+      name 'update'
+      usage 'update [options]'
+      summary 'Update a module that has been created by or converted for use by PDK.'
 
-module PDK::CLI
-  @update_cmd = @base_cmd.define_command do
-    name 'update'
-    usage _('update [options]')
-    summary _('Update a module that has been created by or converted for use by PDK.')
+      flag nil, :noop, 'Do not update the module, just output what would be done.'
+      flag nil, :force, 'Update the module automatically, with no prompts.'
 
-    flag nil, :noop, _('Do not update the module, just output what would be done.')
-    flag nil, :force, _('Update the module automatically, with no prompts.')
+      PDK::CLI.template_ref_option(self)
 
-    run do |opts, _args, _cmd|
-      require 'pdk/module/update'
+      run do |opts, _args, _cmd|
+        # 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) || PDK.context.is_a?(PDK::Context::ControlRepo)
+          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?
+        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?
 
-      if opts[:noop] && opts[:force]
-        raise PDK::CLI::ExitWithError, _('You can not specify --noop and --force when updating a module')
-      end
+        raise PDK::CLI::ExitWithError, 'You can not specify --noop and --force when updating a module' if opts[:noop] && opts[:force]
+
+        if Gem::Version.new(PDK::VERSION) < Gem::Version.new(PDK::Util.module_pdk_version)
+          PDK.logger.warn "This module has been updated to PDK #{PDK::Util.module_pdk_version} which is newer than your PDK version (#{PDK::VERSION}), proceed with caution!"
+
+          unless opts[:force]
+            raise PDK::CLI::ExitWithError,
+                  'Please update your PDK installation and try again. ' \
+                  'You may also use the --force flag to override this and ' \
+                  'continue at your own risk.'
+          end
+        end
 
-      updater = PDK::Module::Update.new(opts)
+        updater = PDK::Module::Update.new(PDK.context.root_path, opts)
 
-      updater.run
+        if updater.pinned_to_puppetlabs_template_tag?
+          PDK.logger.info format('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
     end
   end
 end

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

@@ -1,4 +1,5 @@
-require 'tty-prompt'
+require 'pdk'
+require 'tty/prompt'
 
 module PDK
   module CLI
@@ -6,6 +7,15 @@ module PDK
       class CommandRedirector < TTY::Prompt::AnswersCollector
         attr_accessor :command
 
+        # Override the initialize method because the original one
+        # doesn't work with Ruby 3.
+        # rubocop:disable Lint/MissingSuper
+        def initialize(prompt, options = {})
+          @prompt  = prompt
+          @answers = options.fetch(:answers) { {} }
+        end
+        # rubocop:enable Lint/MissingSuper
+
         def pastel
           @pastel ||= Pastel.new
         end
@@ -15,9 +25,9 @@ module PDK
         end
 
         def run
-          @prompt.puts _('Did you mean \'%{command}\'?') % { command: pastel.bold(@command) }
+          @prompt.puts "Did you mean '#{pastel.bold(@command)}'?"
           @prompt.yes?('-->')
-        rescue TTY::Prompt::Reader::InputInterrupt
+        rescue PDK::CLI::Util::Interview::READER::InputInterrupt
           nil
         end
       end

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

@@ -1,9 +1,21 @@
-require 'tty-prompt'
+require 'tty/prompt'
+require 'pdk'
 
 module PDK
   module CLI
     module Util
       class Interview < TTY::Prompt::AnswersCollector
+        READER = defined?(TTY::Reader) ? TTY::Reader : TTY::Prompt::Reader
+
+        # Override the initialize method because the original one
+        # doesn't work with Ruby 3.
+        # rubocop:disable Lint/MissingSuper
+        def initialize(prompt, options = {})
+          @prompt  = prompt
+          @answers = options.fetch(:answers) { {} }
+        end
+        # rubocop:enable Lint/MissingSuper
+
         def pastel
           @pastel ||= Pastel.new
         end
@@ -27,11 +39,17 @@ module PDK
           num_questions = @questions.count
           @questions.each do |question_name, question|
             @name = question_name
-            @prompt.print pastel.bold(_('[Q %{current_number}/%{questions_total}]') % { current_number: i, questions_total: num_questions }) + ' '
+            @prompt.print "#{pastel.bold(format('[Q %{current_number}/%{questions_total}]', current_number: i, questions_total: num_questions))} "
             @prompt.puts pastel.bold(question[:question])
             @prompt.puts question[:help] if question.key?(:help)
-            if question.key?(:choices)
-              multi_select(_('-->'), per_page: question[:choices].count) do |q|
+
+            case question[:type]
+            when :yes
+              yes?('-->') do |q|
+                q.default(question[:default]) if question.key?(:default)
+              end
+            when :multi_select
+              multi_select('-->', per_page: question[:choices].count) do |q|
                 q.enum ')'
                 q.default(*question[:default]) if question.key?(:default)
 
@@ -40,12 +58,10 @@ module PDK
                 end
               end
             else
-              ask(_('-->')) do |q|
+              ask('-->') do |q|
                 q.required(question.fetch(:required, false))
 
-                if question.key?(:validate_pattern)
-                  q.validate(question[:validate_pattern], question[:validate_message])
-                end
+                q.validate(question[:validate_pattern], question[:validate_message]) if question.key?(:validate_pattern)
 
                 q.default(question[:default]) if question.key?(:default)
               end
@@ -54,7 +70,7 @@ module PDK
             @prompt.puts ''
           end
           @answers
-        rescue TTY::Prompt::Reader::InputInterrupt
+        rescue READER::InputInterrupt
           nil
         end
       end

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

@@ -1,9 +1,12 @@
+require 'pdk'
+
 module PDK
   module CLI
     module Util
       class OptionNormalizer
         def self.comma_separated_list_to_array(list, _options = {})
-          raise _('Error: expected comma separated list') unless OptionValidator.comma_separated_list?(list)
+          raise 'Error: expected comma separated list' unless OptionValidator.comma_separated_list?(list)
+
           list.split(',').compact
         end
 
@@ -29,10 +32,7 @@ module PDK
             begin
               OptionValidator.enum(format, PDK::Report.formats)
             rescue ArgumentError
-              raise PDK::CLI::ExitWithError, _("'%{name}' is not a valid report format (%{valid})") % {
-                name:  format,
-                valid: PDK::Report.formats.join(', '),
-              }
+              raise PDK::CLI::ExitWithError, format("'%{name}' is not a valid report format (%{valid})", name: format, valid: PDK::Report.formats.join(', '))
             end
 
             case target
@@ -44,7 +44,7 @@ module PDK
               target = PDK::Report.default_target
             end
 
-            { method: "write_#{format}".to_sym, target: target }
+            { method: :"write_#{format}", target: target }
           end
         end
       end

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

@@ -1,18 +1,23 @@
+require 'pdk'
+
 module PDK
   module CLI
     module Util
       class OptionValidator
         def self.comma_separated_list?(list, _options = {})
-          (list =~ %r{^[\w\-]+(?:,[\w\-]+)+$}) ? true : false
+          /^[\w-]+(?:,[\w-]+)+$/.match?(list)
+        end
+
+        # @return [Boolean] true if the fact name is valid
+        def self.valid_fact_name?(name)
+          name.length > 1
         end
 
         def self.enum(val, valid_entries, _options = {})
           vals = val.is_a?(Array) ? val : [val]
           invalid_entries = vals.reject { |e| valid_entries.include?(e) }
 
-          unless invalid_entries.empty?
-            raise ArgumentError, _('Error: the following values are invalid: %{invalid_entries}') % { invalid_entries: invalid_entries }
-          end
+          raise ArgumentError, format('Error: the following values are invalid: %{invalid_entries}', invalid_entries: invalid_entries) unless invalid_entries.empty?
 
           val
         end
@@ -20,7 +25,7 @@ module PDK
         # Validate the module name against the regular expression in the
         # documentation: https://docs.puppet.com/puppet/4.10/modules_fundamentals.html#allowed-module-names
         def self.valid_module_name?(string)
-          !(string =~ %r{\A[a-z][a-z0-9_]*\Z}).nil?
+          !(string =~ /\A[a-z][a-z0-9_]*\Z/).nil?
         end
         singleton_class.send(:alias_method, :valid_task_name?, :valid_module_name?)
 
@@ -28,13 +33,18 @@ module PDK
         # Let's assume that only strings similar to module names can actually be resolved by the puppet language.
         singleton_class.send(:alias_method, :valid_provider_name?, :valid_module_name?)
 
+        # The name has to be a ruby symbol.
+        # While overly strict, let's apply the provider and module name rules for consistency.
+        singleton_class.send(:alias_method, :valid_transport_name?, :valid_provider_name?)
+
         # Validate a Puppet namespace against the regular expression in the
         # documentation: https://docs.puppet.com/puppet/4.10/lang_reserved.html#classes-and-defined-resource-types
         def self.valid_namespace?(string)
           return false if (string || '').split('::').last == 'init'
 
-          !(string =~ %r{\A([a-z][a-z0-9_]*)(::[a-z][a-z0-9_]*)*\Z}).nil?
+          !(string =~ /\A([a-z][a-z0-9_]*)(::[a-z][a-z0-9_]*)*\Z/).nil?
         end
+        singleton_class.send(:alias_method, :valid_function_name?, :valid_namespace?)
 
         singleton_class.send(:alias_method, :valid_class_name?, :valid_namespace?)
         singleton_class.send(:alias_method, :valid_defined_type_name?, :valid_namespace?)
@@ -44,11 +54,11 @@ module PDK
         # The parameter should also not be a reserved word or overload
         # a metaparameter.
         def self.valid_param_name?(string)
-          reserved_words = %w[trusted facts server_facts title name].freeze
-          metaparams = %w[alias audit before loglevel noop notify require schedule stage subscribe tag].freeze
+          reserved_words = ['trusted', 'facts', 'server_facts', 'title', 'name'].freeze
+          metaparams = ['alias', 'audit', 'before', 'loglevel', 'noop', 'notify', 'require', 'schedule', 'stage', 'subscribe', 'tag'].freeze
           return false if reserved_words.include?(string) || metaparams.include?(string)
 
-          !(string =~ %r{\A[a-z][a-zA-Z0-9_]*\Z}).nil?
+          !(string =~ /\A[a-z][a-zA-Z0-9_]*\Z/).nil?
         end
       end
     end

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

@@ -0,0 +1,13 @@
+require 'tty-spinner'
+
+# Replace the built-in tty check in tty-spinner with our own implementation
+# that allows us to mock the behaviour during acceptance tests.
+module TTY
+  class Spinner
+    def tty?
+      require 'pdk/cli/util'
+
+      PDK::CLI::Util.interactive?
+    end
+  end
+end