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