overcommit 0.75.0 → 0.76.0

data/lib/overcommit/hook/prepare_commit_msg/replace_branch.rb

@@ -17,6 +17,28 @@ module Overcommit::Hook::PrepareCommitMsg
   #
   # Similarly, a replacement text of `[\1][\2]` would result in `[123][topic]`.
   #
+  # The hook does not prepend the text if the commit message already starts
+  # with it, or with an autosquash prefix (`fixup! `, `squash! `, `amend! `).
+  # This matters when you remove `message` or `commit` from
+  # `skipped_commit_types`: `git commit -m '[#123] Fix'`, `--amend`, and
+  # `--fixup` then keep one prefix.
+  #
+  # === Ticket IDs
+  #
+  # This config prepends `[PROJ-123] ` on a branch such as
+  # `task/PROJ-123/fix-login`, also for `-m` and `--amend` commits:
+  #
+  #    PrepareCommitMsg:
+  #      ReplaceBranch:
+  #        enabled: true
+  #        branch_pattern: '\A.*?([A-Z][A-Z0-9]+-\d+).*\z'
+  #        replacement_text: '[\1] '
+  #        skipped_commit_types: ['template', 'merge', 'squash']
+  #        on_warn: pass # do not warn on branches without a ticket ID
+  #
+  # It keeps `template` skipped, because a commit template can start with a
+  # `#` comment line, and the prefix would turn that line into the subject.
+  #
   # == When to run this hook
   #
   # You can configure this to run only for specific types of commits by setting
@@ -31,6 +53,10 @@ module Overcommit::Hook::PrepareCommitMsg
   class ReplaceBranch < Base
     DEFAULT_BRANCH_PATTERN = /\A(\d+)-(\w+).*\z/.freeze
 
+    # `git rebase --autosquash` finds these commits only when the prefix starts
+    # the subject.
+    AUTOSQUASH_PREFIX = /\A(?:fixup|squash|amend)! /.freeze
+
     def run
       return :pass if skip?
 
@@ -40,10 +66,14 @@ module Overcommit::Hook::PrepareCommitMsg
 
       return :warn unless branch_pattern.match?(Overcommit::GitRepo.current_branch)
 
-      Overcommit::Utils.log.debug("Writing #{commit_message_filename} with #{new_template}")
-
       modify_commit_message do |old_contents|
-        "#{new_template}#{old_contents}"
+        if keep_message?(old_contents)
+          Overcommit::Utils.log.debug("Keeping #{commit_message_filename} unchanged")
+          old_contents
+        else
+          Overcommit::Utils.log.debug("Writing #{commit_message_filename} with #{new_template}")
+          "#{new_template}#{old_contents}"
+        end
       end
 
       :pass
@@ -57,6 +87,25 @@ module Overcommit::Hook::PrepareCommitMsg
         end
     end
 
+    # Compare bytes: String methods such as `lstrip` raise on a message that is
+    # not valid in the default encoding, for example an amended Latin-1 commit.
+    def keep_message?(contents)
+      message = contents.b.lstrip
+      message.match?(AUTOSQUASH_PREFIX) || starts_with_new_template?(message)
+    end
+
+    # Strip the template, because users type the prefix with or without the
+    # trailing space of `replacement_text`. Without that space, a template that
+    # ends in a word character, such as `PROJ-12`, must not match `PROJ-123`.
+    # A blank template never matches, so a whitespace-only `replacement_text`
+    # is still prepended as before.
+    def starts_with_new_template?(message)
+      template = new_template.b.strip
+      return false if template.empty? || !message.start_with?(template)
+
+      !(template.match?(/\w\z/) && message[template.size]&.match?(/\w/))
+    end
+
     def branch_pattern
       @branch_pattern ||=
         begin

data/lib/overcommit/hook_context/base.rb

@@ -99,7 +99,10 @@ module Overcommit::HookContext
       return @input_string if defined?(@input_string)
 
       @input_mutex.synchronize do
-        @input_string = @input.read unless defined?(@input_string)
+        unless defined?(@input_string)
+          @input.binmode if @input.respond_to?(:binmode)
+          @input_string = @input.read
+        end
       end
 
       @input_string

data/lib/overcommit/hook_context/commit_msg.rb

@@ -14,7 +14,7 @@ module Overcommit::HookContext
       commit_message.strip.empty?
     end
 
-    # User commit message stripped of comments and diff (from verbose output).
+    # User commit message with Git's comment handling and no verbose diff.
     def commit_message
       commit_message_lines.join
     end
@@ -27,9 +27,11 @@ module Overcommit::HookContext
     end
 
     def commit_message_lines
-      raw_commit_message_lines.
-        take_while { |line| !line.start_with?('diff --git') }.
-        reject     { |line| line.start_with?(comment_character) }
+      lines = raw_commit_message_lines.take_while { |line| !line.start_with?('diff --git') }
+      if cleanup_mode == 'strip'
+        lines.reject! { |line| line.start_with?(comment_character) }
+      end
+      lines
     end
 
     def comment_character
@@ -48,6 +50,10 @@ module Overcommit::HookContext
 
     private
 
+    def cleanup_mode
+      @cleanup_mode ||= Overcommit::GitConfig.commit_cleanup_mode
+    end
+
     def raw_commit_message_lines
       ::IO.readlines(commit_message_file)
     end

data/lib/overcommit/hook_context/helpers/stash_unstaged_changes.rb

@@ -17,6 +17,7 @@ module Overcommit::HookContext
         # editors/tools which watch for file changes.
         if !initial_commit? && unstaged_changes?
           stash_changes
+          restore_staged_changes if @changes_stashed
 
           # While running hooks make it appear as if nothing changed
           restore_modified_times
@@ -82,7 +83,7 @@ module Overcommit::HookContext
         stash_message = "Overcommit: Stash of repo state before hook run at #{Time.now}"
         result = Overcommit::Utils.with_environment('GIT_LITERAL_PATHSPECS' => '0') do
           Overcommit::Utils.execute(
-            %w[git -c commit.gpgsign=false stash save --keep-index --quiet] + [stash_message]
+            %w[git -c commit.gpgsign=false stash save --quiet] + [stash_message]
           )
         end
 
@@ -95,6 +96,19 @@ module Overcommit::HookContext
         end
 
         @changes_stashed = `git stash list -1`.include?(stash_message)
+        @stash_commit = `git rev-parse stash@{0}`.strip if @changes_stashed
+      end
+
+      # Restore the staged tree explicitly: older Git versions' --keep-index
+      # leave deleted files and the old paths of renamed files in the working tree.
+      # read-tree updates both the index and working tree without moving HEAD.
+      def restore_staged_changes
+        result = Overcommit::Utils.execute(%w[git read-tree --reset -u stash@{0}^2])
+        unless result.success?
+          raise Overcommit::Exceptions::HookSetupFailed,
+                "Unable to restore staged changes for #{hook_script_name} hook run:" \
+                "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}#{stash_recovery_message}"
+        end
       end
 
       # Restores the file modification times for all modified files to make it
@@ -116,7 +130,7 @@ module Overcommit::HookContext
         unless result.success?
           raise Overcommit::Exceptions::HookCleanupFailed,
                 "Unable to cleanup working tree after #{hook_script_name} hooks run:" \
-                "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+                "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}#{stash_recovery_message}"
         end
 
         # Hard-resetting a staged submodule removal results in the index being
@@ -136,9 +150,17 @@ module Overcommit::HookContext
         unless result.success?
           raise Overcommit::Exceptions::HookCleanupFailed,
                 "Unable to restore working tree after #{hook_script_name} hooks run:" \
-                "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}"
+                "\nSTDOUT:#{result.stdout}\nSTDERR:#{result.stderr}#{stash_recovery_message}"
         end
       end
+
+      def stash_recovery_message
+        return '' unless @stash_commit
+
+        "\nYour changes are preserved in Git stash #{@stash_commit}.\n" \
+          "Release any file locks and use a clean working tree to recover on a new branch:\n" \
+          "  git stash branch overcommit-recovery #{@stash_commit}\n"
+      end
     end
   end
 end

data/lib/overcommit/hook_loader/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'overcommit/utils/messages_utils'
+
 module Overcommit::HookLoader
   # Responsible for loading hooks from a file.
   class Base
@@ -22,27 +24,57 @@ module Overcommit::HookLoader
 
     private
 
+    def validate_line_aware_config(hook_config)
+      pattern = hook_config['message_pattern']
+      unless pattern.is_a?(Regexp) && pattern.names.include?('file')
+        raise Overcommit::Exceptions::HookLoadError,
+              '`message_pattern` must be a Regexp with a named `file` capture group'
+      end
+
+      warning_pattern = hook_config['warning_message_type_pattern']
+      unless warning_pattern.nil? || warning_pattern.is_a?(Regexp) || warning_pattern.is_a?(String)
+        raise Overcommit::Exceptions::HookLoadError,
+              '`warning_message_type_pattern` must be a Regexp or String'
+      end
+    end
+
+    def create_line_aware_command_hook_class(hook_base)
+      Class.new(hook_base) do
+        def run
+          result = execute(command, args: applicable_files)
+          return :pass if result.success?
+
+          output = result.stdout.split("\n")
+          return [:fail, result.stderr] if output.empty?
+
+          Overcommit::Utils::MessagesUtils.extract_messages(
+            output,
+            @config['message_pattern'],
+            Overcommit::Utils::MessagesUtils.create_type_categorizer(
+              @config['warning_message_type_pattern']
+            )
+          )
+        end
+      end
+    end
+
     attr_reader :log
 
     # Load and return a {Hook} from a CamelCase hook name.
     def create_hook(hook_name)
       hook_type_class = Overcommit::Hook.const_get(@context.hook_class_name)
       hook_base_class = hook_type_class.const_get(:Base)
-      hook_class = hook_type_class.const_get(hook_name)
-      unless hook_class < hook_base_class
+      hook_class = hook_type_class.const_get(hook_name, false)
+      unless hook_class.is_a?(Class) && hook_class < hook_base_class
         raise Overcommit::Exceptions::HookLoadError,
               "Class #{hook_name} is not a subclass of #{hook_base_class}."
       end
 
-      begin
-        Overcommit::Hook.const_get(@context.hook_class_name).
-                         const_get(hook_name).
-                         new(@config, @context)
-      rescue LoadError, NameError => e
-        raise Overcommit::Exceptions::HookLoadError,
-              "Unable to load hook '#{hook_name}': #{e}",
-              e.backtrace
-      end
+      hook_class.new(@config, @context)
+    rescue LoadError, NameError => e
+      raise Overcommit::Exceptions::HookLoadError,
+            "Unable to load hook '#{hook_name}': #{e}",
+            e.backtrace
     end
   end
 end

data/lib/overcommit/hook_loader/built_in_hook_loader.rb

@@ -6,7 +6,8 @@ module Overcommit::HookLoader
     def load_hooks
       @config.enabled_builtin_hooks(@context).map do |hook_name|
         underscored_hook_name = Overcommit::Utils.snake_case(hook_name)
-        require "overcommit/hook/#{@context.hook_type_name}/#{underscored_hook_name}"
+        require File.join(Overcommit::HOOK_DIRECTORY, @context.hook_type_name,
+                          "#{underscored_hook_name}.rb")
         create_hook(hook_name)
       end
     end

data/lib/overcommit/hook_loader/plugin_hook_loader.rb

@@ -5,11 +5,11 @@ require 'digest'
 module Overcommit::HookLoader
   # Responsible for loading hooks that are specific to the repository Overcommit
   # is running in.
-  class PluginHookLoader < Base
+  class PluginHookLoader < Base # rubocop:disable Metrics/ClassLength
     def load_hooks
-      check_for_modified_plugins if @config.verify_signatures?
+      check_for_unverified_plugins if @config.verify_signatures?
 
-      hooks = plugin_paths.map do |plugin_path|
+      hooks = load_gem_hooks + plugin_paths.map do |plugin_path|
         require plugin_path
 
         hook_name = Overcommit::Utils.camel_case(File.basename(plugin_path, '.rb'))
@@ -22,9 +22,9 @@ module Overcommit::HookLoader
     end
 
     def update_signatures
-      log.success('No plugin signatures have changed') if modified_plugins.empty?
+      log.success('All plugin signatures have been verified') if unverified_plugins.empty?
 
-      modified_plugins.each do |plugin|
+      unverified_plugins.each do |plugin|
         plugin.update_signature!
         log.warning "Updated signature of plugin #{plugin.hook_name}"
       end
@@ -32,6 +32,34 @@ module Overcommit::HookLoader
 
     private
 
+    def gem_plugins
+      @gem_plugins ||= @config.enabled_gem_hooks(@context).
+        map { |name| name.split('::').first }.uniq.sort.map do |namespace|
+          Overcommit::GemPlugin.new(namespace, @config, @context)
+        end
+    end
+
+    def load_gem_hooks
+      sources = gem_plugins.map { |plugin| [plugin, plugin.hook_paths] }
+      sources.flat_map do |plugin, paths|
+        hook_module = Overcommit::Hook.const_get(@context.hook_class_name)
+        if hook_module.const_defined?(plugin.namespace, false)
+          namespace = hook_module.const_get(plugin.namespace, false)
+          unless namespace.instance_of?(Module)
+            raise Overcommit::Exceptions::HookLoadError,
+                  "Gem namespace #{plugin.namespace} conflicts with an existing hook"
+          end
+        else
+          hook_module.const_set(plugin.namespace, Module.new)
+        end
+        plugin.activate
+        paths.zip(plugin.hook_names).map do |path, name|
+          require path
+          create_hook(name)
+        end
+      end
+    end
+
     def plugin_paths
       directory = File.join(@config.plugin_directory, @context.hook_type_name)
       Dir[File.join(directory, '*.rb')].sort
@@ -47,20 +75,20 @@ module Overcommit::HookLoader
       @config.enabled_ad_hoc_hooks(@context)
     end
 
-    def modified_plugins
-      (plugin_hook_names + ad_hoc_hook_names).
-        map { |hook_name| Overcommit::HookSigner.new(hook_name, @config, @context) }.
-        select(&:signature_changed?)
+    def unverified_plugins
+      signers = (plugin_hook_names + ad_hoc_hook_names).
+        map { |hook_name| Overcommit::HookSigner.new(hook_name, @config, @context) }
+      (gem_plugins + signers).reject(&:signature_verified?)
     end
 
-    def check_for_modified_plugins
-      return if modified_plugins.empty?
+    def check_for_unverified_plugins
+      return if unverified_plugins.empty?
 
       log.bold_warning "The following #{@context.hook_script_name} plugins " \
                        'have been added, changed, or had their configuration modified:'
       log.newline
 
-      modified_plugins.each do |signer|
+      unverified_plugins.each do |signer|
         log.warning " * #{signer.hook_name} in #{signer.hook_path}"
       end
 
@@ -74,16 +102,12 @@ module Overcommit::HookLoader
       raise Overcommit::Exceptions::InvalidHookSignature
     end
 
-    def create_ad_hoc_hook(hook_name)
-      hook_module = Overcommit::Hook.const_get(@context.hook_class_name)
-      hook_base = hook_module.const_get('Base')
-
+    def create_git_hook_class(hook_base)
       # Implement a simple class that executes the command and returns pass/fail
       # based on the exit status
-      hook_class = Class.new(hook_base) do
+      Class.new(hook_base) do
         def run
           result = @context.execute_hook(command)
-
           if result.success?
             :pass
           else
@@ -91,6 +115,25 @@ module Overcommit::HookLoader
           end
         end
       end
+    end
+
+    def create_ad_hoc_hook(hook_name)
+      hook_module = Overcommit::Hook.const_get(@context.hook_class_name)
+      hook_base = hook_module.const_get('Base')
+
+      hook_config = @config.for_hook(hook_name, @context.hook_class_name)
+      hook_class =
+        if hook_config['message_pattern']
+          validate_line_aware_config(hook_config)
+          create_line_aware_command_hook_class(hook_base)
+        else
+          create_git_hook_class(hook_base)
+        end
+
+      # A later load may configure the same hook to use a different command format.
+      if hook_module.const_defined?(hook_name, false)
+        hook_module.send(:remove_const, hook_name)
+      end
 
       hook_module.const_set(hook_name, hook_class).new(@config, @context)
     rescue LoadError, NameError => e

data/lib/overcommit/hook_runner.rb

@@ -197,7 +197,7 @@ module Overcommit
     end
 
     def load_hooks
-      require "overcommit/hook/#{@context.hook_type_name}/base"
+      require File.join(Overcommit::HOOK_DIRECTORY, @context.hook_type_name, 'base.rb')
 
       @hooks += HookLoader::BuiltInHookLoader.new(@config, @context, @log).load_hooks
 

data/lib/overcommit/hook_signer.rb

@@ -45,7 +45,7 @@ module Overcommit
                   'must be tracked by Git in order to be signed'
           end
 
-          File.join(Overcommit::Utils.repo_root, command.first.to_s)
+          File.expand_path(command.first.to_s, Overcommit::Utils.repo_root)
         end
       end
     end
@@ -58,25 +58,17 @@ module Overcommit
         file.start_with?(Overcommit::Utils.repo_root)
     end
 
-    # Return whether the signature for this hook has changed since it was last
-    # calculated.
+    # Return whether this exact combination of hook code and configuration
+    # has been explicitly trusted before.
     #
     # @return [true,false]
-    def signature_changed?
-      signature != stored_signature
+    def signature_verified?
+      signature_store.include?(signature)
     end
 
-    # Update the current stored signature for this hook.
+    # Remember the current signature without forgetting older approvals.
     def update_signature!
-      scope = Overcommit::GitConfig.signature_scope
-      result = Overcommit::Utils.execute(
-        %W[git config #{scope}] + [signature_config_key, signature]
-      )
-
-      unless result.success?
-        raise Overcommit::Exceptions::GitConfigError,
-              "Unable to write to local repo git config: #{result.stderr}"
-      end
+      signature_store.add(signature)
     end
 
     private
@@ -103,20 +95,8 @@ module Overcommit
       File.read(hook_path)
     end
 
-    def stored_signature
-      scope = Overcommit::GitConfig.signature_scope
-      result = Overcommit::Utils.execute(
-        %W[git config #{scope} --get] + [signature_config_key]
-      )
-
-      if result.status == 1 # Key doesn't exist
-        return ''
-      elsif result.status != 0
-        raise Overcommit::Exceptions::GitConfigError,
-              "Unable to read from local repo git config: #{result.stderr}"
-      end
-
-      result.stdout.chomp
+    def signature_store
+      @signature_store ||= Overcommit::Signature.new(signature_config_key)
     end
 
     def signature_config_key

data/lib/overcommit/signature.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+
+module Overcommit
+  # Repository-local approvals, indexed by hook identity and SHA256 signature.
+  # These files are outside Git's object database so fetching cannot add trust.
+  class Signature
+    def initialize(config_key)
+      @config_key = config_key
+      scope = Overcommit::GitConfig.signature_scope
+      root = if scope == '--worktree'
+               Overcommit::Utils.git_path('overcommit-signatures')
+             else
+               File.join(Overcommit::Utils.git_dir, 'overcommit-signatures')
+             end
+      @directory = File.join(root, Digest::SHA256.hexdigest(config_key))
+      migrate_legacy_signature(scope)
+    end
+
+    def include?(signature)
+      File.read(path(signature)) == contents(signature)
+    rescue Errno::ENOENT
+      false
+    rescue SystemCallError => e
+      raise Overcommit::Exceptions::SignatureError, "Unable to read signature history: #{e}"
+    end
+
+    def recorded?
+      File.directory?(@directory)
+    end
+
+    def add(signature)
+      FileUtils.mkdir_p(@directory)
+      File.write(path(signature), contents(signature), mode: 'w', perm: 0o600)
+    rescue SystemCallError => e
+      raise Overcommit::Exceptions::SignatureError, "Unable to write signature history: #{e}"
+    end
+
+    private
+
+    def path(signature)
+      File.join(@directory, signature)
+    end
+
+    def contents(signature)
+      "#{@config_key}\n#{signature}\n"
+    end
+
+    # Preserve an existing approval before removing its legacy Git config key.
+    # Removing the key means deleting history files actually revokes trust.
+    def migrate_legacy_signature(scope)
+      result = Overcommit::Utils.execute(%W[git config #{scope} --get] + [@config_key])
+      return if result.status == 1
+
+      check_config_result(result)
+      signature = result.stdout.chomp
+      add(signature) if signature.match?(/\A[0-9a-f]{64}\z/)
+      result = Overcommit::Utils.execute(%W[git config #{scope} --unset-all] + [@config_key])
+      check_config_result(result) unless result.status == 5 # Already removed by another process.
+    end
+
+    def check_config_result(result)
+      return if result.success?
+
+      raise Overcommit::Exceptions::GitConfigError,
+            "Unable to migrate local repo git config signature: #{result.stderr}"
+    end
+  end
+end

data/lib/overcommit/subprocess.rb

@@ -35,7 +35,8 @@ module Overcommit
         process.start
         if options[:input]
           begin
-            process.io.stdin.puts(options[:input])
+            process.io.stdin.binmode
+            process.io.stdin.write(options[:input])
           rescue StandardError
             # Silently ignore if the standard input stream of the spawned
             # process is closed before we get a chance to write to it. This

data/lib/overcommit/utils/messages_utils.rb

@@ -37,6 +37,20 @@ module Overcommit::Utils
         end
       end
 
+      def create_type_categorizer(warning_pattern)
+        return nil if warning_pattern.nil?
+
+        lambda do |type|
+          warning =
+            if warning_pattern.is_a?(Regexp)
+              type && warning_pattern.match?(type)
+            else
+              type&.include?(warning_pattern)
+            end
+          warning ? :warning : :error
+        end
+      end
+
       private
 
       def extract_file(match, message)

data/lib/overcommit/utils.rb

@@ -166,12 +166,7 @@ module Overcommit
         return if Process.ppid.zero?
 
         if OS.windows?
-          result = execute([
-            'powershell.exe', '-NoProfile', '-NonInteractive', '-Command',
-            "(Get-CimInstance Win32_Process -Filter 'ProcessId = #{Process.ppid}').CommandLine",
-          ])
-          command = result.stdout.strip
-          command if result.success? && !command.empty?
+          windows_parent_command
         elsif OS.cygwin?
           # Cygwin's `ps` command behaves differently than the traditional
           # Linux version, but a comparable `procps` is provided to compensate.
@@ -294,6 +289,69 @@ module Overcommit
 
       private
 
+      def windows_parent_command
+        native_windows_parent_command
+      rescue LoadError, StandardError
+        # win32ole is optional and absent from newer Ruby distributions.
+        # Use Script Host when it is unavailable or the COM query is denied.
+        scripted_windows_parent_command
+      end
+
+      def scripted_windows_parent_command
+        begin
+          result = execute([
+            'cscript.exe', '//nologo', '//B', '//U',
+            File.expand_path('../../libexec/overcommit-parent-command.js', __dir__),
+            Process.ppid.to_s,
+          ])
+          if result.success?
+            command = result.stdout.dup.force_encoding('UTF-16LE').encode('UTF-8').
+              delete_prefix("\uFEFF").strip
+            return command.empty? ? nil : command
+          end
+        rescue Errno::ENOENT, ChildProcess::LaunchError, EncodingError
+          # Preserve PowerShell when Script Host is disabled or unavailable.
+        end
+        powershell_windows_parent_command
+      end
+
+      def powershell_windows_parent_command
+        result = execute([
+          'powershell.exe', '-NoProfile', '-NonInteractive', '-Command',
+          <<~POWERSHELL,
+            $parentId = #{Process.ppid}
+            for ($level = 0; $level -lt 4; $level++) {
+              $process = Get-CimInstance Win32_Process -Filter "ProcessId = $parentId"
+              if (!$process) { break }
+              if ($process.Name -ine 'env.exe') { $process.CommandLine; break }
+              $parentId = $process.ParentProcessId
+            }
+          POWERSHELL
+        ])
+        command = result.stdout.strip
+        command if result.success? && !command.empty?
+      end
+
+      # Avoid starting PowerShell for every query when Ruby provides COM support.
+      def native_windows_parent_command
+        require 'win32ole'
+        service = WIN32OLE.connect('winmgmts:root/cimv2')
+        parent_id = Process.ppid
+        # Git for Windows' /usr/bin/env launcher remains between Git and Ruby.
+        4.times do
+          processes = service.ExecQuery(
+            'SELECT Name, CommandLine, ParentProcessId FROM Win32_Process ' \
+            "WHERE ProcessId = #{parent_id}"
+          )
+          process = processes.to_enum.first
+          return unless process
+          return process.CommandLine unless process.Name.to_s.casecmp?('env.exe')
+
+          parent_id = process.ParentProcessId
+        end
+        nil
+      end
+
       # Log debug output.
       #
       # This is necessary since some specs indirectly call utility functions but