pdk 2.7.0 → 3.0.0

data/lib/pdk/module/build.rb

@@ -7,8 +7,7 @@ module PDK
         new(options).build
       end
 
-      attr_reader :module_dir
-      attr_reader :target_dir
+      attr_reader :module_dir, :target_dir
 
       def initialize(options = {})
         @module_dir = PDK::Util::Filesystem.expand_path(options[:module_dir] || Dir.pwd)
@@ -86,7 +85,7 @@ module PDK
       def release_name
         @release_name ||= [
           metadata['name'],
-          metadata['version'],
+          metadata['version']
         ].join('-')
       end
 
@@ -126,8 +125,8 @@ module PDK
           PDK::Util::Filesystem.cp(path, dest_path, preserve: true)
         end
       rescue ArgumentError => e
-        raise PDK::CLI::ExitWithError, '%{message} Rename the file or exclude it from the package ' \
-                                       'by adding it to the .pdkignore file in your module.' % { message: e.message }
+        raise PDK::CLI::ExitWithError, format('%{message} Rename the file or exclude it from the package ' \
+                                              'by adding it to the .pdkignore file in your module.', message: e.message)
       end
 
       # Check if the given path matches one of the patterns listed in the
@@ -137,7 +136,7 @@ module PDK
       #
       # @return [Boolean] true if the path matches and should be ignored.
       def ignored_path?(path)
-        path = path.to_s + '/' if PDK::Util::Filesystem.directory?(path)
+        path = "#{path}/" if PDK::Util::Filesystem.directory?(path)
 
         !ignored_files.match_paths([path], module_dir).empty?
       end
@@ -154,10 +153,8 @@ module PDK
         symlink_path = Pathname.new(path)
         module_path = Pathname.new(module_dir)
 
-        PDK.logger.warn 'Symlinks in modules are not supported and will not be included in the package. Please investigate symlink %{from} -> %{to}.' % {
-          from: symlink_path.relative_path_from(module_path),
-          to:   symlink_path.realpath.relative_path_from(module_path),
-        }
+        PDK.logger.warn format('Symlinks in modules are not supported and will not be included in the package. Please investigate symlink %{from} -> %{to}.',
+                               from: symlink_path.relative_path_from(module_path), to: symlink_path.realpath.relative_path_from(module_path))
       end
 
       # Checks if the path length will fit into the POSIX.1-1998 (ustar) tar
@@ -180,11 +177,7 @@ module PDK
       #
       # @return [nil]
       def validate_ustar_path!(path)
-        if path.bytesize > 256
-          raise ArgumentError, "The path '%{path}' is longer than 256 bytes." % {
-            path: path,
-          }
-        end
+        raise ArgumentError, format("The path '%{path}' is longer than 256 bytes.", path: path) if path.bytesize > 256
 
         if path.bytesize <= 100
           prefix = ''
@@ -196,6 +189,7 @@ module PDK
           loop do
             nxt = parts.pop || ''
             break if newpath.bytesize + 1 + nxt.bytesize >= 100
+
             newpath = File.join(nxt, newpath)
           end
 
@@ -206,9 +200,9 @@ module PDK
         return unless path.bytesize > 100 || prefix.bytesize > 155
 
         raise ArgumentError,
-              "'%{path}' could not be split at a directory separator into two " \
-              'parts, the first having a maximum length of 155 bytes and the ' \
-              'second having a maximum length of 100 bytes.' % { path: path }
+              format("'%{path}' could not be split at a directory separator into two " \
+                     'parts, the first having a maximum length of 155 bytes and the ' \
+                     'second having a maximum length of 100 bytes.', path: path)
       end
 
       # Checks if the path contains any non-ASCII characters.
@@ -224,10 +218,10 @@ module PDK
       #
       # @return [nil]
       def validate_path_encoding!(path)
-        return unless path =~ %r{[^\x00-\x7F]}
+        return unless /[^\x00-\x7F]/.match?(path)
 
-        raise ArgumentError, "'%{path}' can only include ASCII characters in its path or " \
-                             'filename in order to be compatible with a wide range of hosts.' % { path: path }
+        raise ArgumentError, format("'%{path}' can only include ASCII characters in its path or " \
+                                    'filename in order to be compatible with a wide range of hosts.', path: path)
       end
 
       # Creates a gzip compressed tarball of the build directory.
@@ -244,31 +238,24 @@ module PDK
         PDK::Util::Filesystem.rm_f(package_file)
 
         Dir.chdir(target_dir) do
-          begin
-            gz = Zlib::GzipWriter.new(File.open(package_file, 'wb')) # rubocop:disable PDK/FileOpen
-            tar = Minitar::Output.new(gz)
-            Find.find(release_name) do |entry|
-              entry_meta = {
-                name: entry,
-              }
-
-              orig_mode = PDK::Util::Filesystem.stat(entry).mode
-              min_mode = Minitar.dir?(entry) ? 0o755 : 0o644
-
-              entry_meta[:mode] = orig_mode | min_mode
-
-              if entry_meta[:mode] != orig_mode
-                PDK.logger.debug('Updated permissions of packaged \'%{entry}\' to %{new_mode}' % {
-                  entry: entry,
-                  new_mode: (entry_meta[:mode] & 0o7777).to_s(8),
-                })
-              end
-
-              Minitar.pack_file(entry_meta, tar)
-            end
-          ensure
-            tar.close
+          gz = Zlib::GzipWriter.new(File.open(package_file, 'wb')) # rubocop:disable PDK/FileOpen
+          tar = Minitar::Output.new(gz)
+          Find.find(release_name) do |entry|
+            entry_meta = {
+              name: entry
+            }
+
+            orig_mode = PDK::Util::Filesystem.stat(entry).mode
+            min_mode = Minitar.dir?(entry) ? 0o755 : 0o644
+
+            entry_meta[:mode] = orig_mode | min_mode
+
+            PDK.logger.debug(format('Updated permissions of packaged \'%{entry}\' to %{new_mode}', entry: entry, new_mode: (entry_meta[:mode] & 0o7777).to_s(8))) if entry_meta[:mode] != orig_mode
+
+            Minitar.pack_file(entry_meta, tar)
           end
+        ensure
+          tar.close
         end
       end
 
@@ -283,7 +270,7 @@ module PDK
         @ignore_file ||= [
           File.join(module_dir, '.pdkignore'),
           File.join(module_dir, '.pmtignore'),
-          File.join(module_dir, '.gitignore'),
+          File.join(module_dir, '.gitignore')
         ].find { |file| PDK::Util::Filesystem.file?(file) && PDK::Util::Filesystem.readable?(file) }
       end
 
@@ -303,9 +290,7 @@ module PDK
                         PathSpec.new(PDK::Util::Filesystem.read_file(ignore_file, open_args: 'rb:UTF-8'))
                       end
 
-            if File.realdirpath(target_dir).start_with?(File.realdirpath(module_dir))
-              ignored = ignored.add("\/#{File.basename(target_dir)}\/")
-            end
+            ignored = ignored.add("/#{File.basename(target_dir)}/") if File.realdirpath(target_dir).start_with?(File.realdirpath(module_dir))
 
             PDK::Module::DEFAULT_IGNORED.each { |r| ignored.add(r) }
 

data/lib/pdk/module/convert.rb

@@ -7,9 +7,7 @@ module PDK
         new(module_dir, options).run
       end
 
-      attr_reader :module_dir
-
-      attr_reader :options
+      attr_reader :module_dir, :options
 
       def initialize(module_dir, options = {})
         @module_dir = module_dir
@@ -100,6 +98,7 @@ module PDK
 
       def test_generators(context = PDK.context)
         return @test_generators unless @test_generators.nil?
+
         require 'pdk/util/puppet_strings'
 
         test_gens = PDK::Util::PuppetStrings.all_objects.map do |generator, objects|
@@ -153,13 +152,11 @@ module PDK
             absolute_file_path = File.join(module_dir, relative_file_path)
             case file_status
             when :unmanage
-              PDK.logger.debug("skipping '%{path}'" % { path: absolute_file_path })
+              PDK.logger.debug(format("skipping '%{path}'", path: absolute_file_path))
             when :delete
               update_manager.remove_file(absolute_file_path)
             when :init
-              if convert? && !PDK::Util::Filesystem.exist?(absolute_file_path)
-                update_manager.add_file(absolute_file_path, file_content)
-              end
+              update_manager.add_file(absolute_file_path, file_content) if convert? && !PDK::Util::Filesystem.exist?(absolute_file_path)
             when :manage
               if PDK::Util::Filesystem.exist?(absolute_file_path)
                 update_manager.modify_file(absolute_file_path, file_content)
@@ -191,11 +188,7 @@ module PDK
         require 'pdk/module/metadata'
 
         if PDK::Util::Filesystem.file?(metadata_path)
-          unless PDK::Util::Filesystem.readable?(metadata_path)
-            raise PDK::CLI::ExitWithError, 'Unable to update module metadata; %{path} exists but it is not readable.' % {
-              path: metadata_path,
-            }
-          end
+          raise PDK::CLI::ExitWithError, format('Unable to update module metadata; %{path} exists but it is not readable.', path: metadata_path) unless PDK::Util::Filesystem.readable?(metadata_path)
 
           begin
             metadata = PDK::Module::Metadata.from_file(metadata_path)
@@ -208,9 +201,7 @@ module PDK
             metadata = PDK::Generate::Module.prepare_metadata(options) unless options[:noop]
           end
         elsif PDK::Util::Filesystem.exist?(metadata_path)
-          raise PDK::CLI::ExitWithError, 'Unable to update module metadata; %{path} exists but it is not a file.' % {
-            path: metadata_path,
-          }
+          raise PDK::CLI::ExitWithError, format('Unable to update module metadata; %{path} exists but it is not a file.', path: metadata_path)
         else
           return if options[:noop]
 
@@ -250,23 +241,23 @@ module PDK
 
         footer = false
 
-        summary.keys.each do |category|
+        summary.each_key do |category|
           next if summary[category].empty?
 
-          PDK::Report.default_target.puts("\n%{banner}" % { banner: generate_banner("Files to be #{category}", 40) })
+          PDK::Report.default_target.puts(format("\n%{banner}", banner: generate_banner("Files to be #{category}", 40)))
           PDK::Report.default_target.puts(summary[category])
           footer = true
         end
 
-        PDK::Report.default_target.puts("\n%{banner}" % { banner: generate_banner('', 40) }) if footer
+        PDK::Report.default_target.puts(format("\n%{banner}", banner: generate_banner('', 40))) if footer
       end
 
       def print_result(banner_text)
         require 'pdk/report'
 
-        PDK::Report.default_target.puts("\n%{banner}" % { banner: generate_banner(banner_text, 40) })
-        summary_to_print = summary.map { |k, v| "#{v.length} files #{k}" unless v.empty? }.compact
-        PDK::Report.default_target.puts("\n%{summary}\n\n" % { summary: "#{summary_to_print.join(', ')}." })
+        PDK::Report.default_target.puts(format("\n%{banner}", banner: generate_banner(banner_text, 40)))
+        summary_to_print = summary.filter_map { |k, v| "#{v.length} files #{k}" unless v.empty? }
+        PDK::Report.default_target.puts(format("\n%{summary}\n\n", summary: "#{summary_to_print.join(', ')}."))
       end
 
       def full_report(path)
@@ -275,7 +266,7 @@ module PDK
         report = ["/* Report generated by PDK at #{Time.now} */"]
         report.concat(update_manager.changes[:modified].map { |_, diff| "\n\n\n#{diff}" })
         PDK::Util::Filesystem.write_file(path, report.join)
-        PDK::Report.default_target.puts("\nYou can find a report of differences in %{path}.\n\n" % { path: path })
+        PDK::Report.default_target.puts(format("\nYou can find a report of differences in %{path}.\n\n", path: path))
       end
 
       def generate_banner(text, width = 80)

data/lib/pdk/module/metadata.rb

@@ -8,81 +8,79 @@ module PDK
       OPERATING_SYSTEMS = {
         'RedHat based Linux' => [
           {
-            'operatingsystem'        => 'CentOS',
-            'operatingsystemrelease' => ['7'],
+            'operatingsystem' => 'CentOS',
+            'operatingsystemrelease' => ['7']
           },
           {
-            'operatingsystem'        => 'OracleLinux',
-            'operatingsystemrelease' => ['7'],
+            'operatingsystem' => 'OracleLinux',
+            'operatingsystemrelease' => ['7']
           },
           {
-            'operatingsystem'        => 'RedHat',
-            'operatingsystemrelease' => ['8'],
+            'operatingsystem' => 'RedHat',
+            'operatingsystemrelease' => ['8']
           },
           {
-            'operatingsystem'        => 'Scientific',
-            'operatingsystemrelease' => ['7'],
-          },
+            'operatingsystem' => 'Scientific',
+            'operatingsystemrelease' => ['7']
+          }
         ],
         'Debian based Linux' => [
           {
-            'operatingsystem'        => 'Debian',
-            'operatingsystemrelease' => ['10'],
+            'operatingsystem' => 'Debian',
+            'operatingsystemrelease' => ['10']
           },
           {
-            'operatingsystem'        => 'Ubuntu',
-            'operatingsystemrelease' => ['18.04'],
-          },
+            'operatingsystem' => 'Ubuntu',
+            'operatingsystemrelease' => ['18.04']
+          }
         ],
         'Fedora' => {
-          'operatingsystem'        => 'Fedora',
-          'operatingsystemrelease' => ['29'],
+          'operatingsystem' => 'Fedora',
+          'operatingsystemrelease' => ['29']
         },
         'OSX' => {
-          'operatingsystem'        => 'Darwin',
-          'operatingsystemrelease' => ['16'],
+          'operatingsystem' => 'Darwin',
+          'operatingsystemrelease' => ['16']
         },
         'SLES' => {
-          'operatingsystem'        => 'SLES',
-          'operatingsystemrelease' => ['15'],
+          'operatingsystem' => 'SLES',
+          'operatingsystemrelease' => ['15']
         },
         'Solaris' => {
-          'operatingsystem'        => 'Solaris',
-          'operatingsystemrelease' => ['11'],
+          'operatingsystem' => 'Solaris',
+          'operatingsystemrelease' => ['11']
         },
         'Windows' => {
-          'operatingsystem'        => 'windows',
-          'operatingsystemrelease' => %w[2019 10],
+          'operatingsystem' => 'windows',
+          'operatingsystemrelease' => ['2019', '10']
         },
         'AIX' => {
-          'operatingsystem'        => 'AIX',
-          'operatingsystemrelease' => %w[6.1 7.1 7.2],
-        },
+          'operatingsystem' => 'AIX',
+          'operatingsystemrelease' => ['6.1', '7.1', '7.2']
+        }
       }.freeze
 
       DEFAULT_OPERATING_SYSTEMS = [
         'RedHat based Linux',
         'Debian based Linux',
-        'Windows',
+        'Windows'
       ].freeze
 
       DEFAULTS = {
-        'name'          => nil,
-        'version'       => '0.1.0',
-        'author'        => nil,
-        'summary'       => '',
-        'license'       => 'Apache-2.0',
-        'source'        => '',
-        'project_page'  => nil,
-        'issues_url'    => nil,
-        'dependencies'  => [],
+        'name' => nil,
+        'version' => '0.1.0',
+        'author' => nil,
+        'summary' => '',
+        'license' => 'Apache-2.0',
+        'source' => '',
+        'project_page' => nil,
+        'issues_url' => nil,
+        'dependencies' => [],
         'data_provider' => nil,
-        'operatingsystem_support' => DEFAULT_OPERATING_SYSTEMS.map { |os_name|
-          OPERATING_SYSTEMS[os_name]
-        }.flatten,
+        'operatingsystem_support' => DEFAULT_OPERATING_SYSTEMS.dup,
         'requirements' => [
-          { 'name' => 'puppet', 'version_requirement' => '>= 6.21.0 < 8.0.0' },
-        ],
+          { 'name' => 'puppet', 'version_requirement' => '>= 7.24 < 9.0.0' }
+        ]
       }.freeze
 
       def initialize(params = {})
@@ -91,23 +89,17 @@ module PDK
       end
 
       def self.from_file(metadata_json_path)
-        if metadata_json_path.nil?
-          raise ArgumentError, 'Cannot read metadata from file: no path to file was given.'
-        end
+        raise ArgumentError, 'Cannot read metadata from file: no path to file was given.' if metadata_json_path.nil?
 
-        unless PDK::Util::Filesystem.file?(metadata_json_path)
-          raise ArgumentError, "'%{file}' does not exist or is not a file." % { file: metadata_json_path }
-        end
+        raise ArgumentError, format("'%{file}' does not exist or is not a file.", file: metadata_json_path) unless PDK::Util::Filesystem.file?(metadata_json_path)
 
-        unless PDK::Util::Filesystem.readable?(metadata_json_path)
-          raise ArgumentError, "Unable to open '%{file}' for reading." % { file: metadata_json_path }
-        end
+        raise ArgumentError, format("Unable to open '%{file}' for reading.", file: metadata_json_path) unless PDK::Util::Filesystem.readable?(metadata_json_path)
 
         require 'json'
         begin
           data = JSON.parse(PDK::Util::Filesystem.read_file(metadata_json_path))
         rescue JSON::JSONError => e
-          raise ArgumentError, 'Invalid JSON in metadata.json: %{msg}' % { msg: e.message }
+          raise ArgumentError, format('Invalid JSON in metadata.json: %{msg}', msg: e.message)
         end
 
         require 'pdk/util'
@@ -122,10 +114,10 @@ module PDK
         self
       end
 
-      def to_json
+      def to_json(*_args)
         require 'json'
 
-        JSON.pretty_generate(@data.dup.delete_if { |_key, value| value.nil? })
+        JSON.pretty_generate(@data.dup.delete_if { |_key, value| value.nil? }) # rubocop:disable Style/CollectionCompact
       end
 
       def write!(path)
@@ -144,9 +136,9 @@ module PDK
 
       def validate_puppet_version_requirement!
         msgs = {
-          no_reqs:       'Module metadata does not contain any requirements.',
+          no_reqs: 'Module metadata does not contain any requirements.',
           no_puppet_req: 'Module metadata does not contain a "puppet" requirement.',
-          no_puppet_ver: 'The "puppet" requirement in module metadata does not specify a "version_requirement".',
+          no_puppet_ver: 'The "puppet" requirement in module metadata does not specify a "version_requirement".'
         }
 
         raise ArgumentError, msgs[:no_reqs] unless @data.key?('requirements')
@@ -162,7 +154,7 @@ module PDK
       end
 
       def missing_fields
-        fields = DEFAULTS.keys - %w[data_provider requirements dependencies]
+        fields = DEFAULTS.keys - ['data_provider', 'requirements', 'dependencies']
         fields.select { |key| @data[key].nil? || @data[key].empty? }
       end
 
@@ -179,7 +171,7 @@ module PDK
 
       # Validates that the given module name is both namespaced and well-formed.
       def validate_name(name)
-        return if name =~ %r{\A[a-z0-9]+[-\/][a-z][a-z0-9_]*\Z}i
+        return if %r{\A[a-z0-9]+[-/][a-z][a-z0-9_]*\Z}i.match?(name)
 
         namespace, modname = name.split(%r{[-/]}, 2)
         modname = :namespace_missing if namespace == ''
@@ -187,15 +179,15 @@ module PDK
         err = case modname
               when nil, '', :namespace_missing
                 'Field must be a dash-separated user name and module name.'
-              when %r{[^a-z0-9_]}i
+              when /[^a-z0-9_]/i
                 'Module name must contain only alphanumeric or underscore characters.'
-              when %r{^[^a-z]}i
+              when /^[^a-z]/i
                 'Module name must begin with a letter.'
               else
                 'Namespace must contain only alphanumeric characters.'
               end
 
-        raise ArgumentError, "Invalid 'name' field in metadata.json: %{err}" % { err: err }
+        raise ArgumentError, format("Invalid 'name' field in metadata.json: %{err}", err: err)
       end
     end
   end

data/lib/pdk/module/release.rb

@@ -8,9 +8,7 @@ module PDK
         new(module_path, options).run
       end
 
-      attr_reader :options
-
-      attr_reader :module_path
+      attr_reader :options, :module_path
 
       def initialize(module_path, options = {})
         @options = options
@@ -21,9 +19,10 @@ module PDK
 
         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' 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, format('%{module_path} is not a valid module', module_path: module_path) unless PDK::Util.in_module_root?(module_path)
+
         @module_path = module_path
       end
 
@@ -41,24 +40,17 @@ module PDK
 
         run_validations(options) unless skip_validation?
 
-        PDK.logger.info 'Releasing %{module_name} - from version %{module_version}' % {
-          module_name:    module_metadata.data['name'],
-          module_version: module_metadata.data['version'],
-        }
+        PDK.logger.info format('Releasing %{module_name} - from version %{module_version}', module_name: module_metadata.data['name'], module_version: module_metadata.data['version'])
 
         PDK::Util::ChangelogGenerator.generate_changelog unless skip_changelog?
 
         # Calculate the new module version
         new_version = specified_version
-        if new_version.nil? && !skip_changelog?
-          new_version = PDK::Util::ChangelogGenerator.compute_next_version(module_metadata.data['version'])
-        end
+        new_version = PDK::Util::ChangelogGenerator.compute_next_version(module_metadata.data['version']) if new_version.nil? && !skip_changelog?
         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}' % {
-            module_version: new_version,
-          }
+          PDK.logger.info format('Updating version to %{module_version}', module_version: new_version)
 
           # Set the new version in metadata file
           module_metadata.data['version'] = new_version
@@ -69,8 +61,8 @@ 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
+          if !latest_version && (new_version != latest_version)
+            raise PDK::CLI::ExitWithError, format('%{new_version} does not match %{latest_version}', new_version: new_version, latest_version: latest_version)
           end
         end
 
@@ -102,6 +94,7 @@ module PDK
 
       def default_package_filename
         return @default_tarball_filename unless @default_tarball_filename.nil?
+
         builder = PDK::Module::Build.new(module_dir: module_path)
         @default_tarball_filename = builder.package_file
       end
@@ -127,7 +120,7 @@ module PDK
         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, format('An error occured generating the module documentation: %{stdout}', stdout: result[:stdout]) unless result[:exit_code].zero?
       end
 
       def run_dependency_checker(_opts)
@@ -138,7 +131,7 @@ module PDK
         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, format('An error occured checking the module dependencies: %{stdout}', stdout: result[:stdout]) unless result[:exit_code].zero?
       end
 
       # @return [String] Path to the built tarball
@@ -148,7 +141,7 @@ 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, format('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'
@@ -158,19 +151,20 @@ module PDK
         uri = URI(forge_upload_url)
         require 'net/http'
         request = Net::HTTP::Post.new(uri.path)
-        request['Authorization'] = 'Bearer ' + forge_token
+        request['Authorization'] = "Bearer #{forge_token}"
         request['Content-Type'] = 'application/json'
         data = { file: file_data }
 
         request.body = data.to_json
 
         require 'openssl'
-        use_ssl = uri.class == URI::HTTPS
+        use_ssl = uri.instance_of?(URI::HTTPS)
         response = Net::HTTP.start(uri.host, uri.port, use_ssl: use_ssl) do |http|
           http.request(request)
         end
 
-        raise PDK::CLI::ExitWithError, 'Error uploading to Puppet Forge: %{result}' % { result: response.body } unless response.is_a?(Net::HTTPSuccess)
+        raise PDK::CLI::ExitWithError, format('Error uploading to Puppet Forge: %{result}', result: response.body) unless response.is_a?(Net::HTTPSuccess)
+
         PDK.logger.info 'Publish to Forge was successful'
       end
 
@@ -235,7 +229,7 @@ module PDK
         !skip_publish?
       end
 
-      #:nocov:
+      # :nocov:
       # These are just convenience methods and are tested elsewhere
       def forge_compatible?
         module_metadata.forge_ready?
@@ -247,7 +241,7 @@ module PDK
         builder = PDK::Module::Build.new(module_dir: module_path)
         @pdk_compatible = builder.module_pdk_compatible?
       end
-      #:nocov:
+      # :nocov:
 
       private
 

data/lib/pdk/module/update.rb

@@ -3,18 +3,14 @@ require 'pdk'
 module PDK
   module Module
     class Update < Convert
-      GIT_DESCRIBE_PATTERN = %r{\A(?<base>.+?)-(?<additional_commits>\d+)-g(?<sha>.+)\Z}
+      GIT_DESCRIBE_PATTERN = /\A(?<base>.+?)-(?<additional_commits>\d+)-g(?<sha>.+)\Z/.freeze
 
       def run
         template_uri.uri_fragment = new_template_version
 
         stage_changes!
 
-        if current_version == new_version
-          PDK.logger.debug 'This module is already up to date with version %{version} of the template.' % {
-            version: new_version,
-          }
-        end
+        PDK.logger.debug format('This module is already up to date with version %{version} of the template.', version: new_version) if current_version == new_version
 
         unless update_manager.changes?
           PDK::Report.default_target.puts('No changes required.')
@@ -97,7 +93,7 @@ module PDK
 
         return data if data.nil?
 
-        if data[:base] =~ %r{^(?:heads|remotes)/}
+        if %r{^(?:heads|remotes)/}.match?(data[:base])
           "#{data[:base].gsub(%r{^(heads/|remotes/\w+?/)}, '')}@#{data[:sha]}"
         else
           data[:base]
@@ -119,12 +115,7 @@ module PDK
                           'Updating %{module_name} using the template at %{template_url}, from %{current_version} to %{new_version}'
                         end
 
-        format_string % {
-          module_name:     module_metadata.data['name'],
-          template_url:    template_uri.bare_uri,
-          current_version: current_version,
-          new_version:     new_version,
-        }
+        format(format_string, module_name: module_metadata.data['name'], template_url: template_uri.bare_uri, current_version: current_version, new_version: new_version)
       end
     end
   end