forked from sds/overcommit
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathutils.rb
More file actions
302 lines (276 loc) · 10.8 KB
/
utils.rb
File metadata and controls
302 lines (276 loc) · 10.8 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
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
# 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
def parent_command
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
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.
#
# @see https://github.com/grosser/parallel/blob/v1.6.1/lib/parallel/processor_count.rb#L17-L51
def processor_count # rubocop:disable all
@processor_count ||=
begin
if Overcommit::OS.windows?
require 'win32ole'
result = WIN32OLE.connect('winmgmts://').ExecQuery(
'select NumberOfLogicalProcessors from Win32_Processor'
)
result.to_enum.collect(&:NumberOfLogicalProcessors).reduce(:+)
elsif File.readable?('/proc/cpuinfo')
IO.read('/proc/cpuinfo').scan(/^processor/).size
elsif File.executable?('/usr/bin/hwprefs')
IO.popen('/usr/bin/hwprefs thread_count').read.to_i
elsif File.executable?('/usr/sbin/psrinfo')
IO.popen('/usr/sbin/psrinfo').read.scan(/^.*on-*line/).size
elsif File.executable?('/usr/sbin/ioscan')
IO.popen('/usr/sbin/ioscan -kC processor') do |out|
out.read.scan(/^.*processor/).size
end
elsif File.executable?('/usr/sbin/pmcycles')
IO.popen('/usr/sbin/pmcycles -m').read.count("\n")
elsif File.executable?('/usr/sbin/lsdev')
IO.popen('/usr/sbin/lsdev -Cc processor -S 1').read.count("\n")
elsif File.executable?('/usr/sbin/sysctl')
IO.popen('/usr/sbin/sysctl -n hw.ncpu').read.to_i
elsif File.executable?('/sbin/sysctl')
IO.popen('/sbin/sysctl -n hw.ncpu').read.to_i
else
# Unknown platform; assume 1 processor
1
end
end
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) if log
end
end
end
end