30066285380

Committed 24 Jul 2026 04:14AM UTC coverage: 91.935% (+0.3%) from 91.62%

Build # 30066285380

Build Type

Pull #887

github

Committed by

web-flow

Commit Message

Merge 91717e3e2 into ac17d9352

Pull Request Pull Request #887: Fix operation state restoration in linked worktrees

Coverage Stats

20 of 22 new or added lines in 2 files covered. (90.91%)

3306 of 3596 relevant lines covered (91.94%)

3265.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.74

/lib/overcommit/utils.rb

# frozen_string_literal: true

require 'etc'
require 'pathname'
require 'overcommit/os'
require 'overcommit/subprocess'
require 'overcommit/command_splitter'
require 'tempfile'

module Overcommit
  # Utility functions for general use.
  module Utils
    # Helper class for doing quick constraint validations on version numbers.
    #
    # This allows us to execute code based on the git version.
    class Version < Gem::Version
      # Overload comparison operators so we can conveniently compare this
      # version directly to a string in code.
      %w[< <= > >= == !=].each do |operator|
        define_method operator do |version|
          case version
          when String
            super(Gem::Version.new(version))
          else
            super(version)
          end
        end
      end
    end

    class << self
      # @return [Overcommit::Logger] logger with which to send debug output
      attr_accessor :log

      def script_path(script)
        File.join(Overcommit::HOME, 'libexec', script)
      end

      # Returns an absolute path to the root of the repository.
      #
      # We do this ourselves rather than call `git rev-parse --show-toplevel` to
      # solve an issue where the .git directory might not actually be valid in
      # tests.
      #
      # @return [String]
      def repo_root
        @repo_root ||=
          begin
            result = execute(%w[git rev-parse --show-toplevel])
            unless result.success?
              raise Overcommit::Exceptions::InvalidGitRepo,
                    'Unable to determine location of GIT_DIR. ' \
                    'Not a recognizable Git repository!'
            end
            result.stdout.chomp("\n")
          end
      end

      # Returns an absolute path to the .git directory for a repo.
      #
      # @return [String]
      def git_dir
        @git_dir ||=
          begin
            cmd = %w[git rev-parse]
            cmd << (GIT_VERSION < '2.5' ? '--git-dir' : '--git-common-dir')
            result = execute(cmd)
            unless result.success?
              raise Overcommit::Exceptions::InvalidGitRepo,
                    'Unable to determine location of GIT_DIR. ' \
                    'Not a recognizable Git repository!'
            end
            File.expand_path(result.stdout.chomp("\n"), Dir.pwd)
          end
      end

      # Returns an absolute path to a file in the current worktree's Git
      # directory.
      #
      # @param path [String]
      # @return [String]
      def git_path(path)
        cmd = %w[git rev-parse]
        if GIT_VERSION < '2.5'
          cmd << '--git-dir'
        else
          cmd += ['--git-path', path]
        end

        result = execute(cmd)
        unless result.success?
          raise Overcommit::Exceptions::InvalidGitRepo,
                'Unable to determine Git path. ' \
                'Not a recognizable Git repository!'
        end

        resolved_path = result.stdout.chomp("\n")
        resolved_path = File.join(resolved_path, path) if GIT_VERSION < '2.5'
        File.expand_path(resolved_path, Dir.pwd)
      end

      # Remove ANSI escape sequences from a string.
      #
      # This is useful for stripping colorized output from external tools.
      #
      # @param text [String]
      # @return [String]
      def strip_color_codes(text)
        text.gsub(/\e\[(\d+)(;\d+)*m/, '')
      end

      # Shamelessly stolen from:
      # stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
      def snake_case(str)
        str.gsub(/::/, '/').
            gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
            gsub(/([a-z\d])([A-Z])/, '\1_\2').
            tr('-', '_').
            downcase
      end

      # Converts a string containing underscores/hyphens/spaces into CamelCase.
      def camel_case(str)
        str.split(/_|-| /).map { |part| part.sub(/^\w/, &:upcase) }.join
      end

      # Returns a list of supported hook types (pre-commit, commit-msg, etc.)
      def supported_hook_types
        Dir[File.join(HOOK_DIRECTORY, '*')].
          select { |file| File.directory?(file) }.
          reject { |file| File.basename(file) == 'shared' }.
          map { |file| File.basename(file).tr('_', '-') }
      end

      # Returns a list of supported hook classes (PreCommit, CommitMsg, etc.)
      def supported_hook_type_classes
        supported_hook_types.map do |file|
          file.split('-').map(&:capitalize).join
        end
      end

      # @param cmd [String]
      # @return [true,false] whether a command can be found given the current
      #   environment path.
      def in_path?(cmd)
        # ENV['PATH'] doesn't include the repo root, but that is a valid
        # location for executables, so we want to add it to the list of places
        # we are checking for the executable.
        paths = [repo_root] + ENV['PATH'].split(File::PATH_SEPARATOR)
        exts  = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
        paths.each do |path|
          exts.each do |ext|
            cmd_with_ext = cmd.upcase.end_with?(ext.upcase) ? cmd : "#{cmd}#{ext}"
            full_path = File.join(path, cmd_with_ext)
            return true if File.executable?(full_path)
          end
        end
        false
      end

      # Return the parent command that triggered this hook run
      #
      # @return [String,nil] the command as a string, if a parent exists.
      def parent_command
        # When run in Docker containers, there may be no parent process.
        return if Process.ppid.zero?

        if OS.windows?
          `wmic process where ProcessId=#{Process.ppid} get CommandLine /FORMAT:VALUE`.
            strip.
            slice(/(?<=CommandLine=).+/)
        elsif OS.cygwin?
          # Cygwin's `ps` command behaves differently than the traditional
          # Linux version, but a comparable `procps` is provided to compensate.
          `procps -ocommand= -p #{Process.ppid}`.chomp
        else
          `ps -ocommand= -p #{Process.ppid}`.chomp
        end
      rescue Errno::EPERM, Errno::ENOENT
        # Process information may not be available, such as inside sandboxed environments
        nil
      end

      # Execute a command in a subprocess, capturing exit status and output from
      # both standard and error streams.
      #
      # This is intended to provide a centralized place to perform any checks or
      # filtering of the command before executing it.
      #
      # The `args` option provides a convenient way of splitting up long
      # argument lists which would otherwise exceed the maximum command line
      # length of the OS. It will break up the list into chunks and run the
      # command with the same prefix `initial_args`, finally combining the
      # output together at the end.
      #
      # This requires that the external command you are running can have its
      # work split up in this way and still produce the same resultant output
      # when outputs of the individual commands are concatenated back together.
      #
      # @param initial_args [Array<String>]
      # @param options [Hash]
      # @option options [Array<String>] :args long list of arguments to split up
      # @return [Overcommit::Subprocess::Result] status, stdout, and stderr
      def execute(initial_args, options = {})
        if initial_args.include?('|')
          raise Overcommit::Exceptions::InvalidCommandArgs,
                'Cannot pipe commands with the `execute` helper'
        end

        result =
          if (splittable_args = options.fetch(:args) { [] }).any?
            debug(initial_args.join(' ') + " ... (#{splittable_args.length} splittable args)")
            Overcommit::CommandSplitter.execute(initial_args, options)
          else
            debug(initial_args.join(' '))
            Overcommit::Subprocess.spawn(initial_args, options)
          end

        debug("EXIT STATUS: #{result.status}")
        debug("STDOUT: #{result.stdout.inspect}")
        debug("STDERR: #{result.stderr.inspect}")

        result
      end

      # Execute a command in a subprocess, returning immediately.
      #
      # This provides a convenient way to execute long-running processes for
      # which we do not need to know the result.
      #
      # @param args [Array<String>]
      # @return [ChildProcess] detached process spawned in the background
      def execute_in_background(args)
        if args.include?('|')
          raise Overcommit::Exceptions::InvalidCommandArgs,
                'Cannot pipe commands with the `execute_in_background` helper'
        end

        debug("Spawning background task: #{args.join(' ')}")
        Subprocess.spawn_detached(args)
      end

      # Return the number of processors used by the OS for process scheduling.
      def processor_count
        @processor_count ||= Etc.nprocessors
      end

      # Calls a block of code with a modified set of environment variables,
      # restoring them once the code has executed.
      def with_environment(env)
        old_env = {}
        env.each do |var, value|
          old_env[var] = ENV[var.to_s]
          ENV[var.to_s] = value
        end

        yield
      ensure
        old_env.each { |var, value| ENV[var.to_s] = value }
      end

      # Returns whether a file is a broken symlink.
      #
      # @return [true,false]
      def broken_symlink?(file)
        # JRuby's implementation of File.exist? returns true for broken
        # symlinks, so we need use File.size?
        Overcommit::Utils::FileUtils.symlink?(file) && File.size?(file).nil?
      end

      # Convert a glob pattern to an absolute path glob pattern rooted from the
      # repository root directory.
      #
      # @param glob [String]
      # @return [String]
      def convert_glob_to_absolute(glob)
        File.join(repo_root, glob)
      end

      # Return whether a pattern matches the given path.
      #
      # @param pattern [String]
      # @param path [String]
      def matches_path?(pattern, path)
        File.fnmatch?(
          pattern, path,
          File::FNM_PATHNAME | # Wildcard doesn't match separator
          File::FNM_DOTMATCH   # Wildcards match dotfiles
        )
      end

      private

      # Log debug output.
      #
      # This is necessary since some specs indirectly call utility functions but
      # don't explicitly set the logger for the Utils class, so we do a quick
      # check here to see if it's set before we attempt to log.
      #
      # @param args [Array<String>]
      def debug(*args)
        log&.debug(*args)
      end
    end
  end
end

1	# frozen_string_literal: true
2
3	require 'etc'	16✔
4	require 'pathname'	16✔
5	require 'overcommit/os'	16✔
6	require 'overcommit/subprocess'	16✔
7	require 'overcommit/command_splitter'	16✔
8	require 'tempfile'	16✔
9
10	module Overcommit	16✔
11	# Utility functions for general use.
12	module Utils	16✔
13	# Helper class for doing quick constraint validations on version numbers.
14	#
15	# This allows us to execute code based on the git version.
16	class Version < Gem::Version	16✔
17	# Overload comparison operators so we can conveniently compare this
18	# version directly to a string in code.
19	%w[< <= > >= == !=].each do \|operator\|	16✔
20	define_method operator do \|version\|	96✔
21	case version	4,000✔
22	when String
23	super(Gem::Version.new(version))	4,000✔
24	else
25	super(version)	×
26	end
27	end
28	end
29	end
30
31	class << self	16✔
32	# @return [Overcommit::Logger] logger with which to send debug output
33	attr_accessor :log	16✔
34
35	def script_path(script)	16✔
36	File.join(Overcommit::HOME, 'libexec', script)	96✔
37	end
38
39	# Returns an absolute path to the root of the repository.
40	#
41	# We do this ourselves rather than call `git rev-parse --show-toplevel` to
42	# solve an issue where the .git directory might not actually be valid in
43	# tests.
44	#
45	# @return [String]
46	def repo_root	16✔
47	@repo_root \|\|=	1,984✔
48	begin
49	result = execute(%w[git rev-parse --show-toplevel])	768✔
50	unless result.success?	768✔
51	raise Overcommit::Exceptions::InvalidGitRepo,	16✔
52	'Unable to determine location of GIT_DIR. ' \
53	'Not a recognizable Git repository!'
54	end
55	result.stdout.chomp("\n")	752✔
56	end
57	end
58
59	# Returns an absolute path to the .git directory for a repo.
60	#
61	# @return [String]
62	def git_dir	16✔
63	@git_dir \|\|=	320✔
64	begin
65	cmd = %w[git rev-parse]	320✔
66	cmd << (GIT_VERSION < '2.5' ? '--git-dir' : '--git-common-dir')	320✔
67	result = execute(cmd)	320✔
68	unless result.success?	320✔
69	raise Overcommit::Exceptions::InvalidGitRepo,	×
70	'Unable to determine location of GIT_DIR. ' \
71	'Not a recognizable Git repository!'
72	end
73	File.expand_path(result.stdout.chomp("\n"), Dir.pwd)	320✔
74	end
75	end
76
77	# Returns an absolute path to a file in the current worktree's Git
78	# directory.
79	#
80	# @param path [String]
81	# @return [String]
82	def git_path(path)	16✔
83	cmd = %w[git rev-parse]	1,760✔
84	if GIT_VERSION < '2.5'	1,760✔
NEW 85	cmd << '--git-dir'	×
86	else
87	cmd += ['--git-path', path]	1,760✔
88	end
89
90	result = execute(cmd)	1,760✔
91	unless result.success?	1,760✔
NEW 92	raise Overcommit::Exceptions::InvalidGitRepo,	×
93	'Unable to determine Git path. ' \
94	'Not a recognizable Git repository!'
95	end
96
97	resolved_path = result.stdout.chomp("\n")	1,760✔
98	resolved_path = File.join(resolved_path, path) if GIT_VERSION < '2.5'	1,760✔
99	File.expand_path(resolved_path, Dir.pwd)	1,760✔
100	end
101
102	# Remove ANSI escape sequences from a string.
103	#
104	# This is useful for stripping colorized output from external tools.
105	#
106	# @param text [String]
107	# @return [String]
108	def strip_color_codes(text)	16✔
109	text.gsub(/\e\[(\d+)(;\d+)*m/, '')	80✔
110	end
111
112	# Shamelessly stolen from:
113	# stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
114	def snake_case(str)	16✔
115	str.gsub(/::/, '/').	9,200✔
116	gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
117	gsub(/([a-z\d])([A-Z])/, '\1_\2').
118	tr('-', '_').
119	downcase
120	end
121
122	# Converts a string containing underscores/hyphens/spaces into CamelCase.
123	def camel_case(str)	16✔
124	str.split(/_\|-\| /).map { \|part\| part.sub(/^\w/, &:upcase) }.join	9,584✔
125	end
126
127	# Returns a list of supported hook types (pre-commit, commit-msg, etc.)
128	def supported_hook_types	16✔
129	Dir[File.join(HOOK_DIRECTORY, '*')].	19,552✔
130	select { \|file\| File.directory?(file) }.	215,072✔
131	reject { \|file\| File.basename(file) == 'shared' }.	195,520✔
132	map { \|file\| File.basename(file).tr('_', '-') }	175,968✔
133	end
134
135	# Returns a list of supported hook classes (PreCommit, CommitMsg, etc.)
136	def supported_hook_type_classes	16✔
137	supported_hook_types.map do \|file\|	18,624✔
138	file.split('-').map(&:capitalize).join	167,616✔
139	end
140	end
141
142	# @param cmd [String]
143	# @return [true,false] whether a command can be found given the current
144	# environment path.
145	def in_path?(cmd)	16✔
146	# ENV['PATH'] doesn't include the repo root, but that is a valid
147	# location for executables, so we want to add it to the list of places
148	# we are checking for the executable.
149	paths = [repo_root] + ENV['PATH'].split(File::PATH_SEPARATOR)	16✔
150	exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']	16✔
151	paths.each do \|path\|	16✔
152	exts.each do \|ext\|	224✔
153	cmd_with_ext = cmd.upcase.end_with?(ext.upcase) ? cmd : "#{cmd}#{ext}"	224✔
154	full_path = File.join(path, cmd_with_ext)	224✔
155	return true if File.executable?(full_path)	224✔
156	end
157	end
158	false	×
159	end
160
161	# Return the parent command that triggered this hook run
162	#
163	# @return [String,nil] the command as a string, if a parent exists.
164	def parent_command	16✔
165	# When run in Docker containers, there may be no parent process.
166	return if Process.ppid.zero?	832✔
167
168	if OS.windows?	816✔
169	`wmic process where ProcessId=#{Process.ppid} get CommandLine /FORMAT:VALUE`.	×
170	strip.
171	slice(/(?<=CommandLine=).+/)
172	elsif OS.cygwin?	816✔
173	# Cygwin's `ps` command behaves differently than the traditional
174	# Linux version, but a comparable `procps` is provided to compensate.
175	`procps -ocommand= -p #{Process.ppid}`.chomp	×
176	else
177	`ps -ocommand= -p #{Process.ppid}`.chomp	816✔
178	end
179	rescue Errno::EPERM, Errno::ENOENT
180	# Process information may not be available, such as inside sandboxed environments
181	nil	×
182	end
183
184	# Execute a command in a subprocess, capturing exit status and output from
185	# both standard and error streams.
186	#
187	# This is intended to provide a centralized place to perform any checks or
188	# filtering of the command before executing it.
189	#
190	# The `args` option provides a convenient way of splitting up long
191	# argument lists which would otherwise exceed the maximum command line
192	# length of the OS. It will break up the list into chunks and run the
193	# command with the same prefix `initial_args`, finally combining the
194	# output together at the end.
195	#
196	# This requires that the external command you are running can have its
197	# work split up in this way and still produce the same resultant output
198	# when outputs of the individual commands are concatenated back together.
199	#
200	# @param initial_args [Array<String>]
201	# @param options [Hash]
202	# @option options [Array<String>] :args long list of arguments to split up
203	# @return [Overcommit::Subprocess::Result] status, stdout, and stderr
204	def execute(initial_args, options = {})	16✔
205	if initial_args.include?('\|')	15,072✔
206	raise Overcommit::Exceptions::InvalidCommandArgs,	16✔
207	'Cannot pipe commands with the `execute` helper'
208	end
209
210	result =
211	if (splittable_args = options.fetch(:args) { [] }).any?	29,488✔
212	debug(initial_args.join(' ') + " ... (#{splittable_args.length} splittable args)")	608✔
213	Overcommit::CommandSplitter.execute(initial_args, options)	608✔
214	else
215	debug(initial_args.join(' '))	14,448✔
216	Overcommit::Subprocess.spawn(initial_args, options)	14,448✔
217	end
218
219	debug("EXIT STATUS: #{result.status}")	15,056✔
220	debug("STDOUT: #{result.stdout.inspect}")	15,056✔
221	debug("STDERR: #{result.stderr.inspect}")	15,056✔
222
223	result	15,056✔
224	end
225
226	# Execute a command in a subprocess, returning immediately.
227	#
228	# This provides a convenient way to execute long-running processes for
229	# which we do not need to know the result.
230	#
231	# @param args [Array<String>]
232	# @return [ChildProcess] detached process spawned in the background
233	def execute_in_background(args)	16✔
234	if args.include?('\|')	16✔
235	raise Overcommit::Exceptions::InvalidCommandArgs,	×
236	'Cannot pipe commands with the `execute_in_background` helper'
237	end
238
239	debug("Spawning background task: #{args.join(' ')}")	16✔
240	Subprocess.spawn_detached(args)	16✔
241	end
242
243	# Return the number of processors used by the OS for process scheduling.
244	def processor_count	16✔
245	@processor_count \|\|= Etc.nprocessors	4,480✔
246	end
247
248	# Calls a block of code with a modified set of environment variables,
249	# restoring them once the code has executed.
250	def with_environment(env)	16✔
251	old_env = {}	27,648✔
252	env.each do \|var, value\|	27,648✔
253	old_env[var] = ENV[var.to_s]	27,344✔
254	ENV[var.to_s] = value	27,344✔
255	end
256
257	yield	27,648✔
258	ensure
259	old_env.each { \|var, value\| ENV[var.to_s] = value }	54,992✔
260	end
261
262	# Returns whether a file is a broken symlink.
263	#
264	# @return [true,false]
265	def broken_symlink?(file)	16✔
266	# JRuby's implementation of File.exist? returns true for broken
267	# symlinks, so we need use File.size?
268	Overcommit::Utils::FileUtils.symlink?(file) && File.size?(file).nil?	9,952✔
269	end
270
271	# Convert a glob pattern to an absolute path glob pattern rooted from the
272	# repository root directory.
273	#
274	# @param glob [String]
275	# @return [String]
276	def convert_glob_to_absolute(glob)	16✔
277	File.join(repo_root, glob)	80✔
278	end
279
280	# Return whether a pattern matches the given path.
281	#
282	# @param pattern [String]
283	# @param path [String]
284	def matches_path?(pattern, path)	16✔
285	File.fnmatch?(	32✔
286	pattern, path,
287	File::FNM_PATHNAME \| # Wildcard doesn't match separator
288	File::FNM_DOTMATCH # Wildcards match dotfiles
289	)
290	end
291
292	private	16✔
293
294	# Log debug output.
295	#
296	# This is necessary since some specs indirectly call utility functions but
297	# don't explicitly set the logger for the Utils class, so we do a quick
298	# check here to see if it's set before we attempt to log.
299	#
300	# @param args [Array<String>]
301	def debug(*args)	16✔
302	log&.debug(*args)	60,240✔
303	end
304	end
305	end
306	end

sds / overcommit / 30066285380

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous