pdk 1.9.0 → 3.2.0

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/util.rb

@@ -1,6 +1,15 @@
+require 'pdk'
+
 module PDK
   module CLI
     module Util
+      autoload :CommandRedirector, 'pdk/cli/util/command_redirector'
+      autoload :OptionNormalizer, 'pdk/cli/util/option_normalizer'
+      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.
       #
       # @param opts [Hash] options to change the behavior of the check logic.
@@ -14,7 +23,7 @@ module PDK
         return unless PDK::Util.module_root.nil?
         return if opts[:check_module_layout] && PDK::Util.in_module_root?
 
-        message = opts.fetch(:message, _('This command must be run from inside a valid module (no metadata.json found).'))
+        message = opts.fetch(:message, 'This command must be run from inside a valid module (no metadata.json found).')
         raise PDK::CLI::ExitWithError.new(message, opts)
       end
       module_function :ensure_in_module!
@@ -22,25 +31,28 @@ module PDK
       def spinner_opts_for_platform
         windows_opts = {
           success_mark: '*',
-          error_mark: 'X',
+          error_mark: 'X'
         }
 
         return windows_opts if Gem.win_platform?
+
         {}
       end
       module_function :spinner_opts_for_platform
 
       def prompt_for_yes(question_text, opts = {})
+        require 'tty/prompt'
+
         prompt = opts[:prompt] || TTY::Prompt.new(help_color: :cyan)
-        validator = proc { |value| [true, false].include?(value) || value =~ %r{\A(?:yes|y|no|n)\Z}i }
+        validator = proc { |value| [true, false].include?(value) || value =~ /\A(?:yes|y|no|n)\Z/i }
         response = nil
 
         begin
           response = prompt.yes?(question_text) do |q|
             q.default opts[:default] unless opts[:default].nil?
-            q.validate(validator, _('Answer "Y" to continue or "n" to cancel.'))
+            q.validate(validator, 'Answer "Y" to continue or "n" to cancel.')
           end
-        rescue TTY::Prompt::Reader::InputInterrupt
+        rescue PDK::CLI::Util::Interview::READER::InputInterrupt
           PDK.logger.info opts[:cancel_message] if opts[:cancel_message]
         end
 
@@ -48,9 +60,32 @@ module PDK
       end
       module_function :prompt_for_yes
 
+      # Uses environment variables to detect if the current process is running in common
+      # Continuous Integration (CI) environments
+      # @return [Boolean] Whether the PDK is in a CI based environment
+      def ci_environment?
+        [
+          'CI',                     # Generic
+          'CONTINUOUS_INTEGRATION', # Generic
+          'APPVEYOR_BUILD_FOLDER',  # AppVeyor CI
+          'GITLAB_CI',              # GitLab CI
+          'JENKINS_URL',            # Jenkins
+          'BUILD_DEFINITIONNAME',   # Azure Pipelines
+          'TEAMCITY_VERSION',       # Team City
+          'BAMBOO_BUILDKEY',        # Bamboo
+          'GOCD_SERVER_URL',        # Go CD
+          'TRAVIS',                 # Travis CI
+          'GITHUB_WORKFLOW' # GitHub Actions
+        ].any? { |name| PDK::Util::Env.key?(name) }
+      end
+      module_function :ci_environment?
+
       def interactive?
+        require 'pdk/logger'
+
         return false if PDK.logger.debug?
-        return !ENV['PDK_FRONTEND'].casecmp('noninteractive').zero? if ENV['PDK_FRONTEND']
+        return !PDK::Util::Env['PDK_FRONTEND'].casecmp('noninteractive').zero? if PDK::Util::Env['PDK_FRONTEND']
+        return false if ci_environment?
         return false unless $stderr.isatty
 
         true
@@ -62,66 +97,89 @@ module PDK
 
         # This means the module does not have a pdk-version tag in the metadata.json
         # and will require a pdk convert.
-        raise PDK::CLI::ExitWithError, _('This module is not PDK compatible. Run `pdk convert` to make it compatible with your version of PDK.') if module_pdk_ver.nil?
+        raise PDK::CLI::ExitWithError, 'This module is not PDK compatible. Run `pdk convert` to make it compatible with your version of PDK.' if module_pdk_ver.nil?
 
         # This checks that the version of pdk in the module's metadata is older
         # than 1.3.1, which means the module will need to run pdk convert to the
         # new templates.
         if Gem::Version.new(module_pdk_ver) < Gem::Version.new('1.3.1')
-          PDK.logger.warn _('This module template is out of date. Run `pdk convert` to make it compatible with your version of PDK.')
+          PDK.logger.warn 'This module template is out of date. Run `pdk convert` to make it compatible with your version of PDK.'
         # This checks if the version of the installed PDK is older than the
         # version in the module's metadata, and advises the user to upgrade to
         # their install of PDK.
         elsif Gem::Version.new(PDK::VERSION) < Gem::Version.new(module_pdk_ver)
-          PDK.logger.warn _('This module is compatible with a newer version of PDK. Upgrade your version of PDK to ensure compatibility.')
+          PDK.logger.warn 'This module is compatible with a newer version of PDK. Upgrade your version of PDK to ensure compatibility.'
         # This checks if the version listed in the module's metadata is older
         # than the installed PDK, and advises the user to run pdk update.
         elsif Gem::Version.new(PDK::VERSION) > Gem::Version.new(module_pdk_ver)
-          PDK.logger.warn _('This module is compatible with an older version of PDK. Run `pdk update` to update it to your version of PDK.')
+          message = 'This module is compatible with an older version of PDK.'
+          message = 'Module templates older than 3.0.0 may experience issues.' if Gem::Version.new(module_pdk_ver) < Gem::Version.new('3.0.0')
+
+          PDK.logger.warn "#{message} Run `pdk update` to update it to the latest version."
         end
       end
       module_function :module_version_check
 
-      def puppet_from_opts_or_env(opts)
-        use_puppet_dev = (opts || {})[:'puppet-dev'] || ENV['PDK_PUPPET_DEV']
-        desired_puppet_version = (opts || {})[:'puppet-version'] || ENV['PDK_PUPPET_VERSION']
-        desired_pe_version = (opts || {})[:'pe-version'] || ENV['PDK_PE_VERSION']
+      def check_for_deprecated_puppet(version)
+        return unless version.is_a?(Gem::Version)
+
+        deprecated_below = Gem::Version.new('7.0.0')
+        return unless version < deprecated_below
+
+        raise PDK::CLI::ExitWithError, "Support for Puppet versions older than #{deprecated_below} has been removed from PDK."
+      end
+      module_function :check_for_deprecated_puppet
+
+      # @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, 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'])
+        desired_pe_version = opts.fetch(:'pe-version', PDK::Util::Env['PDK_PE_VERSION'])
 
         begin
           puppet_env =
             if use_puppet_dev
+              PDK::Util::PuppetVersion.fetch_puppet_dev(run: :once)
               PDK::Util::PuppetVersion.puppet_dev_env
             elsif desired_puppet_version
               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
         end
 
         # Notify user of what Ruby version will be used.
-        PDK.logger.info(_('Using Ruby %{version}') % {
-          version: puppet_env[:ruby_version],
-        })
+        PDK.logger.info(format('Using Ruby %{version}', version: puppet_env[:ruby_version])) unless logging_disabled
+
+        check_for_deprecated_puppet(puppet_env[:gem_version])
 
         gemset = { puppet: puppet_env[:gem_version].to_s }
 
         # Notify user of what gems are being activated.
-        gemset.each do |gem, version|
-          next if version.nil?
+        unless logging_disabled
+          gemset.each do |gem, version|
+            next if version.nil?
 
-          PDK.logger.info(_('Using %{gem} %{version}') % {
-            gem: gem.to_s.capitalize,
-            version: version,
-          })
+            PDK.logger.info(format('Using %{gem} %{version}', gem: gem.to_s.capitalize, version: version))
+          end
         end
 
         {
           gemset: gemset,
-          ruby_version: puppet_env[:ruby_version],
+          ruby_version: puppet_env[:ruby_version]
         }
       end
       module_function :puppet_from_opts_or_env
@@ -129,24 +187,21 @@ module PDK
       def validate_puppet_version_opts(opts)
         puppet_ver_specs = []
         puppet_ver_specs << '--puppet-version option' if opts[:'puppet-version']
-        puppet_ver_specs << 'PDK_PUPPET_VERSION environment variable' if ENV['PDK_PUPPET_VERSION'] && !ENV['PDK_PUPPET_VERSION'].empty?
+        puppet_ver_specs << 'PDK_PUPPET_VERSION environment variable' if PDK::Util::Env['PDK_PUPPET_VERSION'] && !PDK::Util::Env['PDK_PUPPET_VERSION'].empty?
 
         pe_ver_specs = []
         pe_ver_specs << '--pe-version option' if opts[:'pe-version']
-        pe_ver_specs << 'PDK_PE_VERSION environment variable' if ENV['PDK_PE_VERSION'] && !ENV['PDK_PE_VERSION'].empty?
+        pe_ver_specs << 'PDK_PE_VERSION environment variable' if PDK::Util::Env['PDK_PE_VERSION'] && !PDK::Util::Env['PDK_PE_VERSION'].empty?
 
         puppet_dev_specs = []
         puppet_dev_specs << '--puppet-dev flag' if opts[:'puppet-dev']
-        puppet_dev_specs << 'PDK_PUPPET_DEV environment variable' if ENV['PDK_PUPPET_DEV'] && !ENV['PDK_PUPPET_DEV'].empty?
+        puppet_dev_specs << 'PDK_PUPPET_DEV environment variable' if PDK::Util::Env['PDK_PUPPET_DEV'] && !PDK::Util::Env['PDK_PUPPET_DEV'].empty?
 
         puppet_dev_specs.each do |pup_dev_spec|
           [puppet_ver_specs, pe_ver_specs].each do |offending|
             next if offending.empty?
 
-            raise PDK::CLI::ExitWithError, _('You cannot specify a %{first} and %{second} at the same time') % {
-              first: pup_dev_spec,
-              second: offending.first,
-            }
+            raise PDK::CLI::ExitWithError, format('You cannot specify a %{first} and %{second} at the same time.', first: pup_dev_spec, second: offending.first)
           end
         end
 
@@ -155,39 +210,41 @@ module PDK
 
           offending = [pup_ver_spec, pe_ver_specs[0]].sort
 
-          raise PDK::CLI::ExitWithError, _('You cannot specify a %{first} and %{second} at the same time.') % {
-            first: offending[0],
-            second: offending[1],
-          }
+          raise PDK::CLI::ExitWithError, format('You cannot specify a %{first} and %{second} at the same time.', first: offending[0], second: offending[1])
+        end
+
+        # We want to mark setting the PE as deprecated.
+        if opts[:'pe-version'] || PDK::Util::Env['PDK_PE_VERSION']
+          PDK.logger.warn('Specifying a Puppet Enterprise version is now deprecated and will be removed in a future version. Please use --puppet-version or PDK_PUPPET_VERSION instead.')
         end
 
         if puppet_dev_specs.size == 2
           warning_str = 'Puppet dev flag from command line: "--puppet-dev" '
           warning_str += 'overrides value from environment: "PDK_PUPPET_DEV=true". You should not specify both.'
 
-          PDK.logger.warn(_(warning_str) % {
-            pup_ver_opt: opts[:'puppet-dev'],
-            pup_ver_env: ENV['PDK_PUPPET_DEV'],
-          })
+          PDK.logger.warn(format(warning_str, pup_ver_opt: opts[:'puppet-dev'], pup_ver_env: PDK::Util::Env['PDK_PUPPET_DEV']))
         elsif puppet_ver_specs.size == 2
           warning_str = 'Puppet version option from command line: "--puppet-version=%{pup_ver_opt}" '
           warning_str += 'overrides value from environment: "PDK_PUPPET_VERSION=%{pup_ver_env}". You should not specify both.'
 
-          PDK.logger.warn(_(warning_str) % {
-            pup_ver_opt: opts[:'puppet-version'],
-            pup_ver_env: ENV['PDK_PUPPET_VERSION'],
-          })
+          PDK.logger.warn(format(warning_str, pup_ver_opt: opts[:'puppet-version'], pup_ver_env: PDK::Util::Env['PDK_PUPPET_VERSION']))
         elsif pe_ver_specs.size == 2
           warning_str = 'Puppet Enterprise version option from command line: "--pe-version=%{pe_ver_opt}" '
           warning_str += 'overrides value from environment: "PDK_PE_VERSION=%{pe_ver_env}". You should not specify both.'
 
-          PDK.logger.warn(_(warning_str) % {
-            pup_ver_opt: opts[:'pe-version'],
-            pup_ver_env: ENV['PDK_PE_VERSION'],
-          })
+          PDK.logger.warn(format(warning_str, pe_ver_opt: opts[:'pe-version'], pe_ver_env: PDK::Util::Env['PDK_PE_VERSION']))
         end
       end
       module_function :validate_puppet_version_opts
+
+      def validate_template_opts(opts)
+        raise PDK::CLI::ExitWithError, '--template-ref requires --template-url to also be specified.' if opts[:'template-ref'] && opts[:'template-url'].nil?
+
+        return unless opts[:'template-url']&.include?('#')
+
+        raise PDK::CLI::ExitWithError, '--template-url may not be used to specify paths containing #\'s.'
+      end
+      module_function :validate_template_opts
     end
   end
 end

data/lib/pdk/cli/validate.rb

@@ -1,124 +1,109 @@
-require 'pdk/util/bundler'
-
-module PDK::CLI
-  @validate_cmd = @base_cmd.define_command do
-    name 'validate'
-    usage _('validate [validators] [options] [targets]')
-    summary _('Run static analysis tests.')
-    description _(
-      "Run metadata, YAML, Puppet, Ruby, or Tasks validation.\n\n" \
-      '[validators] is an optional comma-separated list of validators to use. ' \
-      'If not specified, all validators are used. ' \
-      "Note that when using PowerShell, the list of validators must be enclosed in single quotes.\n\n" \
-      '[targets] is an optional space-separated list of files or directories to be validated. ' \
-      'If not specified, validators are run against all applicable files in the module.',
-    )
-
-    PDK::CLI.puppet_version_options(self)
-    PDK::CLI.puppet_dev_option(self)
-    flag nil, :list, _('List all available validators.')
-    flag :a, 'auto-correct', _('Automatically correct problems where possible.')
-    flag nil, :parallel, _('Run validations in parallel.')
-
-    run do |opts, args, _cmd|
-      if args == ['help']
-        PDK::CLI.run(['validate', '--help'])
-        exit 0
-      end
-
-      validator_names = PDK::Validate.validators.map { |v| v.name }
-      validators = PDK::Validate.validators
-      targets = []
-
-      if opts[:list]
-        PDK.logger.info(_('Available validators: %{validator_names}') % { validator_names: validator_names.join(', ') })
-        exit 0
-      end
-
-      PDK::CLI::Util.validate_puppet_version_opts(opts)
-
-      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 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) }
-
-          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(', ') })
-          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 }
-          if val
-            validators = [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.
-            PDK.logger.info(_('Running all available validators...'))
-          end
+module PDK
+  module CLI
+    @validate_cmd = @base_cmd.define_command do
+      name 'validate'
+      usage 'validate [validators] [options] [targets]'
+      summary 'Run static analysis tests.'
+      description "Run metadata, YAML, Puppet, Ruby, or Tasks validation.\n\n" \
+                  '[validators] is an optional comma-separated list of validators to use. ' \
+                  'If not specified, all validators are used. ' \
+                  "Note that when using PowerShell, the list of validators must be enclosed in single quotes.\n\n" \
+                  '[targets] is an optional space-separated list of files or directories to be validated. ' \
+                  'If not specified, validators are run against all applicable files in the module.'
+
+      PDK::CLI.puppet_version_options(self)
+      PDK::CLI.puppet_dev_option(self)
+      flag nil, :list, 'List all available validators.'
+      flag :a, 'auto-correct', 'Automatically correct problems where possible.'
+      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
         end
-      else
-        PDK.logger.info(_('Running all available validators...'))
-      end
-
-      # Subsequent arguments are targets.
-      targets.concat(args[1..-1]) if args.length > 1
-
-      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
 
-      options = targets.empty? ? {} : { targets: targets }
-      options[:auto_correct] = true if opts.key?(:'auto-correct')
+        require 'pdk/validate'
 
-      # 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::PuppetVersion.fetch_puppet_dev if opts.key?(:'puppet-dev')
-      PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
-
-      options.merge!(puppet_env[:gemset])
-
-      PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
+        if opts[:list]
+          PDK.logger.info(format('Available validators: %{validator_names}', validator_names: PDK::Validate.validator_names.join(', ')))
+          exit 0
+        end
 
-      exit_code = 0
-      if opts[:parallel]
-        exec_group = PDK::CLI::ExecGroup.new(_('Validating module using %{num_of_threads} threads' % { num_of_threads: validators.count }), opts)
+        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
 
-        validators.each do |validator|
-          exec_group.register do
-            validator.invoke(report, options.merge(exec_group: exec_group))
+        PDK::CLI::Util.module_version_check if PDK.context.is_a?(PDK::Context::Module)
+
+        # 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_to_run = PDK::Validate.validator_names.select { |name| vals.include?(name) }
+
+            vals.reject { |v| PDK::Validate.validator_names.include?(v) }
+                .each do |v|
+              PDK.logger.warn(format("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.validator_names.find { |name| args[0] == name }
+            if 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.
+              PDK.logger.info('Running all available validators...')
+            end
           end
+        else
+          PDK.logger.info('Running all available validators...')
         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
+        validators_to_run = PDK::Validate.validator_names if validators_to_run.nil?
+
+        # Subsequent arguments are targets.
+        targets.concat(args.to_a[1..]) if args.length > 1
+
+        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
+
+        options = targets.empty? ? {} : { targets: targets }
+        options[:auto_correct] = true if opts[:'auto-correct']
+        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, 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])
         end
-      end
 
-      report_formats.each do |format|
-        report.send(format[:method], format[:target])
+        exit exit_code
       end
-
-      exit exit_code
     end
   end
 end