pdk 1.9.0 → 3.2.0

data/README.md

@@ -1,4 +1,8 @@
-# pdk [![Build Status](https://travis-ci.org/puppetlabs/pdk.svg?branch=master)](https://travis-ci.org/puppetlabs/pdk) [![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/x70e2fqllbaootpd?svg=true)](https://ci.appveyor.com/project/puppetlabs/pdk) [![Coverage Status](https://coveralls.io/repos/github/puppetlabs/pdk/badge.svg?branch=master)](https://coveralls.io/github/puppetlabs/pdk?branch=master)
+# pdk
+
+[![Code Owners](https://img.shields.io/badge/owners-DevX--team-blue)](https://github.com/puppetlabs/pdk/blob/main/CODEOWNERS)
+[![ci](https://github.com/puppetlabs/pdk/actions/workflows/ci.yml/badge.svg)](https://github.com/puppetlabs/pdk/actions/workflows/ci.yml) 
+[![Gem Version](https://badge.fury.io/rb/pdk.svg)](https://badge.fury.io/rb/pdk)
 
 * [Installation](#installation)
 * [Basic usage](#basic-usage)
@@ -13,15 +17,16 @@ PDK includes testing tools, a complete module skeleton, and command line tools t
 
 PDK includes the following tools:
 
-Tool   | Description
-----------------|-------------------------
-metadata-json-lint | Validates and lints `metadata.json` files in modules against  Puppet's module metadatastyle guidelines.
-pdk | Command line tool for generating and testing modules
-puppet-lint | Checks your Puppet code against the recommendations in the Puppet Language style guide.
-puppet-syntax | Checks for correct syntax in Puppet manifests, templates, and Hiera YAML.
-puppetlabs_spec_helper | Provides classes, methods, and Rake tasks to help with spec testing Puppet code.
-rspec-puppet | Tests the behavior of Puppet when it compiles your manifests into a catalog of Puppet resources.
-rspec-puppet-facts | Adds support for running rspec-puppet tests against the facts for your supported operating systems.
+|Tool|Description|Owned by Puppet|
+|----|-----------|---------------|
+|facterdb|A gem that contains facts for Operating Systems.| N |
+|metadata-json-lint|Validates and lints `metadata.json` files in modules against Puppet module metadata style guidelines.| N |
+|pdk|Tool to generate and test modules and module content, such as classes, from the command line.| Y |
+|puppet-lint|Checks your Puppet code against the recommendations in the Puppet language style guide.| Y |
+|puppet-syntax|Checks for correct syntax in Puppet manifests, templates, and Hiera YAML.| N |
+|puppetlabs_spec_helper|Provides classes, methods, and Rake tasks to help with spec testing Puppet code.| Y |
+|rspec-puppet|Tests the behavior of Puppet when it compiles your manifests into a catalog of Puppet resources.| Y |
+|rspec-puppet-facts|Adds support for running `rspec-puppet` tests against the facts for your supported operating systems.| N |
 
 
 ## Installation
@@ -93,7 +98,7 @@ This command validates the metadata, Puppet code syntax and style, and Ruby synt
 
 ### Run unit tests
 
-PDK's [default template](https://github.com/puppetlabs/pdk-templates) sets up [rspec](http://rspec.info/) for Ruby-level unit testing, and [rspec-puppet](https://github.com/rodjek/rspec-puppet/) for catalog-level unit testing.
+PDK's [default template](https://github.com/puppetlabs/pdk-templates) sets up [rspec](http://rspec.info/) for Ruby-level unit testing, and [rspec-puppet](https://github.com/puppetlabs/rspec-puppet/) for catalog-level unit testing.
 
 In the module's directory, run unit tests with:
 
@@ -103,22 +108,19 @@ pdk test unit
 
 This command runs all available unit tests.
 
-## Experimental features
-
-### `pdk bundle` command
-
-This command executes arbitrary commands in a bundler context within the module you're currently working on. Arguments to this command are passed straight through to bundler. This command is experimental  and can lead to errors that can't be resolved by the pdk itself.
-
-Note that for most uses, you must use the `--` to separate bundler options from pdk options. Compare the following two commands:
-
 ## Module Compatibility
 
-**PDK Version Compatibility:** Modules created with PDK version validate against and run on all Puppet and Ruby version combinations currently under maintenance (see https://docs.puppet.com/puppet/latest/about_agent.html and https://puppet.com/misc/puppet-enterprise-lifecycle)
+**PDK Version Compatibility:** Modules created with PDK validate against and run on all Puppet and Ruby version combinations currently under maintenance (see https://docs.puppet.com/puppet/latest/about_agent.html and https://puppet.com/misc/puppet-enterprise-lifecycle)
 
 ## Contributing
 
 PDK encourages community contributions. See the [CONTRIBUTING.md](CONTRIBUTING.md) file for development notes.
 
+## License
+
+This codebase is licensed under Apache 2.0. However, the open source dependencies included in this codebase might be subject to other software licenses such as AGPL, GPL2.0, and MIT.
+
 ## Contact Information
 
-To contact us with questions: [pdk-maintainers@puppet.com](mailto:pdk-maintainers@puppet.com)
+* [For reporting bugs](https://github.com/puppetlabs/pdk/blob/main/CONTRIBUTING.md#reporting-bugs)
+* To contact us with questions, [join the Puppet Community on Slack](https://slack.puppet.com/)

data/lib/pdk/answer_file.rb

@@ -1,121 +1,12 @@
-require 'json'
-require 'pdk/util/filesystem'
+require 'pdk'
 
 module PDK
-  # Singleton accessor to the current answer file being used by the PDK.
-  #
-  # @return [PDK::AnswerFile] The AnswerFile instance currently being used by
-  #   the PDK.
-  def self.answers
-    @answer_file ||= PDK::AnswerFile.new
-  end
-
-  # Specify the path to a custom answer file that the PDK should use.
-  #
-  # @param path [String] A path on disk to the file where the PDK should store
-  #   answers to interactive questions.
-  def self.answer_file=(path)
-    @answer_file = PDK::AnswerFile.new(path)
-  end
-
   class AnswerFile
-    attr_reader :answers
-    attr_reader :answer_file_path
-
-    include PDK::Util::Filesystem
-
-    # Initialises the AnswerFile object, which stores the responses to certain
-    # interactive questions.
-    #
-    # @param answer_file_path [String, nil] The path on disk to the file where
-    #   the answers will be stored and read from. If not specified (or `nil`),
-    #   the default path will be used (see #default_answer_file_path).
-    #
-    # @raise (see #read_from_disk)
-    def initialize(answer_file_path = nil)
-      @answer_file_path = answer_file_path || default_answer_file_path
-      @answers = read_from_disk
-    end
-
-    # Retrieve the stored answer to a question.
-    #
-    # @param question [String] The question name/identifying string.
-    #
-    # @return [Object] The answer to the question, or `nil` if no answer found.
-    def [](question)
-      answers[question]
-    end
-
-    # Update the stored answers in memory and then save them to disk.
-    #
-    # @param new_answers [Hash{String => Object}] The new questions and answers
-    #   to be merged into the existing answers.
-    #
-    # @raise [PDK::CLI::FatalError] if the new answers are not provided as
-    #   a Hash.
-    # @raise (see #save_to_disk)
-    def update!(new_answers = {})
-      unless new_answers.is_a?(Hash)
-        raise PDK::CLI::FatalError, _('Answer file can be updated only with a Hash')
-      end
-
-      answers.merge!(new_answers)
-
-      save_to_disk
-    end
-
-    private
-
     # Determine the default path to the answer file.
     #
     # @return [String] The path on disk to the default answer file.
-    def default_answer_file_path
-      File.join(PDK::Util.cachedir, 'answers.json')
-    end
-
-    # Read existing answers into memory from the answer file on disk.
-    #
-    # @raise [PDK::CLI::FatalError] If the answer file exists but can not be
-    #   read.
-    #
-    # @return [Hash{String => Object}] The existing questions and answers.
-    def read_from_disk
-      return {} if !File.file?(answer_file_path) || File.zero?(answer_file_path)
-
-      unless File.readable?(answer_file_path)
-        raise PDK::CLI::FatalError, _("Unable to open '%{file}' for reading") % {
-          file: answer_file_path,
-        }
-      end
-
-      answers = JSON.parse(File.read(answer_file_path))
-      if answers.is_a?(Hash)
-        answers
-      else
-        PDK.logger.warn _("Answer file '%{path}' did not contain a valid set of answers, recreating it") % {
-          path: answer_file_path,
-        }
-        {}
-      end
-    rescue JSON::JSONError
-      PDK.logger.warn _("Answer file '%{path}' did not contain valid JSON, recreating it") % {
-        path: answer_file_path,
-      }
-      {}
-    end
-
-    # Save the in memory answer set to the answer file on disk.
-    #
-    # @raise [PDK::CLI::FatalError] if the answer file can not be written to.
-    def save_to_disk
-      FileUtils.mkdir_p(File.dirname(answer_file_path))
-
-      write_file(answer_file_path, JSON.pretty_generate(answers))
-    rescue SystemCallError, IOError => e
-      raise PDK::CLI::FatalError, _("Unable to write '%{file}': %{msg}") % {
-        file: answer_file_path,
-        msg:  e.message,
-      }
+    def self.default_answer_file_path
+      PDK::Util::Filesystem.expand_path(File.join(PDK::Util.cachedir, 'answers.json'))
     end
   end
 end

data/lib/pdk/bolt.rb

@@ -0,0 +1,20 @@
+require 'pdk'
+
+module PDK
+  module Bolt
+    # Returns true or false depending on if any of the common files and directories in
+    # a Bolt Project are found in the specified directory. If a directory is not specified,
+    # the current working directory is used.
+    #
+    # @see https://puppet.com/docs/bolt/latest/bolt_project_directories.html
+    #
+    # @return [boolean] True if any bolt specific files or directories are present
+    #
+    def bolt_project_root?(path = Dir.pwd)
+      return true if File.basename(path) == 'Boltdir' && PDK::Util::Filesystem.directory?(path)
+
+      PDK::Util::Filesystem.file?(File.join(path, 'bolt.yaml'))
+    end
+    module_function :bolt_project_root?
+  end
+end

data/lib/pdk/cli/build.rb

@@ -1,76 +1,73 @@
-require 'pdk/cli/util'
+module PDK
+  module CLI
+    @build_cmd = @base_cmd.define_command do
+      name 'build'
+      usage 'build [options]'
+      summary 'Builds a package from the module that can be published to the Puppet Forge.'
 
-module PDK::CLI
-  @build_cmd = @base_cmd.define_command do
-    name 'build'
-    usage _('build [options]')
-    summary _('Builds a package from the module that can be published to the Puppet Forge.')
+      option nil, 'target-dir',
+             'The target directory where you want PDK to write the package.',
+             argument: :required, default: File.join(Dir.pwd, 'pkg')
 
-    option nil, 'target-dir',
-           _('The target directory where you want PDK to write the package.'),
-           argument: :required, default: File.join(Dir.pwd, 'pkg')
+      option nil, 'force', 'Skips the prompts and builds the module package.'
 
-    option nil, 'force', _('Skips the prompts and builds the module package.')
+      run do |opts, _args, _cmd|
+        require 'pdk/module/build'
+        require 'pdk/module/metadata'
+        require 'pdk/cli/util'
 
-    run do |opts, _args, _cmd|
-      require 'pdk/module/build'
+        # Make sure build is being run in a valid module directory with a metadata.json
+        PDK::CLI::Util.ensure_in_module!(
+          message: '`pdk build` can only be run from inside a valid module with a metadata.json.',
+          log_level: :info
+        )
 
-      # Make sure build is being run in a valid module directory with a metadata.json
-      PDK::CLI::Util.ensure_in_module!(
-        message:   _('`pdk build` can only be run from inside a valid module with a metadata.json.'),
-        log_level: :info,
-      )
+        module_metadata = PDK::Module::Metadata.from_file('metadata.json')
 
-      module_metadata = PDK::Module::Metadata.from_file('metadata.json')
-
-      # TODO: Ensure forge metadata has been set, or call out to interview
-      #       to set it.
-      #
-      unless module_metadata.forge_ready?
-        if opts[:force]
-          PDK.logger.error _('This module is missing required fields in the metadata.json. Re-run the build command without --force to add this information.')
-          exit 1
-        else
-          module_metadata.interview_for_forge!
-          module_metadata.write!('metadata.json')
+        # TODO: Ensure forge metadata has been set, or call out to interview
+        #       to set it.
+        #
+        unless module_metadata.forge_ready?
+          if opts[:force]
+            PDK.logger.warn "This module is missing the following fields in the metadata.json: #{module_metadata.missing_fields.join(', ')}. " \
+                            'These missing fields may affect the visibility of the module on the Forge.'
+          else
+            module_metadata.interview_for_forge!
+            module_metadata.write!('metadata.json')
+          end
         end
-      end
 
-      builder = PDK::Module::Build.new(opts)
+        builder = PDK::Module::Build.new(opts)
 
-      unless opts[:force]
-        if builder.package_already_exists?
-          PDK.logger.info _("The file '%{package}' already exists.") % { package: builder.package_file }
+        unless opts[:force]
+          if builder.package_already_exists?
+            PDK.logger.info format("The file '%{package}' already exists.", package: builder.package_file)
 
-          unless PDK::CLI::Util.prompt_for_yes(_('Overwrite?'), default: false)
-            PDK.logger.info _('Build cancelled; exiting.')
-            exit 0
+            unless PDK::CLI::Util.prompt_for_yes('Overwrite?', default: false)
+              PDK.logger.info 'Build cancelled; exiting.'
+              exit 0
+            end
           end
-        end
 
-        unless builder.module_pdk_compatible?
-          PDK.logger.info _('This module is not compatible with PDK, so PDK can not validate or test this build. ' \
+          unless builder.module_pdk_compatible?
+            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`.')
+                            '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.')
-            exit 0
+            unless PDK::CLI::Util.prompt_for_yes('Continue build without converting?')
+              PDK.logger.info 'Build cancelled; exiting.'
+              exit 0
+            end
           end
         end
-      end
 
-      PDK.logger.info _('Building %{module_name} version %{module_version}') % {
-        module_name:    module_metadata.data['name'],
-        module_version: module_metadata.data['version'],
-      }
+        PDK.logger.info format('Building %{module_name} version %{module_version}', module_name: module_metadata.data['name'], module_version: module_metadata.data['version'])
 
-      builder.build
+        builder.build
 
-      PDK.logger.info _('Build of %{package_name} has completed successfully. Built package can be found here: %{package_path}') % {
-        package_name: module_metadata.data['name'],
-        package_path: builder.package_file,
-      }
+        PDK.logger.info format('Build of %{package_name} has completed successfully. Built package can be found here: %{package_path}', package_name: module_metadata.data['name'],
+                                                                                                                                        package_path: builder.package_file)
+      end
     end
   end
 end

data/lib/pdk/cli/bundle.rb

@@ -1,42 +1,46 @@
+module PDK
+  module CLI
+    @bundle_cmd = @base_cmd.define_command do
+      name 'bundle'
+      usage 'bundle [bundler_options]'
+      summary 'Command pass-through to bundler'
+      description <<~EOF
+        For advanced users, pdk bundle runs arbitrary commands in the bundler environment that pdk manages.
+        Careless use of this command can lead to errors that pdk can't help recover from.
+      EOF
+      skip_option_parsing
 
-module PDK::CLI
-  @bundle_cmd = @base_cmd.define_command do
-    name 'bundle'
-    usage _('bundle [bundler_options]')
-    summary _('(Experimental) Command pass-through to bundler')
-    description _(<<-EOF
-[experimental] For advanced users, pdk bundle runs arbitrary commands in the bundler environment that pdk manages.
-Careless use of this command can lead to errors that pdk can't help recover from.
+      run do |_opts, args, _cmd|
+        require 'pdk/util/bundler'
 
-Note that for PowerShell the '--' needs to be escaped using a backtick: '`--' to avoid it being parsed by the shell.
-EOF
-                 )
-    skip_option_parsing
+        PDK::CLI::Util.ensure_in_module!(
+          message: '`pdk bundle` can only be run from inside a valid module directory.'
+        )
 
-    run do |_opts, args, _cmd|
-      PDK::CLI::Util.ensure_in_module!(
-        message: _('`pdk bundle` can only be run from inside a valid module directory.'),
-      )
+        PDK::CLI::Util.validate_puppet_version_opts({})
 
-      PDK::CLI::Util.validate_puppet_version_opts({})
+        screen_view_name = ['bundle']
+        screen_view_name << args[0] if args.size >= 1
+        screen_view_name << args[1] if args.size >= 2 && args[0] == 'exec'
 
-      # Ensure that the correct Ruby is activated before running commend.
-      puppet_env = PDK::CLI::Util.puppet_from_opts_or_env({})
-      PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
+        # Ensure that the correct Ruby is activated before running command.
+        puppet_env = PDK::CLI::Util.puppet_from_opts_or_env({})
+        PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
 
-      gemfile_env = PDK::Util::Bundler::BundleHelper.gemfile_env(puppet_env[:gemset])
+        gemfile_env = PDK::Util::Bundler::BundleHelper.gemfile_env(puppet_env[:gemset])
 
-      command = PDK::CLI::Exec::Command.new(PDK::CLI::Exec.bundle_bin, *args).tap do |c|
-        c.context = :pwd
-        c.update_environment(gemfile_env)
-      end
+        require 'pdk/cli/exec'
+        require 'pdk/cli/exec/interactive_command'
 
-      result = command.execute!
+        command = PDK::CLI::Exec::InteractiveCommand.new(PDK::CLI::Exec.bundle_bin, *args).tap do |c|
+          c.context = :pwd
+          c.update_environment(gemfile_env)
+        end
 
-      $stderr.puts result[:stdout]
-      $stderr.puts result[:stderr]
+        result = command.execute!
 
-      exit result[:exit_code]
+        exit result[:exit_code]
+      end
     end
   end
 end

data/lib/pdk/cli/console.rb

@@ -0,0 +1,148 @@
+module PDK
+  module CLI
+    @console_cmd = @base_cmd.define_command do
+      name 'console'
+      usage 'console [console_options]'
+      summary '(Experimental) Start a session of the puppet debugger console.'
+      default_subcommand 'help'
+      description <<~EOF
+        The pdk console runs a interactive session of the puppet debugger tool to test out snippets of code, run
+        language evaluations, datatype prototyping and much more.  A virtual playground for your puppet code!
+        For usage details see the puppet debugger docs at https://docs.puppet-debugger.com.
+
+      EOF
+
+      PDK::CLI.puppet_version_options(self)
+      PDK::CLI.puppet_dev_option(self)
+      # we have to skip option parsing because it is expected the user
+      # will be passing additional args that are passed to the debugger
+      skip_option_parsing
+
+      # TODO: using -h or --help skips the pdk help and passes to puppet debugger help
+      run do |_opts, args, _cmd|
+        require 'pdk/cli/util'
+        require 'pdk/util'
+
+        PDK::CLI::Util.ensure_in_module!(
+          message: 'Console can only be run from inside a valid module directory',
+          log_level: :fatal
+        )
+
+        PDK::CLI::Util.module_version_check
+
+        processed_options, processed_args = process_opts(args)
+
+        PDK::CLI::Util.validate_puppet_version_opts(processed_options)
+
+        # TODO: figure out if we need to remove default configs set by puppet
+        # so it is scoped for the module only
+        # "--environmentpath"...
+        flags = if PDK::Util.in_module_root?
+                  ["--basemodulepath=#{base_module_path}",
+                   "--modulepath=#{base_module_path}"]
+                else
+                  []
+                end
+        debugger_args = ['debugger'] + processed_args + flags
+        result = run_in_module(debugger_args, **processed_options)
+
+        exit result[:exit_code]
+      end
+
+      # Logs a fatal message about the gem missing and how to add it
+      def inform_user_for_missing_gem(gem_name = 'puppet-debugger', version = '~> 0.14')
+        PDK.logger.fatal(<<~EOF
+          Your Gemfile is missing the #{gem_name} gem.  You can add the missing gem
+          by updating your #{File.join(PDK::Util.module_root, '.sync.yml')} file with the following
+          and running pdk update.
+
+          Gemfile:
+            required:
+              ":development":
+                - gem: #{gem_name}
+                  version: "#{version}"
+
+        EOF
+                        )
+      end
+
+      # @return [Boolean] - true if the gem was found in the lockfile
+      # @param [String] - name of ruby gem to check in bundle lockfile
+      def gem_in_bundle_lockfile?(gem_name)
+        require 'bundler'
+        require 'pdk/util/bundler'
+
+        lock_file_path = PDK::Util::Bundler::BundleHelper.new.gemfile_lock
+        PDK.logger.debug("Checking lockfile #{lock_file_path} for #{gem_name}")
+        lock_file = ::Bundler::LockfileParser.new(::Bundler.read_file(lock_file_path))
+        !lock_file.specs.find { |spec| spec.name.eql?(gem_name) }.nil?
+      rescue ::Bundler::GemfileNotFound => e
+        PDK.logger.debug e.message
+        false
+      end
+
+      def check_fixtures_dir
+        existing_path = base_module_path.split(':').find do |path|
+          PDK::Util::Filesystem.directory?(path) && Dir.entries(path).length > 2
+        end
+        PDK.logger.warn 'Module fixtures not found, please run pdk bundle exec rake spec_prep.' unless existing_path
+      end
+
+      # @return [Array] - array of split options [{:"puppet-version"=>"6.9.0"}, ['--loglevel=debug']]
+      # options are for the pdk and debugger pass through
+      def process_opts(opts)
+        args = opts.map do |e|
+          if /\A-{2}puppet|pe-version|dev/.match?(e)
+            value = e.split('=')
+            value.count < 2 ? value + [''] : value
+          end
+        end
+        args = args.compact.to_h
+        # symbolize keys
+        args = args.inject({}) do |memo, (k, v)| # rubocop:disable Style/EachWithObject
+          memo[k.sub('--', '').to_sym] = v
+          memo
+        end
+        # pass through all other args that are bound for puppet debugger
+        processed_args = opts.grep_v(/\A-{2}puppet|pe-version|dev/)
+        [args, processed_args]
+      end
+
+      # @param opts [Hash] - the options passed into the CRI command
+      # @param bundle_args [Array] array of bundle exec args and puppet debugger args
+      # @return [Hash] - a command result hash
+      def run_in_module(bundle_args, opts)
+        require 'pdk/cli/exec'
+        require 'pdk/cli/exec/interactive_command'
+        require 'pdk/util/ruby_version'
+        require 'pdk/util/bundler'
+
+        check_fixtures_dir
+        output = opts[:debug].nil?
+        puppet_env = PDK::CLI::Util.puppet_from_opts_or_env(opts, output)
+        gemfile_env = PDK::Util::Bundler::BundleHelper.gemfile_env(puppet_env[:gemset])
+        PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
+        PDK::Util::RubyVersion.instance(puppet_env[:ruby_version])
+        PDK::Util::Bundler.ensure_bundle!(**puppet_env[:gemset])
+        unless gem_in_bundle_lockfile?('puppet-debugger')
+          inform_user_for_missing_gem
+          return { exit_code: 1 }
+        end
+
+        debugger_args = ['exec', 'puppet'] + bundle_args
+        command = PDK::CLI::Exec::InteractiveCommand.new(PDK::CLI::Exec.bundle_bin, *debugger_args).tap do |c|
+          c.context = :pwd
+          c.update_environment(gemfile_env)
+        end
+        command.execute!
+      end
+
+      # @return [String] - the basemodulepath of the fixtures and modules from the current module
+      # also includes ./modules in case librarian puppet is used
+      def base_module_path
+        base_module_path = File.join(PDK::Util.module_fixtures_dir, 'modules')
+        "#{base_module_path}:#{File.join(PDK::Util.module_root, 'modules')}"
+      end
+    end
+  end
+end

data/lib/pdk/cli/convert.rb

@@ -1,41 +1,50 @@
-require 'pdk/cli/util'
-
-module PDK::CLI
-  @convert_cmd = @base_cmd.define_command do
-    name 'convert'
-    usage _('convert [options]')
-    summary _('Convert an existing module to be compatible with the PDK.')
-
-    PDK::CLI.template_url_option(self)
-    PDK::CLI.skip_interview_option(self)
-    PDK::CLI.full_interview_option(self)
-    flag nil, :noop, _('Do not convert the module, just output what would be done.')
-    flag nil, :force, _('Convert the module automatically, with no prompts.')
-
-    run do |opts, _args, _cmd|
-      require 'pdk/module/convert'
-
-      PDK::CLI::Util.ensure_in_module!(
-        check_module_layout: true,
-        message:             _('`pdk convert` can only be run from inside a valid module directory.'),
-        log_level:           :info,
-      )
-
-      if opts[:noop] && opts[:force]
-        raise PDK::CLI::ExitWithError, _('You can not specify --noop and --force when converting a module')
+module PDK
+  module CLI
+    @convert_cmd = @base_cmd.define_command do
+      name 'convert'
+      usage 'convert [options]'
+      summary 'Convert an existing module to be compatible with the PDK.'
+
+      PDK::CLI.template_url_option(self)
+      PDK::CLI.template_ref_option(self)
+      PDK::CLI.skip_interview_option(self)
+      PDK::CLI.full_interview_option(self)
+      flag nil, :noop, 'Do not convert the module, just output what would be done.'
+      flag nil, :force, 'Convert the module automatically, with no prompts.'
+      flag nil, :'add-tests', 'Add any missing tests while converting the module.'
+      flag nil, :'default-template', 'Convert the module to use the default PDK template.'
+
+      run do |opts, _args, _cmd|
+        # Write the context information to the debug log
+        PDK.context.to_debug_log
+
+        unless PDK.context.is_a?(PDK::Context::Module) || PDK.context.is_a?(PDK::Context::ControlRepo)
+          raise PDK::CLI::ExitWithError, '`pdk convert` can only be run from inside a valid module directory.'
+        end
+
+        raise PDK::CLI::ExitWithError, 'You can not specify --noop and --force when converting a module' if opts[:noop] && opts[:force]
+
+        if opts[:'default-template']
+          raise PDK::CLI::ExitWithError, 'You can not specify --template-url and --default-template.' if opts[:'template-url']
+
+          opts[:'template-url'] = PDK::Util::TemplateURI.default_template_addressable_uri.to_s
+          PDK.config.set(['user', 'module_defaults', 'template-url'], nil)
+        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
+
+        if opts[:force] && opts[:'full-interview']
+          PDK.logger.info 'Ignoring --full-interview and continuing with --force.'
+          opts[:'full-interview'] = false
+        end
+
+        PDK::Module::Convert.invoke(PDK.context.root_path, opts)
       end
-
-      if opts[:'skip-interview'] && opts[:'full-interview']
-        PDK.logger.info _('Ignoring --full-interview and continuing with --skip-interview.')
-        opts[:'full-interview'] = false
-      end
-
-      if opts[:force] && opts[:'full-interview']
-        PDK.logger.info _('Ignoring --full-interview and continuing with --force.')
-        opts[:'full-interview'] = false
-      end
-
-      PDK::Module::Convert.invoke(opts)
     end
   end
 end