pdk 2.7.0 → 3.0.0

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(format("Rendering '%{template}'...", template: template_file))
             new_template_file(template_file, template_data_hash).render
           end
 
@@ -30,34 +30,34 @@ module PDK
           # @param item_path [String] The path of the single item to render
           # @return [String]
           # @api private
-          #:nocov:
+          # :nocov:
           def single_item_path(item_path)
             File.join(template_root, 'object_templates', item_path)
           end
-          #:nocov:
+          # :nocov:
 
           # Helper method used during testing
-          #:nocov:
+          # :nocov:
           # @api private
           def new_template_file(template_file, template_data_hash)
             TemplateFile.new(template_file, template_data_hash)
           end
-          #:nocov:
+          # :nocov:
 
           # Helper method used during testing
-          #:nocov:
+          # :nocov:
           # @api private
           def new_legacy_template_dir(context, uri, path, module_metadata = {})
             LegacyTemplateDir.new(context, uri, path, module_metadata)
           end
-          #:nocov:
+          # :nocov:
 
           # Renders a new module
           #
           # @param options [Hash{Object => Object}] A list of options to pass through to the renderer. See PDK::Template::TemplateDir helper methods for other options
           # @see #render
           # @api private
-          #:nocov: This is tested in acceptance and packaging tests
+          # :nocov: This is tested in acceptance and packaging tests
           def render_module(options = {})
             require 'pdk/template/renderer/v1/template_file'
 
@@ -71,8 +71,8 @@ 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 })
-              dest_path = template_file.sub(%r{\.erb\Z}, '')
+              PDK.logger.debug(format("Rendering '%{template}'...", template: template_file))
+              dest_path = template_file.sub(/\.erb\Z/, '')
               config = legacy_template_dir.config_for(dest_path)
 
               dest_status = if template_loc.start_with?(moduleroot_init)
@@ -88,9 +88,9 @@ module PDK
               else
                 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 }
+                rescue StandardError => e
+                  error_msg = format("Failed to render template '%{template}'\n" \
+                                     '%{exception}: %{message}', template: template_file, exception: e.class, message: e.message)
                   raise PDK::CLI::FatalError, error_msg
                 end
               end
@@ -98,7 +98,7 @@ module PDK
               yield dest_path, dest_content, dest_status
             end
           end
-          #:nocov:
+          # :nocov:
 
           # Returns all files in the given template directories
           #
@@ -111,17 +111,16 @@ 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, format("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
-                end
+                dirlocs << dir if PDK::Util::Filesystem.file?(template_path) && !PDK::Util::Filesystem.symlink?(template_path)
               end
               temp_paths.map do |template_path|
-                template_path.sub!(%r{\A#{Regexp.escape(dir)}#{Regexp.escape(File::SEPARATOR)}}, '')
+                template_path.sub!(/\A#{Regexp.escape(dir)}#{Regexp.escape(File::SEPARATOR)}/, '')
               end
             end
-            Hash[temp_paths.zip dirlocs]
+            (temp_paths.zip dirlocs).to_h
           end
         end
       end

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

@@ -20,9 +20,7 @@ module PDK
           def initialize(template_file, data = {})
             @template_file = template_file
 
-            if data.key?(:configs)
-              @configs = data[:configs]
-            end
+            @configs = data[:configs] if data.key?(:configs)
 
             super(data)
           end
@@ -65,11 +63,9 @@ module PDK
           #
           # @api private
           def template_content
-            if PDK::Util::Filesystem.file?(@template_file) && PDK::Util::Filesystem.readable?(@template_file)
-              return PDK::Util::Filesystem.read_file(@template_file)
-            end
+            return PDK::Util::Filesystem.read_file(@template_file) if PDK::Util::Filesystem.file?(@template_file) && PDK::Util::Filesystem.readable?(@template_file)
 
-            raise ArgumentError, "'%{template}' is not a readable file" % { template: @template_file }
+            raise ArgumentError, format("'%{template}' is not a readable file", template: @template_file)
           end
 
           # Renders the content of the template file as an ERB template.
@@ -82,7 +78,7 @@ module PDK
           def render_erb
             require 'erb'
 
-            renderer = ERB.new(template_content, nil, '-')
+            renderer = ERB.new(template_content, trim_mode: '-')
             renderer.filename = @template_file
             renderer.result(binding)
           end

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

@@ -11,7 +11,7 @@ module PDK
         # Whether the template directory and context are valid for the V1 renderer
         # @see PDK::Template::Renderer.instance
         def self.compatible?(template_root, _context)
-          %w[moduleroot moduleroot_init].all? { |dir| PDK::Util::Filesystem.directory?(File.join(template_root, dir)) }
+          ['moduleroot', 'moduleroot_init'].all? { |dir| PDK::Util::Filesystem.directory?(File.join(template_root, dir)) }
         end
 
         # Creates an instance of the V1 Renderer

data/lib/pdk/template/renderer.rb

@@ -14,6 +14,7 @@ module PDK
       # @return [AbstractRenderer, nil] An instance of an AbstractRenderer subclass. Returns nil if no renderer could be found
       def self.instance(template_uri, template_root, context)
         return V1.instance(template_root, template_uri, context) if V1.compatible?(template_root, context)
+
         nil
       end
 

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 format('Could not find a compatible template renderer for %{path}', path: path) if @renderer.nil?
       end
 
       # Later additions may include Control Repo rendering, for example
@@ -48,7 +48,7 @@ module PDK
       # def render_new_control_repo(name, repo_metadata = {}, options = {})
       #   render(CONTROL_REPO_TEMPLATE_TYPE, name, options.merge(include_first_time: true, control_repo_metadata: repo_metadata)) { |*args| yield(*args) }
       # end
-      #:nocov: These are just helper methods and are tested elsewhere.
+      # :nocov: These are just helper methods and are tested elsewhere.
 
       # Render an existing module
       # @see PDK::Template::Renderer::AbstractRenderer.render
@@ -61,7 +61,7 @@ module PDK
       def render_new_module(module_name, module_metadata = {}, options = {})
         @renderer.render(MODULE_TEMPLATE_TYPE, module_name, options.merge(include_first_time: true, module_metadata: module_metadata)) { |*args| yield(*args) }
       end
-      #:nocov:
+      # :nocov:
     end
   end
 end

data/lib/pdk/template.rb

@@ -37,12 +37,8 @@ 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 }
-      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 }
-      end
+      raise ArgumentError, format('%{class_name}.with must be passed a block.', class_name: name) unless block_given?
+      raise ArgumentError, format('%{class_name}.with must be passed a PDK::Util::TemplateURI, got a %{uri_type}', uri_type: uri.class, class_name: name) unless uri.is_a? PDK::Util::TemplateURI
 
       Fetcher.with(uri) do |fetcher|
         template_dir = TemplateDir.instance(uri, fetcher.path, context)

data/lib/pdk/tests/unit.rb

@@ -48,14 +48,14 @@ module PDK
 
       def self.parallel_with_no_tests?(ran_in_parallel, json_result, result)
         ran_in_parallel && json_result.empty? &&
-          ((!result[:exit_code].zero? && result[:stderr].strip =~ %r{Pass files or folders to run$}) ||
-           result[:stderr].strip =~ %r{No files for parallel_spec to run against$})
+          ((!result[:exit_code].zero? && result[:stderr].strip =~ /Pass files or folders to run$/) ||
+           result[:stderr].strip =~ /No files for parallel_spec to run against$/)
       end
 
       def self.print_failure(result, exception)
         $stderr.puts ''
-        result[:stdout].each_line { |line| $stderr.puts line.rstrip } unless result[:stdout].nil?
-        result[:stderr].each_line { |line| $stderr.puts line.rstrip } unless result[:stderr].nil?
+        result[:stdout]&.each_line { |line| $stderr.puts line.rstrip }
+        result[:stderr]&.each_line { |line| $stderr.puts line.rstrip }
         $stderr.puts ''
         raise PDK::CLI::FatalError, exception
       end
@@ -95,7 +95,7 @@ module PDK
         # Ref - https://github.com/puppetlabs/pdk/issues/828
         tests = tests.tr('\\', '/') unless tests.nil?
 
-        environment = { 'CI_SPEC_OPTIONS' => '--format j' }
+        environment = {}
         environment['PUPPET_GEM_VERSION'] = options[:puppet] if options[:puppet]
         spinner_msg = options[:parallel] ? 'Running unit tests in parallel.' : 'Running unit tests.'
 
@@ -109,6 +109,17 @@ module PDK
           return result[:exit_code]
         end
 
+        # Run interactive_rake for documentation output when utilising verbose option.
+        if (options[:verbose]) && (options[:format])
+          environment['CI_SPEC_OPTIONS'] = '--format documentation'
+          result = interactive_rake(cmd(tests, options), environment)
+          # Caveat: Report will not be written to format option(s) file(s) when there are event failures.
+          return result[:exit_code] unless (result[:exit_code]).zero?
+
+          spinner_msg = "Exporting unit tests -> #{options[:format]}"
+        end
+
+        environment['CI_SPEC_OPTIONS'] = '--format j'
         result = rake(cmd(tests, options), spinner_msg, environment)
 
         json_result = if options[:parallel]
@@ -122,7 +133,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, format('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]
 
@@ -135,38 +146,38 @@ module PDK
 
       def self.parse_output(report, json_data, duration)
         # Output messages to stderr.
-        json_data['messages'] && json_data['messages'].each { |msg| $stderr.puts msg }
+        json_data['messages']&.each { |msg| $stderr.puts msg }
 
         example_results = {
           # Only possibilities are passed, failed, pending:
           # https://github.com/rspec/rspec-core/blob/main/lib/rspec/core/example.rb#L548
           'passed' => [],
           'failed' => [],
-          'pending' => [],
+          'pending' => []
         }
 
-        json_data['examples'] && json_data['examples'].each do |ex|
+        json_data['examples']&.each do |ex|
           example_results[ex['status']] << ex if example_results.key?(ex['status'])
         end
 
         example_results.each do |result, examples|
           # Translate rspec example results to JUnit XML testcase results
-          state = case result
-                  when 'passed' then :passed
-                  when 'failed' then :failure
-                  when 'pending' then :skipped
-                  end
+          state_map = {
+            'passed' => :passed,
+            'failed' => :failure,
+            'pending' => :skipped
+          }
 
           examples.each do |ex|
             report.add_event(
               source: 'rspec',
-              state: state,
+              state: state_map[result],
               file: ex['file_path'],
               line: ex['line_number'],
               test: ex['full_description'],
               severity: ex['status'],
               message: ex['pending_message'] || (ex['exception'] && ex['exception']['message']) || nil,
-              trace: (ex['exception'] && ex['exception']['backtrace']) || nil,
+              trace: (ex['exception'] && ex['exception']['backtrace']) || nil
             )
           end
         end
@@ -174,12 +185,8 @@ module PDK
         return unless json_data['summary']
 
         # TODO: standardize summary output
-        $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'],
-          pending: json_data['summary']['pending_count'],
-        }
+        $stderr.puts '  ' << (format('Evaluated %{total} tests in %{duration} seconds: %{failures} failures, %{pending} pending.', total: json_data['summary']['example_count'], duration: duration,
+                                                                                                                                   failures: json_data['summary']['failure_count'], pending: json_data['summary']['pending_count'])) # rubocop:disable Layout/LineLength
       end
 
       def self.merge_json_results(json_data)
@@ -191,6 +198,7 @@ module PDK
         message_set = Set.new
         json_data.each do |json|
           next unless json['messages']
+
           message_set |= json['messages']
         end
         merged_json_result['messages'] = message_set.to_a
@@ -199,6 +207,7 @@ module PDK
         all_examples = []
         json_data.each do |json|
           next unless json['examples']
+
           all_examples.concat json['examples']
         end
         merged_json_result['examples'] = all_examples
@@ -207,10 +216,11 @@ module PDK
         summary_hash = {
           'example_count' => 0,
           'failure_count' => 0,
-          'pending_count' => 0,
+          'pending_count' => 0
         }
         json_data.each do |json|
           next unless json['summary']
+
           summary_hash['example_count'] += json['summary']['example_count']
           summary_hash['failure_count'] += json['summary']['failure_count']
           summary_hash['pending_count'] += json['summary']['pending_count']
@@ -233,12 +243,13 @@ module PDK
         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, format('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, format('Unable to enumerate examples. rspec reported: %{message}', message: rspec_message)
         else
           examples = []
           rspec_json['examples'].each do |example|

data/lib/pdk/util/bundler.rb

@@ -3,9 +3,9 @@ require 'pdk'
 module PDK
   module Util
     module Bundler
-      class BundleHelper; end
+      # class BundleHelper; end
 
-      def self.ensure_bundle!(gem_overrides = nil)
+      def self.ensure_bundle!(gem_overrides = {})
         bundle = BundleHelper.new
 
         # This will default ensure_bundle! to re-resolving everything to latest
@@ -17,7 +17,7 @@ module PDK
         end
 
         unless bundle.gemfile?
-          PDK.logger.debug("No Gemfile found in '%{cwd}'. Skipping bundler management." % { cwd: Dir.pwd })
+          PDK.logger.debug(format("No Gemfile found in '%{cwd}'. Skipping bundler management.", cwd: Dir.pwd))
           return
         end
 
@@ -44,9 +44,7 @@ module PDK
         # If there are missing dependencies after updating the lockfile, let `bundle install`
         # go out and get them. If the specified puppet gem version points to a remote location
         # or local filepath, then run bundle install as well.
-        if !bundle.installed?(gem_overrides) || (gem_overrides[:puppet] && gem_overrides[:puppet].start_with?('file://', 'git://', 'https://'))
-          bundle.install!(gem_overrides)
-        end
+        bundle.install!(gem_overrides) if !bundle.installed?(gem_overrides) || gem_overrides[:puppet]&.start_with?('file://', 'git://', 'https://')
 
         mark_as_bundled!(bundle.gemfile, gem_overrides)
       end
@@ -81,6 +79,7 @@ module PDK
 
         def gemfile_lock
           return if gemfile.nil?
+
           @gemfile_lock ||= File.join(File.dirname(gemfile), 'Gemfile.lock')
         end
 
@@ -115,20 +114,16 @@ module PDK
             # Subsequent 'bundle install' will still pick up any new dependencies.
             vendored_lockfiles = [
               File.join(PDK::Util.package_cachedir, "Gemfile-#{PDK::Util::RubyVersion.active_ruby_version}.lock"),
-              File.join(PDK::Util.package_cachedir, 'Gemfile.lock'),
+              File.join(PDK::Util.package_cachedir, 'Gemfile.lock')
             ]
 
             vendored_gemfile_lock = vendored_lockfiles.find do |lockfile|
               PDK::Util::Filesystem.exist?(lockfile)
             end
 
-            unless vendored_gemfile_lock
-              raise PDK::CLI::FatalError, 'Vendored Gemfile.lock (%{source}) not found.' % {
-                source: vendored_gemfile_lock,
-              }
-            end
+            raise PDK::CLI::FatalError, format('Vendored Gemfile.lock (%{source}) not found.', source: vendored_gemfile_lock) unless vendored_gemfile_lock
 
-            PDK.logger.debug('Using vendored Gemfile.lock from %{source}.' % { source: vendored_gemfile_lock })
+            PDK.logger.debug(format('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']
@@ -211,6 +206,7 @@ module PDK
 
         def binstubs!(gems)
           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,7 +214,7 @@ 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?
+            PDK.logger.fatal(format("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
 

data/lib/pdk/util/changelog_generator.rb

@@ -4,7 +4,7 @@ module PDK
   module Util
     module ChangelogGenerator
       # Taken from the version regex in https://forgeapi.puppet.com/schemas/module.json
-      VERSION_REGEX = %r{^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$}
+      VERSION_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$/.freeze
       GEM = 'github_changelog_generator'.freeze
 
       # Raises if the github_changelog_generator is not available
@@ -16,7 +16,7 @@ module PDK
 
         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, format('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
@@ -29,11 +29,12 @@ 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, format('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, format('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.include?('UNCATEGORIZED PRS; GO LABEL THEM') # rubocop:disable Metrics/LineLength
+
         output
       end
 
@@ -42,9 +43,10 @@ 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, format('Invalid version string %{version}', version: current_version) unless VERSION_REGEX.match?(current_version)
+
         version = Gem::Version.create(current_version).segments
-        PDK.logger.info 'Determing the target version from \'%{file}\'' % { file: changelog_file }
+        PDK.logger.info format('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
@@ -83,24 +85,24 @@ module PDK
           if line.start_with?('[')
             # We're leaving the latest changes so we can break
             break if in_changelog_entry
+
             in_changelog_entry = true
           end
-          if in_changelog_entry && line.start_with?('##')
-            data += line
-          end
+          data += line if in_changelog_entry && line.start_with?('##')
         end
 
         # Check for meta headers in first two header line matches
-        if data =~ %r{^### Changed}
+        case data
+        when /^### Changed/
           # Major Version bump
           version[0] += 1
           version[1] = 0
           version[2] = 0
-        elsif data =~ %r{^### Added}
+        when /^### Added/
           # Minor Version bump
           version[1] += 1
           version[2] = 0
-        elsif data =~ %r{^### Fixed}
+        when /^### Fixed/
           # Patch Version bump
           version[2] += 1
         end
@@ -128,6 +130,7 @@ module PDK
 
       def self.changelog_content
         return '' if changelog_file.nil?
+
         PDK::Util::Filesystem.read_file(changelog_file, open_args: 'rb:utf-8')
       end
     end

data/lib/pdk/util/env.rb

@@ -21,6 +21,7 @@ module PDK
         def [](key)
           env_hash.each do |item, value|
             next unless key.casecmp(item).zero?
+
             return value
           end
           nil

data/lib/pdk/util/filesystem.rb

@@ -14,19 +14,20 @@ module PDK
         # Make sure all written files have a trailing newline.
         content += "\n" unless content[-1] == "\n"
 
-        File.open(path, 'wb') { |f| f.write(content) }
+        File.binwrite(path, content)
       end
       module_function :write_file
 
       def read_file(file, nil_on_error: false, open_args: 'r')
         File.read(file, open_args: Array(open_args))
-      rescue => e
+      rescue StandardError => e
         raise e unless nil_on_error
+
         nil
       end
       module_function :read_file
 
-      #:nocov:
+      # :nocov:
       # These methods just wrap core Ruby functionality and
       # can be ignored for code coverage
       def directory?(*args)
@@ -34,8 +35,8 @@ module PDK
       end
       module_function :directory?
 
-      def mkdir_p(*args)
-        FileUtils.mkdir_p(*args)
+      def mkdir_p(*args, **kwargs)
+        FileUtils.mkdir_p(*args, **kwargs)
       end
       module_function :mkdir_p
 
@@ -74,18 +75,18 @@ module PDK
       end
       module_function :exist?
 
-      def rm(*args)
-        FileUtils.rm(*args)
+      def rm(*args, **kwargs)
+        FileUtils.rm(*args, **kwargs)
       end
       module_function :rm
 
-      def rm_f(*args)
-        FileUtils.rm_f(*args)
+      def rm_f(*args, **kwargs)
+        FileUtils.rm_f(*args, **kwargs)
       end
       module_function :rm_f
 
-      def rm_rf(*args)
-        FileUtils.rm_rf(*args)
+      def rm_rf(*args, **kwargs)
+        FileUtils.rm_rf(*args, **kwargs)
       end
       module_function :rm_rf
 
@@ -95,7 +96,7 @@ module PDK
       module_function :remove_entry_secure
 
       def zero?(*args)
-        File.zero?(*args)
+        File.empty?(*args)
       end
       module_function :zero?
 
@@ -109,13 +110,13 @@ module PDK
       end
       module_function :symlink?
 
-      def cp(*args)
-        FileUtils.cp(*args)
+      def cp(*args, **kwargs)
+        FileUtils.cp(*args, **kwargs)
       end
       module_function :cp
 
-      def mv(*args)
-        FileUtils.mv(*args)
+      def mv(*args, **kwargs)
+        FileUtils.mv(*args, **kwargs)
       rescue Errno::ENOENT
         # PDK-1169 - FileUtils.mv raises Errno::ENOENT when moving files inside
         #            VMWare shared folders on Windows. So we need to catch this
@@ -132,7 +133,7 @@ module PDK
         end
       end
       module_function :mv
-      #:nocov:
+      # :nocov:
     end
   end
 end