pdk 2.7.0 → 3.0.0

data/lib/pdk/util/windows/api_types.rb

@@ -1,81 +1,87 @@
 require 'ffi'
 require 'pdk/util/windows/string'
 
-module PDK::Util::Windows::APITypes
-  module ::FFI::Library
-    def attach_function_private(*args)
-      attach_function(*args)
-      private args[0]
-    end
-  end
+module PDK
+  module Util
+    module Windows
+      module APITypes
+        module ::FFI
+          module Library
+            def attach_function_private(*args)
+              attach_function(*args)
+              private args[0]
+            end
+          end
+        end
 
-  class ::FFI::Pointer
-    def self.from_string_to_wide_string(str, &_block)
-      str = PDK::Util::Windows::String.wide_string(str)
-      FFI::MemoryPointer.new(:byte, str.bytesize) do |ptr|
-        # uchar here is synonymous with byte
-        ptr.put_array_of_uchar(0, str.bytes.to_a)
+        module ::FFI
+          class Pointer
+            def self.from_string_to_wide_string(str, &_block)
+              str = PDK::Util::Windows::String.wide_string(str)
+              FFI::MemoryPointer.new(:byte, str.bytesize) do |ptr|
+                # uchar here is synonymous with byte
+                ptr.put_array_of_uchar(0, str.bytes.to_a)
 
-        yield ptr
-      end
+                yield ptr
+              end
 
-      # ptr has already had free called, so nothing to return
-      nil
-    end
+              # ptr has already had free called, so nothing to return
+              nil
+            end
 
-    def read_wide_string(char_length, dst_encoding = Encoding::UTF_8, encode_options = {})
-      # char_length is number of wide chars (typically excluding NULLs), *not* bytes
-      str = get_bytes(0, char_length * 2).force_encoding('UTF-16LE')
-      str.encode(dst_encoding, str.encoding, **encode_options)
-    rescue StandardError => e
-      PDK.logger.debug 'Unable to convert value %{string} to encoding %{encoding} due to %{error}' % {
-        string:   str.dump,
-        encoding: dst_encoding,
-        error:    e.inspect,
-      }
-      raise
-    end
+            def read_wide_string(char_length, dst_encoding = Encoding::UTF_8, encode_options = {})
+              # char_length is number of wide chars (typically excluding NULLs), *not* bytes
+              str = get_bytes(0, char_length * 2).force_encoding('UTF-16LE')
+              str.encode(dst_encoding, str.encoding, **encode_options)
+            rescue StandardError => e
+              PDK.logger.debug format('Unable to convert value %{string} to encoding %{encoding} due to %{error}', string: str.dump, encoding: dst_encoding, error: e.inspect)
+              raise
+            end
 
-    def read_arbitrary_wide_string_up_to(max_char_length = 512, null_terminator = :single_null, encode_options = {})
-      unless [:single_null, :double_null].include?(null_terminator)
-        raise ArgumentError,
-              'Unable to read wide strings with %{null_terminator} terminal nulls' % { null_terminator: null_terminator }
-      end
+            def read_arbitrary_wide_string_up_to(max_char_length = 512, null_terminator = :single_null, encode_options = {})
+              unless [:single_null, :double_null].include?(null_terminator)
+                raise ArgumentError,
+                      format('Unable to read wide strings with %{null_terminator} terminal nulls', null_terminator: null_terminator)
+              end
 
-      terminator_width = (null_terminator == :single_null) ? 1 : 2
-      reader_method = (null_terminator == :single_null) ? :get_uint16 : :get_uint32
+              terminator_width = null_terminator == :single_null ? 1 : 2
+              reader_method = null_terminator == :single_null ? :get_uint16 : :get_uint32
 
-      # Look for the null_terminator; if found, read up to that null
-      # (exclusive)
-      (0...max_char_length - terminator_width).each do |i|
-        return read_wide_string(i, Encoding::UTF_8, encode_options) if send(reader_method, (i * 2)).zero?
-      end
+              # Look for the null_terminator; if found, read up to that null
+              # (exclusive)
+              (0...max_char_length - terminator_width).each do |i|
+                return read_wide_string(i, Encoding::UTF_8, encode_options) if send(reader_method, (i * 2)).zero?
+              end
 
-      # String is longer than the max, read just up to the max
-      read_wide_string(max_char_length, Encoding::UTF_8, encode_options)
-    end
-  end
+              # String is longer than the max, read just up to the max
+              read_wide_string(max_char_length, Encoding::UTF_8, encode_options)
+            end
+          end
+        end
 
-  # FFI Types
-  # https://github.com/ffi/ffi/wiki/Types
+        # FFI Types
+        # https://github.com/ffi/ffi/wiki/Types
 
-  # Windows - Common Data Types
-  # https://msdn.microsoft.com/en-us/library/cc230309.aspx
+        # Windows - Common Data Types
+        # https://msdn.microsoft.com/en-us/library/cc230309.aspx
 
-  # Windows Data Types
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
+        # Windows Data Types
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
 
-  FFI.typedef :uint32, :dword
-  # buffer_inout is similar to pointer (platform specific), but optimized for buffers
-  FFI.typedef :buffer_inout, :lpwstr
-  # buffer_in is similar to pointer (platform specific), but optimized for CONST read only buffers
-  FFI.typedef :buffer_in, :lpcwstr
-  # 8 bits per byte
-  FFI.typedef :uchar, :byte
-  FFI.typedef :uint16, :wchar
+        FFI.typedef :uint32, :dword
+        # buffer_inout is similar to pointer (platform specific), but optimized for buffers
+        FFI.typedef :buffer_inout, :lpwstr
+        # buffer_in is similar to pointer (platform specific), but optimized for CONST read only buffers
+        FFI.typedef :buffer_in, :lpcwstr
+        # 8 bits per byte
+        FFI.typedef :uchar, :byte
+        FFI.typedef :uint16, :wchar
 
-  # FFI bool can be only 1 byte at times,
-  # Win32 BOOL is a signed int, and is always 4 bytes, even on x64
-  # https://blogs.msdn.com/b/oldnewthing/archive/2011/03/28/10146459.aspx
-  FFI.typedef :int32, :win32_bool
+        # FFI bool can be only 1 byte at times,
+        # Win32 BOOL is a signed int, and is always 4 bytes, even on x64
+        # https://blogs.msdn.com/b/oldnewthing/archive/2011/03/28/10146459.aspx
+        FFI.typedef :int32, :win32_bool
+      end
+    end
+  end
 end

data/lib/pdk/util/windows/file.rb

@@ -1,36 +1,40 @@
 require 'pdk/util/windows'
 
-module PDK::Util::Windows::File
-  require 'ffi'
-  extend FFI::Library
-  extend PDK::Util::Windows::String
+module PDK
+  module Util
+    module Windows
+      module File
+        require 'ffi'
+        extend FFI::Library
+        extend PDK::Util::Windows::String
 
-  def get_long_pathname(path)
-    converted = ''
-    FFI::Pointer.from_string_to_wide_string(path) do |path_ptr|
-      # includes terminating NULL
-      buffer_size = GetLongPathNameW(path_ptr, FFI::Pointer::NULL, 0)
-      FFI::MemoryPointer.new(:wchar, buffer_size) do |converted_ptr|
-        if GetLongPathNameW(path_ptr, converted_ptr, buffer_size) == PDK::Util::Windows::WIN32_FALSE
-          raise 'Failed to call GetLongPathName'
+        def get_long_pathname(path)
+          converted = ''
+          FFI::Pointer.from_string_to_wide_string(path) do |path_ptr|
+            # includes terminating NULL
+            buffer_size = GetLongPathNameW(path_ptr, FFI::Pointer::NULL, 0)
+            FFI::MemoryPointer.new(:wchar, buffer_size) do |converted_ptr|
+              raise 'Failed to call GetLongPathName' if GetLongPathNameW(path_ptr, converted_ptr, buffer_size) == PDK::Util::Windows::WIN32_FALSE
+
+              converted = converted_ptr.read_wide_string(buffer_size - 1)
+            end
+          end
+
+          converted
         end
+        module_function :get_long_pathname
+
+        ffi_convention :stdcall
 
-        converted = converted_ptr.read_wide_string(buffer_size - 1)
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa364980(v=vs.85).aspx
+        # DWORD WINAPI GetLongPathName(
+        #   _In_  LPCTSTR lpszShortPath,
+        #   _Out_ LPTSTR  lpszLongPath,
+        #   _In_  DWORD   cchBuffer
+        # );
+        ffi_lib :kernel32
+        attach_function :GetLongPathNameW, [:lpcwstr, :lpwstr, :dword], :dword
       end
     end
-
-    converted
   end
-  module_function :get_long_pathname
-
-  ffi_convention :stdcall
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa364980(v=vs.85).aspx
-  # DWORD WINAPI GetLongPathName(
-  #   _In_  LPCTSTR lpszShortPath,
-  #   _Out_ LPTSTR  lpszLongPath,
-  #   _In_  DWORD   cchBuffer
-  # );
-  ffi_lib :kernel32
-  attach_function :GetLongPathNameW, [:lpcwstr, :lpwstr, :dword], :dword
 end

data/lib/pdk/util/windows/process.rb

@@ -1,76 +1,74 @@
 require 'pdk/util/windows'
 
-module PDK::Util::Windows::Process
-  require 'ffi'
-  extend PDK::Util::Windows::String
-  extend FFI::Library
+module PDK
+  module Util
+    module Windows
+      module Process
+        require 'ffi'
+        extend PDK::Util::Windows::String
+        extend FFI::Library
 
-  def environment_hash
-    env_ptr = GetEnvironmentStringsW()
+        def environment_hash
+          env_ptr = GetEnvironmentStringsW()
 
-    contains_unicode_replacement = ->(string) do
-      return false unless string.include?("\uFFFD")
+          contains_unicode_replacement = lambda do |string|
+            return false unless string.include?("\uFFFD")
 
-      PDK.logger.warning "Discarding environment variable #{string} which contains invalid bytes"
-      true
-    end
+            PDK.logger.warning "Discarding environment variable #{string} which contains invalid bytes"
+            true
+          end
 
-    # pass :invalid => :replace to the Ruby String#encode to use replacement
-    # characters
-    pairs = env_ptr.read_arbitrary_wide_string_up_to(65_534, :double_null, invalid: :replace)
-                   .split(?\x00)
-                   .reject { |env_str| env_str.nil? || env_str.empty? || env_str[0] == '=' }
-                   .reject { |env_str| contains_unicode_replacement.call(env_str) }
-                   .map { |env_pair| env_pair.split('=', 2) }
-    Hash[pairs]
-  ensure
-    if env_ptr && !env_ptr.null?
-      if FreeEnvironmentStringsW(env_ptr) == PDK::Util::Windows::WIN32_FALSE
-        PDK.logger.debug 'FreeEnvironmentStringsW memory leak'
-      end
-    end
-  end
-  module_function :environment_hash
+          # pass :invalid => :replace to the Ruby String#encode to use replacement
+          # characters
+          pairs = env_ptr.read_arbitrary_wide_string_up_to(65_534, :double_null, invalid: :replace)
+                         .split(?\x00)
+                         .reject { |env_str| env_str.nil? || env_str.empty? || env_str[0] == '=' }
+                         .reject { |env_str| contains_unicode_replacement.call(env_str) }
+                         .map { |env_pair| env_pair.split('=', 2) }
+          pairs.to_h
+        ensure
+          PDK.logger.debug 'FreeEnvironmentStringsW memory leak' if env_ptr && !env_ptr.null? && (FreeEnvironmentStringsW(env_ptr) == PDK::Util::Windows::WIN32_FALSE)
+        end
+        module_function :environment_hash
 
-  def set_environment_variable(name, val)
-    raise ArgumentError, 'Environment variable name must not be nil or empty' if name.nil? || name.empty?
+        def set_environment_variable(name, val)
+          raise ArgumentError, 'Environment variable name must not be nil or empty' if name.nil? || name.empty?
 
-    FFI::MemoryPointer.from_string_to_wide_string(name) do |name_ptr|
-      if val.nil?
-        if SetEnvironmentVariableW(name_ptr, FFI::MemoryPointer::NULL) == PDK::Util::Windows::WIN32_FALSE
-          raise 'Failed to remove environment variable: %{name}' % { name: name }
-        end
-      else
-        FFI::MemoryPointer.from_string_to_wide_string(val) do |val_ptr|
-          if SetEnvironmentVariableW(name_ptr, val_ptr) == PDK::Util::Windows::WIN32_FALSE
-            raise 'Failed to set environment variaible: %{name}' % { name: name }
+          FFI::MemoryPointer.from_string_to_wide_string(name) do |name_ptr|
+            if val.nil?
+              raise format('Failed to remove environment variable: %{name}', name: name) if SetEnvironmentVariableW(name_ptr, FFI::MemoryPointer::NULL) == PDK::Util::Windows::WIN32_FALSE
+            else
+              FFI::MemoryPointer.from_string_to_wide_string(val) do |val_ptr|
+                raise format('Failed to set environment variaible: %{name}', name: name) if SetEnvironmentVariableW(name_ptr, val_ptr) == PDK::Util::Windows::WIN32_FALSE
+              end
+            end
           end
         end
-      end
-    end
-  end
-  module_function :set_environment_variable
+        module_function :set_environment_variable
 
-  ffi_convention :stdcall
+        ffi_convention :stdcall
 
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683187(v=vs.85).aspx
-  # LPTCH GetEnvironmentStrings(void);
-  ffi_lib :kernel32
-  attach_function_private :GetEnvironmentStringsW, [], :pointer
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683187(v=vs.85).aspx
+        # LPTCH GetEnvironmentStrings(void);
+        ffi_lib :kernel32
+        attach_function_private :GetEnvironmentStringsW, [], :pointer
 
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683151(v=vs.85).aspx
-  # BOOL FreeEnvironmentStrings(
-  #   _In_ LPTCH lpszEnvironmentBlock
-  # );
-  ffi_lib :kernel32
-  attach_function_private :FreeEnvironmentStringsW, [:pointer], :win32_bool
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683151(v=vs.85).aspx
+        # BOOL FreeEnvironmentStrings(
+        #   _In_ LPTCH lpszEnvironmentBlock
+        # );
+        ffi_lib :kernel32
+        attach_function_private :FreeEnvironmentStringsW, [:pointer], :win32_bool
 
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms686206(v=vs.85).aspx
-  # BOOL WINAPI SetEnvironmentVariableW(
-  #   _In_     LPCTSTR lpName,
-  #   _In_opt_ LPCTSTR lpValue
-  # );
-  ffi_lib :kernel32
-  attach_function_private :SetEnvironmentVariableW, [:lpcwstr, :lpcwstr],
-                          :win32_bool
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/ms686206(v=vs.85).aspx
+        # BOOL WINAPI SetEnvironmentVariableW(
+        #   _In_     LPCTSTR lpName,
+        #   _In_opt_ LPCTSTR lpValue
+        # );
+        ffi_lib :kernel32
+        attach_function_private :SetEnvironmentVariableW, [:lpcwstr, :lpcwstr],
+                                :win32_bool
+      end
+    end
+  end
 end

data/lib/pdk/util/windows/string.rb

@@ -1,16 +1,23 @@
 require 'pdk/util/windows'
 
-module PDK::Util::Windows::String
-  def wide_string(str)
-    # if given a nil string, assume caller wants to pass a nil pointer to win32
-    return if str.nil?
-    # ruby (< 2.1) does not respect multibyte terminators, so it is possible
-    # for a string to contain a single trailing null byte, followed by garbage
-    # causing buffer overruns.
-    #
-    # See http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?revision=41920&view=revision
-    newstr = str + "\0".encode(str.encoding)
-    newstr.encode!('UTF-16LE')
+module PDK
+  module Util
+    module Windows
+      module String
+        def wide_string(str)
+          # if given a nil string, assume caller wants to pass a nil pointer to win32
+          return if str.nil?
+
+          # ruby (< 2.1) does not respect multibyte terminators, so it is possible
+          # for a string to contain a single trailing null byte, followed by garbage
+          # causing buffer overruns.
+          #
+          # See http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?revision=41920&view=revision
+          newstr = str + "\0".encode(str.encoding)
+          newstr.encode!('UTF-16LE')
+        end
+        module_function :wide_string
+      end
+    end
   end
-  module_function :wide_string
 end

data/lib/pdk/util.rb

@@ -22,18 +22,9 @@ module PDK
     autoload :VendoredFile, 'pdk/util/vendored_file'
     autoload :Version, 'pdk/util/version'
 
-    MODULE_FOLDERS = %w[
-      manifests
-      lib/puppet
-      lib/puppet_x
-      lib/facter
-      tasks
-      facts.d
-      functions
-      types
-    ].freeze
-
-    #:nocov:
+    MODULE_FOLDERS = ['manifests', 'lib/puppet', 'lib/puppet_x', 'lib/facter', 'tasks', 'facts.d', 'functions', 'types'].freeze
+
+    # :nocov:
     # This method just wraps core Ruby functionality and
     # can be ignored for code coverage
 
@@ -41,7 +32,7 @@ module PDK
     def exit_process(exit_code)
       exit exit_code
     end
-    #:nocov:
+    # :nocov:
 
     # Searches upwards from current working directory for the given target file.
     #
@@ -57,6 +48,7 @@ module PDK
       until !PDK::Util::Filesystem.directory?(current) || current == previous
         filename = File.join(current, target)
         return filename if PDK::Util::Filesystem.file?(filename)
+
         previous = current
         current = PDK::Util::Filesystem.expand_path('..', current)
       end
@@ -84,9 +76,8 @@ module PDK
     # @return [String] Canonical path
     def canonical_path(path)
       if Gem.win_platform?
-        unless PDK::Util::Filesystem.exist?(path)
-          raise PDK::CLI::FatalError, "Cannot resolve a full path to '%{path}', as it does not currently exist." % { path: path }
-        end
+        raise PDK::CLI::FatalError, format("Cannot resolve a full path to '%{path}', as it does not currently exist.", path: path) unless PDK::Util::Filesystem.exist?(path)
+
         PDK::Util::Windows::File.get_long_pathname(path)
       else
         PDK::Util::Filesystem.expand_path(path)
@@ -115,6 +106,7 @@ module PDK
 
     def pdk_package_basedir
       raise PDK::CLI::FatalError, 'Package basedir requested for non-package install.' unless package_install?
+
       require 'pdk/util/version'
 
       File.dirname(PDK::Util::Version.version_file)
@@ -152,6 +144,7 @@ module PDK
       return @system_configdir = File.join(File::SEPARATOR, 'opt', 'puppetlabs', 'pdk', 'config') unless Gem.win_platform?
 
       return @system_configdir = File.join(PDK::Util::Env['ProgramData'], 'PuppetLabs', 'PDK') unless PDK::Util::Env['ProgramData'].nil?
+
       @system_configdir = File.join(PDK::Util::Env['AllUsersProfile'], 'PuppetLabs', 'PDK')
     end
     module_function :system_configdir
@@ -166,8 +159,6 @@ module PDK
         File.dirname(metadata_path)
       elsif in_module_root?
         Dir.pwd
-      else
-        nil
       end
     end
     module_function :module_root
@@ -263,9 +254,10 @@ module PDK
     # @return [Object] duplicate of the original object
     #   the current working dir does not appear to be within a module.
     def deep_duplicate(object)
-      if object.is_a?(Array)
+      case object
+      when Array
         object.map { |item| deep_duplicate(item) }
-      elsif object.is_a?(Hash)
+      when Hash
         hash = object.dup
         hash.each_pair { |key, value| hash[key] = deep_duplicate(value) }
         hash

data/lib/pdk/validate/control_repo/control_repo_validator_group.rb

@@ -14,7 +14,7 @@ module PDK
 
         def validators
           [
-            EnvironmentConfValidator,
+            EnvironmentConfValidator
           ].freeze
         end
       end

data/lib/pdk/validate/control_repo/environment_conf_validator.rb

@@ -4,7 +4,7 @@ module PDK
   module Validate
     module ControlRepo
       class EnvironmentConfValidator < InternalRubyValidator
-        ALLOWED_SETTINGS = %w[modulepath manifest config_version environment_timeout].freeze
+        ALLOWED_SETTINGS = ['modulepath', 'manifest', 'config_version', 'environment_timeout'].freeze
 
         def name
           'environment-conf'
@@ -19,9 +19,7 @@ module PDK
         end
 
         def spinner_text
-          'Checking Puppet Environment settings (%{patterns}).' % {
-            patterns: pattern.join(' '),
-          }
+          format('Checking Puppet Environment settings (%{patterns}).', patterns: pattern.join(' '))
         end
 
         def validate_target(report, target)
@@ -31,7 +29,7 @@ module PDK
               source: name,
               state: :failure,
               severity: 'error',
-              message: 'Could not be read.',
+              message: 'Could not be read.'
             )
             return 1
           end
@@ -44,19 +42,20 @@ module PDK
               # Remove the 'environment.' setting_name prefix
               setting_name = setting_name.slice(12..-1)
               next if ALLOWED_SETTINGS.include?(setting_name)
+
               # A hash indicates that the ini file has a section in it.
               message = if setting_value.is_a?(Hash)
-                          "Invalid section '%{name}'" % { name: setting_name }
+                          format("Invalid section '%{name}'", name: setting_name)
                         else
-                          "Invalid setting '%{name}'" % { name: setting_name }
+                          format("Invalid setting '%{name}'", name: setting_name)
                         end
 
               report.add_event(
-                file:     target,
-                source:   name,
-                state:    :failure,
+                file: target,
+                source: name,
+                state: :failure,
                 severity: 'error',
-                message:  message,
+                message: message
               )
               is_valid = false
             end
@@ -64,32 +63,33 @@ module PDK
             timeout = env_conf.fetch('environment_timeout', nil)
             unless timeout.nil? || timeout == '0' || timeout == 'unlimited'
               report.add_event(
-                file:     target,
-                source:   name,
-                state:    :failure,
+                file: target,
+                source: name,
+                state: :failure,
                 severity: 'error',
-                message:  "environment_timeout is set to '%{timeout}' but should be 0, 'unlimited' or not set." % { timeout: timeout },
+                message: format("environment_timeout is set to '%{timeout}' but should be 0, 'unlimited' or not set.", timeout: timeout)
               )
               is_valid = false
             end
 
             return 1 unless is_valid
+
             report.add_event(
-              file:     target,
-              source:   name,
-              state:    :passed,
-              severity: 'ok',
+              file: target,
+              source: name,
+              state: :passed,
+              severity: 'ok'
             )
-            return 0
+            0
           rescue StandardError => e
             report.add_event(
-              file:     target,
-              source:   name,
-              state:    :failure,
+              file: target,
+              source: name,
+              state: :failure,
               severity: 'error',
-              message:  e.message,
+              message: e.message
             )
-            return 1
+            1
           end
         end
       end

data/lib/pdk/validate/external_command_validator.rb

@@ -76,7 +76,7 @@ module PDK
           PDK::Util::RubyVersion.bin_path,
           File.join(PDK::Util::RubyVersion.gem_home, 'bin'),
           PDK::Util::RubyVersion.gem_paths_raw.map { |gem_path_raw| File.join(gem_path_raw, 'bin') },
-          PDK::Util.package_install? ? File.join(PDK::Util.pdk_package_basedir, 'bin') : nil,
+          PDK::Util.package_install? ? File.join(PDK::Util.pdk_package_basedir, 'bin') : nil
         ].flatten.compact
       end
 
@@ -86,14 +86,17 @@ module PDK
       # @api private
       def cmd_path
         return @cmd_path unless @cmd_path.nil?
+
         @cmd_path = File.join(context.root_path, 'bin', cmd)
         # Return the path to the command if it exists on disk, or we have a gemfile (i.e. Bundled install)
         # The Bundle may be created after the prepare_invoke so if the file doesn't exist, it may not be an error
         return @cmd_path if PDK::Util::Filesystem.exist?(@cmd_path) || !PDK::Util::Bundler::BundleHelper.new.gemfile.nil?
+
         # But if there is no Gemfile AND cmd doesn't exist in the default path, we need to go searching...
         @cmd_path = alternate_bin_paths.map { |alternate_path| File.join(alternate_path, cmd) }
                                        .find { |path| PDK::Util::Filesystem.exist?(path) }
         return @cmd_path unless @cmd_path.nil?
+
         # If we can't find it anywhere, just let the OS find it
         @cmd_path = cmd
       end
@@ -121,6 +124,7 @@ module PDK
       # @see PDK::Validate::Validator.prepare_invoke!
       def prepare_invoke!
         return if @prepared
+
         super
 
         @targets, @skipped, @invalid = parse_targets
@@ -144,6 +148,7 @@ module PDK
         @commands = []
         target_groups.each do |invokation_targets|
           next if invokation_targets.empty? && !allow_empty_targets?
+
           cmd_argv = parse_options(invokation_targets).unshift(cmd_path).compact
           cmd_argv.unshift(File.join(PDK::Util::RubyVersion.bin_path, 'ruby.exe'), '-W0') if Gem.win_platform?