pdk 1.9.0 → 3.2.0

data/lib/pdk/module/update_manager.rb

@@ -1,9 +1,4 @@
-require 'diff/lcs'
-require 'diff/lcs/hunk'
-require 'English'
-require 'fileutils'
-require 'set'
-require 'pdk/util/filesystem'
+require 'pdk'
 
 module PDK
   module Module
@@ -11,9 +6,12 @@ module PDK
       # Initialises a blank UpdateManager object, which is used to store and
       # process file additions/removals/modifications.
       def initialize
+        require 'set'
+
         @modified_files = Set.new
         @added_files = Set.new
         @removed_files = Set.new
+        @executable_files = Set.new
         @diff_cache = {}
       end
 
@@ -40,17 +38,27 @@ module PDK
         @removed_files << path
       end
 
+      # Store a pending file execute mode change.
+      #
+      # @param path [String] The path to the file to be made executable.
+      def make_file_executable(path)
+        @executable_files << path
+      end
+
       # Generate a summary of the changes that will be applied to the module.
       #
       # @raise (see #calculate_diffs)
       # @return [Hash{Symbol => Set,Hash}] the summary of the pending changes.
       def changes
+        require 'pdk/util/filesystem'
+
         calculate_diffs
 
         {
-          added:    @added_files,
-          removed:  @removed_files.select { |f| File.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,
+          'made executable': @executable_files
         }
       end
 
@@ -61,7 +69,8 @@ module PDK
       def changes?
         !changes[:added].empty? ||
           !changes[:removed].empty? ||
-          changes[:modified].any? { |_, value| !value.nil? }
+          changes[:modified].any? { |_, value| !value.nil? } ||
+          !changes[:'made executable'].empty?
       end
 
       # Check if the update manager will change the specified file upon sync.
@@ -73,7 +82,16 @@ module PDK
       def changed?(path)
         changes[:added].any? { |add| add[:path] == path } ||
           changes[:removed].include?(path) ||
-          changes[:modified].keys.include?(path)
+          changes[:modified].key?(path) ||
+          changes[:'made executable'].include?(path)
+      end
+
+      def clear!
+        @modified_files.clear
+        @added_files.clear
+        @removed_files.clear
+        @executable_files.clear
+        nil
       end
 
       # Apply any pending changes stored in the UpdateManager to the module.
@@ -94,6 +112,10 @@ module PDK
         files_to_write.each do |file|
           write_file(file[:path], file[:content])
         end
+
+        @executable_files.each do |file|
+          update_execute_bits(file)
+        end
       end
 
       # Remove a file from disk.
@@ -106,17 +128,16 @@ module PDK
       #
       # @raise [PDK::CLI::ExitWithError] if the file could not be removed.
       def unlink_file(path)
-        if File.file?(path)
-          PDK.logger.debug(_("unlinking '%{path}'") % { path: path })
-          FileUtils.rm(path)
+        require 'pdk/util/filesystem'
+
+        if PDK::Util::Filesystem.file?(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
@@ -127,14 +148,14 @@ module PDK
       # @raise [PDK::CLI::ExitWithError] if a file being modified isn't
       #   readable.
       def calculate_diffs
+        require 'pdk/util/filesystem'
+
         @modified_files.each do |file|
           next if @diff_cache.key?(file[:path])
 
-          unless File.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 = File.read(file[:path])
+          old_content = PDK::Util::Filesystem.read_file(file[:path])
           file_diff = unified_diff(file[:path], old_content, file[:content])
           @diff_cache[file[:path]] = file_diff
         end
@@ -147,11 +168,13 @@ module PDK
       #
       # @raise [PDK::CLI::ExitWithError] if the file is not writeable.
       def write_file(path, content)
-        FileUtils.mkdir_p(File.dirname(path))
-        PDK.logger.debug(_("writing '%{path}'") % { path: path })
+        require 'pdk/util/filesystem'
+
+        PDK::Util::Filesystem.mkdir_p(File.dirname(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.
@@ -167,6 +190,9 @@ module PDK
       #
       # @return [String] The unified diff of the pending changes to the file.
       def unified_diff(path, old_content, new_content, lines_of_context = 3)
+        require 'diff/lcs'
+        require 'English'
+
         output = []
 
         old_lines = old_content.split($INPUT_RECORD_SEPARATOR).map(&:chomp)
@@ -174,9 +200,11 @@ module PDK
 
         diffs = Diff::LCS.diff(old_lines, new_lines)
 
-        return nil if diffs.empty?
+        return if diffs.empty?
+
+        require 'diff/lcs/hunk'
 
-        file_mtime = File.stat(path).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
+        file_mtime = PDK::Util::Filesystem.stat(path).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
         now = Time.now.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
 
         output << "--- #{path}\t#{file_mtime}"
@@ -186,25 +214,33 @@ 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)
 
         output.join($INPUT_RECORD_SEPARATOR)
       end
+
+      # Set the execute bits on a file
+      def update_execute_bits(path)
+        require 'pdk/util/filesystem'
+
+        PDK.logger.debug(format("making '%{path}' executable", path: path))
+        PDK::Util::Filesystem.make_executable(path)
+      rescue Errno::EACCES
+        raise PDK::CLI::ExitWithError, format("You do not have permission to make '%{path}' executable", path: path)
+      end
     end
   end
 end

data/lib/pdk/module.rb

@@ -1,7 +1,12 @@
-require 'pathspec'
-
 module PDK
   module Module
+    autoload :Build, 'pdk/module/build'
+    autoload :Convert, 'pdk/module/convert'
+    autoload :Metadata, 'pdk/module/metadata'
+    autoload :Release, 'pdk/module/release'
+    autoload :UpdateManager, 'pdk/module/update_manager'
+    autoload :Update, 'pdk/module/update'
+
     DEFAULT_IGNORED = [
       '/pkg/',
       '~*',
@@ -10,9 +15,12 @@ module PDK
       '/REVISION',
       '/spec/fixtures/modules/',
       '/vendor/',
+      '.DS_Store'
     ].freeze
 
     def default_ignored_pathspec(ignore_dotfiles = true)
+      require 'pathspec'
+
       PathSpec.new(DEFAULT_IGNORED).tap do |ps|
         ps.add('.*') if ignore_dotfiles
       end

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