root / scripts / get_maintainer.pl @ 43642b38
History | View | Annotate | Download (53.5 kB)
1 |
#!/usr/bin/perl -w |
---|---|
2 |
# (c) 2007, Joe Perches <joe@perches.com> |
3 |
# created from checkpatch.pl |
4 |
# |
5 |
# Print selected MAINTAINERS information for |
6 |
# the files modified in a patch or for a file |
7 |
# |
8 |
# usage: perl scripts/get_maintainer.pl [OPTIONS] <patch> |
9 |
# perl scripts/get_maintainer.pl [OPTIONS] -f <file> |
10 |
# |
11 |
# Licensed under the terms of the GNU GPL License version 2 |
12 |
|
13 |
use strict; |
14 |
|
15 |
my $P = $0; |
16 |
my $V = '0.26'; |
17 |
|
18 |
use Getopt::Long qw(:config no_auto_abbrev); |
19 |
|
20 |
my $lk_path = "./"; |
21 |
my $email = 1; |
22 |
my $email_usename = 1; |
23 |
my $email_maintainer = 1; |
24 |
my $email_list = 1; |
25 |
my $email_subscriber_list = 0; |
26 |
my $email_git_penguin_chiefs = 0; |
27 |
my $email_git = 0; |
28 |
my $email_git_all_signature_types = 0; |
29 |
my $email_git_blame = 0; |
30 |
my $email_git_blame_signatures = 1; |
31 |
my $email_git_fallback = 1; |
32 |
my $email_git_min_signatures = 1; |
33 |
my $email_git_max_maintainers = 5; |
34 |
my $email_git_min_percent = 5; |
35 |
my $email_git_since = "1-year-ago"; |
36 |
my $email_hg_since = "-365"; |
37 |
my $interactive = 0; |
38 |
my $email_remove_duplicates = 1; |
39 |
my $email_use_mailmap = 1; |
40 |
my $output_multiline = 1; |
41 |
my $output_separator = ", "; |
42 |
my $output_roles = 0; |
43 |
my $output_rolestats = 1; |
44 |
my $scm = 0; |
45 |
my $web = 0; |
46 |
my $subsystem = 0; |
47 |
my $status = 0; |
48 |
my $keywords = 1; |
49 |
my $sections = 0; |
50 |
my $file_emails = 0; |
51 |
my $from_filename = 0; |
52 |
my $pattern_depth = 0; |
53 |
my $version = 0; |
54 |
my $help = 0; |
55 |
|
56 |
my $vcs_used = 0; |
57 |
|
58 |
my $exit = 0; |
59 |
|
60 |
my %commit_author_hash; |
61 |
my %commit_signer_hash; |
62 |
|
63 |
my @penguin_chief = (); |
64 |
push(@penguin_chief, "Linus Torvalds:torvalds\@linux-foundation.org"); |
65 |
#Andrew wants in on most everything - 2009/01/14 |
66 |
#push(@penguin_chief, "Andrew Morton:akpm\@linux-foundation.org"); |
67 |
|
68 |
my @penguin_chief_names = (); |
69 |
foreach my $chief (@penguin_chief) { |
70 |
if ($chief =~ m/^(.*):(.*)/) { |
71 |
my $chief_name = $1; |
72 |
my $chief_addr = $2; |
73 |
push(@penguin_chief_names, $chief_name); |
74 |
} |
75 |
} |
76 |
my $penguin_chiefs = "\(" . join("|", @penguin_chief_names) . "\)"; |
77 |
|
78 |
# Signature types of people who are either |
79 |
# a) responsible for the code in question, or |
80 |
# b) familiar enough with it to give relevant feedback |
81 |
my @signature_tags = (); |
82 |
push(@signature_tags, "Signed-off-by:"); |
83 |
push(@signature_tags, "Reviewed-by:"); |
84 |
push(@signature_tags, "Acked-by:"); |
85 |
|
86 |
# rfc822 email address - preloaded methods go here. |
87 |
my $rfc822_lwsp = "(?:(?:\\r\\n)?[ \\t])"; |
88 |
my $rfc822_char = '[\\000-\\377]'; |
89 |
|
90 |
# VCS command support: class-like functions and strings |
91 |
|
92 |
my %VCS_cmds; |
93 |
|
94 |
my %VCS_cmds_git = ( |
95 |
"execute_cmd" => \&git_execute_cmd, |
96 |
"available" => '(which("git") ne "") && (-d ".git")', |
97 |
"find_signers_cmd" => |
98 |
"git log --no-color --since=\$email_git_since " . |
99 |
'--format="GitCommit: %H%n' . |
100 |
'GitAuthor: %an <%ae>%n' . |
101 |
'GitDate: %aD%n' . |
102 |
'GitSubject: %s%n' . |
103 |
'%b%n"' . |
104 |
" -- \$file", |
105 |
"find_commit_signers_cmd" => |
106 |
"git log --no-color " . |
107 |
'--format="GitCommit: %H%n' . |
108 |
'GitAuthor: %an <%ae>%n' . |
109 |
'GitDate: %aD%n' . |
110 |
'GitSubject: %s%n' . |
111 |
'%b%n"' . |
112 |
" -1 \$commit", |
113 |
"find_commit_author_cmd" => |
114 |
"git log --no-color " . |
115 |
'--format="GitCommit: %H%n' . |
116 |
'GitAuthor: %an <%ae>%n' . |
117 |
'GitDate: %aD%n' . |
118 |
'GitSubject: %s%n"' . |
119 |
" -1 \$commit", |
120 |
"blame_range_cmd" => "git blame -l -L \$diff_start,+\$diff_length \$file", |
121 |
"blame_file_cmd" => "git blame -l \$file", |
122 |
"commit_pattern" => "^GitCommit: ([0-9a-f]{40,40})", |
123 |
"blame_commit_pattern" => "^([0-9a-f]+) ", |
124 |
"author_pattern" => "^GitAuthor: (.*)", |
125 |
"subject_pattern" => "^GitSubject: (.*)", |
126 |
); |
127 |
|
128 |
my %VCS_cmds_hg = ( |
129 |
"execute_cmd" => \&hg_execute_cmd, |
130 |
"available" => '(which("hg") ne "") && (-d ".hg")', |
131 |
"find_signers_cmd" => |
132 |
"hg log --date=\$email_hg_since " . |
133 |
"--template='HgCommit: {node}\\n" . |
134 |
"HgAuthor: {author}\\n" . |
135 |
"HgSubject: {desc}\\n'" . |
136 |
" -- \$file", |
137 |
"find_commit_signers_cmd" => |
138 |
"hg log " . |
139 |
"--template='HgSubject: {desc}\\n'" . |
140 |
" -r \$commit", |
141 |
"find_commit_author_cmd" => |
142 |
"hg log " . |
143 |
"--template='HgCommit: {node}\\n" . |
144 |
"HgAuthor: {author}\\n" . |
145 |
"HgSubject: {desc|firstline}\\n'" . |
146 |
" -r \$commit", |
147 |
"blame_range_cmd" => "", # not supported |
148 |
"blame_file_cmd" => "hg blame -n \$file", |
149 |
"commit_pattern" => "^HgCommit: ([0-9a-f]{40,40})", |
150 |
"blame_commit_pattern" => "^([ 0-9a-f]+):", |
151 |
"author_pattern" => "^HgAuthor: (.*)", |
152 |
"subject_pattern" => "^HgSubject: (.*)", |
153 |
); |
154 |
|
155 |
my $conf = which_conf(".get_maintainer.conf"); |
156 |
if (-f $conf) { |
157 |
my @conf_args; |
158 |
open(my $conffile, '<', "$conf") |
159 |
or warn "$P: Can't find a readable .get_maintainer.conf file $!\n"; |
160 |
|
161 |
while (<$conffile>) { |
162 |
my $line = $_; |
163 |
|
164 |
$line =~ s/\s*\n?$//g; |
165 |
$line =~ s/^\s*//g; |
166 |
$line =~ s/\s+/ /g; |
167 |
|
168 |
next if ($line =~ m/^\s*#/); |
169 |
next if ($line =~ m/^\s*$/); |
170 |
|
171 |
my @words = split(" ", $line); |
172 |
foreach my $word (@words) { |
173 |
last if ($word =~ m/^#/); |
174 |
push (@conf_args, $word); |
175 |
} |
176 |
} |
177 |
close($conffile); |
178 |
unshift(@ARGV, @conf_args) if @conf_args; |
179 |
} |
180 |
|
181 |
if (!GetOptions( |
182 |
'email!' => \$email, |
183 |
'git!' => \$email_git, |
184 |
'git-all-signature-types!' => \$email_git_all_signature_types, |
185 |
'git-blame!' => \$email_git_blame, |
186 |
'git-blame-signatures!' => \$email_git_blame_signatures, |
187 |
'git-fallback!' => \$email_git_fallback, |
188 |
'git-chief-penguins!' => \$email_git_penguin_chiefs, |
189 |
'git-min-signatures=i' => \$email_git_min_signatures, |
190 |
'git-max-maintainers=i' => \$email_git_max_maintainers, |
191 |
'git-min-percent=i' => \$email_git_min_percent, |
192 |
'git-since=s' => \$email_git_since, |
193 |
'hg-since=s' => \$email_hg_since, |
194 |
'i|interactive!' => \$interactive, |
195 |
'remove-duplicates!' => \$email_remove_duplicates, |
196 |
'mailmap!' => \$email_use_mailmap, |
197 |
'm!' => \$email_maintainer, |
198 |
'n!' => \$email_usename, |
199 |
'l!' => \$email_list, |
200 |
's!' => \$email_subscriber_list, |
201 |
'multiline!' => \$output_multiline, |
202 |
'roles!' => \$output_roles, |
203 |
'rolestats!' => \$output_rolestats, |
204 |
'separator=s' => \$output_separator, |
205 |
'subsystem!' => \$subsystem, |
206 |
'status!' => \$status, |
207 |
'scm!' => \$scm, |
208 |
'web!' => \$web, |
209 |
'pattern-depth=i' => \$pattern_depth, |
210 |
'k|keywords!' => \$keywords, |
211 |
'sections!' => \$sections, |
212 |
'fe|file-emails!' => \$file_emails, |
213 |
'f|file' => \$from_filename, |
214 |
'v|version' => \$version, |
215 |
'h|help|usage' => \$help, |
216 |
)) { |
217 |
die "$P: invalid argument - use --help if necessary\n"; |
218 |
} |
219 |
|
220 |
if ($help != 0) { |
221 |
usage(); |
222 |
exit 0; |
223 |
} |
224 |
|
225 |
if ($version != 0) { |
226 |
print("${P} ${V}\n"); |
227 |
exit 0; |
228 |
} |
229 |
|
230 |
if (-t STDIN && !@ARGV) { |
231 |
# We're talking to a terminal, but have no command line arguments. |
232 |
die "$P: missing patchfile or -f file - use --help if necessary\n"; |
233 |
} |
234 |
|
235 |
$output_multiline = 0 if ($output_separator ne ", "); |
236 |
$output_rolestats = 1 if ($interactive); |
237 |
$output_roles = 1 if ($output_rolestats); |
238 |
|
239 |
if ($sections) { |
240 |
$email = 0; |
241 |
$email_list = 0; |
242 |
$scm = 0; |
243 |
$status = 0; |
244 |
$subsystem = 0; |
245 |
$web = 0; |
246 |
$keywords = 0; |
247 |
$interactive = 0; |
248 |
} else { |
249 |
my $selections = $email + $scm + $status + $subsystem + $web; |
250 |
if ($selections == 0) { |
251 |
die "$P: Missing required option: email, scm, status, subsystem or web\n"; |
252 |
} |
253 |
} |
254 |
|
255 |
if ($email && |
256 |
($email_maintainer + $email_list + $email_subscriber_list + |
257 |
$email_git + $email_git_penguin_chiefs + $email_git_blame) == 0) { |
258 |
die "$P: Please select at least 1 email option\n"; |
259 |
} |
260 |
|
261 |
if (!top_of_tree($lk_path)) { |
262 |
die "$P: The current directory does not appear to be " |
263 |
. "a QEMU source tree.\n"; |
264 |
} |
265 |
|
266 |
## Read MAINTAINERS for type/value pairs |
267 |
|
268 |
my @typevalue = (); |
269 |
my %keyword_hash; |
270 |
|
271 |
open (my $maint, '<', "${lk_path}MAINTAINERS") |
272 |
or die "$P: Can't open MAINTAINERS: $!\n"; |
273 |
while (<$maint>) { |
274 |
my $line = $_; |
275 |
|
276 |
if ($line =~ m/^(\C):\s*(.*)/) { |
277 |
my $type = $1; |
278 |
my $value = $2; |
279 |
|
280 |
##Filename pattern matching |
281 |
if ($type eq "F" || $type eq "X") { |
282 |
$value =~ s@\.@\\\.@g; ##Convert . to \. |
283 |
$value =~ s/\*/\.\*/g; ##Convert * to .* |
284 |
$value =~ s/\?/\./g; ##Convert ? to . |
285 |
##if pattern is a directory and it lacks a trailing slash, add one |
286 |
if ((-d $value)) { |
287 |
$value =~ s@([^/])$@$1/@; |
288 |
} |
289 |
} elsif ($type eq "K") { |
290 |
$keyword_hash{@typevalue} = $value; |
291 |
} |
292 |
push(@typevalue, "$type:$value"); |
293 |
} elsif (!/^(\s)*$/) { |
294 |
$line =~ s/\n$//g; |
295 |
push(@typevalue, $line); |
296 |
} |
297 |
} |
298 |
close($maint); |
299 |
|
300 |
|
301 |
# |
302 |
# Read mail address map |
303 |
# |
304 |
|
305 |
my $mailmap; |
306 |
|
307 |
read_mailmap(); |
308 |
|
309 |
sub read_mailmap { |
310 |
$mailmap = { |
311 |
names => {}, |
312 |
addresses => {} |
313 |
}; |
314 |
|
315 |
return if (!$email_use_mailmap || !(-f "${lk_path}.mailmap")); |
316 |
|
317 |
open(my $mailmap_file, '<', "${lk_path}.mailmap") |
318 |
or warn "$P: Can't open .mailmap: $!\n"; |
319 |
|
320 |
while (<$mailmap_file>) { |
321 |
s/#.*$//; #strip comments |
322 |
s/^\s+|\s+$//g; #trim |
323 |
|
324 |
next if (/^\s*$/); #skip empty lines |
325 |
#entries have one of the following formats: |
326 |
# name1 <mail1> |
327 |
# <mail1> <mail2> |
328 |
# name1 <mail1> <mail2> |
329 |
# name1 <mail1> name2 <mail2> |
330 |
# (see man git-shortlog) |
331 |
if (/^(.+)<(.+)>$/) { |
332 |
my $real_name = $1; |
333 |
my $address = $2; |
334 |
|
335 |
$real_name =~ s/\s+$//; |
336 |
($real_name, $address) = parse_email("$real_name <$address>"); |
337 |
$mailmap->{names}->{$address} = $real_name; |
338 |
|
339 |
} elsif (/^<([^\s]+)>\s*<([^\s]+)>$/) { |
340 |
my $real_address = $1; |
341 |
my $wrong_address = $2; |
342 |
|
343 |
$mailmap->{addresses}->{$wrong_address} = $real_address; |
344 |
|
345 |
} elsif (/^(.+)<([^\s]+)>\s*<([^\s]+)>$/) { |
346 |
my $real_name = $1; |
347 |
my $real_address = $2; |
348 |
my $wrong_address = $3; |
349 |
|
350 |
$real_name =~ s/\s+$//; |
351 |
($real_name, $real_address) = |
352 |
parse_email("$real_name <$real_address>"); |
353 |
$mailmap->{names}->{$wrong_address} = $real_name; |
354 |
$mailmap->{addresses}->{$wrong_address} = $real_address; |
355 |
|
356 |
} elsif (/^(.+)<([^\s]+)>\s*([^\s].*)<([^\s]+)>$/) { |
357 |
my $real_name = $1; |
358 |
my $real_address = $2; |
359 |
my $wrong_name = $3; |
360 |
my $wrong_address = $4; |
361 |
|
362 |
$real_name =~ s/\s+$//; |
363 |
($real_name, $real_address) = |
364 |
parse_email("$real_name <$real_address>"); |
365 |
|
366 |
$wrong_name =~ s/\s+$//; |
367 |
($wrong_name, $wrong_address) = |
368 |
parse_email("$wrong_name <$wrong_address>"); |
369 |
|
370 |
my $wrong_email = format_email($wrong_name, $wrong_address, 1); |
371 |
$mailmap->{names}->{$wrong_email} = $real_name; |
372 |
$mailmap->{addresses}->{$wrong_email} = $real_address; |
373 |
} |
374 |
} |
375 |
close($mailmap_file); |
376 |
} |
377 |
|
378 |
## use the filenames on the command line or find the filenames in the patchfiles |
379 |
|
380 |
my @files = (); |
381 |
my @range = (); |
382 |
my @keyword_tvi = (); |
383 |
my @file_emails = (); |
384 |
|
385 |
if (!@ARGV) { |
386 |
push(@ARGV, "&STDIN"); |
387 |
} |
388 |
|
389 |
foreach my $file (@ARGV) { |
390 |
if ($file ne "&STDIN") { |
391 |
##if $file is a directory and it lacks a trailing slash, add one |
392 |
if ((-d $file)) { |
393 |
$file =~ s@([^/])$@$1/@; |
394 |
} elsif (!(-f $file)) { |
395 |
die "$P: file '${file}' not found\n"; |
396 |
} |
397 |
} |
398 |
if ($from_filename) { |
399 |
push(@files, $file); |
400 |
if ($file ne "MAINTAINERS" && -f $file && ($keywords || $file_emails)) { |
401 |
open(my $f, '<', $file) |
402 |
or die "$P: Can't open $file: $!\n"; |
403 |
my $text = do { local($/) ; <$f> }; |
404 |
close($f); |
405 |
if ($keywords) { |
406 |
foreach my $line (keys %keyword_hash) { |
407 |
if ($text =~ m/$keyword_hash{$line}/x) { |
408 |
push(@keyword_tvi, $line); |
409 |
} |
410 |
} |
411 |
} |
412 |
if ($file_emails) { |
413 |
my @poss_addr = $text =~ m$[A-Za-zÀ-ÿ\"\' \,\.\+-]*\s*[\,]*\s*[\(\<\{]{0,1}[A-Za-z0-9_\.\+-]+\@[A-Za-z0-9\.-]+\.[A-Za-z0-9]+[\)\>\}]{0,1}$g; |
414 |
push(@file_emails, clean_file_emails(@poss_addr)); |
415 |
} |
416 |
} |
417 |
} else { |
418 |
my $file_cnt = @files; |
419 |
my $lastfile; |
420 |
|
421 |
open(my $patch, "< $file") |
422 |
or die "$P: Can't open $file: $!\n"; |
423 |
|
424 |
# We can check arbitrary information before the patch |
425 |
# like the commit message, mail headers, etc... |
426 |
# This allows us to match arbitrary keywords against any part |
427 |
# of a git format-patch generated file (subject tags, etc...) |
428 |
|
429 |
my $patch_prefix = ""; #Parsing the intro |
430 |
|
431 |
while (<$patch>) { |
432 |
my $patch_line = $_; |
433 |
if (m/^\+\+\+\s+(\S+)/) { |
434 |
my $filename = $1; |
435 |
$filename =~ s@^[^/]*/@@; |
436 |
$filename =~ s@\n@@; |
437 |
$lastfile = $filename; |
438 |
push(@files, $filename); |
439 |
$patch_prefix = "^[+-].*"; #Now parsing the actual patch |
440 |
} elsif (m/^\@\@ -(\d+),(\d+)/) { |
441 |
if ($email_git_blame) { |
442 |
push(@range, "$lastfile:$1:$2"); |
443 |
} |
444 |
} elsif ($keywords) { |
445 |
foreach my $line (keys %keyword_hash) { |
446 |
if ($patch_line =~ m/${patch_prefix}$keyword_hash{$line}/x) { |
447 |
push(@keyword_tvi, $line); |
448 |
} |
449 |
} |
450 |
} |
451 |
} |
452 |
close($patch); |
453 |
|
454 |
if ($file_cnt == @files) { |
455 |
warn "$P: file '${file}' doesn't appear to be a patch. " |
456 |
. "Add -f to options?\n"; |
457 |
} |
458 |
@files = sort_and_uniq(@files); |
459 |
} |
460 |
} |
461 |
|
462 |
@file_emails = uniq(@file_emails); |
463 |
|
464 |
my %email_hash_name; |
465 |
my %email_hash_address; |
466 |
my @email_to = (); |
467 |
my %hash_list_to; |
468 |
my @list_to = (); |
469 |
my @scm = (); |
470 |
my @web = (); |
471 |
my @subsystem = (); |
472 |
my @status = (); |
473 |
my %deduplicate_name_hash = (); |
474 |
my %deduplicate_address_hash = (); |
475 |
my $signature_pattern; |
476 |
|
477 |
my @maintainers = get_maintainers(); |
478 |
|
479 |
if (@maintainers) { |
480 |
@maintainers = merge_email(@maintainers); |
481 |
output(@maintainers); |
482 |
} |
483 |
|
484 |
if ($scm) { |
485 |
@scm = uniq(@scm); |
486 |
output(@scm); |
487 |
} |
488 |
|
489 |
if ($status) { |
490 |
@status = uniq(@status); |
491 |
output(@status); |
492 |
} |
493 |
|
494 |
if ($subsystem) { |
495 |
@subsystem = uniq(@subsystem); |
496 |
output(@subsystem); |
497 |
} |
498 |
|
499 |
if ($web) { |
500 |
@web = uniq(@web); |
501 |
output(@web); |
502 |
} |
503 |
|
504 |
exit($exit); |
505 |
|
506 |
sub range_is_maintained { |
507 |
my ($start, $end) = @_; |
508 |
|
509 |
for (my $i = $start; $i < $end; $i++) { |
510 |
my $line = $typevalue[$i]; |
511 |
if ($line =~ m/^(\C):\s*(.*)/) { |
512 |
my $type = $1; |
513 |
my $value = $2; |
514 |
if ($type eq 'S') { |
515 |
if ($value =~ /(maintain|support)/i) { |
516 |
return 1; |
517 |
} |
518 |
} |
519 |
} |
520 |
} |
521 |
return 0; |
522 |
} |
523 |
|
524 |
sub range_has_maintainer { |
525 |
my ($start, $end) = @_; |
526 |
|
527 |
for (my $i = $start; $i < $end; $i++) { |
528 |
my $line = $typevalue[$i]; |
529 |
if ($line =~ m/^(\C):\s*(.*)/) { |
530 |
my $type = $1; |
531 |
my $value = $2; |
532 |
if ($type eq 'M') { |
533 |
return 1; |
534 |
} |
535 |
} |
536 |
} |
537 |
return 0; |
538 |
} |
539 |
|
540 |
sub get_maintainers { |
541 |
%email_hash_name = (); |
542 |
%email_hash_address = (); |
543 |
%commit_author_hash = (); |
544 |
%commit_signer_hash = (); |
545 |
@email_to = (); |
546 |
%hash_list_to = (); |
547 |
@list_to = (); |
548 |
@scm = (); |
549 |
@web = (); |
550 |
@subsystem = (); |
551 |
@status = (); |
552 |
%deduplicate_name_hash = (); |
553 |
%deduplicate_address_hash = (); |
554 |
if ($email_git_all_signature_types) { |
555 |
$signature_pattern = "(.+?)[Bb][Yy]:"; |
556 |
} else { |
557 |
$signature_pattern = "\(" . join("|", @signature_tags) . "\)"; |
558 |
} |
559 |
|
560 |
# Find responsible parties |
561 |
|
562 |
my %exact_pattern_match_hash = (); |
563 |
|
564 |
foreach my $file (@files) { |
565 |
|
566 |
my %hash; |
567 |
my $tvi = find_first_section(); |
568 |
while ($tvi < @typevalue) { |
569 |
my $start = find_starting_index($tvi); |
570 |
my $end = find_ending_index($tvi); |
571 |
my $exclude = 0; |
572 |
my $i; |
573 |
|
574 |
#Do not match excluded file patterns |
575 |
|
576 |
for ($i = $start; $i < $end; $i++) { |
577 |
my $line = $typevalue[$i]; |
578 |
if ($line =~ m/^(\C):\s*(.*)/) { |
579 |
my $type = $1; |
580 |
my $value = $2; |
581 |
if ($type eq 'X') { |
582 |
if (file_match_pattern($file, $value)) { |
583 |
$exclude = 1; |
584 |
last; |
585 |
} |
586 |
} |
587 |
} |
588 |
} |
589 |
|
590 |
if (!$exclude) { |
591 |
for ($i = $start; $i < $end; $i++) { |
592 |
my $line = $typevalue[$i]; |
593 |
if ($line =~ m/^(\C):\s*(.*)/) { |
594 |
my $type = $1; |
595 |
my $value = $2; |
596 |
if ($type eq 'F') { |
597 |
if (file_match_pattern($file, $value)) { |
598 |
my $value_pd = ($value =~ tr@/@@); |
599 |
my $file_pd = ($file =~ tr@/@@); |
600 |
$value_pd++ if (substr($value,-1,1) ne "/"); |
601 |
$value_pd = -1 if ($value =~ /^\.\*/); |
602 |
if ($value_pd >= $file_pd && |
603 |
range_is_maintained($start, $end) && |
604 |
range_has_maintainer($start, $end)) { |
605 |
$exact_pattern_match_hash{$file} = 1; |
606 |
} |
607 |
if ($pattern_depth == 0 || |
608 |
(($file_pd - $value_pd) < $pattern_depth)) { |
609 |
$hash{$tvi} = $value_pd; |
610 |
} |
611 |
} |
612 |
} |
613 |
} |
614 |
} |
615 |
} |
616 |
$tvi = $end + 1; |
617 |
} |
618 |
|
619 |
foreach my $line (sort {$hash{$b} <=> $hash{$a}} keys %hash) { |
620 |
add_categories($line); |
621 |
if ($sections) { |
622 |
my $i; |
623 |
my $start = find_starting_index($line); |
624 |
my $end = find_ending_index($line); |
625 |
for ($i = $start; $i < $end; $i++) { |
626 |
my $line = $typevalue[$i]; |
627 |
if ($line =~ /^[FX]:/) { ##Restore file patterns |
628 |
$line =~ s/([^\\])\.([^\*])/$1\?$2/g; |
629 |
$line =~ s/([^\\])\.$/$1\?/g; ##Convert . back to ? |
630 |
$line =~ s/\\\./\./g; ##Convert \. to . |
631 |
$line =~ s/\.\*/\*/g; ##Convert .* to * |
632 |
} |
633 |
$line =~ s/^([A-Z]):/$1:\t/g; |
634 |
print("$line\n"); |
635 |
} |
636 |
print("\n"); |
637 |
} |
638 |
} |
639 |
} |
640 |
|
641 |
if ($keywords) { |
642 |
@keyword_tvi = sort_and_uniq(@keyword_tvi); |
643 |
foreach my $line (@keyword_tvi) { |
644 |
add_categories($line); |
645 |
} |
646 |
} |
647 |
|
648 |
foreach my $email (@email_to, @list_to) { |
649 |
$email->[0] = deduplicate_email($email->[0]); |
650 |
} |
651 |
|
652 |
foreach my $file (@files) { |
653 |
if ($email && |
654 |
($email_git || ($email_git_fallback && |
655 |
!$exact_pattern_match_hash{$file}))) { |
656 |
vcs_file_signoffs($file); |
657 |
} |
658 |
if ($email && $email_git_blame) { |
659 |
vcs_file_blame($file); |
660 |
} |
661 |
} |
662 |
|
663 |
if ($email) { |
664 |
foreach my $chief (@penguin_chief) { |
665 |
if ($chief =~ m/^(.*):(.*)/) { |
666 |
my $email_address; |
667 |
|
668 |
$email_address = format_email($1, $2, $email_usename); |
669 |
if ($email_git_penguin_chiefs) { |
670 |
push(@email_to, [$email_address, 'chief penguin']); |
671 |
} else { |
672 |
@email_to = grep($_->[0] !~ /${email_address}/, @email_to); |
673 |
} |
674 |
} |
675 |
} |
676 |
|
677 |
foreach my $email (@file_emails) { |
678 |
my ($name, $address) = parse_email($email); |
679 |
|
680 |
my $tmp_email = format_email($name, $address, $email_usename); |
681 |
push_email_address($tmp_email, ''); |
682 |
add_role($tmp_email, 'in file'); |
683 |
} |
684 |
} |
685 |
|
686 |
my @to = (); |
687 |
if ($email || $email_list) { |
688 |
if ($email) { |
689 |
@to = (@to, @email_to); |
690 |
} |
691 |
if ($email_list) { |
692 |
@to = (@to, @list_to); |
693 |
} |
694 |
} |
695 |
|
696 |
if ($interactive) { |
697 |
@to = interactive_get_maintainers(\@to); |
698 |
} |
699 |
|
700 |
return @to; |
701 |
} |
702 |
|
703 |
sub file_match_pattern { |
704 |
my ($file, $pattern) = @_; |
705 |
if (substr($pattern, -1) eq "/") { |
706 |
if ($file =~ m@^$pattern@) { |
707 |
return 1; |
708 |
} |
709 |
} else { |
710 |
if ($file =~ m@^$pattern@) { |
711 |
my $s1 = ($file =~ tr@/@@); |
712 |
my $s2 = ($pattern =~ tr@/@@); |
713 |
if ($s1 == $s2) { |
714 |
return 1; |
715 |
} |
716 |
} |
717 |
} |
718 |
return 0; |
719 |
} |
720 |
|
721 |
sub usage { |
722 |
print <<EOT; |
723 |
usage: $P [options] patchfile |
724 |
$P [options] -f file|directory |
725 |
version: $V |
726 |
|
727 |
MAINTAINER field selection options: |
728 |
--email => print email address(es) if any |
729 |
--git => include recent git \*-by: signers |
730 |
--git-all-signature-types => include signers regardless of signature type |
731 |
or use only ${signature_pattern} signers (default: $email_git_all_signature_types) |
732 |
--git-fallback => use git when no exact MAINTAINERS pattern (default: $email_git_fallback) |
733 |
--git-chief-penguins => include ${penguin_chiefs} |
734 |
--git-min-signatures => number of signatures required (default: $email_git_min_signatures) |
735 |
--git-max-maintainers => maximum maintainers to add (default: $email_git_max_maintainers) |
736 |
--git-min-percent => minimum percentage of commits required (default: $email_git_min_percent) |
737 |
--git-blame => use git blame to find modified commits for patch or file |
738 |
--git-since => git history to use (default: $email_git_since) |
739 |
--hg-since => hg history to use (default: $email_hg_since) |
740 |
--interactive => display a menu (mostly useful if used with the --git option) |
741 |
--m => include maintainer(s) if any |
742 |
--n => include name 'Full Name <addr\@domain.tld>' |
743 |
--l => include list(s) if any |
744 |
--s => include subscriber only list(s) if any |
745 |
--remove-duplicates => minimize duplicate email names/addresses |
746 |
--roles => show roles (status:subsystem, git-signer, list, etc...) |
747 |
--rolestats => show roles and statistics (commits/total_commits, %) |
748 |
--file-emails => add email addresses found in -f file (default: 0 (off)) |
749 |
--scm => print SCM tree(s) if any |
750 |
--status => print status if any |
751 |
--subsystem => print subsystem name if any |
752 |
--web => print website(s) if any |
753 |
|
754 |
Output type options: |
755 |
--separator [, ] => separator for multiple entries on 1 line |
756 |
using --separator also sets --nomultiline if --separator is not [, ] |
757 |
--multiline => print 1 entry per line |
758 |
|
759 |
Other options: |
760 |
--pattern-depth => Number of pattern directory traversals (default: 0 (all)) |
761 |
--keywords => scan patch for keywords (default: $keywords) |
762 |
--sections => print all of the subsystem sections with pattern matches |
763 |
--mailmap => use .mailmap file (default: $email_use_mailmap) |
764 |
--version => show version |
765 |
--help => show this help information |
766 |
|
767 |
Default options: |
768 |
[--email --nogit --git-fallback --m --n --l --multiline -pattern-depth=0 |
769 |
--remove-duplicates --rolestats] |
770 |
|
771 |
Notes: |
772 |
Using "-f directory" may give unexpected results: |
773 |
Used with "--git", git signators for _all_ files in and below |
774 |
directory are examined as git recurses directories. |
775 |
Any specified X: (exclude) pattern matches are _not_ ignored. |
776 |
Used with "--nogit", directory is used as a pattern match, |
777 |
no individual file within the directory or subdirectory |
778 |
is matched. |
779 |
Used with "--git-blame", does not iterate all files in directory |
780 |
Using "--git-blame" is slow and may add old committers and authors |
781 |
that are no longer active maintainers to the output. |
782 |
Using "--roles" or "--rolestats" with git send-email --cc-cmd or any |
783 |
other automated tools that expect only ["name"] <email address> |
784 |
may not work because of additional output after <email address>. |
785 |
Using "--rolestats" and "--git-blame" shows the #/total=% commits, |
786 |
not the percentage of the entire file authored. # of commits is |
787 |
not a good measure of amount of code authored. 1 major commit may |
788 |
contain a thousand lines, 5 trivial commits may modify a single line. |
789 |
If git is not installed, but mercurial (hg) is installed and an .hg |
790 |
repository exists, the following options apply to mercurial: |
791 |
--git, |
792 |
--git-min-signatures, --git-max-maintainers, --git-min-percent, and |
793 |
--git-blame |
794 |
Use --hg-since not --git-since to control date selection |
795 |
File ".get_maintainer.conf", if it exists in the QEMU source root |
796 |
directory, can change whatever get_maintainer defaults are desired. |
797 |
Entries in this file can be any command line argument. |
798 |
This file is prepended to any additional command line arguments. |
799 |
Multiple lines and # comments are allowed. |
800 |
EOT |
801 |
} |
802 |
|
803 |
sub top_of_tree { |
804 |
my ($lk_path) = @_; |
805 |
|
806 |
if ($lk_path ne "" && substr($lk_path,length($lk_path)-1,1) ne "/") { |
807 |
$lk_path .= "/"; |
808 |
} |
809 |
if ( (-f "${lk_path}COPYING") |
810 |
&& (-f "${lk_path}MAINTAINERS") |
811 |
&& (-f "${lk_path}Makefile") |
812 |
&& (-d "${lk_path}docs") |
813 |
&& (-f "${lk_path}VERSION") |
814 |
&& (-f "${lk_path}vl.c")) { |
815 |
return 1; |
816 |
} |
817 |
return 0; |
818 |
} |
819 |
|
820 |
sub parse_email { |
821 |
my ($formatted_email) = @_; |
822 |
|
823 |
my $name = ""; |
824 |
my $address = ""; |
825 |
|
826 |
if ($formatted_email =~ /^([^<]+)<(.+\@.*)>.*$/) { |
827 |
$name = $1; |
828 |
$address = $2; |
829 |
} elsif ($formatted_email =~ /^\s*<(.+\@\S*)>.*$/) { |
830 |
$address = $1; |
831 |
} elsif ($formatted_email =~ /^(.+\@\S*).*$/) { |
832 |
$address = $1; |
833 |
} |
834 |
|
835 |
$name =~ s/^\s+|\s+$//g; |
836 |
$name =~ s/^\"|\"$//g; |
837 |
$address =~ s/^\s+|\s+$//g; |
838 |
|
839 |
if ($name =~ /[^\w \-]/i) { ##has "must quote" chars |
840 |
$name =~ s/(?<!\\)"/\\"/g; ##escape quotes |
841 |
$name = "\"$name\""; |
842 |
} |
843 |
|
844 |
return ($name, $address); |
845 |
} |
846 |
|
847 |
sub format_email { |
848 |
my ($name, $address, $usename) = @_; |
849 |
|
850 |
my $formatted_email; |
851 |
|
852 |
$name =~ s/^\s+|\s+$//g; |
853 |
$name =~ s/^\"|\"$//g; |
854 |
$address =~ s/^\s+|\s+$//g; |
855 |
|
856 |
if ($name =~ /[^\w \-]/i) { ##has "must quote" chars |
857 |
$name =~ s/(?<!\\)"/\\"/g; ##escape quotes |
858 |
$name = "\"$name\""; |
859 |
} |
860 |
|
861 |
if ($usename) { |
862 |
if ("$name" eq "") { |
863 |
$formatted_email = "$address"; |
864 |
} else { |
865 |
$formatted_email = "$name <$address>"; |
866 |
} |
867 |
} else { |
868 |
$formatted_email = $address; |
869 |
} |
870 |
|
871 |
return $formatted_email; |
872 |
} |
873 |
|
874 |
sub find_first_section { |
875 |
my $index = 0; |
876 |
|
877 |
while ($index < @typevalue) { |
878 |
my $tv = $typevalue[$index]; |
879 |
if (($tv =~ m/^(\C):\s*(.*)/)) { |
880 |
last; |
881 |
} |
882 |
$index++; |
883 |
} |
884 |
|
885 |
return $index; |
886 |
} |
887 |
|
888 |
sub find_starting_index { |
889 |
my ($index) = @_; |
890 |
|
891 |
while ($index > 0) { |
892 |
my $tv = $typevalue[$index]; |
893 |
if (!($tv =~ m/^(\C):\s*(.*)/)) { |
894 |
last; |
895 |
} |
896 |
$index--; |
897 |
} |
898 |
|
899 |
return $index; |
900 |
} |
901 |
|
902 |
sub find_ending_index { |
903 |
my ($index) = @_; |
904 |
|
905 |
while ($index < @typevalue) { |
906 |
my $tv = $typevalue[$index]; |
907 |
if (!($tv =~ m/^(\C):\s*(.*)/)) { |
908 |
last; |
909 |
} |
910 |
$index++; |
911 |
} |
912 |
|
913 |
return $index; |
914 |
} |
915 |
|
916 |
sub get_maintainer_role { |
917 |
my ($index) = @_; |
918 |
|
919 |
my $i; |
920 |
my $start = find_starting_index($index); |
921 |
my $end = find_ending_index($index); |
922 |
|
923 |
my $role; |
924 |
my $subsystem = $typevalue[$start]; |
925 |
if (length($subsystem) > 20) { |
926 |
$subsystem = substr($subsystem, 0, 17); |
927 |
$subsystem =~ s/\s*$//; |
928 |
$subsystem = $subsystem . "..."; |
929 |
} |
930 |
|
931 |
for ($i = $start + 1; $i < $end; $i++) { |
932 |
my $tv = $typevalue[$i]; |
933 |
if ($tv =~ m/^(\C):\s*(.*)/) { |
934 |
my $ptype = $1; |
935 |
my $pvalue = $2; |
936 |
if ($ptype eq "S") { |
937 |
$role = $pvalue; |
938 |
} |
939 |
} |
940 |
} |
941 |
|
942 |
$role = lc($role); |
943 |
if ($role eq "supported") { |
944 |
$role = "supporter"; |
945 |
} elsif ($role eq "maintained") { |
946 |
$role = "maintainer"; |
947 |
} elsif ($role eq "odd fixes") { |
948 |
$role = "odd fixer"; |
949 |
} elsif ($role eq "orphan") { |
950 |
$role = "orphan minder"; |
951 |
} elsif ($role eq "obsolete") { |
952 |
$role = "obsolete minder"; |
953 |
} elsif ($role eq "buried alive in reporters") { |
954 |
$role = "chief penguin"; |
955 |
} |
956 |
|
957 |
return $role . ":" . $subsystem; |
958 |
} |
959 |
|
960 |
sub get_list_role { |
961 |
my ($index) = @_; |
962 |
|
963 |
my $i; |
964 |
my $start = find_starting_index($index); |
965 |
my $end = find_ending_index($index); |
966 |
|
967 |
my $subsystem = $typevalue[$start]; |
968 |
if (length($subsystem) > 20) { |
969 |
$subsystem = substr($subsystem, 0, 17); |
970 |
$subsystem =~ s/\s*$//; |
971 |
$subsystem = $subsystem . "..."; |
972 |
} |
973 |
|
974 |
if ($subsystem eq "THE REST") { |
975 |
$subsystem = ""; |
976 |
} |
977 |
|
978 |
return $subsystem; |
979 |
} |
980 |
|
981 |
sub add_categories { |
982 |
my ($index) = @_; |
983 |
|
984 |
my $i; |
985 |
my $start = find_starting_index($index); |
986 |
my $end = find_ending_index($index); |
987 |
|
988 |
push(@subsystem, $typevalue[$start]); |
989 |
|
990 |
for ($i = $start + 1; $i < $end; $i++) { |
991 |
my $tv = $typevalue[$i]; |
992 |
if ($tv =~ m/^(\C):\s*(.*)/) { |
993 |
my $ptype = $1; |
994 |
my $pvalue = $2; |
995 |
if ($ptype eq "L") { |
996 |
my $list_address = $pvalue; |
997 |
my $list_additional = ""; |
998 |
my $list_role = get_list_role($i); |
999 |
|
1000 |
if ($list_role ne "") { |
1001 |
$list_role = ":" . $list_role; |
1002 |
} |
1003 |
if ($list_address =~ m/([^\s]+)\s+(.*)$/) { |
1004 |
$list_address = $1; |
1005 |
$list_additional = $2; |
1006 |
} |
1007 |
if ($list_additional =~ m/subscribers-only/) { |
1008 |
if ($email_subscriber_list) { |
1009 |
if (!$hash_list_to{lc($list_address)}) { |
1010 |
$hash_list_to{lc($list_address)} = 1; |
1011 |
push(@list_to, [$list_address, |
1012 |
"subscriber list${list_role}"]); |
1013 |
} |
1014 |
} |
1015 |
} else { |
1016 |
if ($email_list) { |
1017 |
if (!$hash_list_to{lc($list_address)}) { |
1018 |
$hash_list_to{lc($list_address)} = 1; |
1019 |
push(@list_to, [$list_address, |
1020 |
"open list${list_role}"]); |
1021 |
} |
1022 |
} |
1023 |
} |
1024 |
} elsif ($ptype eq "M") { |
1025 |
my ($name, $address) = parse_email($pvalue); |
1026 |
if ($name eq "") { |
1027 |
if ($i > 0) { |
1028 |
my $tv = $typevalue[$i - 1]; |
1029 |
if ($tv =~ m/^(\C):\s*(.*)/) { |
1030 |
if ($1 eq "P") { |
1031 |
$name = $2; |
1032 |
$pvalue = format_email($name, $address, $email_usename); |
1033 |
} |
1034 |
} |
1035 |
} |
1036 |
} |
1037 |
if ($email_maintainer) { |
1038 |
my $role = get_maintainer_role($i); |
1039 |
push_email_addresses($pvalue, $role); |
1040 |
} |
1041 |
} elsif ($ptype eq "T") { |
1042 |
push(@scm, $pvalue); |
1043 |
} elsif ($ptype eq "W") { |
1044 |
push(@web, $pvalue); |
1045 |
} elsif ($ptype eq "S") { |
1046 |
push(@status, $pvalue); |
1047 |
} |
1048 |
} |
1049 |
} |
1050 |
} |
1051 |
|
1052 |
sub email_inuse { |
1053 |
my ($name, $address) = @_; |
1054 |
|
1055 |
return 1 if (($name eq "") && ($address eq "")); |
1056 |
return 1 if (($name ne "") && exists($email_hash_name{lc($name)})); |
1057 |
return 1 if (($address ne "") && exists($email_hash_address{lc($address)})); |
1058 |
|
1059 |
return 0; |
1060 |
} |
1061 |
|
1062 |
sub push_email_address { |
1063 |
my ($line, $role) = @_; |
1064 |
|
1065 |
my ($name, $address) = parse_email($line); |
1066 |
|
1067 |
if ($address eq "") { |
1068 |
return 0; |
1069 |
} |
1070 |
|
1071 |
if (!$email_remove_duplicates) { |
1072 |
push(@email_to, [format_email($name, $address, $email_usename), $role]); |
1073 |
} elsif (!email_inuse($name, $address)) { |
1074 |
push(@email_to, [format_email($name, $address, $email_usename), $role]); |
1075 |
$email_hash_name{lc($name)}++ if ($name ne ""); |
1076 |
$email_hash_address{lc($address)}++; |
1077 |
} |
1078 |
|
1079 |
return 1; |
1080 |
} |
1081 |
|
1082 |
sub push_email_addresses { |
1083 |
my ($address, $role) = @_; |
1084 |
|
1085 |
my @address_list = (); |
1086 |
|
1087 |
if (rfc822_valid($address)) { |
1088 |
push_email_address($address, $role); |
1089 |
} elsif (@address_list = rfc822_validlist($address)) { |
1090 |
my $array_count = shift(@address_list); |
1091 |
while (my $entry = shift(@address_list)) { |
1092 |
push_email_address($entry, $role); |
1093 |
} |
1094 |
} else { |
1095 |
if (!push_email_address($address, $role)) { |
1096 |
warn("Invalid MAINTAINERS address: '" . $address . "'\n"); |
1097 |
} |
1098 |
} |
1099 |
} |
1100 |
|
1101 |
sub add_role { |
1102 |
my ($line, $role) = @_; |
1103 |
|
1104 |
my ($name, $address) = parse_email($line); |
1105 |
my $email = format_email($name, $address, $email_usename); |
1106 |
|
1107 |
foreach my $entry (@email_to) { |
1108 |
if ($email_remove_duplicates) { |
1109 |
my ($entry_name, $entry_address) = parse_email($entry->[0]); |
1110 |
if (($name eq $entry_name || $address eq $entry_address) |
1111 |
&& ($role eq "" || !($entry->[1] =~ m/$role/)) |
1112 |
) { |
1113 |
if ($entry->[1] eq "") { |
1114 |
$entry->[1] = "$role"; |
1115 |
} else { |
1116 |
$entry->[1] = "$entry->[1],$role"; |
1117 |
} |
1118 |
} |
1119 |
} else { |
1120 |
if ($email eq $entry->[0] |
1121 |
&& ($role eq "" || !($entry->[1] =~ m/$role/)) |
1122 |
) { |
1123 |
if ($entry->[1] eq "") { |
1124 |
$entry->[1] = "$role"; |
1125 |
} else { |
1126 |
$entry->[1] = "$entry->[1],$role"; |
1127 |
} |
1128 |
} |
1129 |
} |
1130 |
} |
1131 |
} |
1132 |
|
1133 |
sub which { |
1134 |
my ($bin) = @_; |
1135 |
|
1136 |
foreach my $path (split(/:/, $ENV{PATH})) { |
1137 |
if (-e "$path/$bin") { |
1138 |
return "$path/$bin"; |
1139 |
} |
1140 |
} |
1141 |
|
1142 |
return ""; |
1143 |
} |
1144 |
|
1145 |
sub which_conf { |
1146 |
my ($conf) = @_; |
1147 |
|
1148 |
foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) { |
1149 |
if (-e "$path/$conf") { |
1150 |
return "$path/$conf"; |
1151 |
} |
1152 |
} |
1153 |
|
1154 |
return ""; |
1155 |
} |
1156 |
|
1157 |
sub mailmap_email { |
1158 |
my ($line) = @_; |
1159 |
|
1160 |
my ($name, $address) = parse_email($line); |
1161 |
my $email = format_email($name, $address, 1); |
1162 |
my $real_name = $name; |
1163 |
my $real_address = $address; |
1164 |
|
1165 |
if (exists $mailmap->{names}->{$email} || |
1166 |
exists $mailmap->{addresses}->{$email}) { |
1167 |
if (exists $mailmap->{names}->{$email}) { |
1168 |
$real_name = $mailmap->{names}->{$email}; |
1169 |
} |
1170 |
if (exists $mailmap->{addresses}->{$email}) { |
1171 |
$real_address = $mailmap->{addresses}->{$email}; |
1172 |
} |
1173 |
} else { |
1174 |
if (exists $mailmap->{names}->{$address}) { |
1175 |
$real_name = $mailmap->{names}->{$address}; |
1176 |
} |
1177 |
if (exists $mailmap->{addresses}->{$address}) { |
1178 |
$real_address = $mailmap->{addresses}->{$address}; |
1179 |
} |
1180 |
} |
1181 |
return format_email($real_name, $real_address, 1); |
1182 |
} |
1183 |
|
1184 |
sub mailmap { |
1185 |
my (@addresses) = @_; |
1186 |
|
1187 |
my @mapped_emails = (); |
1188 |
foreach my $line (@addresses) { |
1189 |
push(@mapped_emails, mailmap_email($line)); |
1190 |
} |
1191 |
merge_by_realname(@mapped_emails) if ($email_use_mailmap); |
1192 |
return @mapped_emails; |
1193 |
} |
1194 |
|
1195 |
sub merge_by_realname { |
1196 |
my %address_map; |
1197 |
my (@emails) = @_; |
1198 |
|
1199 |
foreach my $email (@emails) { |
1200 |
my ($name, $address) = parse_email($email); |
1201 |
if (exists $address_map{$name}) { |
1202 |
$address = $address_map{$name}; |
1203 |
$email = format_email($name, $address, 1); |
1204 |
} else { |
1205 |
$address_map{$name} = $address; |
1206 |
} |
1207 |
} |
1208 |
} |
1209 |
|
1210 |
sub git_execute_cmd { |
1211 |
my ($cmd) = @_; |
1212 |
my @lines = (); |
1213 |
|
1214 |
my $output = `$cmd`; |
1215 |
$output =~ s/^\s*//gm; |
1216 |
@lines = split("\n", $output); |
1217 |
|
1218 |
return @lines; |
1219 |
} |
1220 |
|
1221 |
sub hg_execute_cmd { |
1222 |
my ($cmd) = @_; |
1223 |
my @lines = (); |
1224 |
|
1225 |
my $output = `$cmd`; |
1226 |
@lines = split("\n", $output); |
1227 |
|
1228 |
return @lines; |
1229 |
} |
1230 |
|
1231 |
sub extract_formatted_signatures { |
1232 |
my (@signature_lines) = @_; |
1233 |
|
1234 |
my @type = @signature_lines; |
1235 |
|
1236 |
s/\s*(.*):.*/$1/ for (@type); |
1237 |
|
1238 |
# cut -f2- -d":" |
1239 |
s/\s*.*:\s*(.+)\s*/$1/ for (@signature_lines); |
1240 |
|
1241 |
## Reformat email addresses (with names) to avoid badly written signatures |
1242 |
|
1243 |
foreach my $signer (@signature_lines) { |
1244 |
$signer = deduplicate_email($signer); |
1245 |
} |
1246 |
|
1247 |
return (\@type, \@signature_lines); |
1248 |
} |
1249 |
|
1250 |
sub vcs_find_signers { |
1251 |
my ($cmd) = @_; |
1252 |
my $commits; |
1253 |
my @lines = (); |
1254 |
my @signatures = (); |
1255 |
|
1256 |
@lines = &{$VCS_cmds{"execute_cmd"}}($cmd); |
1257 |
|
1258 |
my $pattern = $VCS_cmds{"commit_pattern"}; |
1259 |
|
1260 |
$commits = grep(/$pattern/, @lines); # of commits |
1261 |
|
1262 |
@signatures = grep(/^[ \t]*${signature_pattern}.*\@.*$/, @lines); |
1263 |
|
1264 |
return (0, @signatures) if !@signatures; |
1265 |
|
1266 |
save_commits_by_author(@lines) if ($interactive); |
1267 |
save_commits_by_signer(@lines) if ($interactive); |
1268 |
|
1269 |
if (!$email_git_penguin_chiefs) { |
1270 |
@signatures = grep(!/${penguin_chiefs}/i, @signatures); |
1271 |
} |
1272 |
|
1273 |
my ($types_ref, $signers_ref) = extract_formatted_signatures(@signatures); |
1274 |
|
1275 |
return ($commits, @$signers_ref); |
1276 |
} |
1277 |
|
1278 |
sub vcs_find_author { |
1279 |
my ($cmd) = @_; |
1280 |
my @lines = (); |
1281 |
|
1282 |
@lines = &{$VCS_cmds{"execute_cmd"}}($cmd); |
1283 |
|
1284 |
if (!$email_git_penguin_chiefs) { |
1285 |
@lines = grep(!/${penguin_chiefs}/i, @lines); |
1286 |
} |
1287 |
|
1288 |
return @lines if !@lines; |
1289 |
|
1290 |
my @authors = (); |
1291 |
foreach my $line (@lines) { |
1292 |
if ($line =~ m/$VCS_cmds{"author_pattern"}/) { |
1293 |
my $author = $1; |
1294 |
my ($name, $address) = parse_email($author); |
1295 |
$author = format_email($name, $address, 1); |
1296 |
push(@authors, $author); |
1297 |
} |
1298 |
} |
1299 |
|
1300 |
save_commits_by_author(@lines) if ($interactive); |
1301 |
save_commits_by_signer(@lines) if ($interactive); |
1302 |
|
1303 |
return @authors; |
1304 |
} |
1305 |
|
1306 |
sub vcs_save_commits { |
1307 |
my ($cmd) = @_; |
1308 |
my @lines = (); |
1309 |
my @commits = (); |
1310 |
|
1311 |
@lines = &{$VCS_cmds{"execute_cmd"}}($cmd); |
1312 |
|
1313 |
foreach my $line (@lines) { |
1314 |
if ($line =~ m/$VCS_cmds{"blame_commit_pattern"}/) { |
1315 |
push(@commits, $1); |
1316 |
} |
1317 |
} |
1318 |
|
1319 |
return @commits; |
1320 |
} |
1321 |
|
1322 |
sub vcs_blame { |
1323 |
my ($file) = @_; |
1324 |
my $cmd; |
1325 |
my @commits = (); |
1326 |
|
1327 |
return @commits if (!(-f $file)); |
1328 |
|
1329 |
if (@range && $VCS_cmds{"blame_range_cmd"} eq "") { |
1330 |
my @all_commits = (); |
1331 |
|
1332 |
$cmd = $VCS_cmds{"blame_file_cmd"}; |
1333 |
$cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd |
1334 |
@all_commits = vcs_save_commits($cmd); |
1335 |
|
1336 |
foreach my $file_range_diff (@range) { |
1337 |
next if (!($file_range_diff =~ m/(.+):(.+):(.+)/)); |
1338 |
my $diff_file = $1; |
1339 |
my $diff_start = $2; |
1340 |
my $diff_length = $3; |
1341 |
next if ("$file" ne "$diff_file"); |
1342 |
for (my $i = $diff_start; $i < $diff_start + $diff_length; $i++) { |
1343 |
push(@commits, $all_commits[$i]); |
1344 |
} |
1345 |
} |
1346 |
} elsif (@range) { |
1347 |
foreach my $file_range_diff (@range) { |
1348 |
next if (!($file_range_diff =~ m/(.+):(.+):(.+)/)); |
1349 |
my $diff_file = $1; |
1350 |
my $diff_start = $2; |
1351 |
my $diff_length = $3; |
1352 |
next if ("$file" ne "$diff_file"); |
1353 |
$cmd = $VCS_cmds{"blame_range_cmd"}; |
1354 |
$cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd |
1355 |
push(@commits, vcs_save_commits($cmd)); |
1356 |
} |
1357 |
} else { |
1358 |
$cmd = $VCS_cmds{"blame_file_cmd"}; |
1359 |
$cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd |
1360 |
@commits = vcs_save_commits($cmd); |
1361 |
} |
1362 |
|
1363 |
foreach my $commit (@commits) { |
1364 |
$commit =~ s/^\^//g; |
1365 |
} |
1366 |
|
1367 |
return @commits; |
1368 |
} |
1369 |
|
1370 |
my $printed_novcs = 0; |
1371 |
sub vcs_exists { |
1372 |
%VCS_cmds = %VCS_cmds_git; |
1373 |
return 1 if eval $VCS_cmds{"available"}; |
1374 |
%VCS_cmds = %VCS_cmds_hg; |
1375 |
return 2 if eval $VCS_cmds{"available"}; |
1376 |
%VCS_cmds = (); |
1377 |
if (!$printed_novcs) { |
1378 |
warn("$P: No supported VCS found. Add --nogit to options?\n"); |
1379 |
warn("Using a git repository produces better results.\n"); |
1380 |
warn("Try latest git repository using:\n"); |
1381 |
warn("git clone git://git.qemu.org/qemu.git\n"); |
1382 |
$printed_novcs = 1; |
1383 |
} |
1384 |
return 0; |
1385 |
} |
1386 |
|
1387 |
sub vcs_is_git { |
1388 |
vcs_exists(); |
1389 |
return $vcs_used == 1; |
1390 |
} |
1391 |
|
1392 |
sub vcs_is_hg { |
1393 |
return $vcs_used == 2; |
1394 |
} |
1395 |
|
1396 |
sub interactive_get_maintainers { |
1397 |
my ($list_ref) = @_; |
1398 |
my @list = @$list_ref; |
1399 |
|
1400 |
vcs_exists(); |
1401 |
|
1402 |
my %selected; |
1403 |
my %authored; |
1404 |
my %signed; |
1405 |
my $count = 0; |
1406 |
my $maintained = 0; |
1407 |
foreach my $entry (@list) { |
1408 |
$maintained = 1 if ($entry->[1] =~ /^(maintainer|supporter)/i); |
1409 |
$selected{$count} = 1; |
1410 |
$authored{$count} = 0; |
1411 |
$signed{$count} = 0; |
1412 |
$count++; |
1413 |
} |
1414 |
|
1415 |
#menu loop |
1416 |
my $done = 0; |
1417 |
my $print_options = 0; |
1418 |
my $redraw = 1; |
1419 |
while (!$done) { |
1420 |
$count = 0; |
1421 |
if ($redraw) { |
1422 |
printf STDERR "\n%1s %2s %-65s", |
1423 |
"*", "#", "email/list and role:stats"; |
1424 |
if ($email_git || |
1425 |
($email_git_fallback && !$maintained) || |
1426 |
$email_git_blame) { |
1427 |
print STDERR "auth sign"; |
1428 |
} |
1429 |
print STDERR "\n"; |
1430 |
foreach my $entry (@list) { |
1431 |
my $email = $entry->[0]; |
1432 |
my $role = $entry->[1]; |
1433 |
my $sel = ""; |
1434 |
$sel = "*" if ($selected{$count}); |
1435 |
my $commit_author = $commit_author_hash{$email}; |
1436 |
my $commit_signer = $commit_signer_hash{$email}; |
1437 |
my $authored = 0; |
1438 |
my $signed = 0; |
1439 |
$authored++ for (@{$commit_author}); |
1440 |
$signed++ for (@{$commit_signer}); |
1441 |
printf STDERR "%1s %2d %-65s", $sel, $count + 1, $email; |
1442 |
printf STDERR "%4d %4d", $authored, $signed |
1443 |
if ($authored > 0 || $signed > 0); |
1444 |
printf STDERR "\n %s\n", $role; |
1445 |
if ($authored{$count}) { |
1446 |
my $commit_author = $commit_author_hash{$email}; |
1447 |
foreach my $ref (@{$commit_author}) { |
1448 |
print STDERR " Author: @{$ref}[1]\n"; |
1449 |
} |
1450 |
} |
1451 |
if ($signed{$count}) { |
1452 |
my $commit_signer = $commit_signer_hash{$email}; |
1453 |
foreach my $ref (@{$commit_signer}) { |
1454 |
print STDERR " @{$ref}[2]: @{$ref}[1]\n"; |
1455 |
} |
1456 |
} |
1457 |
|
1458 |
$count++; |
1459 |
} |
1460 |
} |
1461 |
my $date_ref = \$email_git_since; |
1462 |
$date_ref = \$email_hg_since if (vcs_is_hg()); |
1463 |
if ($print_options) { |
1464 |
$print_options = 0; |
1465 |
if (vcs_exists()) { |
1466 |
print STDERR <<EOT |
1467 |
|
1468 |
Version Control options: |
1469 |
g use git history [$email_git] |
1470 |
gf use git-fallback [$email_git_fallback] |
1471 |
b use git blame [$email_git_blame] |
1472 |
bs use blame signatures [$email_git_blame_signatures] |
1473 |
c# minimum commits [$email_git_min_signatures] |
1474 |
%# min percent [$email_git_min_percent] |
1475 |
d# history to use [$$date_ref] |
1476 |
x# max maintainers [$email_git_max_maintainers] |
1477 |
t all signature types [$email_git_all_signature_types] |
1478 |
m use .mailmap [$email_use_mailmap] |
1479 |
EOT |
1480 |
} |
1481 |
print STDERR <<EOT |
1482 |
|
1483 |
Additional options: |
1484 |
0 toggle all |
1485 |
tm toggle maintainers |
1486 |
tg toggle git entries |
1487 |
tl toggle open list entries |
1488 |
ts toggle subscriber list entries |
1489 |
f emails in file [$file_emails] |
1490 |
k keywords in file [$keywords] |
1491 |
r remove duplicates [$email_remove_duplicates] |
1492 |
p# pattern match depth [$pattern_depth] |
1493 |
EOT |
1494 |
} |
1495 |
print STDERR |
1496 |
"\n#(toggle), A#(author), S#(signed) *(all), ^(none), O(options), Y(approve): "; |
1497 |
|
1498 |
my $input = <STDIN>; |
1499 |
chomp($input); |
1500 |
|
1501 |
$redraw = 1; |
1502 |
my $rerun = 0; |
1503 |
my @wish = split(/[, ]+/, $input); |
1504 |
foreach my $nr (@wish) { |
1505 |
$nr = lc($nr); |
1506 |
my $sel = substr($nr, 0, 1); |
1507 |
my $str = substr($nr, 1); |
1508 |
my $val = 0; |
1509 |
$val = $1 if $str =~ /^(\d+)$/; |
1510 |
|
1511 |
if ($sel eq "y") { |
1512 |
$interactive = 0; |
1513 |
$done = 1; |
1514 |
$output_rolestats = 0; |
1515 |
$output_roles = 0; |
1516 |
last; |
1517 |
} elsif ($nr =~ /^\d+$/ && $nr > 0 && $nr <= $count) { |
1518 |
$selected{$nr - 1} = !$selected{$nr - 1}; |
1519 |
} elsif ($sel eq "*" || $sel eq '^') { |
1520 |
my $toggle = 0; |
1521 |
$toggle = 1 if ($sel eq '*'); |
1522 |
for (my $i = 0; $i < $count; $i++) { |
1523 |
$selected{$i} = $toggle; |
1524 |
} |
1525 |
} elsif ($sel eq "0") { |
1526 |
for (my $i = 0; $i < $count; $i++) { |
1527 |
$selected{$i} = !$selected{$i}; |
1528 |
} |
1529 |
} elsif ($sel eq "t") { |
1530 |
if (lc($str) eq "m") { |
1531 |
for (my $i = 0; $i < $count; $i++) { |
1532 |
$selected{$i} = !$selected{$i} |
1533 |
if ($list[$i]->[1] =~ /^(maintainer|supporter)/i); |
1534 |
} |
1535 |
} elsif (lc($str) eq "g") { |
1536 |
for (my $i = 0; $i < $count; $i++) { |
1537 |
$selected{$i} = !$selected{$i} |
1538 |
if ($list[$i]->[1] =~ /^(author|commit|signer)/i); |
1539 |
} |
1540 |
} elsif (lc($str) eq "l") { |
1541 |
for (my $i = 0; $i < $count; $i++) { |
1542 |
$selected{$i} = !$selected{$i} |
1543 |
if ($list[$i]->[1] =~ /^(open list)/i); |
1544 |
} |
1545 |
} elsif (lc($str) eq "s") { |
1546 |
for (my $i = 0; $i < $count; $i++) { |
1547 |
$selected{$i} = !$selected{$i} |
1548 |
if ($list[$i]->[1] =~ /^(subscriber list)/i); |
1549 |
} |
1550 |
} |
1551 |
} elsif ($sel eq "a") { |
1552 |
if ($val > 0 && $val <= $count) { |
1553 |
$authored{$val - 1} = !$authored{$val - 1}; |
1554 |
} elsif ($str eq '*' || $str eq '^') { |
1555 |
my $toggle = 0; |
1556 |
$toggle = 1 if ($str eq '*'); |
1557 |
for (my $i = 0; $i < $count; $i++) { |
1558 |
$authored{$i} = $toggle; |
1559 |
} |
1560 |
} |
1561 |
} elsif ($sel eq "s") { |
1562 |
if ($val > 0 && $val <= $count) { |
1563 |
$signed{$val - 1} = !$signed{$val - 1}; |
1564 |
} elsif ($str eq '*' || $str eq '^') { |
1565 |
my $toggle = 0; |
1566 |
$toggle = 1 if ($str eq '*'); |
1567 |
for (my $i = 0; $i < $count; $i++) { |
1568 |
$signed{$i} = $toggle; |
1569 |
} |
1570 |
} |
1571 |
} elsif ($sel eq "o") { |
1572 |
$print_options = 1; |
1573 |
$redraw = 1; |
1574 |
} elsif ($sel eq "g") { |
1575 |
if ($str eq "f") { |
1576 |
bool_invert(\$email_git_fallback); |
1577 |
} else { |
1578 |
bool_invert(\$email_git); |
1579 |
} |
1580 |
$rerun = 1; |
1581 |
} elsif ($sel eq "b") { |
1582 |
if ($str eq "s") { |
1583 |
bool_invert(\$email_git_blame_signatures); |
1584 |
} else { |
1585 |
bool_invert(\$email_git_blame); |
1586 |
} |
1587 |
$rerun = 1; |
1588 |
} elsif ($sel eq "c") { |
1589 |
if ($val > 0) { |
1590 |
$email_git_min_signatures = $val; |
1591 |
$rerun = 1; |
1592 |
} |
1593 |
} elsif ($sel eq "x") { |
1594 |
if ($val > 0) { |
1595 |
$email_git_max_maintainers = $val; |
1596 |
$rerun = 1; |
1597 |
} |
1598 |
} elsif ($sel eq "%") { |
1599 |
if ($str ne "" && $val >= 0) { |
1600 |
$email_git_min_percent = $val; |
1601 |
$rerun = 1; |
1602 |
} |
1603 |
} elsif ($sel eq "d") { |
1604 |
if (vcs_is_git()) { |
1605 |
$email_git_since = $str; |
1606 |
} elsif (vcs_is_hg()) { |
1607 |
$email_hg_since = $str; |
1608 |
} |
1609 |
$rerun = 1; |
1610 |
} elsif ($sel eq "t") { |
1611 |
bool_invert(\$email_git_all_signature_types); |
1612 |
$rerun = 1; |
1613 |
} elsif ($sel eq "f") { |
1614 |
bool_invert(\$file_emails); |
1615 |
$rerun = 1; |
1616 |
} elsif ($sel eq "r") { |
1617 |
bool_invert(\$email_remove_duplicates); |
1618 |
$rerun = 1; |
1619 |
} elsif ($sel eq "m") { |
1620 |
bool_invert(\$email_use_mailmap); |
1621 |
read_mailmap(); |
1622 |
$rerun = 1; |
1623 |
} elsif ($sel eq "k") { |
1624 |
bool_invert(\$keywords); |
1625 |
$rerun = 1; |
1626 |
} elsif ($sel eq "p") { |
1627 |
if ($str ne "" && $val >= 0) { |
1628 |
$pattern_depth = $val; |
1629 |
$rerun = 1; |
1630 |
} |
1631 |
} elsif ($sel eq "h" || $sel eq "?") { |
1632 |
print STDERR <<EOT |
1633 |
|
1634 |
Interactive mode allows you to select the various maintainers, submitters, |
1635 |
commit signers and mailing lists that could be CC'd on a patch. |
1636 |
|
1637 |
Any *'d entry is selected. |
1638 |
|
1639 |
If you have git or hg installed, you can choose to summarize the commit |
1640 |
history of files in the patch. Also, each line of the current file can |
1641 |
be matched to its commit author and that commits signers with blame. |
1642 |
|
1643 |
Various knobs exist to control the length of time for active commit |
1644 |
tracking, the maximum number of commit authors and signers to add, |
1645 |
and such. |
1646 |
|
1647 |
Enter selections at the prompt until you are satisfied that the selected |
1648 |
maintainers are appropriate. You may enter multiple selections separated |
1649 |
by either commas or spaces. |
1650 |
|
1651 |
EOT |
1652 |
} else { |
1653 |
print STDERR "invalid option: '$nr'\n"; |
1654 |
$redraw = 0; |
1655 |
} |
1656 |
} |
1657 |
if ($rerun) { |
1658 |
print STDERR "git-blame can be very slow, please have patience..." |
1659 |
if ($email_git_blame); |
1660 |
goto &get_maintainers; |
1661 |
} |
1662 |
} |
1663 |
|
1664 |
#drop not selected entries |
1665 |
$count = 0; |
1666 |
my @new_emailto = (); |
1667 |
foreach my $entry (@list) { |
1668 |
if ($selected{$count}) { |
1669 |
push(@new_emailto, $list[$count]); |
1670 |
} |
1671 |
$count++; |
1672 |
} |
1673 |
return @new_emailto; |
1674 |
} |
1675 |
|
1676 |
sub bool_invert { |
1677 |
my ($bool_ref) = @_; |
1678 |
|
1679 |
if ($$bool_ref) { |
1680 |
$$bool_ref = 0; |
1681 |
} else { |
1682 |
$$bool_ref = 1; |
1683 |
} |
1684 |
} |
1685 |
|
1686 |
sub deduplicate_email { |
1687 |
my ($email) = @_; |
1688 |
|
1689 |
my $matched = 0; |
1690 |
my ($name, $address) = parse_email($email); |
1691 |
$email = format_email($name, $address, 1); |
1692 |
$email = mailmap_email($email); |
1693 |
|
1694 |
return $email if (!$email_remove_duplicates); |
1695 |
|
1696 |
($name, $address) = parse_email($email); |
1697 |
|
1698 |
if ($name ne "" && $deduplicate_name_hash{lc($name)}) { |
1699 |
$name = $deduplicate_name_hash{lc($name)}->[0]; |
1700 |
$address = $deduplicate_name_hash{lc($name)}->[1]; |
1701 |
$matched = 1; |
1702 |
} elsif ($deduplicate_address_hash{lc($address)}) { |
1703 |
$name = $deduplicate_address_hash{lc($address)}->[0]; |
1704 |
$address = $deduplicate_address_hash{lc($address)}->[1]; |
1705 |
$matched = 1; |
1706 |
} |
1707 |
if (!$matched) { |
1708 |
$deduplicate_name_hash{lc($name)} = [ $name, $address ]; |
1709 |
$deduplicate_address_hash{lc($address)} = [ $name, $address ]; |
1710 |
} |
1711 |
$email = format_email($name, $address, 1); |
1712 |
$email = mailmap_email($email); |
1713 |
return $email; |
1714 |
} |
1715 |
|
1716 |
sub save_commits_by_author { |
1717 |
my (@lines) = @_; |
1718 |
|
1719 |
my @authors = (); |
1720 |
my @commits = (); |
1721 |
my @subjects = (); |
1722 |
|
1723 |
foreach my $line (@lines) { |
1724 |
if ($line =~ m/$VCS_cmds{"author_pattern"}/) { |
1725 |
my $author = $1; |
1726 |
$author = deduplicate_email($author); |
1727 |
push(@authors, $author); |
1728 |
} |
1729 |
push(@commits, $1) if ($line =~ m/$VCS_cmds{"commit_pattern"}/); |
1730 |
push(@subjects, $1) if ($line =~ m/$VCS_cmds{"subject_pattern"}/); |
1731 |
} |
1732 |
|
1733 |
for (my $i = 0; $i < @authors; $i++) { |
1734 |
my $exists = 0; |
1735 |
foreach my $ref(@{$commit_author_hash{$authors[$i]}}) { |
1736 |
if (@{$ref}[0] eq $commits[$i] && |
1737 |
@{$ref}[1] eq $subjects[$i]) { |
1738 |
$exists = 1; |
1739 |
last; |
1740 |
} |
1741 |
} |
1742 |
if (!$exists) { |
1743 |
push(@{$commit_author_hash{$authors[$i]}}, |
1744 |
[ ($commits[$i], $subjects[$i]) ]); |
1745 |
} |
1746 |
} |
1747 |
} |
1748 |
|
1749 |
sub save_commits_by_signer { |
1750 |
my (@lines) = @_; |
1751 |
|
1752 |
my $commit = ""; |
1753 |
my $subject = ""; |
1754 |
|
1755 |
foreach my $line (@lines) { |
1756 |
$commit = $1 if ($line =~ m/$VCS_cmds{"commit_pattern"}/); |
1757 |
$subject = $1 if ($line =~ m/$VCS_cmds{"subject_pattern"}/); |
1758 |
if ($line =~ /^[ \t]*${signature_pattern}.*\@.*$/) { |
1759 |
my @signatures = ($line); |
1760 |
my ($types_ref, $signers_ref) = extract_formatted_signatures(@signatures); |
1761 |
my @types = @$types_ref; |
1762 |
my @signers = @$signers_ref; |
1763 |
|
1764 |
my $type = $types[0]; |
1765 |
my $signer = $signers[0]; |
1766 |
|
1767 |
$signer = deduplicate_email($signer); |
1768 |
|
1769 |
my $exists = 0; |
1770 |
foreach my $ref(@{$commit_signer_hash{$signer}}) { |
1771 |
if (@{$ref}[0] eq $commit && |
1772 |
@{$ref}[1] eq $subject && |
1773 |
@{$ref}[2] eq $type) { |
1774 |
$exists = 1; |
1775 |
last; |
1776 |
} |
1777 |
} |
1778 |
if (!$exists) { |
1779 |
push(@{$commit_signer_hash{$signer}}, |
1780 |
[ ($commit, $subject, $type) ]); |
1781 |
} |
1782 |
} |
1783 |
} |
1784 |
} |
1785 |
|
1786 |
sub vcs_assign { |
1787 |
my ($role, $divisor, @lines) = @_; |
1788 |
|
1789 |
my %hash; |
1790 |
my $count = 0; |
1791 |
|
1792 |
return if (@lines <= 0); |
1793 |
|
1794 |
if ($divisor <= 0) { |
1795 |
warn("Bad divisor in " . (caller(0))[3] . ": $divisor\n"); |
1796 |
$divisor = 1; |
1797 |
} |
1798 |
|
1799 |
@lines = mailmap(@lines); |
1800 |
|
1801 |
return if (@lines <= 0); |
1802 |
|
1803 |
@lines = sort(@lines); |
1804 |
|
1805 |
# uniq -c |
1806 |
$hash{$_}++ for @lines; |
1807 |
|
1808 |
# sort -rn |
1809 |
foreach my $line (sort {$hash{$b} <=> $hash{$a}} keys %hash) { |
1810 |
my $sign_offs = $hash{$line}; |
1811 |
my $percent = $sign_offs * 100 / $divisor; |
1812 |
|
1813 |
$percent = 100 if ($percent > 100); |
1814 |
$count++; |
1815 |
last if ($sign_offs < $email_git_min_signatures || |
1816 |
$count > $email_git_max_maintainers || |
1817 |
$percent < $email_git_min_percent); |
1818 |
push_email_address($line, ''); |
1819 |
if ($output_rolestats) { |
1820 |
my $fmt_percent = sprintf("%.0f", $percent); |
1821 |
add_role($line, "$role:$sign_offs/$divisor=$fmt_percent%"); |
1822 |
} else { |
1823 |
add_role($line, $role); |
1824 |
} |
1825 |
} |
1826 |
} |
1827 |
|
1828 |
sub vcs_file_signoffs { |
1829 |
my ($file) = @_; |
1830 |
|
1831 |
my @signers = (); |
1832 |
my $commits; |
1833 |
|
1834 |
$vcs_used = vcs_exists(); |
1835 |
return if (!$vcs_used); |
1836 |
|
1837 |
my $cmd = $VCS_cmds{"find_signers_cmd"}; |
1838 |
$cmd =~ s/(\$\w+)/$1/eeg; # interpolate $cmd |
1839 |
|
1840 |
($commits, @signers) = vcs_find_signers($cmd); |
1841 |
|
1842 |
foreach my $signer (@signers) { |
1843 |
$signer = deduplicate_email($signer); |
1844 |
} |
1845 |
|
1846 |
vcs_assign("commit_signer", $commits, @signers); |
1847 |
} |
1848 |
|
1849 |
sub vcs_file_blame { |
1850 |
my ($file) = @_; |
1851 |
|
1852 |
my @signers = (); |
1853 |
my @all_commits = (); |
1854 |
my @commits = (); |
1855 |
my $total_commits; |
1856 |
my $total_lines; |
1857 |
|
1858 |
$vcs_used = vcs_exists(); |
1859 |
return if (!$vcs_used); |
1860 |
|
1861 |
@all_commits = vcs_blame($file); |
1862 |
@commits = uniq(@all_commits); |
1863 |
$total_commits = @commits; |
1864 |
$total_lines = @all_commits; |
1865 |
|
1866 |
if ($email_git_blame_signatures) { |
1867 |
if (vcs_is_hg()) { |
1868 |
my $commit_count; |
1869 |
my @commit_signers = (); |
1870 |
my $commit = join(" -r ", @commits); |
1871 |
my $cmd; |
1872 |
|
1873 |
$cmd = $VCS_cmds{"find_commit_signers_cmd"}; |
1874 |
$cmd =~ s/(\$\w+)/$1/eeg; #substitute variables in $cmd |
1875 |
|
1876 |
($commit_count, @commit_signers) = vcs_find_signers($cmd); |
1877 |
|
1878 |
push(@signers, @commit_signers); |
1879 |
} else { |
1880 |
foreach my $commit (@commits) { |
1881 |
my $commit_count; |
1882 |
my @commit_signers = (); |
1883 |
my $cmd; |
1884 |
|
1885 |
$cmd = $VCS_cmds{"find_commit_signers_cmd"}; |
1886 |
$cmd =~ s/(\$\w+)/$1/eeg; #substitute variables in $cmd |
1887 |
|
1888 |
($commit_count, @commit_signers) = vcs_find_signers($cmd); |
1889 |
|
1890 |
push(@signers, @commit_signers); |
1891 |
} |
1892 |
} |
1893 |
} |
1894 |
|
1895 |
if ($from_filename) { |
1896 |
if ($output_rolestats) { |
1897 |
my @blame_signers; |
1898 |
if (vcs_is_hg()) {{ # Double brace for last exit |
1899 |
my $commit_count; |
1900 |
my @commit_signers = (); |
1901 |
@commits = uniq(@commits); |
1902 |
@commits = sort(@commits); |
1903 |
my $commit = join(" -r ", @commits); |
1904 |
my $cmd; |
1905 |
|
1906 |
$cmd = $VCS_cmds{"find_commit_author_cmd"}; |
1907 |
$cmd =~ s/(\$\w+)/$1/eeg; #substitute variables in $cmd |
1908 |
|
1909 |
my @lines = (); |
1910 |
|
1911 |
@lines = &{$VCS_cmds{"execute_cmd"}}($cmd); |
1912 |
|
1913 |
if (!$email_git_penguin_chiefs) { |
1914 |
@lines = grep(!/${penguin_chiefs}/i, @lines); |
1915 |
} |
1916 |
|
1917 |
last if !@lines; |
1918 |
|
1919 |
my @authors = (); |
1920 |
foreach my $line (@lines) { |
1921 |
if ($line =~ m/$VCS_cmds{"author_pattern"}/) { |
1922 |
my $author = $1; |
1923 |
$author = deduplicate_email($author); |
1924 |
push(@authors, $author); |
1925 |
} |
1926 |
} |
1927 |
|
1928 |
save_commits_by_author(@lines) if ($interactive); |
1929 |
save_commits_by_signer(@lines) if ($interactive); |
1930 |
|
1931 |
push(@signers, @authors); |
1932 |
}} |
1933 |
else { |
1934 |
foreach my $commit (@commits) { |
1935 |
my $i; |
1936 |
my $cmd = $VCS_cmds{"find_commit_author_cmd"}; |
1937 |
$cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd |
1938 |
my @author = vcs_find_author($cmd); |
1939 |
next if !@author; |
1940 |
|
1941 |
my $formatted_author = deduplicate_email($author[0]); |
1942 |
|
1943 |
my $count = grep(/$commit/, @all_commits); |
1944 |
for ($i = 0; $i < $count ; $i++) { |
1945 |
push(@blame_signers, $formatted_author); |
1946 |
} |
1947 |
} |
1948 |
} |
1949 |
if (@blame_signers) { |
1950 |
vcs_assign("authored lines", $total_lines, @blame_signers); |
1951 |
} |
1952 |
} |
1953 |
foreach my $signer (@signers) { |
1954 |
$signer = deduplicate_email($signer); |
1955 |
} |
1956 |
vcs_assign("commits", $total_commits, @signers); |
1957 |
} else { |
1958 |
foreach my $signer (@signers) { |
1959 |
$signer = deduplicate_email($signer); |
1960 |
} |
1961 |
vcs_assign("modified commits", $total_commits, @signers); |
1962 |
} |
1963 |
} |
1964 |
|
1965 |
sub uniq { |
1966 |
my (@parms) = @_; |
1967 |
|
1968 |
my %saw; |
1969 |
@parms = grep(!$saw{$_}++, @parms); |
1970 |
return @parms; |
1971 |
} |
1972 |
|
1973 |
sub sort_and_uniq { |
1974 |
my (@parms) = @_; |
1975 |
|
1976 |
my %saw; |
1977 |
@parms = sort @parms; |
1978 |
@parms = grep(!$saw{$_}++, @parms); |
1979 |
return @parms; |
1980 |
} |
1981 |
|
1982 |
sub clean_file_emails { |
1983 |
my (@file_emails) = @_; |
1984 |
my @fmt_emails = (); |
1985 |
|
1986 |
foreach my $email (@file_emails) { |
1987 |
$email =~ s/[\(\<\{]{0,1}([A-Za-z0-9_\.\+-]+\@[A-Za-z0-9\.-]+)[\)\>\}]{0,1}/\<$1\>/g; |
1988 |
my ($name, $address) = parse_email($email); |
1989 |
if ($name eq '"[,\.]"') { |
1990 |
$name = ""; |
1991 |
} |
1992 |
|
1993 |
my @nw = split(/[^A-Za-zÀ-ÿ\'\,\.\+-]/, $name); |
1994 |
if (@nw > 2) { |
1995 |
my $first = $nw[@nw - 3]; |
1996 |
my $middle = $nw[@nw - 2]; |
1997 |
my $last = $nw[@nw - 1]; |
1998 |
|
1999 |
if (((length($first) == 1 && $first =~ m/[A-Za-z]/) || |
2000 |
(length($first) == 2 && substr($first, -1) eq ".")) || |
2001 |
(length($middle) == 1 || |
2002 |
(length($middle) == 2 && substr($middle, -1) eq "."))) { |
2003 |
$name = "$first $middle $last"; |
2004 |
} else { |
2005 |
$name = "$middle $last"; |
2006 |
} |
2007 |
} |
2008 |
|
2009 |
if (substr($name, -1) =~ /[,\.]/) { |
2010 |
$name = substr($name, 0, length($name) - 1); |
2011 |
} elsif (substr($name, -2) =~ /[,\.]"/) { |
2012 |
$name = substr($name, 0, length($name) - 2) . '"'; |
2013 |
} |
2014 |
|
2015 |
if (substr($name, 0, 1) =~ /[,\.]/) { |
2016 |
$name = substr($name, 1, length($name) - 1); |
2017 |
} elsif (substr($name, 0, 2) =~ /"[,\.]/) { |
2018 |
$name = '"' . substr($name, 2, length($name) - 2); |
2019 |
} |
2020 |
|
2021 |
my $fmt_email = format_email($name, $address, $email_usename); |
2022 |
push(@fmt_emails, $fmt_email); |
2023 |
} |
2024 |
return @fmt_emails; |
2025 |
} |
2026 |
|
2027 |
sub merge_email { |
2028 |
my @lines; |
2029 |
my %saw; |
2030 |
|
2031 |
for (@_) { |
2032 |
my ($address, $role) = @$_; |
2033 |
if (!$saw{$address}) { |
2034 |
if ($output_roles) { |
2035 |
push(@lines, "$address ($role)"); |
2036 |
} else { |
2037 |
push(@lines, $address); |
2038 |
} |
2039 |
$saw{$address} = 1; |
2040 |
} |
2041 |
} |
2042 |
|
2043 |
return @lines; |
2044 |
} |
2045 |
|
2046 |
sub output { |
2047 |
my (@parms) = @_; |
2048 |
|
2049 |
if ($output_multiline) { |
2050 |
foreach my $line (@parms) { |
2051 |
print("${line}\n"); |
2052 |
} |
2053 |
} else { |
2054 |
print(join($output_separator, @parms)); |
2055 |
print("\n"); |
2056 |
} |
2057 |
} |
2058 |
|
2059 |
my $rfc822re; |
2060 |
|
2061 |
sub make_rfc822re { |
2062 |
# Basic lexical tokens are specials, domain_literal, quoted_string, atom, and |
2063 |
# comment. We must allow for rfc822_lwsp (or comments) after each of these. |
2064 |
# This regexp will only work on addresses which have had comments stripped |
2065 |
# and replaced with rfc822_lwsp. |
2066 |
|
2067 |
my $specials = '()<>@,;:\\\\".\\[\\]'; |
2068 |
my $controls = '\\000-\\037\\177'; |
2069 |
|
2070 |
my $dtext = "[^\\[\\]\\r\\\\]"; |
2071 |
my $domain_literal = "\\[(?:$dtext|\\\\.)*\\]$rfc822_lwsp*"; |
2072 |
|
2073 |
my $quoted_string = "\"(?:[^\\\"\\r\\\\]|\\\\.|$rfc822_lwsp)*\"$rfc822_lwsp*"; |
2074 |
|
2075 |
# Use zero-width assertion to spot the limit of an atom. A simple |
2076 |
# $rfc822_lwsp* causes the regexp engine to hang occasionally. |
2077 |
my $atom = "[^$specials $controls]+(?:$rfc822_lwsp+|\\Z|(?=[\\[\"$specials]))"; |
2078 |
my $word = "(?:$atom|$quoted_string)"; |
2079 |
my $localpart = "$word(?:\\.$rfc822_lwsp*$word)*"; |
2080 |
|
2081 |
my $sub_domain = "(?:$atom|$domain_literal)"; |
2082 |
my $domain = "$sub_domain(?:\\.$rfc822_lwsp*$sub_domain)*"; |
2083 |
|
2084 |
my $addr_spec = "$localpart\@$rfc822_lwsp*$domain"; |
2085 |
|
2086 |
my $phrase = "$word*"; |
2087 |
my $route = "(?:\@$domain(?:,\@$rfc822_lwsp*$domain)*:$rfc822_lwsp*)"; |
2088 |
my $route_addr = "\\<$rfc822_lwsp*$route?$addr_spec\\>$rfc822_lwsp*"; |
2089 |
my $mailbox = "(?:$addr_spec|$phrase$route_addr)"; |
2090 |
|
2091 |
my $group = "$phrase:$rfc822_lwsp*(?:$mailbox(?:,\\s*$mailbox)*)?;\\s*"; |
2092 |
my $address = "(?:$mailbox|$group)"; |
2093 |
|
2094 |
return "$rfc822_lwsp*$address"; |
2095 |
} |
2096 |
|
2097 |
sub rfc822_strip_comments { |
2098 |
my $s = shift; |
2099 |
# Recursively remove comments, and replace with a single space. The simpler |
2100 |
# regexps in the Email Addressing FAQ are imperfect - they will miss escaped |
2101 |
# chars in atoms, for example. |
2102 |
|
2103 |
while ($s =~ s/^((?:[^"\\]|\\.)* |
2104 |
(?:"(?:[^"\\]|\\.)*"(?:[^"\\]|\\.)*)*) |
2105 |
\((?:[^()\\]|\\.)*\)/$1 /osx) {} |
2106 |
return $s; |
2107 |
} |
2108 |
|
2109 |
# valid: returns true if the parameter is an RFC822 valid address |
2110 |
# |
2111 |
sub rfc822_valid { |
2112 |
my $s = rfc822_strip_comments(shift); |
2113 |
|
2114 |
if (!$rfc822re) { |
2115 |
$rfc822re = make_rfc822re(); |
2116 |
} |
2117 |
|
2118 |
return $s =~ m/^$rfc822re$/so && $s =~ m/^$rfc822_char*$/; |
2119 |
} |
2120 |
|
2121 |
# validlist: In scalar context, returns true if the parameter is an RFC822 |
2122 |
# valid list of addresses. |
2123 |
# |
2124 |
# In list context, returns an empty list on failure (an invalid |
2125 |
# address was found); otherwise a list whose first element is the |
2126 |
# number of addresses found and whose remaining elements are the |
2127 |
# addresses. This is needed to disambiguate failure (invalid) |
2128 |
# from success with no addresses found, because an empty string is |
2129 |
# a valid list. |
2130 |
|
2131 |
sub rfc822_validlist { |
2132 |
my $s = rfc822_strip_comments(shift); |
2133 |
|
2134 |
if (!$rfc822re) { |
2135 |
$rfc822re = make_rfc822re(); |
2136 |
} |
2137 |
# * null list items are valid according to the RFC |
2138 |
# * the '1' business is to aid in distinguishing failure from no results |
2139 |
|
2140 |
my @r; |
2141 |
if ($s =~ m/^(?:$rfc822re)?(?:,(?:$rfc822re)?)*$/so && |
2142 |
$s =~ m/^$rfc822_char*$/) { |
2143 |
while ($s =~ m/(?:^|,$rfc822_lwsp*)($rfc822re)/gos) { |
2144 |
push(@r, $1); |
2145 |
} |
2146 |
return wantarray ? (scalar(@r), @r) : 1; |
2147 |
} |
2148 |
return wantarray ? () : 0; |
2149 |
} |