pdk 1.9.0 → 3.2.0

data/lib/pdk/cli/new/module.rb

@@ -1,41 +1,52 @@
-module PDK::CLI
-  @new_module_cmd = @new_cmd.define_command do
-    name 'module'
-    usage _('module [options] [module_name] [target_dir]')
-    summary _('Create a new module named [module_name] using given options')
+module PDK
+  module CLI
+    @new_module_cmd = @new_cmd.define_command do
+      name 'module'
+      usage 'module [options] [module_name] [target_dir]'
+      summary 'Create a new module named [module_name] using given options'
 
-    PDK::CLI.template_url_option(self)
-    PDK::CLI.skip_interview_option(self)
-    PDK::CLI.full_interview_option(self)
+      PDK::CLI.template_url_option(self)
+      PDK::CLI.template_ref_option(self)
+      PDK::CLI.skip_interview_option(self)
+      PDK::CLI.full_interview_option(self)
 
-    option nil, 'license', _('Specifies the license this module is written under. ' \
-      "This should be a identifier from https://spdx.org/licenses/. Common values are 'Apache-2.0', 'MIT', or 'proprietary'."), argument: :required
-    option nil, 'skip-bundle-install', _('Do not automatically run `bundle install` after creating the module.'), hidden: true
+      option nil, 'license', 'Specifies the license this module is written under. ' \
+                             "This should be a identifier from https://spdx.org/licenses/. Common values are 'Apache-2.0', 'MIT', or 'proprietary'.", argument: :required
+      option nil, 'skip-bundle-install', 'Do not automatically run `bundle install` after creating the module.', hidden: true
 
-    run do |opts, args, _cmd|
-      require 'pdk/generate/module'
+      run do |opts, args, _cmd|
+        require 'pdk/generate/module'
 
-      module_name = args[0]
-      target_dir = args[1]
+        module_name = args[0]
+        target_dir = args[1]
 
-      if opts[:'skip-interview'] && opts[:'full-interview']
-        PDK.logger.info _('Ignoring --full-interview and continuing with --skip-interview.')
-        opts[:'full-interview'] = false
-      end
+        PDK::CLI::Util.validate_template_opts(opts)
+
+        if opts[:'skip-interview'] && opts[:'full-interview']
+          PDK.logger.info 'Ignoring --full-interview and continuing with --skip-interview.'
+          opts[:'full-interview'] = false
+        end
 
-      unless module_name.nil? || module_name.empty?
-        module_name_parts = module_name.split('-', 2)
-        if module_name_parts.size > 1
-          opts[:username] = module_name_parts[0]
-          opts[:module_name] = module_name_parts[1]
+        if module_name.nil? || module_name.empty?
+          if opts[:'skip-interview']
+            raise PDK::CLI::ExitWithError,
+                  'You must specify a module name on the command line when running ' \
+                  'with --skip-interview.'
+          end
         else
-          opts[:module_name] = module_name
+          module_name_parts = module_name.split('-', 2)
+          if module_name_parts.size > 1
+            opts[:username] = module_name_parts[0]
+            opts[:module_name] = module_name_parts[1]
+          else
+            opts[:module_name] = module_name
+          end
+          opts[:target_dir] = target_dir.nil? ? opts[:module_name] : target_dir
         end
-        opts[:target_dir] = target_dir.nil? ? opts[:module_name] : target_dir
-      end
 
-      PDK.logger.info(_('Creating new module: %{modname}') % { modname: module_name })
-      PDK::Generate::Module.invoke(opts)
+        PDK.logger.info(format('Creating new module: %{modname}', modname: module_name))
+        PDK::Generate::Module.invoke(opts)
+      end
     end
   end
 end

data/lib/pdk/cli/new/provider.rb

@@ -1,27 +1,27 @@
-module PDK::CLI
-  @new_provider_cmd = @new_cmd.define_command do
-    name 'provider'
-    usage _('provider [options] <name>')
-    summary _('[experimental] Create a new ruby provider named <name> using given options')
+module PDK
+  module CLI
+    @new_provider_cmd = @new_cmd.define_command do
+      name 'provider'
+      usage 'provider [options] <name>'
+      summary '[experimental] Create a new ruby provider named <name> using given options'
 
-    PDK::CLI.template_url_option(self)
+      run do |opts, args, _cmd|
+        PDK::CLI::Util.ensure_in_module!
 
-    run do |opts, args, _cmd|
-      PDK::CLI::Util.ensure_in_module!
+        provider_name = args[0]
 
-      provider_name = args[0]
-      module_dir = Dir.pwd
+        if provider_name.nil? || provider_name.empty?
+          puts command.help
+          exit 1
+        end
 
-      if provider_name.nil? || provider_name.empty?
-        puts command.help
-        exit 1
-      end
+        raise PDK::CLI::ExitWithError, format("'%{name}' is not a valid provider name", name: provider_name) unless Util::OptionValidator.valid_provider_name?(provider_name)
 
-      unless Util::OptionValidator.valid_provider_name?(provider_name)
-        raise PDK::CLI::ExitWithError, _("'%{name}' is not a valid provider name") % { name: provider_name }
-      end
+        require 'pdk/generate/provider'
 
-      PDK::Generate::Provider.new(module_dir, provider_name, opts).run
+        updates = PDK::Generate::Provider.new(PDK.context, provider_name, opts).run
+        PDK::CLI::Util::UpdateManagerPrinter.print_summary(updates, tense: :past)
+      end
     end
   end
 end

data/lib/pdk/cli/new/task.rb

@@ -1,31 +1,32 @@
-module PDK::CLI
-  @new_task_cmd = @new_cmd.define_command do
-    name 'task'
-    usage _('task [options] <name>')
-    summary _('Create a new task named <name> using given options')
+module PDK
+  module CLI
+    @new_task_cmd = @new_cmd.define_command do
+      name 'task'
+      usage 'task [options] <name>'
+      summary 'Create a new task named <name> using given options'
 
-    PDK::CLI.template_url_option(self)
-    option nil, :description, _('A short description of the purpose of the task'), argument: :required
+      option nil, :description, 'A short description of the purpose of the task', argument: :required
 
-    run do |opts, args, _cmd|
-      PDK::CLI::Util.ensure_in_module!(
-        message:   _('Tasks can only be created from inside a valid module directory.'),
-        log_level: :info,
-      )
+      run do |opts, args, _cmd|
+        require 'pdk/generate/task'
 
-      task_name = args[0]
-      module_dir = Dir.pwd
+        PDK::CLI::Util.ensure_in_module!(
+          message: 'Tasks can only be created from inside a valid module directory.',
+          log_level: :info
+        )
 
-      if task_name.nil? || task_name.empty?
-        puts command.help
-        exit 1
-      end
+        task_name = args[0]
 
-      unless Util::OptionValidator.valid_task_name?(task_name)
-        raise PDK::CLI::ExitWithError, _("'%{name}' is not a valid task name") % { name: task_name }
-      end
+        if task_name.nil? || task_name.empty?
+          puts command.help
+          exit 1
+        end
 
-      PDK::Generate::Task.new(module_dir, task_name, opts).run
+        raise PDK::CLI::ExitWithError, format("'%{name}' is not a valid task name", name: task_name) unless Util::OptionValidator.valid_task_name?(task_name)
+
+        updates = PDK::Generate::Task.new(PDK.context, task_name, opts).run
+        PDK::CLI::Util::UpdateManagerPrinter.print_summary(updates, tense: :past)
+      end
     end
   end
 end

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

@@ -0,0 +1,52 @@
+module PDK
+  module CLI
+    @new_define_cmd = @new_cmd.define_command do
+      name 'test'
+      usage 'test [options] <name>'
+      summary 'Create a new test for the object named <name>'
+      flag :u, :unit, 'Create a new unit test.'
+      PDK::CLI.puppet_version_options(self)
+      PDK::CLI.puppet_dev_option(self)
+
+      run do |opts, args, _cmd|
+        require 'pdk/util/puppet_strings'
+        require 'pdk/util/bundler'
+
+        PDK::CLI::Util.validate_puppet_version_opts(opts)
+        PDK::CLI::Util.ensure_in_module!(
+          message: 'Tests can only be created from inside a valid module directory.',
+          log_level: :info
+        )
+
+        object_name = args[0]
+
+        if object_name.nil? || object_name.empty?
+          puts command.help
+          exit 1
+        end
+
+        unless opts[:unit]
+          # At a future time, we'll replace this conditional with an interactive
+          # question to choose the test type.
+          PDK.logger.info 'Test type not specified, assuming unit.'
+          opts[:unit] = true
+        end
+
+        puppet_env = PDK::CLI::Util.puppet_from_opts_or_env(opts)
+        PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
+        PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
+
+        begin
+          generator, obj = PDK::Util::PuppetStrings.find_object(object_name)
+
+          updates = generator.new(PDK.context, obj['name'], opts.merge(spec_only: true)).run
+          PDK::CLI::Util::UpdateManagerPrinter.print_summary(updates, tense: :past)
+        rescue PDK::Util::PuppetStrings::NoObjectError
+          raise PDK::CLI::ExitWithError, format('Unable to find anything called "%{object}" to generate unit tests for.', object: object_name)
+        rescue PDK::Util::PuppetStrings::NoGeneratorError => e
+          raise PDK::CLI::ExitWithError, format('PDK does not support generating unit tests for "%{object_type}" objects.', object_type: e.message)
+        end
+      end
+    end
+  end
+end

data/lib/pdk/cli/new/transport.rb

@@ -0,0 +1,27 @@
+module PDK
+  module CLI
+    @new_transport_cmd = @new_cmd.define_command do
+      name 'transport'
+      usage 'transport [options] <name>'
+      summary '[experimental] Create a new ruby transport named <name> using given options'
+
+      run do |opts, args, _cmd|
+        PDK::CLI::Util.ensure_in_module!
+
+        transport_name = args[0]
+
+        if transport_name.nil? || transport_name.empty?
+          puts command.help
+          exit 1
+        end
+
+        raise PDK::CLI::ExitWithError, format("'%{name}' is not a valid transport name", name: transport_name) unless Util::OptionValidator.valid_transport_name?(transport_name)
+
+        require 'pdk/generate/transport'
+
+        updates = PDK::Generate::Transport.new(PDK.context, transport_name, opts).run
+        PDK::CLI::Util::UpdateManagerPrinter.print_summary(updates, tense: :past)
+      end
+    end
+  end
+end

data/lib/pdk/cli/new.rb

@@ -1,13 +1,15 @@
-module PDK::CLI
-  @new_cmd = @base_cmd.define_command do
-    name 'new'
-    usage _('new <thing> [options]')
-    summary _('create a new module, etc.')
-    description _('Creates a new <thing> using relevant options.')
-    default_subcommand 'help'
-  end
+module PDK
+  module CLI
+    @new_cmd = @base_cmd.define_command do
+      name 'new'
+      usage 'new <thing> [options]'
+      summary 'create a new module, etc.'
+      description 'Creates a new <thing> using relevant options.'
+      default_subcommand 'help'
+    end
 
-  @new_cmd.add_command Cri::Command.new_basic_help
+    @new_cmd.add_command Cri::Command.new_basic_help
+  end
 end
 
 require 'pdk/cli/new/class'
@@ -15,3 +17,7 @@ require 'pdk/cli/new/defined_type'
 require 'pdk/cli/new/module'
 require 'pdk/cli/new/provider'
 require 'pdk/cli/new/task'
+require 'pdk/cli/new/test'
+require 'pdk/cli/new/transport'
+require 'pdk/cli/new/fact'
+require 'pdk/cli/new/function'

data/lib/pdk/cli/release/prep.rb

@@ -0,0 +1,39 @@
+require 'pdk/cli/release'
+
+module PDK
+  module CLI
+    @release_prep_cmd = @release_cmd.define_command do
+      name 'prep'
+      usage 'prep [options]'
+      summary '(Experimental) Performs all the pre-release checks to ensure module is ready to be released'
+
+      flag nil, :force,                'Prepare the module automatically, with no prompts.'
+      flag nil, :'skip-validation',    'Skips the module validation check.'
+      flag nil, :'skip-changelog',     'Skips the automatic changelog generation.'
+      flag nil, :'skip-dependency',    'Skips the module dependency check.'
+      flag nil, :'skip-documentation', 'Skips the documentation update.'
+
+      option nil, :version, 'Update the module to the specified version prior to release. When not specified, the new version will be computed from the Changelog where possible.',
+             argument: :required
+
+      run do |opts, _args, cmd|
+        # Make sure build is being run in a valid module directory with a metadata.json
+        PDK::CLI::Util.ensure_in_module!(
+          message: "`pdk release #{cmd.name}` can only be run from inside a valid module with a metadata.json.",
+          log_level: :info
+        )
+
+        opts[:'skip-build'] = true
+        opts[:'skip-publish'] = true
+
+        Release.prepare_interview(opts) unless opts[:force]
+
+        release = PDK::Module::Release.new(nil, opts)
+
+        Release.module_compatibility_checks!(release, opts)
+
+        release.run
+      end
+    end
+  end
+end

data/lib/pdk/cli/release/publish.rb

@@ -0,0 +1,46 @@
+require 'pdk/cli/release'
+
+module PDK
+  module CLI
+    @release_publish_cmd = @release_cmd.define_command do
+      name 'publish'
+      usage 'publish [options] <tarball>'
+      summary '(Experimental) Publishes the module <tarball> to the Forge.'
+
+      flag nil, :force,                'Publish the module automatically, with no prompts.'
+
+      option nil, :'forge-upload-url', 'Set forge upload url path.',
+             argument: :required, default: 'https://forgeapi.puppetlabs.com/v3/releases'
+
+      option nil, :'forge-token', 'Set Forge API token (you may also set via environment variable PDK_FORGE_TOKEN)', argument: :required
+
+      run do |opts, _args, cmd|
+        # Make sure build is being run in a valid module directory with a metadata.json
+        PDK::CLI::Util.ensure_in_module!(
+          message: "`pdk release #{cmd.name}` can only be run from inside a valid module with a metadata.json.",
+          log_level: :info
+        )
+
+        opts[:'skip-validation'] = true
+        opts[:'skip-changelog'] = true
+        opts[:'skip-dependency'] = true
+        opts[:'skip-documentation'] = true
+        opts[:'skip-build'] = true
+        opts[:'skip-versionset'] = true
+        opts[:force] = true unless PDK::CLI::Util.interactive?
+        opts[:'forge-token'] ||= PDK::Util::Env['PDK_FORGE_TOKEN']
+
+        if opts[:'forge-token'].nil? || opts[:'forge-token'].empty?
+          PDK.logger.error 'You must supply a Forge API token either via `--forge-token` option or PDK_FORGE_TOKEN environment variable.'
+          exit 1
+        end
+
+        Release.prepare_publish_interview(TTY::Prompt.new(help_color: :cyan), opts) unless opts[:force]
+
+        release = PDK::Module::Release.new(nil, opts)
+
+        release.run
+      end
+    end
+  end
+end

data/lib/pdk/cli/release.rb

@@ -0,0 +1,185 @@
+require 'pdk/cli/util'
+require 'pdk/validate'
+require 'pdk/util/bundler'
+require 'pdk/cli/util/interview'
+require 'pdk/util/changelog_generator'
+require 'pdk/module/build'
+
+module PDK
+  module CLI
+    @release_cmd = @base_cmd.define_command do
+      name 'release'
+      usage 'release [options]'
+      summary '(Experimental) Release a module to the Puppet Forge.'
+
+      flag nil, :force,                'Release the module automatically, with no prompts.'
+      flag nil, :'skip-validation',    'Skips the module validation check.'
+      flag nil, :'skip-changelog',     'Skips the automatic changelog generation.'
+      flag nil, :'skip-dependency',    'Skips the module dependency check.'
+      flag nil, :'skip-documentation', 'Skips the documentation update.'
+      flag nil, :'skip-build',         'Skips module build.'
+      flag nil, :'skip-publish',       'Skips publishing the module to the forge.'
+
+      option nil, :'forge-upload-url', 'Set forge upload url path.',
+             argument: :required, default: 'https://forgeapi.puppetlabs.com/v3/releases'
+
+      option nil, :'forge-token', 'Set Forge API token.',
+             argument: :optional
+
+      option nil, :version, 'Update the module to the specified version prior to release. When not specified, the new version will be computed from the Changelog where possible.',
+             argument: :required
+
+      option nil, :file, 'Path to the built module to push to the Forge. This option can only be used when --skip-build is also used. Defaults to pkg/<module version>.tar.gz',
+             argument: :required
+
+      run do |opts, _args, _cmd|
+        # Make sure build is being run in a valid module directory with a metadata.json
+        PDK::CLI::Util.ensure_in_module!(
+          message: '`pdk release` can only be run from inside a valid module with a metadata.json.',
+          log_level: :info
+        )
+
+        Release.prepare_interview(opts) unless opts[:force]
+
+        release = PDK::Module::Release.new(nil, opts)
+
+        Release.module_compatibility_checks!(release, opts)
+
+        release.run
+      end
+    end
+
+    module Release
+      # Checks whether the module is compatible with PDK release process
+      # @param release PDK::Module::Release Object representing the release
+      # @param opts Options Hash from Cri
+      def self.module_compatibility_checks!(release, opts)
+        unless release.module_metadata.forge_ready?
+          if opts[:force]
+            PDK.logger.warn "This module is missing the following fields in the metadata.json: #{release.module_metadata.missing_fields.join(', ')}. " \
+                            'These missing fields may affect the visibility of the module on the Forge.'
+          else
+            release.module_metadata.interview_for_forge!
+            release.write_module_metadata!
+          end
+        end
+
+        unless release.pdk_compatible? # rubocop:disable Style/GuardClause Nope!
+          if opts[:force]
+            PDK.logger.warn 'This module is not compatible with PDK, so PDK can not validate or test this build.'
+          else
+            PDK.logger.info 'This module is not compatible with PDK, so PDK can not validate or test this build. ' \
+                            'Unvalidated modules may have errors when uploading to the Forge. ' \
+                            'To make this module PDK compatible and use validate features, cancel the build and run `pdk convert`.'
+            unless PDK::CLI::Util.prompt_for_yes('Continue build without converting?')
+              PDK.logger.info 'Build cancelled; exiting.'
+              PDK::Util.exit_process(1)
+            end
+          end
+        end
+      end
+
+      def self.prepare_interview(opts)
+        questions = []
+
+        unless opts[:'skip-validation']
+          questions << {
+            name: 'validation',
+            question: 'Do you want to run the module validation ?',
+            type: :yes
+          }
+        end
+        unless opts[:'skip-changelog']
+          questions << {
+            name: 'changelog',
+            question: 'Do you want to run the automatic changelog generation ?',
+            type: :yes
+          }
+        end
+        unless opts[:version]
+          questions << {
+            name: 'setversion',
+            question: 'Do you want to set the module version ?',
+            type: :yes
+          }
+        end
+        unless opts[:'skip-dependency']
+          questions << {
+            name: 'dependency',
+            question: 'Do you want to run the dependency-checker on this module?',
+            type: :yes
+          }
+        end
+        unless opts[:'skip-documentation']
+          questions << {
+            name: 'documentation',
+            question: 'Do you want to update the documentation for this module?',
+            type: :yes
+          }
+        end
+        unless opts[:'skip-publish']
+          questions << {
+            name: 'publish',
+            question: 'Do you want to publish the module on the Puppet Forge?',
+            type: :yes
+          }
+        end
+
+        prompt = TTY::Prompt.new(help_color: :cyan)
+        interview = PDK::CLI::Util::Interview.new(prompt)
+        interview.add_questions(questions)
+        answers = interview.run
+
+        unless answers.nil?
+          opts[:'skip-validation'] = !answers['validation']
+          opts[:'skip-changelog'] = !answers['changelog']
+          opts[:'skip-dependency'] = !answers['dependency']
+          opts[:'skip-documentation'] = !answers['documentation']
+          opts[:'skip-publish'] = !answers['publish']
+
+          prepare_version_interview(prompt, opts) if answers['setversion']
+
+          prepare_publish_interview(prompt, opts) if answers['publish']
+        end
+        answers
+      end
+
+      def self.prepare_version_interview(prompt, opts)
+        questions = [
+          {
+            name: 'version',
+            question: 'Please set the module version',
+            help: 'This value is the version that will be used in the changelog generator and building of the module.',
+            required: true,
+            validate_pattern: /(\*|\d+(\.\d+){0,2}(\.\*)?)$/i,
+            validate_message: 'The version format should be in the format x.y.z where x represents the major version, y the minor version and z the build number.'
+          }
+        ]
+        interview = PDK::CLI::Util::Interview.new(prompt)
+        interview.add_questions(questions)
+        ver_answer = interview.run
+        opts[:version] = ver_answer['version']
+      end
+
+      def self.prepare_publish_interview(prompt, opts)
+        return if opts[:'forge-token']
+
+        questions = [
+          {
+            name: 'apikey',
+            question: 'Please set the api key(authorization token) to upload on the Puppet Forge',
+            help: 'This value is used for authentication on the Puppet Forge to upload your module tarball.',
+            required: true
+          }
+        ]
+        interview = PDK::CLI::Util::Interview.new(prompt)
+        interview.add_questions(questions)
+        api_answer = interview.run
+        opts[:'forge-token'] = api_answer['apikey']
+      end
+    end
+  end
+end
+
+require 'pdk/cli/release/prep'
+require 'pdk/cli/release/publish'

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

@@ -0,0 +1,83 @@
+module PDK
+  module CLI
+    module Remove
+      module Config
+        def self.run(opts, args)
+          item_name = args.count.positive? ? 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, format("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(format("Could not remove '%{name}' as it has not been set", name: item_name))
+            return 0
+          end
+
+          PDK.logger.info(format("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(format("Could not remove '%{name}' as it is already empty", name: item_name))
+              else
+                PDK.logger.info(format("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(format("Cleared '%{name}' which had a value of '%{from}'", name: item_name, from: current_value))
+            else
+              PDK.logger.info(format("Removed '%{value}' from '%{name}'", value: item_value, name: item_name))
+            end
+          elsif !new_value.nil?
+            PDK.logger.info(format("Could not remove '%{name}' as it using a default value of '%{to}'", name: item_name, to: new_value))
+          else
+            PDK.logger.info(format("Removed '%{name}' which had a value of '%{from}'", name: item_name, from: current_value))
+          end
+
+          # Same output as `get config`
+          $stdout.puts format('%{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
+end