pdk 2.6.1 → 2.7.0

data/lib/pdk/module/release.rb

@@ -1,4 +1,5 @@
 require 'pdk'
+require 'uri'
 
 module PDK
   module Module
@@ -16,21 +17,21 @@ module PDK
 
         # TODO: Currently the release process can ONLY be run if the working directory IS the module root. However, in the future
         # this WILL change, so we have the API arguments for it, but only accept `nil` for the first parameter
-        raise PDK::CLI::ExitWithError, _('Running the release process outside of the working directory is not supported') unless module_path.nil?
+        raise PDK::CLI::ExitWithError, 'Running the release process outside of the working directory is not supported' unless module_path.nil?
 
         if module_path.nil?
           module_path = PDK::Util.module_root
-          raise PDK::CLI::ExitWithError, _('The module release process requires a valid module path') % { module_path: module_path } if module_path.nil?
+          raise PDK::CLI::ExitWithError, 'The module release process requires a valid module path' % { module_path: module_path } if module_path.nil?
         end
-        raise PDK::CLI::ExitWithError, _('%{module_path} is not a valid module') % { module_path: module_path } unless PDK::Util.in_module_root?(module_path)
+        raise PDK::CLI::ExitWithError, '%{module_path} is not a valid module' % { module_path: module_path } unless PDK::Util.in_module_root?(module_path)
         @module_path = module_path
       end
 
       def run
         # Pre-release checks
         unless force?
-          raise PDK::CLI::ExitWithError, _('The module is not PDK compatible') if requires_pdk_compatibility? && !pdk_compatible?
-          raise PDK::CLI::ExitWithError, _('The module is not Forge compatible') if requires_forge_compatibility? && !forge_compatible?
+          raise PDK::CLI::ExitWithError, 'The module is not PDK compatible' if requires_pdk_compatibility? && !pdk_compatible?
+          raise PDK::CLI::ExitWithError, 'The module is not Forge compatible' if requires_forge_compatibility? && !forge_compatible?
         end
 
         # Note that these checks are duplicated in the run_publish method, however it's a much better
@@ -40,7 +41,7 @@ module PDK
 
         run_validations(options) unless skip_validation?
 
-        PDK.logger.info _('Releasing %{module_name} - from version %{module_version}') % {
+        PDK.logger.info 'Releasing %{module_name} - from version %{module_version}' % {
           module_name:    module_metadata.data['name'],
           module_version: module_metadata.data['version'],
         }
@@ -55,7 +56,7 @@ module PDK
         new_version = module_metadata.data['version'] if new_version.nil?
 
         if new_version != module_metadata.data['version']
-          PDK.logger.info _('Updating version to %{module_version}') % {
+          PDK.logger.info 'Updating version to %{module_version}' % {
             module_version: new_version,
           }
 
@@ -69,7 +70,7 @@ module PDK
           # Check if the versions match
           latest_version = PDK::Util::ChangelogGenerator.latest_version
           unless latest_version
-            raise PDK::CLI::ExitWithError, _('%{new_version} does not match %{latest_version}') % { new_version: new_version, latest_version: latest_version } if new_version != latest_version
+            raise PDK::CLI::ExitWithError, '%{new_version} does not match %{latest_version}' % { new_version: new_version, latest_version: latest_version } if new_version != latest_version
           end
         end
 
@@ -118,26 +119,26 @@ module PDK
         PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
 
         validator_exit_code, = PDK::Validate.invoke_validators_by_name(PDK.context, PDK::Validate.validator_names, false, options)
-        raise PDK::CLI::ExitWithError, _('An error occured during validation') unless validator_exit_code.zero?
+        raise PDK::CLI::ExitWithError, 'An error occured during validation' unless validator_exit_code.zero?
       end
 
       def run_documentation(_opts)
-        PDK.logger.info _('Updating documentation using puppet strings')
+        PDK.logger.info 'Updating documentation using puppet strings'
         docs_command = PDK::CLI::Exec::InteractiveCommand.new(PDK::CLI::Exec.bundle_bin, 'exec', 'puppet', 'strings', 'generate', '--format', 'markdown', '--out', 'REFERENCE.md')
         docs_command.context = :module
         result = docs_command.execute!
-        raise PDK::CLI::ExitWithError, _('An error occured generating the module documentation: %{stdout}') % { stdout: result[:stdout] } unless result[:exit_code].zero?
+        raise PDK::CLI::ExitWithError, 'An error occured generating the module documentation: %{stdout}' % { stdout: result[:stdout] } unless result[:exit_code].zero?
       end
 
       def run_dependency_checker(_opts)
         # run dependency-checker and output dependent modules list
-        PDK.logger.info _('Running dependency checks')
+        PDK.logger.info 'Running dependency checks'
 
         dep_command = PDK::CLI::Exec::Command.new('dependency-checker', 'metadata.json')
         dep_command.context = :module
         result = dep_command.execute!
 
-        raise PDK::CLI::ExitWithError, _('An error occured checking the module dependencies: %{stdout}') % { stdout: result[:stdout] } unless result[:exit_code].zero?
+        raise PDK::CLI::ExitWithError, 'An error occured checking the module dependencies: %{stdout}' % { stdout: result[:stdout] } unless result[:exit_code].zero?
       end
 
       # @return [String] Path to the built tarball
@@ -147,13 +148,13 @@ module PDK
 
       def run_publish(_opts, tarball_path)
         validate_publish_options!
-        raise PDK::CLI::ExitWithError, _('Module tarball %{tarball_path} does not exist') % { tarball_path: tarball_path } unless PDK::Util::Filesystem.file?(tarball_path)
+        raise PDK::CLI::ExitWithError, 'Module tarball %{tarball_path} does not exist' % { tarball_path: tarball_path } unless PDK::Util::Filesystem.file?(tarball_path)
 
         # TODO: Replace this code when the upload functionality is added to the forge ruby gem
         require 'base64'
         file_data = Base64.encode64(PDK::Util::Filesystem.read_file(tarball_path, open_args: 'rb'))
 
-        PDK.logger.info _('Uploading tarball to puppet forge...')
+        PDK.logger.info 'Uploading tarball to puppet forge...'
         uri = URI(forge_upload_url)
         require 'net/http'
         request = Net::HTTP::Post.new(uri.path)
@@ -169,14 +170,14 @@ module PDK
           http.request(request)
         end
 
-        raise PDK::CLI::ExitWithError, _('Error uploading to Puppet Forge: %{result}') % { result: response.body } unless response.is_a?(Net::HTTPSuccess)
-        PDK.logger.info _('Publish to Forge was successful')
+        raise PDK::CLI::ExitWithError, 'Error uploading to Puppet Forge: %{result}' % { result: response.body } unless response.is_a?(Net::HTTPSuccess)
+        PDK.logger.info 'Publish to Forge was successful'
       end
 
       def validate_publish_options!
         return if skip_publish?
-        raise PDK::CLI::ExitWithError, _('Missing forge-upload-url option') unless forge_upload_url
-        raise PDK::CLI::ExitWithError, _('Missing forge-token option') unless forge_token
+        raise PDK::CLI::ExitWithError, 'Missing forge-upload-url option' unless forge_upload_url
+        raise PDK::CLI::ExitWithError, 'Missing forge-token option' unless forge_token
       end
 
       def force?

data/lib/pdk/module/update.rb

@@ -11,13 +11,13 @@ module PDK
         stage_changes!
 
         if current_version == new_version
-          PDK.logger.debug _('This module is already up to date with version %{version} of the template.') % {
+          PDK.logger.debug 'This module is already up to date with version %{version} of the template.' % {
             version: new_version,
           }
         end
 
         unless update_manager.changes?
-          PDK::Report.default_target.puts(_('No changes required.'))
+          PDK::Report.default_target.puts('No changes required.')
           return
         end
 
@@ -29,7 +29,7 @@ module PDK
         return if noop?
 
         unless force?
-          message = _('Do you want to continue and make these changes to your module?')
+          message = 'Do you want to continue and make these changes to your module?'
           return unless PDK::CLI::Util.prompt_for_yes(message)
         end
 
@@ -114,9 +114,9 @@ module PDK
 
       def update_message
         format_string = if template_uri.default?
-                          _('Updating %{module_name} using the default template, from %{current_version} to %{new_version}')
+                          'Updating %{module_name} using the default template, from %{current_version} to %{new_version}'
                         else
-                          _('Updating %{module_name} using the template at %{template_url}, from %{current_version} to %{new_version}')
+                          'Updating %{module_name} using the template at %{template_url}, from %{current_version} to %{new_version}'
                         end
 
         format_string % {

data/lib/pdk/module/update_manager.rb

@@ -115,13 +115,13 @@ module PDK
         require 'pdk/util/filesystem'
 
         if PDK::Util::Filesystem.file?(path)
-          PDK.logger.debug(_("unlinking '%{path}'") % { path: path })
+          PDK.logger.debug("unlinking '%{path}'" % { path: path })
           PDK::Util::Filesystem.rm(path)
         else
-          PDK.logger.debug(_("'%{path}': already gone") % { path: path })
+          PDK.logger.debug("'%{path}': already gone" % { path: path })
         end
       rescue => e
-        raise PDK::CLI::ExitWithError, _("Unable to remove '%{path}': %{message}") % {
+        raise PDK::CLI::ExitWithError, "Unable to remove '%{path}': %{message}" % {
           path:    path,
           message: e.message,
         }
@@ -141,7 +141,7 @@ module PDK
           next if @diff_cache.key?(file[:path])
 
           unless PDK::Util::Filesystem.readable?(file[:path])
-            raise PDK::CLI::ExitWithError, _("Unable to open '%{path}' for reading") % { path: file[:path] }
+            raise PDK::CLI::ExitWithError, "Unable to open '%{path}' for reading" % { path: file[:path] }
           end
 
           old_content = PDK::Util::Filesystem.read_file(file[:path])
@@ -160,10 +160,10 @@ module PDK
         require 'pdk/util/filesystem'
 
         PDK::Util::Filesystem.mkdir_p(File.dirname(path))
-        PDK.logger.debug(_("writing '%{path}'") % { path: path })
+        PDK.logger.debug("writing '%{path}'" % { path: path })
         PDK::Util::Filesystem.write_file(path, content)
       rescue Errno::EACCES
-        raise PDK::CLI::ExitWithError, _("You do not have permission to write to '%{path}'") % { path: path }
+        raise PDK::CLI::ExitWithError, "You do not have permission to write to '%{path}'" % { path: path }
       end
 
       # Generate a unified diff of the changes to be made to a file.

data/lib/pdk/report/event.rb

@@ -195,11 +195,11 @@ module PDK
       #   a String.
       def sanitise_file(value)
         if value.nil? || (value.is_a?(String) && value.empty?)
-          raise ArgumentError, _('File not specified.')
+          raise ArgumentError, 'File not specified.'
         end
 
         unless value.is_a?(String)
-          raise ArgumentError, _('File must be a String.')
+          raise ArgumentError, 'File must be a String.'
         end
 
         require 'pathname'
@@ -235,17 +235,17 @@ module PDK
       #   a String or Symbol representation of a valid state.
       def sanitise_state(value)
         if value.nil? || (value.is_a?(String) && value.empty?)
-          raise ArgumentError, _('State not specified.')
+          raise ArgumentError, 'State not specified.'
         end
 
         value = value.to_sym if value.is_a?(String)
         unless value.is_a?(Symbol)
-          raise ArgumentError, _('State must be a Symbol, not %{type}') % { type: value.class }
+          raise ArgumentError, 'State must be a Symbol, not %{type}' % { type: value.class }
         end
 
         valid_states = [:passed, :error, :failure, :skipped]
         unless valid_states.include?(value)
-          raise ArgumentError, _('Invalid state %{state}. Valid states are: %{valid}.') % {
+          raise ArgumentError, 'Invalid state %{state}. Valid states are: %{valid}.' % {
             state: value.inspect,
             valid: valid_states.map(&:inspect).join(', '),
           }
@@ -264,7 +264,7 @@ module PDK
       # @raise [ArgumentError] if the value is nil or an empty String.
       def sanitise_source(value)
         if value.nil? || (value.is_a?(String) && value.empty?)
-          raise ArgumentError, _('Source not specified.')
+          raise ArgumentError, 'Source not specified.'
         end
 
         value.to_s
@@ -285,11 +285,11 @@ module PDK
         end
 
         unless valid_types.include?(value.class)
-          raise ArgumentError, _('Line must be an Integer or a String representation of an Integer.')
+          raise ArgumentError, 'Line must be an Integer or a String representation of an Integer.'
         end
 
         if value.is_a?(String) && value !~ %r{\A[0-9]+\Z}
-          raise ArgumentError, _('The line number can contain only the digits 0-9.')
+          raise ArgumentError, 'The line number can contain only the digits 0-9.'
         end
 
         value.to_i
@@ -310,11 +310,11 @@ module PDK
         end
 
         unless valid_types.include?(value.class)
-          raise ArgumentError, _('Column must be an Integer or a String representation of an Integer.')
+          raise ArgumentError, 'Column must be an Integer or a String representation of an Integer.'
         end
 
         if value.is_a?(String) && value !~ %r{\A[0-9]+\Z}
-          raise ArgumentError, _('The column number can contain only the digits 0-9.')
+          raise ArgumentError, 'The column number can contain only the digits 0-9.'
         end
 
         value.to_i
@@ -332,7 +332,7 @@ module PDK
         valid_types = [Array]
 
         unless valid_types.include?(value.class)
-          raise ArgumentError, _('Trace must be an Array of stack trace lines.')
+          raise ArgumentError, 'Trace must be an Array of stack trace lines.'
         end
 
         # Drop any stacktrace lines that include '/gems/' in the path or

data/lib/pdk/template/fetcher/git.rb

@@ -22,7 +22,7 @@ module PDK
           # We don't do a checkout of local-path repos. There are lots of edge
           # cases or user un-expectations.
           if PDK::Util::Git.work_tree?(uri.shell_path)
-            PDK.logger.warn _("Repository '%{repo}' has a work-tree; skipping git reset.") % {
+            PDK.logger.warn "Repository '%{repo}' has a work-tree; skipping git reset." % {
               repo: uri.shell_path,
             }
             @path = uri.shell_path
@@ -49,7 +49,7 @@ module PDK
           unless clone_result[:exit_code].zero?
             PDK.logger.error clone_result[:stdout]
             PDK.logger.error clone_result[:stderr]
-            raise PDK::CLI::FatalError, _("Unable to clone git repository at '%{repo}' into '%{dest}'.") % { repo: origin_repo, dest: temp_dir }
+            raise PDK::CLI::FatalError, "Unable to clone git repository at '%{repo}' into '%{dest}'." % { repo: origin_repo, dest: temp_dir }
           end
           @path = PDK::Util.canonical_path(temp_dir)
 
@@ -63,10 +63,10 @@ module PDK
 
               PDK.logger.error reset_result[:stdout]
               PDK.logger.error reset_result[:stderr]
-              raise PDK::CLI::FatalError, _("Unable to checkout '%{ref}' of git repository at '%{path}'.") % { ref: git_ref, path: temp_dir }
+              raise PDK::CLI::FatalError, "Unable to checkout '%{ref}' of git repository at '%{path}'." % { ref: git_ref, path: temp_dir }
             end
           else
-            PDK.logger.warn _("Uncommitted changes found when attempting to checkout '%{ref}' of git repository at '%{path}'; skipping git reset.") % { ref: git_ref, path: temp_dir }
+            PDK.logger.warn "Uncommitted changes found when attempting to checkout '%{ref}' of git repository at '%{path}'; skipping git reset." % { ref: git_ref, path: temp_dir }
             @metadata['template-ref'] = describe_path_and_ref(temp_dir)
           end
         end

data/lib/pdk/template/fetcher.rb

@@ -35,7 +35,7 @@ module PDK
       # @raise [ArgumentError] If no block is given to this method.
       # @return [void]
       def self.with(uri, options = {})
-        raise ArgumentError, _('%{class_name}.with must be passed a block.') % { class_name: name } unless block_given?
+        raise ArgumentError, '%{class_name}.with must be passed a block.' % { class_name: name } unless block_given?
         fetcher = instance(uri, options)
 
         begin

data/lib/pdk/template/renderer/v1/legacy_template_dir.rb

@@ -93,7 +93,7 @@ module PDK
               begin
                 YAML.safe_load(PDK::Util::Filesystem.read_file(loc), [], [], true)
               rescue Psych::SyntaxError => e
-                PDK.logger.warn _("'%{file}' is not a valid YAML file: %{problem} %{context} at line %{line} column %{column}") % {
+                PDK.logger.warn "'%{file}' is not a valid YAML file: %{problem} %{context} at line %{line} column %{column}" % {
                   file:    loc,
                   problem: e.problem,
                   context: e.context,

data/lib/pdk/template/renderer/v1/renderer.rb

@@ -21,7 +21,7 @@ module PDK
             template_file = single_item_path(relative_file_path)
             return nil unless PDK::Util::Filesystem.file?(template_file) && PDK::Util::Filesystem.readable?(template_file)
 
-            PDK.logger.debug(_("Rendering '%{template}'...") % { template: template_file })
+            PDK.logger.debug("Rendering '%{template}'..." % { template: template_file })
             new_template_file(template_file, template_data_hash).render
           end
 
@@ -71,7 +71,7 @@ module PDK
 
             files_in_template(dirs).each do |template_file, template_loc|
               template_file = template_file.to_s
-              PDK.logger.debug(_("Rendering '%{template}'...") % { template: template_file })
+              PDK.logger.debug("Rendering '%{template}'..." % { template: template_file })
               dest_path = template_file.sub(%r{\.erb\Z}, '')
               config = legacy_template_dir.config_for(dest_path)
 
@@ -89,10 +89,8 @@ module PDK
                 begin
                   dest_content = new_template_file(File.join(template_loc, template_file), configs: config, template_dir: legacy_template_dir).render
                 rescue => error
-                  error_msg = _(
-                    "Failed to render template '%{template}'\n" \
-                    '%{exception}: %{message}',
-                  ) % { template: template_file, exception: error.class, message: error.message }
+                  error_msg = "Failed to render template '%{template}'\n" \
+                              '%{exception}: %{message}' % { template: template_file, exception: error.class, message: error.message }
                   raise PDK::CLI::FatalError, error_msg
                 end
               end
@@ -113,7 +111,7 @@ module PDK
             temp_paths = []
             dirlocs = []
             dirs.each do |dir|
-              raise ArgumentError, _("The directory '%{dir}' doesn't exist") % { dir: dir } unless PDK::Util::Filesystem.directory?(dir)
+              raise ArgumentError, "The directory '%{dir}' doesn't exist" % { dir: dir } unless PDK::Util::Filesystem.directory?(dir)
               temp_paths += PDK::Util::Filesystem.glob(File.join(dir, *glob_suffix), File::FNM_DOTMATCH).select do |template_path|
                 if PDK::Util::Filesystem.file?(template_path) && !PDK::Util::Filesystem.symlink?(template_path)
                   dirlocs << dir

data/lib/pdk/template/renderer/v1/template_file.rb

@@ -69,7 +69,7 @@ module PDK
               return PDK::Util::Filesystem.read_file(@template_file)
             end
 
-            raise ArgumentError, _("'%{template}' is not a readable file") % { template: @template_file }
+            raise ArgumentError, "'%{template}' is not a readable file" % { template: @template_file }
           end
 
           # Renders the content of the template file as an ERB template.
@@ -80,6 +80,8 @@ module PDK
           #
           # @api private
           def render_erb
+            require 'erb'
+
             renderer = ERB.new(template_content, nil, '-')
             renderer.filename = @template_file
             renderer.result(binding)

data/lib/pdk/template/template_dir.rb

@@ -36,7 +36,7 @@ module PDK
         @metadata = {}
 
         @renderer = renderer.nil? ? Renderer.instance(uri, path, context) : renderer
-        raise _('Could not find a compatible template renderer for %{path}') % { path: path } if @renderer.nil?
+        raise 'Could not find a compatible template renderer for %{path}' % { path: path } if @renderer.nil?
       end
 
       # Later additions may include Control Repo rendering, for example

data/lib/pdk/template.rb

@@ -38,10 +38,10 @@ module PDK
     # @api public
     def self.with(uri, context)
       unless block_given?
-        raise ArgumentError, _('%{class_name}.with must be passed a block.') % { class_name: name }
+        raise ArgumentError, '%{class_name}.with must be passed a block.' % { class_name: name }
       end
       unless uri.is_a? PDK::Util::TemplateURI
-        raise ArgumentError, _('%{class_name}.with must be passed a PDK::Util::TemplateURI, got a %{uri_type}') % { uri_type: uri.class, class_name: name }
+        raise ArgumentError, '%{class_name}.with must be passed a PDK::Util::TemplateURI, got a %{uri_type}' % { uri_type: uri.class, class_name: name }
       end
 
       Fetcher.with(uri) do |fetcher|

data/lib/pdk/tests/unit.rb

@@ -61,23 +61,23 @@ module PDK
       end
 
       def self.tear_down
-        result = rake('spec_clean', _('Cleaning up after running unit tests.'))
+        result = rake('spec_clean', 'Cleaning up after running unit tests.')
 
         return if result[:exit_code].zero?
 
-        PDK.logger.error(_('The spec_clean rake task failed with the following error(s):'))
-        print_failure(result, _('Failed to clean up after running unit tests'))
+        PDK.logger.error('The spec_clean rake task failed with the following error(s):')
+        print_failure(result, 'Failed to clean up after running unit tests')
       end
 
       def self.setup
-        result = rake('spec_prep', _('Preparing to run the unit tests.'))
+        result = rake('spec_prep', 'Preparing to run the unit tests.')
 
         return if result[:exit_code].zero?
 
         tear_down
 
-        PDK.logger.error(_('The spec_prep rake task failed with the following error(s):'))
-        print_failure(result, _('Failed to prepare to run the unit tests.'))
+        PDK.logger.error('The spec_prep rake task failed with the following error(s):')
+        print_failure(result, 'Failed to prepare to run the unit tests.')
       end
 
       def self.invoke(report, options = {})
@@ -97,7 +97,7 @@ module PDK
 
         environment = { 'CI_SPEC_OPTIONS' => '--format j' }
         environment['PUPPET_GEM_VERSION'] = options[:puppet] if options[:puppet]
-        spinner_msg = options[:parallel] ? _('Running unit tests in parallel.') : _('Running unit tests.')
+        spinner_msg = options[:parallel] ? 'Running unit tests in parallel.' : 'Running unit tests.'
 
         if options[:interactive]
           environment['CI_SPEC_OPTIONS'] = if options[:verbose]
@@ -122,7 +122,7 @@ module PDK
           result[:exit_code] = 0
         end
 
-        raise PDK::CLI::FatalError, _('Unit test output did not contain a valid JSON result: %{output}') % { output: result[:stdout] } if json_result.nil? || json_result.empty?
+        raise PDK::CLI::FatalError, 'Unit test output did not contain a valid JSON result: %{output}' % { output: result[:stdout] } if json_result.nil? || json_result.empty?
 
         json_result = merge_json_results(json_result) if options[:parallel]
 
@@ -174,7 +174,7 @@ module PDK
         return unless json_data['summary']
 
         # TODO: standardize summary output
-        $stderr.puts '  ' << _('Evaluated %{total} tests in %{duration} seconds: %{failures} failures, %{pending} pending.') % {
+        $stderr.puts '  ' << 'Evaluated %{total} tests in %{duration} seconds: %{failures} failures, %{pending} pending.' % {
           total: json_data['summary']['example_count'],
           duration: duration,
           failures: json_data['summary']['failure_count'],
@@ -230,15 +230,15 @@ module PDK
         environment = {}
         environment['PUPPET_GEM_VERSION'] = options[:puppet] if options[:puppet]
 
-        output = rake('spec_list_json', _('Finding unit tests.'), environment)
+        output = rake('spec_list_json', 'Finding unit tests.', environment)
 
         rspec_json = PDK::Util.find_first_json_in(output[:stdout])
-        raise PDK::CLI::FatalError, _('Failed to find valid JSON in output from rspec: %{output}' % { output: output[:stdout] }) unless rspec_json
+        raise PDK::CLI::FatalError, 'Failed to find valid JSON in output from rspec: %{output}' % { output: output[:stdout] } unless rspec_json
         if rspec_json['examples'].empty?
           rspec_message = rspec_json['messages'][0]
           return [] if rspec_message == 'No examples found.'
 
-          raise PDK::CLI::FatalError, _('Unable to enumerate examples. rspec reported: %{message}' % { message: rspec_message })
+          raise PDK::CLI::FatalError, 'Unable to enumerate examples. rspec reported: %{message}' % { message: rspec_message }
         else
           examples = []
           rspec_json['examples'].each do |example|

data/lib/pdk/util/bundler.rb

@@ -12,12 +12,12 @@ module PDK
         gem_overrides ||= { puppet: nil, hiera: nil, facter: nil }
 
         if already_bundled?(bundle.gemfile, gem_overrides)
-          PDK.logger.debug(_('Bundler managed gems already up to date.'))
+          PDK.logger.debug('Bundler managed gems already up to date.')
           return
         end
 
         unless bundle.gemfile?
-          PDK.logger.debug(_("No Gemfile found in '%{cwd}'. Skipping bundler management.") % { cwd: Dir.pwd })
+          PDK.logger.debug("No Gemfile found in '%{cwd}'. Skipping bundler management." % { cwd: Dir.pwd })
           return
         end
 
@@ -93,7 +93,7 @@ module PDK
         end
 
         def installed?(gem_overrides = {})
-          PDK.logger.debug(_('Checking for missing Gemfile dependencies.'))
+          PDK.logger.debug('Checking for missing Gemfile dependencies.')
 
           argv = ['check', "--gemfile=#{gemfile}", '--dry-run']
 
@@ -123,25 +123,25 @@ module PDK
             end
 
             unless vendored_gemfile_lock
-              raise PDK::CLI::FatalError, _('Vendored Gemfile.lock (%{source}) not found.') % {
+              raise PDK::CLI::FatalError, 'Vendored Gemfile.lock (%{source}) not found.' % {
                 source: vendored_gemfile_lock,
               }
             end
 
-            PDK.logger.debug(_('Using vendored Gemfile.lock from %{source}.') % { source: vendored_gemfile_lock })
+            PDK.logger.debug('Using vendored Gemfile.lock from %{source}.' % { source: vendored_gemfile_lock })
             PDK::Util::Filesystem.cp(vendored_gemfile_lock, File.join(PDK::Util.module_root, 'Gemfile.lock'))
           else
             argv = ['lock']
 
             cmd = bundle_command(*argv).tap do |c|
-              c.add_spinner(_('Resolving default Gemfile dependencies.'))
+              c.add_spinner('Resolving default Gemfile dependencies.')
             end
 
             result = cmd.execute!
 
             unless result[:exit_code].zero?
               PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n")) unless PDK.logger.debug?
-              raise PDK::CLI::FatalError, _('Unable to resolve default Gemfile dependencies.')
+              raise PDK::CLI::FatalError, 'Unable to resolve default Gemfile dependencies.'
             end
 
             # After initial lockfile generation, re-resolve json gem to built-in
@@ -154,7 +154,7 @@ module PDK
         end
 
         def update_lock!(options = {})
-          PDK.logger.debug(_('Updating Gemfile dependencies.'))
+          PDK.logger.debug('Updating Gemfile dependencies.')
 
           argv = ['lock', "--lockfile=#{gemfile_lock}", '--update']
 
@@ -182,7 +182,7 @@ module PDK
 
           unless result[:exit_code].zero?
             PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n")) unless PDK.logger.debug?
-            raise PDK::CLI::FatalError, _('Unable to resolve Gemfile dependencies.')
+            raise PDK::CLI::FatalError, 'Unable to resolve Gemfile dependencies.'
           end
 
           true
@@ -195,7 +195,7 @@ module PDK
           argv << '-j4' unless Gem.win_platform? && Gem::Version.new(PDK::Util::RubyVersion.active_ruby_version) < Gem::Version.new('2.3.5')
 
           cmd = bundle_command(*argv).tap do |c|
-            c.add_spinner(_('Installing missing Gemfile dependencies.'))
+            c.add_spinner('Installing missing Gemfile dependencies.')
             c.update_environment(gemfile_env(gem_overrides)) unless gem_overrides.empty?
           end
 
@@ -203,14 +203,14 @@ module PDK
 
           unless result[:exit_code].zero?
             PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n")) unless PDK.logger.debug?
-            raise PDK::CLI::FatalError, _('Unable to install missing Gemfile dependencies.')
+            raise PDK::CLI::FatalError, 'Unable to install missing Gemfile dependencies.'
           end
 
           true
         end
 
         def binstubs!(gems)
-          raise PDK::CLI::FatalError, _('Unable to install requested binstubs as the Gemfile is missing') if gemfile.nil?
+          raise PDK::CLI::FatalError, 'Unable to install requested binstubs as the Gemfile is missing' if gemfile.nil?
           binstub_dir = File.join(File.dirname(gemfile), 'bin')
           return true if gems.all? { |gem| PDK::Util::Filesystem.file?(File.join(binstub_dir, gem)) }
 
@@ -218,8 +218,8 @@ module PDK
           result = cmd.execute!
 
           unless result[:exit_code].zero?
-            PDK.logger.fatal(_("Failed to generate binstubs for '%{gems}':\n%{output}") % { gems: gems.join(' '), output: result.values_at(:stdout, :stderr).join("\n") }) unless PDK.logger.debug?
-            raise PDK::CLI::FatalError, _('Unable to install requested binstubs.')
+            PDK.logger.fatal("Failed to generate binstubs for '%{gems}':\n%{output}" % { gems: gems.join(' '), output: result.values_at(:stdout, :stderr).join("\n") }) unless PDK.logger.debug?
+            raise PDK::CLI::FatalError, 'Unable to install requested binstubs.'
           end
 
           true

data/lib/pdk/util/changelog_generator.rb

@@ -9,16 +9,14 @@ module PDK
 
       # Raises if the github_changelog_generator is not available
       def self.github_changelog_generator_available!
-        check_command = PDK::CLI::Exec::InteractiveCommand.new(PDK::CLI::Exec.bundle_bin, 'show', 'github_changelog_generator')
+        check_command = PDK::CLI::Exec::InteractiveCommand.new(PDK::CLI::Exec.bundle_bin, 'info', 'github_changelog_generator')
         check_command.context = :module
 
         result = check_command.execute!
 
         return if result[:exit_code].zero?
 
-        raise PDK::CLI::ExitWithError, _(
-          'Unable to generate the changelog as the %{gem} gem is not included in this module\'s Gemfile',
-        ) % { gem: GEM }
+        raise PDK::CLI::ExitWithError, 'Unable to generate the changelog as the %{gem} gem is not included in this module\'s Gemfile' % { gem: GEM }
       end
 
       # Runs the Changelog Generator gem (in the module's context) to automatically create a CHANGLELOG.MD file
@@ -31,11 +29,11 @@ module PDK
         changelog_command.context = :module
 
         result = changelog_command.execute!
-        raise PDK::CLI::ExitWithError, _('Error generating changelog: %{stdout}' % { stdout: result[:stdout] }) unless result[:exit_code].zero?
+        raise PDK::CLI::ExitWithError, 'Error generating changelog: %{stdout}' % { stdout: result[:stdout] } unless result[:exit_code].zero?
 
         output = changelog_content
 
-        raise PDK::CLI::ExitWithError, _('The generated changelog contains uncategorized Pull Requests. Please label them and try again. See %{changelog_file} for more details' % { changelog_file: changelog_file }) if output =~ %r{UNCATEGORIZED PRS; GO LABEL THEM} # rubocop:disable Metrics/LineLength
+        raise PDK::CLI::ExitWithError, 'The generated changelog contains uncategorized Pull Requests. Please label them and try again. See %{changelog_file} for more details' % { changelog_file: changelog_file } if output =~ %r{UNCATEGORIZED PRS; GO LABEL THEM} # rubocop:disable Metrics/LineLength
         output
       end
 
@@ -44,9 +42,9 @@ module PDK
       # @param current_version [String, Gem::Version] The current version of the module
       # @return [String] The new version. May be the same as the current version if there are no notable changes
       def self.compute_next_version(current_version)
-        raise PDK::CLI::ExitWithError, _('Invalid version string %{version}' % { version: current_version }) unless current_version =~ VERSION_REGEX
+        raise PDK::CLI::ExitWithError, 'Invalid version string %{version}' % { version: current_version } unless current_version =~ VERSION_REGEX
         version = Gem::Version.create(current_version).segments
-        PDK.logger.info _('Determing the target version from \'%{file}\'') % { file: changelog_file }
+        PDK.logger.info 'Determing the target version from \'%{file}\'' % { file: changelog_file }
 
         # Grab all lines that start with ## between from the latest changes
         # For example given the changelog below