pdk 2.7.1 → 3.0.0

data/lib/pdk/module/update_manager.rb

@@ -47,9 +47,9 @@ module PDK
         calculate_diffs
 
         {
-          added:    @added_files,
-          removed:  @removed_files.select { |f| PDK::Util::Filesystem.exist?(f) },
-          modified: @diff_cache.reject { |_, value| value.nil? },
+          added: @added_files,
+          removed: @removed_files.select { |f| PDK::Util::Filesystem.exist?(f) },
+          modified: @diff_cache.compact
         }
       end
 
@@ -115,16 +115,13 @@ module PDK
         require 'pdk/util/filesystem'
 
         if PDK::Util::Filesystem.file?(path)
-          PDK.logger.debug("unlinking '%{path}'" % { path: path })
+          PDK.logger.debug(format("unlinking '%{path}'", path: path))
           PDK::Util::Filesystem.rm(path)
         else
-          PDK.logger.debug("'%{path}': already gone" % { path: path })
+          PDK.logger.debug(format("'%{path}': already gone", path: path))
         end
-      rescue => e
-        raise PDK::CLI::ExitWithError, "Unable to remove '%{path}': %{message}" % {
-          path:    path,
-          message: e.message,
-        }
+      rescue StandardError => e
+        raise PDK::CLI::ExitWithError, format("Unable to remove '%{path}': %{message}", path: path, message: e.message)
       end
 
       private
@@ -140,9 +137,7 @@ module PDK
         @modified_files.each do |file|
           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] }
-          end
+          raise PDK::CLI::ExitWithError, format("Unable to open '%{path}' for reading", path: file[:path]) unless PDK::Util::Filesystem.readable?(file[:path])
 
           old_content = PDK::Util::Filesystem.read_file(file[:path])
           file_diff = unified_diff(file[:path], old_content, file[:content])
@@ -160,10 +155,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(format("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, format("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.
@@ -203,19 +198,17 @@ module PDK
         file_length_difference = 0
 
         diffs.each do |piece|
-          begin
-            hunk = Diff::LCS::Hunk.new(old_lines, new_lines, piece, lines_of_context, file_length_difference)
-            file_length_difference = hunk.file_length_difference
+          hunk = Diff::LCS::Hunk.new(old_lines, new_lines, piece, lines_of_context, file_length_difference)
+          file_length_difference = hunk.file_length_difference
 
-            next unless oldhunk
+          next unless oldhunk
 
-            # If the hunk overlaps with the oldhunk, merge them.
-            next if lines_of_context > 0 && hunk.merge(oldhunk)
+          # If the hunk overlaps with the oldhunk, merge them.
+          next if lines_of_context.positive? && hunk.merge(oldhunk)
 
-            output << oldhunk.diff(:unified)
-          ensure
-            oldhunk = hunk
-          end
+          output << oldhunk.diff(:unified)
+        ensure
+          oldhunk = hunk
         end
 
         output << oldhunk.diff(:unified)

data/lib/pdk/module.rb

@@ -15,7 +15,7 @@ module PDK
       '/REVISION',
       '/spec/fixtures/modules/',
       '/vendor/',
-      '.DS_Store',
+      '.DS_Store'
     ].freeze
 
     def default_ignored_pathspec(ignore_dotfiles = true)

data/lib/pdk/monkey_patches.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module OS
+  # Os detection: Are we on Windows?
+  def self.windows?
+    (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+  end
+end
+
+# Patch childprocess so that it is Ruby 3 compliant.
+# This could be removed if the following PR is ever merged
+# and released:
+# https://github.com/enkessler/childprocess/pull/185
+module ChildProcess
+  class << self
+    def build(*args)
+      case os
+      when :macosx, :linux, :solaris, :bsd, :cygwin, :aix
+        if posix_spawn?
+          Unix::PosixSpawnProcess.new(*args)
+        elsif jruby?
+          JRuby::Process.new(*args)
+        else
+          Unix::ForkExecProcess.new(*args)
+        end
+      when :windows
+        Windows::Process.new(*args)
+      else
+        raise Error, "unsupported platform #{platform_name.inspect}"
+      end
+    end
+  end
+
+  class AbstractProcess
+    def initialize(*args)
+      raise ArgumentError, "all arguments must be String: #{args.inspect}" unless args.all?(String)
+
+      @args        = args
+      @started     = false
+      @exit_code   = nil
+      @io          = nil
+      @cwd         = nil
+      @detach      = false
+      @duplex      = false
+      @leader      = false
+      @environment = {}
+    end
+  end
+
+  if OS.windows?
+    module Windows
+      module Lib
+        extend FFI::Library
+        def self.msvcrt_name
+          RbConfig::CONFIG['RUBY_SO_NAME'][/msvc\w+/] || 'ucrtbase'
+        end
+
+        ffi_lib 'kernel32', msvcrt_name
+        ffi_convention :stdcall
+
+        # We have to redefine the function declarations so that they are available
+        # with the patched ffi_lib.
+        enum :wait_status, [
+          :wait_object_0,  0, # rubocop:disable Naming/VariableNumber
+          :wait_timeout,   0x102,
+          :wait_abandoned, 0x80,
+          :wait_failed,    0xFFFFFFFF
+        ]
+
+        #
+        # BOOL WINAPI CreateProcess(
+        #   __in_opt     LPCTSTR lpApplicationName,
+        #   __inout_opt  LPTSTR lpCommandLine,
+        #   __in_opt     LPSECURITY_ATTRIBUTES lpProcessAttributes,
+        #   __in_opt     LPSECURITY_ATTRIBUTES lpThreadAttributes,
+        #   __in         BOOL bInheritHandles,
+        #   __in         DWORD dwCreationFlags,
+        #   __in_opt     LPVOID lpEnvironment,
+        #   __in_opt     LPCTSTR lpCurrentDirectory,
+        #   __in         LPSTARTUPINFO lpStartupInfo,
+        #   __out        LPPROCESS_INFORMATION lpProcessInformation
+        # );
+        #
+
+        attach_function :create_process, :CreateProcessW, [
+          :pointer,
+          :buffer_inout,
+          :pointer,
+          :pointer,
+          :bool,
+          :ulong,
+          :pointer,
+          :pointer,
+          :pointer,
+          :pointer
+        ], :bool
+
+        #
+        #   DWORD WINAPI FormatMessage(
+        #   __in      DWORD dwFlags,
+        #   __in_opt  LPCVOID lpSource,
+        #   __in      DWORD dwMessageId,
+        #   __in      DWORD dwLanguageId,
+        #   __out     LPTSTR lpBuffer,
+        #   __in      DWORD nSize,
+        #   __in_opt  va_list *Arguments
+        # );
+        #
+
+        attach_function :format_message, :FormatMessageA, [
+          :ulong,
+          :pointer,
+          :ulong,
+          :ulong,
+          :pointer,
+          :ulong,
+          :pointer
+        ], :ulong
+
+        attach_function :close_handle, :CloseHandle, [:pointer], :bool
+
+        #
+        # HANDLE WINAPI OpenProcess(
+        #   __in  DWORD dwDesiredAccess,
+        #   __in  BOOL bInheritHandle,
+        #   __in  DWORD dwProcessId
+        # );
+        #
+
+        attach_function :open_process, :OpenProcess, [:ulong, :bool, :ulong], :pointer
+
+        #
+        # HANDLE WINAPI CreateJobObject(
+        #   _In_opt_  LPSECURITY_ATTRIBUTES lpJobAttributes,
+        #   _In_opt_  LPCTSTR lpName
+        # );
+        #
+
+        attach_function :create_job_object, :CreateJobObjectA, [:pointer, :pointer], :pointer
+
+        #
+        # BOOL WINAPI AssignProcessToJobObject(
+        #   _In_  HANDLE hJob,
+        #   _In_  HANDLE hProcess
+        # );
+
+        attach_function :assign_process_to_job_object, :AssignProcessToJobObject, [:pointer, :pointer], :bool
+
+        #
+        # BOOL WINAPI SetInformationJobObject(
+        #   _In_  HANDLE hJob,
+        #   _In_  JOBOBJECTINFOCLASS JobObjectInfoClass,
+        #   _In_  LPVOID lpJobObjectInfo,
+        #   _In_  DWORD cbJobObjectInfoLength
+        # );
+        #
+
+        attach_function :set_information_job_object, :SetInformationJobObject, [:pointer, :int, :pointer, :ulong], :bool
+
+        #
+        #
+        # DWORD WINAPI WaitForSingleObject(
+        #   __in  HANDLE hHandle,
+        #   __in  DWORD dwMilliseconds
+        # );
+        #
+
+        attach_function :wait_for_single_object, :WaitForSingleObject, [:pointer, :ulong], :wait_status, blocking: true
+
+        #
+        # BOOL WINAPI GetExitCodeProcess(
+        #   __in   HANDLE hProcess,
+        #   __out  LPDWORD lpExitCode
+        # );
+        #
+
+        attach_function :get_exit_code, :GetExitCodeProcess, [:pointer, :pointer], :bool
+
+        #
+        # BOOL WINAPI GenerateConsoleCtrlEvent(
+        #   __in  DWORD dwCtrlEvent,
+        #   __in  DWORD dwProcessGroupId
+        # );
+        #
+
+        attach_function :generate_console_ctrl_event, :GenerateConsoleCtrlEvent, [:ulong, :ulong], :bool
+
+        #
+        # BOOL WINAPI TerminateProcess(
+        #   __in  HANDLE hProcess,
+        #   __in  UINT uExitCode
+        # );
+        #
+
+        attach_function :terminate_process, :TerminateProcess, [:pointer, :uint], :bool
+
+        #
+        # intptr_t _get_osfhandle(
+        #    int fd
+        # );
+        #
+
+        attach_function :get_osfhandle, :_get_osfhandle, [:int], :intptr_t
+
+        #
+        # int _open_osfhandle (
+        #    intptr_t osfhandle,
+        #    int flags
+        # );
+        #
+
+        attach_function :open_osfhandle, :_open_osfhandle, [:pointer, :int], :int
+
+        # BOOL WINAPI SetHandleInformation(
+        #   __in  HANDLE hObject,
+        #   __in  DWORD dwMask,
+        #   __in  DWORD dwFlags
+        # );
+
+        attach_function :set_handle_information, :SetHandleInformation, [:pointer, :ulong, :ulong], :bool
+
+        # BOOL WINAPI GetHandleInformation(
+        #   __in   HANDLE hObject,
+        #   __out  LPDWORD lpdwFlags
+        # );
+
+        attach_function :get_handle_information, :GetHandleInformation, [:pointer, :pointer], :bool
+
+        # BOOL WINAPI CreatePipe(
+        #   __out     PHANDLE hReadPipe,
+        #   __out     PHANDLE hWritePipe,
+        #   __in_opt  LPSECURITY_ATTRIBUTES lpPipeAttributes,
+        #   __in      DWORD nSize
+        # );
+
+        attach_function :create_pipe, :CreatePipe, [:pointer, :pointer, :pointer, :ulong], :bool
+
+        #
+        # HANDLE WINAPI GetCurrentProcess(void);
+        #
+
+        attach_function :current_process, :GetCurrentProcess, [], :pointer
+
+        #
+        # BOOL WINAPI DuplicateHandle(
+        #   __in   HANDLE hSourceProcessHandle,
+        #   __in   HANDLE hSourceHandle,
+        #   __in   HANDLE hTargetProcessHandle,
+        #   __out  LPHANDLE lpTargetHandle,
+        #   __in   DWORD dwDesiredAccess,
+        #   __in   BOOL bInheritHandle,
+        #   __in   DWORD dwOptions
+        # );
+        #
+
+        attach_function :_duplicate_handle, :DuplicateHandle, [
+          :pointer,
+          :pointer,
+          :pointer,
+          :pointer,
+          :ulong,
+          :bool,
+          :ulong
+        ], :bool
+      end
+    end
+  end
+end

data/lib/pdk/report/event.rb

@@ -194,13 +194,9 @@ module PDK
       # @raise [ArgumentError] if the value is nil, an empty String, or not
       #   a String.
       def sanitise_file(value)
-        if value.nil? || (value.is_a?(String) && value.empty?)
-          raise ArgumentError, 'File not specified.'
-        end
+        raise ArgumentError, 'File not specified.' if value.nil? || (value.is_a?(String) && value.empty?)
 
-        unless value.is_a?(String)
-          raise ArgumentError, 'File must be a String.'
-        end
+        raise ArgumentError, 'File must be a String.' unless value.is_a?(String)
 
         require 'pathname'
         require 'pdk/util'
@@ -234,22 +230,13 @@ module PDK
       # @raise [ArgumentError] if the value is nil, an empty String, or not
       #   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.'
-        end
+        raise ArgumentError, 'State not specified.' if value.nil? || (value.is_a?(String) && value.empty?)
 
         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 }
-        end
+        raise ArgumentError, format('State must be a Symbol, not %{type}', type: value.class) unless value.is_a?(Symbol)
 
         valid_states = [:passed, :error, :failure, :skipped]
-        unless valid_states.include?(value)
-          raise ArgumentError, 'Invalid state %{state}. Valid states are: %{valid}.' % {
-            state: value.inspect,
-            valid: valid_states.map(&:inspect).join(', '),
-          }
-        end
+        raise ArgumentError, format('Invalid state %{state}. Valid states are: %{valid}.', state: value.inspect, valid: valid_states.map(&:inspect).join(', ')) unless valid_states.include?(value)
 
         value
       end
@@ -263,9 +250,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.'
-        end
+        raise ArgumentError, 'Source not specified.' if value.nil? || (value.is_a?(String) && value.empty?)
 
         value.to_s
       end
@@ -284,13 +269,9 @@ module PDK
           valid_types << Fixnum # rubocop:disable Lint/UnifiedInteger
         end
 
-        unless valid_types.include?(value.class)
-          raise ArgumentError, 'Line must be an Integer or a String representation of an Integer.'
-        end
+        raise ArgumentError, 'Line must be an Integer or a String representation of an Integer.' unless valid_types.include?(value.class)
 
-        if value.is_a?(String) && value !~ %r{\A[0-9]+\Z}
-          raise ArgumentError, 'The line number can contain only the digits 0-9.'
-        end
+        raise ArgumentError, 'The line number can contain only the digits 0-9.' if value.is_a?(String) && value !~ /\A[0-9]+\Z/
 
         value.to_i
       end
@@ -309,13 +290,9 @@ module PDK
           valid_types << Fixnum # rubocop:disable Lint/UnifiedInteger
         end
 
-        unless valid_types.include?(value.class)
-          raise ArgumentError, 'Column must be an Integer or a String representation of an Integer.'
-        end
+        raise ArgumentError, 'Column must be an Integer or a String representation of an Integer.' unless valid_types.include?(value.class)
 
-        if value.is_a?(String) && value !~ %r{\A[0-9]+\Z}
-          raise ArgumentError, 'The column number can contain only the digits 0-9.'
-        end
+        raise ArgumentError, 'The column number can contain only the digits 0-9.' if value.is_a?(String) && value !~ /\A[0-9]+\Z/
 
         value.to_i
       end
@@ -331,14 +308,12 @@ module PDK
 
         valid_types = [Array]
 
-        unless valid_types.include?(value.class)
-          raise ArgumentError, 'Trace must be an Array of stack trace lines.'
-        end
+        raise ArgumentError, 'Trace must be an Array of stack trace lines.' unless valid_types.include?(value.class)
 
         # Drop any stacktrace lines that include '/gems/' in the path or
         # are the original rspec binstub lines
         value.reject do |line|
-          (line =~ %r{/gems/}) || (line =~ %r{bin/rspec:})
+          line.include?('/gems/') || line.include?('bin/rspec:')
         end
       end
 

data/lib/pdk/report.rb

@@ -6,7 +6,7 @@ module PDK
 
     # @return [Array<String>] the list of supported report formats.
     def self.formats
-      @report_formats ||= %w[junit text].freeze
+      @report_formats ||= ['junit', 'text'].freeze
     end
 
     # @return [Symbol] the method name of the default report format.
@@ -60,9 +60,9 @@ module PDK
         testsuite = REXML::Element.new('testsuite')
         testsuite.attributes['name'] = testsuite_name
         testsuite.attributes['tests'] = testcases.length
-        testsuite.attributes['errors'] = testcases.select(&:error?).length
-        testsuite.attributes['failures'] = testcases.select(&:failure?).length
-        testsuite.attributes['skipped'] = testcases.select(&:skipped?).length
+        testsuite.attributes['errors'] = testcases.count(&:error?)
+        testsuite.attributes['failures'] = testcases.count(&:failure?)
+        testsuite.attributes['skipped'] = testcases.count(&:skipped?)
         testsuite.attributes['time'] = 0
         testsuite.attributes['timestamp'] = Time.now.strftime('%Y-%m-%dT%H:%M:%S')
         testsuite.attributes['hostname'] = Socket.gethostname

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

@@ -14,6 +14,7 @@ module PDK
         # @see PDK::Template::Fetcher::AbstractTemplateFetcher.fetch!
         def fetch!
           return if fetched
+
           super
 
           # Default metadata for all git fetching methods
@@ -22,9 +23,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." % {
-              repo: uri.shell_path,
-            }
+            PDK.logger.warn format("Repository '%{repo}' has a work-tree; skipping git reset.", repo: uri.shell_path)
             @path = uri.shell_path
             @temporary = false
             @metadata['template-ref'] = describe_path_and_ref(@path)
@@ -49,7 +48,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, format("Unable to clone git repository at '%{repo}' into '%{dest}'.", repo: origin_repo, dest: temp_dir)
           end
           @path = PDK::Util.canonical_path(temp_dir)
 
@@ -63,22 +62,22 @@ 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, format("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 format("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
 
         private
 
-        #:nocov: This is a just a wrapper for another method
+        # :nocov: This is a just a wrapper for another method
         def describe_path_and_ref(path, ref = nil)
           require 'pdk/util/git'
           PDK::Util::Git.describe(File.join(path, '.git'), ref)
         end
-        #:nocov:
+        # :nocov:
       end
     end
   end

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

@@ -16,6 +16,7 @@ module PDK
         # @see PDK::Template::Fetcher::AbstractTemplateFetcher.fetch!
         def fetch!
           return if fetched
+
           super
 
           @path = uri.shell_path

data/lib/pdk/template/fetcher.rb

@@ -13,6 +13,7 @@ module PDK
       # @return [PDK::Template::Fetcher::AbstractTemplateFetcher] An instance of a class which implements the AbstractFetcher class
       def self.instance(uri, options = {})
         return Git.new(uri, options) if Git.fetchable?(uri, options)
+
         Local.new(uri, options)
       end
 
@@ -35,7 +36,8 @@ 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, format('%{class_name}.with must be passed a block.', class_name: name) unless block_given?
+
         fetcher = instance(uri, options)
 
         begin
@@ -78,7 +80,7 @@ module PDK
           @metadata = {
             'pdk-version' => PDK::Util::Version.version_string,
             'template-url' => nil,
-            'template-ref' => nil,
+            'template-ref' => nil
           }
           @fetched = false
           @temporary = false

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

@@ -65,7 +65,7 @@ module PDK
                                'unmanaged'
                              elsif c['delete']
                                'deleted'
-                             elsif @sync_config && @sync_config.key?(dest_path)
+                             elsif @sync_config&.key?(dest_path)
                                'customized'
                              else
                                'default'
@@ -91,15 +91,10 @@ module PDK
               require 'yaml'
 
               begin
-                YAML.safe_load(PDK::Util::Filesystem.read_file(loc), [], [], true)
+                YAML.safe_load(PDK::Util::Filesystem.read_file(loc), permitted_classes: [], permitted_symbols: [], aliases: true)
               rescue Psych::SyntaxError => e
-                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,
-                  line:    e.line,
-                  column:  e.column,
-                }
+                PDK.logger.warn format("'%{file}' is not a valid YAML file: %{problem} %{context} at line %{line} column %{column}", file: loc, problem: e.problem, context: e.context, line: e.line,
+                                                                                                                                     column: e.column)
                 {}
               end
             else