]> git.madduck.net Git - code/myrepos.git/blob - mr

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Add --insecure option that can be used to ignore SSL cert errors when bootstrapping...
[code/myrepos.git] / mr
1 #!/usr/bin/perl
2
3 =head1 NAME
4
5 mr - a Multiple Repository management tool
6
7 =head1 SYNOPSIS
8
9 B<mr> [options] checkout
10
11 B<mr> [options] update
12
13 B<mr> [options] status
14
15 B<mr> [options] commit [-m "message"]
16
17 B<mr> [options] record [-m "message"]
18
19 B<mr> [options] diff
20
21 B<mr> [options] log
22
23 B<mr> [options] bootstrap url [directory]
24
25 B<mr> [options] register [repository]
26
27 B<mr> [options] config section ["parameter=[value]" ...]
28
29 B<mr> [options] action [params ...]
30
31 B<mr> [options] [online|offline]
32
33 B<mr> [options] remember action [params ...]
34
35 =head1 DESCRIPTION
36
37 B<mr> is a Multiple Repository management tool. It can checkout, update, or
38 perform other actions on a set of repositories as if they were one combined
39 repository. It supports any combination of subversion, git, cvs, mercurial,
40 bzr and darcs repositories, and support for other revision control systems can
41 easily be added.
42
43 B<mr> cds into and operates on all registered repositories at or below your
44 working directory. Or, if you are in a subdirectory of a repository that
45 contains no other registered repositories, it will stay in that directory,
46 and work on only that repository,
47
48 B<mr> is configured by .mrconfig files, which list the repositories. It
49 starts by reading the .mrconfig file in your home directory, and this can
50 in turn chain load .mrconfig files from repositories.
51
52 These predefined commands should be fairly familiar to users of any revision
53 control system:
54
55 =over 4
56
57 =item checkout (or co)
58
59 Checks out any repositories that are not already checked out.
60
61 =item update
62
63 Updates each repository from its configured remote repository.
64
65 If a repository isn't checked out yet, it will first check it out.
66
67 =item status
68
69 Displays a status report for each repository, showing what
70 uncommitted changes are present in the repository.
71
72 =item commit (or ci)
73
74 Commits changes to each repository. (By default, changes are pushed to the
75 remote repository too, when using distributed systems like git. If you
76 don't like this default, you can change it in your .mrconfig, or use record
77 instead.)
78
79 The optional -m parameter allows specifying a commit message.
80
81 =item record
82
83 Records changes to the local repository, but does not push them to the
84 remote repository. Only supported for distributed revision control systems.
85
86 The optional -m parameter allows specifying a commit message.
87
88 =item push
89
90 Pushes committed local changes to the remote repository. A no-op for
91 centralized revision control systems.
92
93 =item diff
94
95 Show a diff of uncommitted changes.
96
97 =item log
98
99 Show the commit log.
100
101 =back
102
103 These commands are also available:
104
105 =over 4
106
107 =item bootstrap url [directory]
108
109 Causes mr to download the url, and use it as a .mrconfig file
110 to checkout the repositories listed in it, into the specified directory.
111
112 The directory will be created if it does not exist. If no directory is
113 specified, the current directory will be used.
114
115 If the .mrconfig file includes a repository named ".", that
116 is checked out into the top of the specified directory.
117
118 =item list (or ls)
119
120 List the repositories that mr will act on.
121
122 =item register
123
124 Register an existing repository in a mrconfig file. By default, the
125 repository in the current directory is registered, or you can specify a
126 directory to register.
127
128 The mrconfig file that is modified is chosen by either the -c option, or by
129 looking for the closest known one at or below the current directory.
130
131 =item config
132
133 Adds, modifies, removes, or prints a value from a mrconfig file. The next
134 parameter is the name of the section the value is in. To add or modify
135 values, use one or more instances of "parameter=value". Use "parameter=" to
136 remove a parameter. Use just "parameter" to get the value of a parameter.
137
138 For example, to add (or edit) a repository in src/foo:
139
140   mr config src/foo checkout="svn co svn://example.com/foo/trunk foo"
141
142 To show the command that mr uses to update the repository in src/foo:
143
144   mr config src/foo update
145
146 To see the built-in library of shell functions contained in mr:
147
148   mr config DEFAULT lib
149
150 The ~/.mrconfig file is used by default. To use a different config file,
151 use the -c option.
152
153 =item offline
154
155 Advises mr that it is in offline mode. Any commands that fail in
156 offline mode will be remembered, and retried when mr is told it's online.
157
158 =item online
159
160 Advices mr that it is in online mode again. Commands that failed while in
161 offline mode will be re-run.
162
163 =item remember
164
165 Remember a command, to be run later when mr re-enters online mode. This
166 implicitly puts mr into offline mode. The command can be any regular mr
167 command. This is useful when you know that a command will fail due to being
168 offline, and so don't want to run it right now at all, but just remember
169 to run it when you go back online.
170
171 =item help
172
173 Displays this help.
174
175 =back
176
177 Actions can be abbreviated to any unambiguous substring, so
178 "mr st" is equivalent to "mr status", and "mr up" is equivalent to "mr
179 update"
180
181 Additional parameters can be passed to most commands, and are passed on
182 unchanged to the underlying revision control system. This is mostly useful
183 if the repositories mr will act on all use the same revision control
184 system.
185
186 =head1 OPTIONS
187
188 =over 4
189
190 =item -d directory
191
192 =item --directory directory
193
194 Specifies the topmost directory that B<mr> should work in. The default is
195 the current working directory.
196
197 =item -c mrconfig
198
199 =item --config mrconfig
200
201 Use the specified mrconfig file. The default is B<~/.mrconfig>
202
203 =item -p
204
205 =item --path
206
207 Search in the current directory, and its parent directories and use
208 the first B<.mrconfig> found, instead of the default B<~/.mrconfig>.
209
210 =item -v
211
212 =item --verbose
213
214 Be verbose.
215
216 =item -q
217
218 =item --quiet
219
220 Be quiet.
221
222 =item -k
223
224 =item --insecure
225
226 Accept untrusted SSL certificates when bootstrapping.
227
228 =item -s
229
230 =item --stats
231
232 Expand the statistics line displayed at the end to include information
233 about exactly which repositories failed and were skipped, if any.
234
235 =item -i
236
237 =item --interactive
238
239 Interactive mode. If a repository fails to be processed, a subshell will be
240 started which you can use to resolve or investigate the problem. Exit the
241 subshell to continue the mr run.
242
243 =item -n [number]
244
245 =item --no-recurse [number]
246
247 If no number if specified, just operate on the repository for the current
248 directory, do not recurse into deeper repositories.
249
250 If a number is specified, will recurse into repositories at most that many
251 subdirectories deep. For example, with -n 2 it would recurse into ./src/foo,
252 but not ./src/packages/bar.
253
254 =item -j [number]
255
256 =item --jobs [number]
257
258 Run the specified number of jobs in parallel, or an unlimited number of jobs
259 with no number specified. This can greatly speed up operations such as updates.
260 It is not recommended for interactive operations.
261
262 Note that running more than 10 jobs at a time is likely to run afoul of
263 ssh connection limits. Running between 3 and 5 jobs at a time will yield
264 a good speedup in updates without loading the machine too much.
265
266 =item -t
267
268 =item --trust-all
269
270 Trust all mrconfig files even if they are not listed in ~/.mrtrust.
271 Use with caution.
272
273 =back
274
275 =head1 "MRCONFIG FILES"
276
277 Here is an example .mrconfig file:
278
279   [src]
280   checkout = svn co svn://svn.example.com/src/trunk src
281   chain = true
282
283   [src/linux-2.6]
284   checkout = git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git &&
285         cd linux-2.6 &&
286         git checkout -b mybranch origin/master
287
288 The .mrconfig file uses a variant of the INI file format. Lines starting with
289 "#" are comments. Values can be continued to the following line by
290 indenting the line with whitespace.
291
292 The "DEFAULT" section allows setting default values for the sections that
293 come after it.
294
295 The "ALIAS" section allows adding aliases for actions. Each parameter
296 is an alias, and its value is the action to use.
297
298 All other sections add repositories. The section header specifies the
299 directory where the repository is located. This is relative to the directory
300 that contains the mrconfig file, but you can also choose to use absolute
301 paths. (Note that you can use environment variables in section names; they
302 will be passed through the shell for expansion. For example, 
303 "[$HOSTNAME]", or "[${HOSTNAME}foo]")
304
305 Within a section, each parameter defines a shell command to run to handle a
306 given action. mr contains default handlers for "update", "status",
307 "commit", and other standard actions. Normally you only need to specify what
308 to do for "checkout".
309
310 Note that these shell commands are run in a "set -e" shell
311 environment, where any additional parameters you pass are available in
312 "$@". The "checkout" command is run in the parent of the repository
313 directory, since the repository isn't checked out yet. All other commands
314 are run inside the repository, though not necessarily at the top of it.
315
316 The "MR_REPO" environment variable is set to the path to the top of the
317 repository. (For the "register" action, "MR_REPO" is instead set to the 
318 basename of the directory that should be created when checking the
319 repository out.)
320
321 The "MR_CONFIG" environment variable is set to the .mrconfig file
322 that defines the repo being acted on, or, if the repo is not yet in a config
323 file, the .mrconfig file that should be modified to register the repo.
324
325 A few parameters have special meanings:
326
327 =over 4
328
329 =item skip
330
331 If the "skip" parameter is set and its command returns true, then B<mr>
332 will skip acting on that repository. The command is passed the action
333 name in $1.
334
335 Here are two examples. The first skips the repo unless
336 mr is run by joey. The second uses the hours_since function
337 (included in mr's built-in library) to skip updating the repo unless it's
338 been at least 12 hours since the last update.
339
340   skip = test `whoami` != joey
341   skip = [ "$1" = update ] && ! hours_since "$1" 12
342
343 =item order
344
345 The "order" parameter can be used to override the default ordering of
346 repositories. The default order value is 10. Use smaller values to make
347 repositories be processed earlier, and larger values to make repositories
348 be processed later.
349
350 Note that if a repository is located in a subdirectory of another
351 repository, ordering it to be processed earlier is not recommended.
352
353 =item chain
354
355 If the "chain" parameter is set and its command returns true, then B<mr>
356 will try to load a .mrconfig file from the root of the repository.
357
358 =item include
359
360 If the "include" parameter is set, its command is ran, and should output
361 additional mrconfig file content. The content is included as if it were
362 part of the including file.
363
364 Unlike all other parameters, this parameter does not need to be placed
365 within a section.
366
367 =item lib
368
369 The "lib" parameter can specify some shell code that will be run before each
370 command, this can be a useful way to define shell functions for other commands
371 to use.
372
373 =back
374
375 When looking for a command to run for a given action, mr first looks for
376 a parameter with the same name as the action. If that is not found, it
377 looks for a parameter named "rcs_action" (substituting in the name of the
378 revision control system and the action). The name of the revision control
379 system is itself determined by running each defined "rcs_test" action,
380 until one succeeds.
381
382 Internally, mr has settings for "git_update", "svn_update", etc. To change
383 the action that is performed for a given revision control system, you can
384 override these rcs specific actions. To add a new revision control system,
385 you can just add rcs specific actions for it.
386
387 The ~/.mrlog file contains commands that mr has remembered to run later,
388 due to being offline. You can delete or edit this file to remove commands,
389 or even to add other commands for 'mr online' to run. If the file is
390 present, mr assumes it is in offline mode.
391
392 =head1 "UNTRUSTED MRCONFIG FILES"
393
394 Since mrconfig files can contain arbitrary shell commands, they can do
395 anything. This flexability is good, but it also allows a malicious mrconfig
396 file to delete your whole home directory. Such a file might be contained
397 inside a repository that your main ~/.mrconfig checks out and chains to. To
398 avoid worries about evil commands in a mrconfig file, mr
399 has the ability to read mrconfig files in untrusted mode. Such files are
400 limited to running only known safe commands (like "git clone") in a
401 carefully checked manner.
402
403 By default, mr trusts all mrconfig files. (This default will change in a
404 future release!) But if you have a ~/.mrtrust file, mr will only trust
405 mrconfig files that are listed within it. (One file per line.) All other
406 files will be treated as untrusted.
407
408 =head1 EXTENSIONS
409
410 mr can be extended to support things such as unison and git-svn. Some
411 files providing such extensions are available in /usr/share/mr/. See
412 the documentation in the files for details about using them.
413
414 =head1 AUTHOR
415
416 Copyright 2007-2009 Joey Hess <joey@kitenet.net>
417
418 Licensed under the GNU GPL version 2 or higher.
419
420 http://kitenet.net/~joey/code/mr/
421
422 =cut
423
424 use warnings;
425 use strict;
426 use Getopt::Long;
427 use Cwd qw(getcwd abs_path);
428
429 # things that can happen when mr runs a command
430 use constant {
431         OK => 0,
432         FAILED => 1,
433         SKIPPED => 2,
434         ABORT => 3,
435 };
436
437 # configurables
438 my $config_overridden=0;
439 my $verbose=0;
440 my $quiet=0;
441 my $stats=0;
442 my $insecure=0;
443 my $interactive=0;
444 my $max_depth;
445 my $no_chdir=0;
446 my $jobs=1;
447 my $trust_all=0;
448 my $directory=getcwd();
449 $ENV{MR_CONFIG}="$ENV{HOME}/.mrconfig";
450
451 # globals :-(
452 my %config;
453 my %configfiles;
454 my %knownactions;
455 my %alias;
456 my (@ok, @failed, @skipped);
457
458 main();
459
460 my %rcs;
461 sub rcs_test {
462         my ($action, $dir, $topdir, $subdir) = @_;
463
464         if (exists $rcs{$dir}) {
465                 return $rcs{$dir};
466         }
467
468         my $test="set -e\n";
469         foreach my $rcs_test (
470                         sort {
471                                 length $a <=> length $b 
472                                           ||
473                                        $a cmp $b
474                         } grep { /_test$/ } keys %{$config{$topdir}{$subdir}}) {
475                 my ($rcs)=$rcs_test=~/(.*)_test/;
476                 $test="my_$rcs_test() {\n$config{$topdir}{$subdir}{$rcs_test}\n}\n".$test;
477                 $test.="if my_$rcs_test; then echo $rcs; fi\n";
478         }
479         $test=$config{$topdir}{$subdir}{lib}."\n".$test
480                 if exists $config{$topdir}{$subdir}{lib};
481         
482         print "mr $action: running rcs test >>$test<<\n" if $verbose;
483         my $rcs=`$test`;
484         chomp $rcs;
485         if ($rcs=~/\n/s) {
486                 $rcs=~s/\n/, /g;
487                 print STDERR "mr $action: found multiple possible repository types ($rcs) for $topdir$subdir\n";
488                 return undef;
489         }
490         if (! length $rcs) {
491                 return $rcs{$dir}=undef;
492         }
493         else {
494                 return $rcs{$dir}=$rcs;
495         }
496 }
497         
498 sub findcommand {
499         my ($action, $dir, $topdir, $subdir, $is_checkout) = @_;
500         
501         if (exists $config{$topdir}{$subdir}{$action}) {
502                 return $config{$topdir}{$subdir}{$action};
503         }
504
505         if ($is_checkout) {
506                 return undef;
507         }
508
509         my $rcs=rcs_test(@_);
510
511         if (defined $rcs && 
512             exists $config{$topdir}{$subdir}{$rcs."_".$action}) {
513                 return $config{$topdir}{$subdir}{$rcs."_".$action};
514         }
515         else {
516                 return undef;
517         }
518 }
519
520 sub action {
521         my ($action, $dir, $topdir, $subdir, $force_checkout) = @_;
522         
523         $ENV{MR_CONFIG}=$configfiles{$topdir};
524         my $lib=exists $config{$topdir}{$subdir}{lib} ?
525                        $config{$topdir}{$subdir}{lib}."\n" : "";
526         my $is_checkout=($action eq 'checkout');
527
528         $ENV{MR_REPO}=$dir;
529
530         if ($is_checkout) {
531                 if (! $force_checkout) {
532                         if (-d $dir) {
533                                 print "mr $action: $dir already exists, skipping checkout\n" if $verbose;
534                                 return SKIPPED;
535                         }
536         
537                         $dir=~s/^(.*)\/[^\/]+\/?$/$1/;
538                 }
539         }
540         elsif ($action =~ /update/) {
541                 if (! -d $dir) {
542                         return action("checkout", $dir, $topdir, $subdir);
543                 }
544         }
545
546         my $skiptest=findcommand("skip", $dir, $topdir, $subdir, $is_checkout);
547         my $command=findcommand($action, $dir, $topdir, $subdir, $is_checkout);
548
549         if (defined $skiptest) {
550                 my $test="set -e;".$lib.
551                         "my_action(){ $skiptest\n }; my_action '$action'";
552                 print "mr $action: running skip test >>$test<<\n" if $verbose;
553                 my $ret=system($test);
554                 if ($ret != 0) {
555                         if (($? & 127) == 2) {
556                                 print STDERR "mr $action: interrupted\n";
557                                 return ABORT;
558                         }
559                         elsif ($? & 127) {
560                                 print STDERR "mr $action: skip test received signal ".($? & 127)."\n";
561                                 return ABORT;
562                         }
563                 }
564                 if ($ret >> 8 == 0) {
565                         print "mr $action: $dir skipped per config file\n" if $verbose;
566                         return SKIPPED;
567                 }
568         }
569
570         if ($is_checkout && ! -d $dir) {
571                 print "mr $action: creating parent directory $dir\n" if $verbose;
572                 system("mkdir", "-p", $dir);
573         }
574
575         if (! $no_chdir && ! chdir($dir)) {
576                 print STDERR "mr $action: failed to chdir to $dir: $!\n";
577                 return FAILED;
578         }
579         elsif (! defined $command) {
580                 my $rcs=rcs_test(@_);
581                 if (! defined $rcs) {
582                         print STDERR "mr $action: unknown repository type and no defined $action command for $topdir$subdir\n";
583                         return FAILED;
584                 }
585                 else {
586                         print STDERR "mr $action: no defined action for $rcs repository $topdir$subdir, skipping\n";
587                         return SKIPPED;
588                 }
589         }
590         else {
591                 if (! $no_chdir) {
592                         print "mr $action: $topdir$subdir\n" unless $quiet;
593                 }
594                 else {
595                         my $s=$directory;
596                         $s=~s/^\Q$topdir$subdir\E\/?//;
597                         print "mr $action: $topdir$subdir (in subdir $s)\n" unless $quiet;
598                 }
599                 $command="set -e; ".$lib.
600                         "my_action(){ $command\n }; my_action ".
601                         join(" ", map { s/\//\/\//g; s/"/\"/g; '"'.$_.'"' } @ARGV);
602                 print "mr $action: running >>$command<<\n" if $verbose;
603                 my $ret=system($command);
604                 if ($ret != 0) {
605                         if (($? & 127) == 2) {
606                                 print STDERR "mr $action: interrupted\n";
607                                 return ABORT;
608                         }
609                         elsif ($? & 127) {
610                                 print STDERR "mr $action: received signal ".($? & 127)."\n";
611                                 return ABORT;
612                         }
613                         print STDERR "mr $action: failed ($ret)\n" if $verbose;
614                         if ($ret >> 8 != 0) {
615                                 print STDERR "mr $action: command failed\n";
616                                 if (-e "$ENV{HOME}/.mrlog" && $action ne 'remember') {
617                                         # recreate original command line to
618                                         # remember, and avoid recursing
619                                         my @orig=@ARGV;
620                                         @ARGV=('-n', $action, @orig);
621                                         action("remember", $dir, $topdir, $subdir);
622                                         @ARGV=@orig;
623                                 }
624                         }
625                         elsif ($ret != 0) {
626                                 print STDERR "mr $action: command died ($ret)\n";
627                         }
628                         return FAILED;
629                 }
630                 else {
631                         if ($action eq 'checkout' && ! -d $dir) {
632                                 print STDERR "mr $action: $dir missing after checkout\n";;
633                                 return FAILED;
634                         }
635
636                         return OK;
637                 }
638         }
639 }
640
641 # run actions on multiple repos, in parallel
642 sub mrs {
643         my $action=shift;
644         my @repos=@_;
645
646         $| = 1;
647         my @active;
648         my @fhs;
649         my @out;
650         my $running=0;
651         while (@fhs or @repos) {
652                 while ((!$jobs || $running < $jobs) && @repos) {
653                         $running++;
654                         my $repo = shift @repos;
655                         pipe(my $outfh, CHILD_STDOUT);
656                         pipe(my $errfh, CHILD_STDERR);
657                         my $pid;
658                         unless ($pid = fork) {
659                                 die "mr $action: cannot fork: $!" unless defined $pid;
660                                 open(STDOUT, ">&CHILD_STDOUT") || die "mr $action cannot reopen stdout: $!";
661                                 open(STDERR, ">&CHILD_STDERR") || die "mr $action cannot reopen stderr: $!";
662                                 close CHILD_STDOUT;
663                                 close CHILD_STDERR;
664                                 close $outfh;
665                                 close $errfh;
666                                 exit action($action, @$repo);
667                         }
668                         close CHILD_STDOUT;
669                         close CHILD_STDERR;
670                         push @active, [$pid, $repo];
671                         push @fhs, [$outfh, $errfh];
672                         push @out, ['',     ''];
673                 }
674                 my ($rin, $rout) = ('','');
675                 my $nfound;
676                 foreach my $fh (@fhs) {
677                         next unless defined $fh;
678                         vec($rin, fileno($fh->[0]), 1) = 1 if defined $fh->[0];
679                         vec($rin, fileno($fh->[1]), 1) = 1 if defined $fh->[1];
680                 }
681                 $nfound = select($rout=$rin, undef, undef, 1);
682                 foreach my $channel (0, 1) {
683                         foreach my $i (0..$#fhs) {
684                                 next unless defined $fhs[$i];
685                                 my $fh = $fhs[$i][$channel];
686                                 next unless defined $fh;
687                                 if (vec($rout, fileno($fh), 1) == 1) {
688                                         my $r = '';
689                                         if (sysread($fh, $r, 1024) == 0) {
690                                                 close($fh);
691                                                 $fhs[$i][$channel] = undef;
692                                                 if (! defined $fhs[$i][0] &&
693                                                     ! defined $fhs[$i][1]) {
694                                                         waitpid($active[$i][0], 0);
695                                                         print STDOUT $out[$i][0];
696                                                         print STDERR $out[$i][1];
697                                                         record($active[$i][1], $? >> 8);
698                                                         splice(@fhs, $i, 1);
699                                                         splice(@active, $i, 1);
700                                                         splice(@out, $i, 1);
701                                                         $running--;
702                                                 }
703                                         }
704                                         $out[$i][$channel] .= $r;
705                                 }
706                         }
707                 }
708         }
709 }
710
711 sub record {
712         my $dir=shift()->[0];
713         my $ret=shift;
714
715         if ($ret == OK) {
716                 push @ok, $dir;
717                 print "\n" unless $quiet;
718         }
719         elsif ($ret == FAILED) {
720                 if ($interactive) {
721                         chdir($dir) unless $no_chdir;
722                         print STDERR "mr: Starting interactive shell. Exit shell to continue.\n";
723                         system((getpwuid($<))[8], "-i");
724                 }
725                 push @failed, $dir;
726                 print "\n" unless $quiet;
727         }
728         elsif ($ret == SKIPPED) {
729                 push @skipped, $dir;
730         }
731         elsif ($ret == ABORT) {
732                 exit 1;
733         }
734         else {
735                 die "unknown exit status $ret";
736         }
737 }
738
739 sub showstats {
740         my $action=shift;
741         if (! @ok && ! @failed && ! @skipped) {
742                 die "mr $action: no repositories found to work on\n";
743         }
744         print "mr $action: finished (".join("; ",
745                 showstat($#ok+1, "ok", "ok"),
746                 showstat($#failed+1, "failed", "failed"),
747                 showstat($#skipped+1, "skipped", "skipped"),
748         ).")\n" unless $quiet;
749         if ($stats) {
750                 if (@skipped) {
751                         print "mr $action: (skipped: ".join(" ", @skipped).")\n" unless $quiet;
752                 }
753                 if (@failed) {
754                         print STDERR "mr $action: (failed: ".join(" ", @failed).")\n";
755                 }
756         }
757 }
758
759 sub showstat {
760         my $count=shift;
761         my $singular=shift;
762         my $plural=shift;
763         if ($count) {
764                 return "$count ".($count > 1 ? $plural : $singular);
765         }
766         return;
767 }
768
769 # an ordered list of repos
770 sub repolist {
771         my @list;
772         foreach my $topdir (sort keys %config) {
773                 foreach my $subdir (sort keys %{$config{$topdir}}) {
774                         push @list, {
775                                 topdir => $topdir,
776                                 subdir => $subdir,
777                                 order => $config{$topdir}{$subdir}{order},
778                         };
779                 }
780         }
781         return sort {
782                 $a->{order}  <=> $b->{order}
783                              ||
784                 $a->{topdir} cmp $b->{topdir}
785                              ||
786                 $a->{subdir} cmp $b->{subdir}
787         } @list;
788 }
789
790 # figure out which repos to act on
791 sub selectrepos {
792         my @repos;
793         foreach my $repo (repolist()) {
794                 my $topdir=$repo->{topdir};
795                 my $subdir=$repo->{subdir};
796
797                 next if $subdir eq 'DEFAULT';
798                 my $dir=($subdir =~/^\//) ? $subdir : $topdir.$subdir;
799                 my $d=$directory;
800                 $dir.="/" unless $dir=~/\/$/;
801                 $d.="/" unless $d=~/\/$/;
802                 next if $dir ne $d && $dir !~ /^\Q$d\E/;
803                 if (defined $max_depth) {
804                         my @a=split('/', $dir);
805                         my @b=split('/', $d);
806                         do { } while (@a && @b && shift(@a) eq shift(@b));
807                         next if @a > $max_depth || @b > $max_depth;
808                 }
809                 push @repos, [$dir, $topdir, $subdir];
810         }
811         if (! @repos) {
812                 # fallback to find a leaf repo
813                 foreach my $repo (reverse repolist()) {
814                         my $topdir=$repo->{topdir};
815                         my $subdir=$repo->{subdir};
816                         
817                         next if $subdir eq 'DEFAULT';
818                         my $dir=($subdir =~/^\//) ? $subdir : $topdir.$subdir;
819                         my $d=$directory;
820                         $dir.="/" unless $dir=~/\/$/;
821                         $d.="/" unless $d=~/\/$/;
822                         if ($d=~/^\Q$dir\E/) {
823                                 push @repos, [$dir, $topdir, $subdir];
824                                 last;
825                         }
826                 }
827                 $no_chdir=1;
828         }
829         return @repos;
830 }
831
832 sub expandenv {
833         my $val=shift;
834         
835
836         if ($val=~/\$/) {
837                 $val=`echo "$val"`;
838                 chomp $val;
839         }
840         
841         return $val;
842 }
843
844 my %trusted;
845 sub is_trusted_config {
846         my $config=shift; # must be abs_pathed already
847
848         # We always trust ~/.mrconfig.
849         return 1 if $config eq abs_path("$ENV{HOME}/.mrconfig");
850
851         return 1 if $trust_all;
852
853         my $trustfile=$ENV{HOME}."/.mrtrust";
854
855         if (! -e $trustfile) {
856                 print "mr: Assuming $config is trusted.\n";
857                 print "mr: For better security, you are encouraged to create ~/.mrtrust\n";
858                 print "mr: and list all trusted mrconfig files in it.\n";
859                 return 1;
860         }
861
862         if (! %trusted) {
863                 $trusted{"$ENV{HOME}/.mrconfig"}=1;
864                 open (TRUST, "<", $trustfile) || die "$trustfile: $!";
865                 while (<TRUST>) {
866                         chomp;
867                         s/^~\//$ENV{HOME}\//;
868                         $trusted{abs_path($_)}=1;
869                 }
870                 close TRUST;
871         }
872
873         return $trusted{$config};
874 }
875
876
877 sub is_trusted_repo {
878         my $repo=shift;
879         
880         # Tightly limit what is allowed in a repo name.
881         # No ../, no absolute paths, and no unusual filenames
882         # that might try to escape to the shell.
883         return $repo =~ /^[-_.+\/A-Za-z0-9]+$/ &&
884                $repo !~ /\.\./ && $repo !~ /^\//;
885 }
886
887 sub is_trusted_checkout {
888         my $command=shift;
889         
890         # To determine if the command is safe, compare it with the
891         # *_trusted_checkout config settings. Those settings are
892         # templates for allowed commands, so make sure that each word
893         # of the command matches the corresponding word of the template.
894         
895         my @words;
896         foreach my $word (split(' ', $command)) {
897                 # strip quoting
898                 if ($word=~/^'(.*)'$/) {
899                         $word=$1;
900                 }
901                 elsif ($word=~/^"(.*)"$/) {
902                         $word=$1;
903                 }
904
905                 push @words, $word;
906         }
907
908         foreach my $key (grep { /_trusted_checkout$/ }
909                          keys %{$config{''}{DEFAULT}}) {
910                 my @twords=split(' ', $config{''}{DEFAULT}{$key});
911                 next if @words > @twords;
912
913                 my $match=1;
914                 my $url;
915                 for (my $c=0; $c < @twords && $match; $c++) {
916                         if ($twords[$c] eq '$url') {
917                                 # Match all the typical characters found in
918                                 # urls, plus @ which svn can use. Note
919                                 # that the "url" might also be a local
920                                 # directory.
921                                 $match=(
922                                         defined $words[$c] &&
923                                         $words[$c] =~ /^[-_.+:@\/A-Za-z0-9]+$/
924                                 );
925                                 $url=$words[$c];
926                         }
927                         elsif ($twords[$c] eq '$repo') {
928                                 # If a repo is not specified, assume it
929                                 # will be the last path component of the
930                                 # url, or something derived from it, and
931                                 # check that.
932                                 if (! defined $words[$c] && defined $url) {
933                                         ($words[$c])=$url=~/\/([^\/]+)\/?$/;
934                                 }
935
936                                 $match=(
937                                         defined $words[$c] &&
938                                         is_trusted_repo($words[$c])
939                                 );
940                         }
941                         elsif (defined $words[$c] && $twords[$c] eq $words[$c]) {
942                                 $match=1;
943                         }
944                         else {
945                                 $match=0;
946                         }
947                 }
948                 return 1 if $match;
949         }
950
951         return 0;
952 }
953
954 my %loaded;
955 sub loadconfig {
956         my $f=shift;
957         my $dir=shift;
958
959         my @toload;
960
961         my $in;
962         my $trusted;
963         if (ref $f eq 'GLOB') {
964                 $dir="";
965                 $in=$f;
966                 $trusted=1;
967         }
968         else {
969                 if (! -e $f) {
970                         return;
971                 }
972
973                 my $absf=abs_path($f);
974                 if ($loaded{$absf}) {
975                         return;
976                 }
977                 $loaded{$absf}=1;
978
979                 $trusted=is_trusted_config($absf);
980
981                 if (! defined $dir) {
982                         ($dir)=$f=~/^(.*\/)[^\/]+$/;
983                         if (! defined $dir) {
984                                 $dir=".";
985                         }
986                 }
987
988                 $dir=abs_path($dir)."/";
989                 
990                 if (! exists $configfiles{$dir}) {
991                         $configfiles{$dir}=$f;
992                 }
993
994                 # copy in defaults from first parent
995                 my $parent=$dir;
996                 while ($parent=~s/^(.*\/)[^\/]+\/?$/$1/) {
997                         if ($parent eq '/') {
998                                 $parent="";
999                         }
1000                         if (exists $config{$parent} &&
1001                             exists $config{$parent}{DEFAULT}) {
1002                                 $config{$dir}{DEFAULT}={ %{$config{$parent}{DEFAULT}} };
1003                                 last;
1004                         }
1005                 }
1006                 
1007                 print "mr: loading config $f\n" if $verbose;
1008                 open($in, "<", $f) || die "mr: open $f: $!\n";
1009         }
1010         my @lines=<$in>;
1011         close $in unless ref $f eq 'GLOB';
1012
1013         my $section;
1014         my $line=0;
1015         while (@lines) {
1016                 $_=shift @lines;
1017                 $line++;
1018                 chomp;
1019                 next if /^\s*\#/ || /^\s*$/;
1020                 if (/^\[([^\]]*)\]\s*$/) {
1021                         $section=$1;
1022
1023                         if (! $trusted) {
1024                                 if (! is_trusted_repo($section) ||
1025                                     $section eq 'ALIAS' ||
1026                                     $section eq 'DEFAULT') {
1027                                         die "mr: illegal section \"[$section]\" in untrusted $f line $line\n";
1028                                 }
1029                         }
1030                         $section=expandenv($section) if $trusted;
1031                 }
1032                 elsif (/^(\w+)\s*=\s*(.*)/) {
1033                         my $parameter=$1;
1034                         my $value=$2;
1035
1036                         # continued value
1037                         while (@lines && $lines[0]=~/^\s(.+)/) {
1038                                 shift(@lines);
1039                                 $line++;
1040                                 $value.="\n$1";
1041                                 chomp $value;
1042                         }
1043
1044                         if (! $trusted) {
1045                                 # Untrusted files can only contain checkout
1046                                 # parameters.
1047                                 if ($parameter ne 'checkout') {
1048                                         die "mr: illegal setting \"$parameter=$value\" in untrusted $f line $line\n";
1049                                 }
1050                                 if (! is_trusted_checkout($value)) {
1051                                         die "mr: illegal checkout command \"$value\" in untrusted $f line $line\n";
1052                                 }
1053                         }
1054
1055                         if ($parameter eq "include") {
1056                                 print "mr: including output of \"$value\"\n" if $verbose;
1057                                 unshift @lines, `$value`;
1058                                 if ($?) {
1059                                         print STDERR "mr: include command exited nonzero ($?)\n";
1060                                 }
1061                                 next;
1062                         }
1063
1064                         if (! defined $section) {
1065                                 die "$f line $.: parameter ($parameter) not in section\n";
1066                         }
1067                         if ($section ne 'ALIAS' &&
1068                             ! exists $config{$dir}{$section} &&
1069                             exists $config{$dir}{DEFAULT}) {
1070                                 # copy in defaults
1071                                 $config{$dir}{$section}={ %{$config{$dir}{DEFAULT}} };
1072                         }
1073                         if ($section eq 'ALIAS') {
1074                                 $alias{$parameter}=$value;
1075                         }
1076                         elsif ($parameter eq 'lib') {
1077                                 $config{$dir}{$section}{lib}.=$value."\n";
1078                         }
1079                         else {
1080                                 $config{$dir}{$section}{$parameter}=$value;
1081                                 if ($parameter =~ /.*_(.*)/) {
1082                                         $knownactions{$1}=1;
1083                                 }
1084                                 else {
1085                                         $knownactions{$parameter}=1;
1086                                 }
1087                                 if ($parameter eq 'chain' &&
1088                                     length $dir && $section ne "DEFAULT" &&
1089                                     -e $dir.$section."/.mrconfig") {
1090                                         my $ret=system($value);
1091                                         if ($ret != 0) {
1092                                                 if (($? & 127) == 2) {
1093                                                         print STDERR "mr: chain test interrupted\n";
1094                                                         exit 2;
1095                                                 }
1096                                                 elsif ($? & 127) {
1097                                                         print STDERR "mr: chain test received signal ".($? & 127)."\n";
1098                                                 }
1099                                         }
1100                                         else {
1101                                                 push @toload, $dir.$section."/.mrconfig";
1102                                         }
1103                                 }
1104                         }
1105                 }
1106                 else {
1107                         die "$f line $line: parse error\n";
1108                 }
1109         }
1110
1111         foreach (@toload) {
1112                 loadconfig($_);
1113         }
1114 }
1115
1116 sub startingconfig {
1117         %alias=%config=%configfiles=%knownactions=%loaded=();
1118         my $datapos=tell(DATA);
1119         loadconfig(\*DATA);
1120         seek(DATA,$datapos,0); # rewind
1121 }
1122
1123 sub modifyconfig {
1124         my $f=shift;
1125         # the section to modify or add
1126         my $targetsection=shift;
1127         # fields to change in the section
1128         # To remove a field, set its value to "".
1129         my %changefields=@_;
1130
1131         my @lines;
1132         my @out;
1133
1134         if (-e $f) {
1135                 open(my $in, "<", $f) || die "mr: open $f: $!\n";
1136                 @lines=<$in>;
1137                 close $in;
1138         }
1139
1140         my $formatfield=sub {
1141                 my $field=shift;
1142                 my @value=split(/\n/, shift);
1143
1144                 return "$field = ".shift(@value)."\n".
1145                         join("", map { "\t$_\n" } @value);
1146         };
1147         my $addfields=sub {
1148                 my @blanks;
1149                 while ($out[$#out] =~ /^\s*$/) {
1150                         unshift @blanks, pop @out;
1151                 }
1152                 foreach my $field (sort keys %changefields) {
1153                         if (length $changefields{$field}) {
1154                                 push @out, "$field = $changefields{$field}\n";
1155                                 delete $changefields{$field};
1156                         }
1157                 }
1158                 push @out, @blanks;
1159         };
1160
1161         my $section;
1162         while (@lines) {
1163                 $_=shift(@lines);
1164
1165                 if (/^\s*\#/ || /^\s*$/) {
1166                         push @out, $_;
1167                 }
1168                 elsif (/^\[([^\]]*)\]\s*$/) {
1169                         if (defined $section && 
1170                             $section eq $targetsection) {
1171                                 $addfields->();
1172                         }
1173
1174                         $section=expandenv($1);
1175
1176                         push @out, $_;
1177                 }
1178                 elsif (/^(\w+)\s*=\s(.*)/) {
1179                         my $parameter=$1;
1180                         my $value=$2;
1181
1182                         # continued value
1183                         while (@lines && $lines[0]=~/^\s(.+)/) {
1184                                 shift(@lines);
1185                                 $value.="\n$1";
1186                                 chomp $value;
1187                         }
1188
1189                         if ($section eq $targetsection) {
1190                                 if (exists $changefields{$parameter}) {
1191                                         if (length $changefields{$parameter}) {
1192                                                 $value=$changefields{$parameter};
1193                                         }
1194                                         delete $changefields{$parameter};
1195                                 }
1196                         }
1197
1198                         push @out, $formatfield->($parameter, $value);
1199                 }
1200         }
1201
1202         if (defined $section && 
1203             $section eq $targetsection) {
1204                 $addfields->();
1205         }
1206         elsif (%changefields) {
1207                 push @out, "\n[$targetsection]\n";
1208                 foreach my $field (sort keys %changefields) {
1209                         if (length $changefields{$field}) {
1210                                 push @out, $formatfield->($field, $changefields{$field});
1211                         }
1212                 }
1213         }
1214
1215         open(my $out, ">", $f) || die "mr: write $f: $!\n";
1216         print $out @out;
1217         close $out;     
1218 }
1219
1220 sub dispatch {
1221         my $action=shift;
1222
1223         # actions that do not operate on all repos
1224         if ($action eq 'help') {
1225                 help(@ARGV);
1226         }
1227         elsif ($action eq 'config') {
1228                 config(@ARGV);
1229         }
1230         elsif ($action eq 'register') {
1231                 register(@ARGV);
1232         }
1233         elsif ($action eq 'bootstrap') {
1234                 bootstrap();
1235         }
1236         elsif ($action eq 'remember' ||
1237                $action eq 'offline' ||
1238                $action eq 'online') {
1239                 my @repos=selectrepos;
1240                 action($action, @{$repos[0]}) if @repos;
1241                 exit 0;
1242         }
1243
1244         if (!$jobs || $jobs > 1) {
1245                 mrs($action, selectrepos());
1246         }
1247         else {
1248                 foreach my $repo (selectrepos()) {
1249                         record($repo, action($action, @$repo));
1250                 }
1251         }
1252 }
1253
1254 sub help {
1255         exec($config{''}{DEFAULT}{help}) || die "exec: $!";
1256 }
1257
1258 sub config {
1259         if (@_ < 2) {
1260                 die "mr config: not enough parameters\n";
1261         }
1262         my $section=shift;
1263         if ($section=~/^\//) {
1264                 # try to convert to a path relative to the config file
1265                 my ($dir)=$ENV{MR_CONFIG}=~/^(.*\/)[^\/]+$/;
1266                 $dir=abs_path($dir);
1267                 $dir.="/" unless $dir=~/\/$/;
1268                 if ($section=~/^\Q$dir\E(.*)/) {
1269                         $section=$1;
1270                 }
1271         }
1272         my %changefields;
1273         foreach (@_) {
1274                 if (/^([^=]+)=(.*)$/) {
1275                         $changefields{$1}=$2;
1276                 }
1277                 else {
1278                         my $found=0;
1279                         foreach my $topdir (sort keys %config) {
1280                                 if (exists $config{$topdir}{$section} &&
1281                                     exists $config{$topdir}{$section}{$_}) {
1282                                         print $config{$topdir}{$section}{$_}."\n";
1283                                         $found=1;
1284                                         last if $section eq 'DEFAULT';
1285                                 }
1286                         }
1287                         if (! $found) {
1288                                 die "mr config: $section $_ not set\n";
1289                         }
1290                 }
1291         }
1292         modifyconfig($ENV{MR_CONFIG}, $section, %changefields) if %changefields;
1293         exit 0;
1294 }
1295
1296 sub register {
1297         if ($config_overridden) {
1298                 # Find the directory that the specified config file is
1299                 # located in.
1300                 ($directory)=abs_path($ENV{MR_CONFIG})=~/^(.*\/)[^\/]+$/;
1301         }
1302         else {
1303                 # Find the closest known mrconfig file to the current
1304                 # directory.
1305                 $directory.="/" unless $directory=~/\/$/;
1306                 my $foundconfig=0;
1307                 foreach my $topdir (reverse sort keys %config) {
1308                         next unless length $topdir;
1309                         if ($directory=~/^\Q$topdir\E/) {
1310                                 $ENV{MR_CONFIG}=$configfiles{$topdir};
1311                                 $directory=$topdir;
1312                                 $foundconfig=1;
1313                                 last;
1314                         }
1315                 }
1316                 if (! $foundconfig) {
1317                         $directory=""; # no config file, use builtin
1318                 }
1319         }
1320         if (@ARGV) {
1321                 my $subdir=shift @ARGV;
1322                 if (! chdir($subdir)) {
1323                         print STDERR "mr register: failed to chdir to $subdir: $!\n";
1324                 }
1325         }
1326
1327         $ENV{MR_REPO}=getcwd();
1328         my $command=findcommand("register", $ENV{MR_REPO}, $directory, 'DEFAULT', 0);
1329         if (! defined $command) {
1330                 die "mr register: unknown repository type\n";
1331         }
1332
1333         $ENV{MR_REPO}=~s/.*\/(.*)/$1/;
1334         $command="set -e; ".$config{$directory}{DEFAULT}{lib}."\n".
1335                 "my_action(){ $command\n }; my_action ".
1336                 join(" ", map { s/\//\/\//g; s/"/\"/g; '"'.$_.'"' } @ARGV);
1337         print "mr register: running >>$command<<\n" if $verbose;
1338         exec($command) || die "exec: $!";
1339 }
1340
1341 sub bootstrap {
1342         my $url=shift @ARGV;
1343         my $dir=shift @ARGV || ".";
1344         
1345         if (! defined $url || ! length $url) {
1346                 die "mr: bootstrap requires url\n";
1347         }
1348         
1349         # Download the config file to a temporary location.
1350         eval q{use File::Temp};
1351         die $@ if $@;
1352         my $tmpconfig=File::Temp->new();
1353         my @curlargs = ("curl", "-A", "mr", "-s", $url, "-o", $tmpconfig);
1354         push(@curlargs, "-k") if $insecure;
1355         my $curlstatus = system(@curlargs);
1356         die "mr bootstrap: invalid SSL certificate for $url (consider -k)\n" if $curlstatus >> 8 == 60;
1357         die "mr bootstrap: download of $url failed\n" if $curlstatus != 0;
1358
1359         if (! -e $dir) {
1360                 system("mkdir", "-p", $dir);
1361         }
1362         chdir($dir) || die "chdir $dir: $!";
1363
1364         # Special case to handle checkout of the "." repo, which 
1365         # would normally be skipped.
1366         my $topdir=abs_path(".")."/";
1367         my @repo=($topdir, $topdir, ".");
1368         loadconfig($tmpconfig, $topdir);
1369         record(\@repo, action("checkout", @repo, 1))
1370                 if exists $config{$topdir}{"."}{"checkout"};
1371
1372         if (-e ".mrconfig") {
1373                 print STDERR "mr bootstrap: .mrconfig file already exists, not overwriting with $url\n";
1374         }
1375         else {
1376                 eval q{use File::Copy};
1377                 die $@ if $@;
1378                 move($tmpconfig, ".mrconfig") || die "rename: $!";
1379         }
1380
1381         # Reload the config file (in case we got a different version)
1382         # and checkout everything else.
1383         startingconfig();
1384         loadconfig(".mrconfig");
1385         dispatch("checkout");
1386         @skipped=grep { abs_path($_) ne abs_path($topdir) } @skipped;
1387         showstats("bootstrap");
1388         exitstats();
1389 }
1390
1391 # alias expansion and command stemming
1392 sub expandaction {
1393         my $action=shift;
1394         if (exists $alias{$action}) {
1395                 $action=$alias{$action};
1396         }
1397         if (! exists $knownactions{$action}) {
1398                 my @matches = grep { /^\Q$action\E/ }
1399                         keys %knownactions, keys %alias;
1400                 if (@matches == 1) {
1401                         $action=$matches[0];
1402                 }
1403                 elsif (@matches == 0) {
1404                         die "mr: unknown action \"$action\" (known actions: ".
1405                                 join(", ", sort keys %knownactions).")\n";
1406                 }
1407                 else {
1408                         die "mr: ambiguous action \"$action\" (matches: ".
1409                                 join(", ", @matches).")\n";
1410                 }
1411         }
1412         return $action;
1413 }
1414
1415 sub find_nearest_mrconfig {
1416         my $dir=getcwd();
1417         while (length $dir) {
1418                 if (-e "$dir/.mrconfig") {
1419                         return "$dir/.mrconfig";
1420                 }
1421                 $dir=~s/\/[^\/]*$//;
1422         }
1423         die "no .mrconfig found in path\n";
1424 }
1425
1426 sub getopts {
1427         my @saved=@ARGV;
1428         Getopt::Long::Configure("bundling", "no_permute");
1429         my $result=GetOptions(
1430                 "d|directory=s" => sub { $directory=abs_path($_[1]) },
1431                 "c|config=s" => sub { $ENV{MR_CONFIG}=$_[1]; $config_overridden=1 },
1432                 "p|path" => sub { $ENV{MR_CONFIG}=find_nearest_mrconfig(); $config_overridden=1 },
1433                 "v|verbose" => \$verbose,
1434                 "q|quiet" => \$quiet,
1435                 "s|stats" => \$stats,
1436                 "k|insecure" => \$insecure,
1437                 "i|interactive" => \$interactive,
1438                 "n|no-recurse:i" => \$max_depth,
1439                 "j|jobs:i" => \$jobs,
1440                 "t|trust-all" => \$trust_all,
1441         );
1442         if (! $result || @ARGV < 1) {
1443                 die("Usage: mr [options] action [params ...]\n".
1444                     "(Use mr help for man page.)\n");
1445         }
1446         
1447         $ENV{MR_SWITCHES}="";
1448         foreach my $option (@saved) {
1449                 last if $option eq $ARGV[0];
1450                 $ENV{MR_SWITCHES}.="$option ";
1451         }
1452 }
1453
1454 sub init {
1455         $SIG{INT}=sub {
1456                 print STDERR "mr: interrupted\n";
1457                 exit 2;
1458         };
1459         
1460         # This can happen if it's run in a directory that was removed
1461         # or other strangeness.
1462         if (! defined $directory) {
1463                 die("mr: failed to determine working directory\n");
1464         }
1465         # Make sure MR_CONFIG is an absolute path, but don't use abs_path since
1466         # the config file might be a symlink to elsewhere, and the directory it's
1467         # in is significant.
1468         if ($ENV{MR_CONFIG} !~ /^\//) {
1469                 $ENV{MR_CONFIG}=getcwd()."/".$ENV{MR_CONFIG};
1470         }
1471         # Try to set MR_PATH to the path to the program.
1472         eval {
1473                 use FindBin qw($Bin $Script);
1474                 $ENV{MR_PATH}=$Bin."/".$Script;
1475         };
1476 }
1477         
1478 sub exitstats {
1479         if (@failed) {
1480                 exit 1;
1481         }
1482         elsif (! @ok && @skipped) {
1483                 exit 1;
1484         }
1485         else {
1486                 exit 0;
1487         }
1488 }
1489
1490 sub main {
1491         getopts();
1492         init();
1493
1494         startingconfig();
1495         loadconfig($ENV{MR_CONFIG});
1496         #use Data::Dumper; print Dumper(\%config);
1497         
1498         my $action=expandaction(shift @ARGV);
1499         dispatch($action);
1500
1501         showstats($action);
1502         exitstats();
1503 }
1504
1505 # Finally, some useful actions that mr knows about by default.
1506 # These can be overridden in ~/.mrconfig.
1507 __DATA__
1508 [ALIAS]
1509 co = checkout
1510 ci = commit
1511 ls = list
1512
1513 [DEFAULT]
1514 order = 10
1515 lib =
1516         error() {
1517                 echo "mr: $@" >&2
1518                 exit 1
1519         }
1520         warning() {
1521                 echo "mr (warning): $@" >&2
1522         }
1523         info() {
1524                 echo "mr: $@" >&2
1525         }
1526         hours_since() {
1527                 if [ -z "$1" ] || [ -z "$2" ]; then
1528                         error "mr: usage: hours_since action num"
1529                 fi
1530                 for dir in .git .svn .bzr CVS .hg _darcs; do
1531                         if [ -e "$MR_REPO/$dir" ]; then
1532                                 flagfile="$MR_REPO/$dir/.mr_last$1"
1533                                 break
1534                         fi
1535                 done
1536                 if [ -z "$flagfile" ]; then
1537                         error "cannot determine flag filename"
1538                 fi
1539                 delta=`perl -wle 'print -f shift() ? int((-M _) * 24) : 9999' "$flagfile"`
1540                 if [ "$delta" -lt "$2" ]; then
1541                         exit 0
1542                 else
1543                         touch "$flagfile"
1544                         exit 1
1545                 fi
1546         }
1547
1548 svn_test = test -d "$MR_REPO"/.svn
1549 git_test = test -d "$MR_REPO"/.git
1550 bzr_test = test -d "$MR_REPO"/.bzr
1551 cvs_test = test -d "$MR_REPO"/CVS
1552 hg_test  = test -d "$MR_REPO"/.hg
1553 darcs_test = test -d "$MR_REPO"/_darcs
1554 git_bare_test =
1555         test -d "$MR_REPO"/refs/heads && test -d "$MR_REPO"/refs/tags &&
1556         test -d "$MR_REPO"/objects && test -f "$MR_REPO"/config &&
1557         test "`GIT_CONFIG="$MR_REPO"/config git config --get core.bare`" = true
1558
1559 svn_update = svn update "$@"
1560 git_update = git pull "$@"
1561 bzr_update = bzr merge --pull "$@"
1562 cvs_update = cvs update "$@"
1563 hg_update  = hg pull "$@" && hg update "$@"
1564 darcs_update = darcs pull -a "$@"
1565
1566 svn_status = svn status "$@"
1567 git_status = git status "$@" || true
1568 bzr_status = bzr status "$@"
1569 cvs_status = cvs status "$@"
1570 hg_status  = hg status "$@"
1571 darcs_status = darcs whatsnew -ls "$@" || true
1572
1573 svn_commit = svn commit "$@"
1574 git_commit = git commit -a "$@" && git push --all
1575 bzr_commit = bzr commit "$@" && bzr push
1576 cvs_commit = cvs commit "$@"
1577 hg_commit  = hg commit -m "$@" && hg push
1578 darcs_commit = darcs record -a -m "$@" && darcs push -a
1579
1580 git_record = git commit -a "$@"
1581 bzr_record = bzr commit "$@"
1582 hg_record  = hg commit -m "$@"
1583 darcs_record = darcs record -a -m "$@"
1584
1585 svn_push = :
1586 git_push = git push "$@"
1587 bzr_push = bzr push "$@"
1588 cvs_push = :
1589 hg_push = hg push "$@"
1590 darcs_push = darcs push -a "$@"
1591
1592 svn_diff = svn diff "$@"
1593 git_diff = git diff "$@"
1594 bzr_diff = bzr diff "$@"
1595 cvs_diff = cvs diff "$@"
1596 hg_diff  = hg diff "$@"
1597 darcs_diff = darcs diff -u "$@"
1598
1599 svn_log = svn log "$@"
1600 git_log = git log "$@"
1601 bzr_log = bzr log "$@"
1602 cvs_log = cvs log "$@"
1603 hg_log  = hg log "$@"
1604 darcs_log = darcs changes "$@"
1605 git_bare_log = git log "$@"
1606
1607 svn_register =
1608         url=`LC_ALL=C svn info . | grep -i '^URL:' | cut -d ' ' -f 2`
1609         if [ -z "$url" ]; then
1610                 error "cannot determine svn url"
1611         fi
1612         echo "Registering svn url: $url in $MR_CONFIG"
1613         mr -c "$MR_CONFIG" config "`pwd`" checkout="svn co '$url' '$MR_REPO'"
1614 git_register = 
1615         url="`LC_ALL=C git config --get remote.origin.url`" || true
1616         if [ -z "$url" ]; then
1617                 error "cannot determine git url"
1618         fi
1619         echo "Registering git url: $url in $MR_CONFIG"
1620         mr -c "$MR_CONFIG" config "`pwd`" checkout="git clone '$url' '$MR_REPO'"
1621 bzr_register =
1622         url="`LC_ALL=C bzr info . | egrep -i 'checkout of branch|parent branch' | awk '{print $NF}'`"
1623         if [ -z "$url" ]; then
1624                 error "cannot determine bzr url"
1625         fi
1626         echo "Registering bzr url: $url in $MR_CONFIG"
1627         mr -c "$MR_CONFIG" config "`pwd`" checkout="bzr clone '$url' '$MR_REPO'"
1628 cvs_register =
1629         repo=`cat CVS/Repository`
1630         root=`cat CVS/Root`
1631         if [ -z "$root" ]; then
1632                 error "cannot determine cvs root"
1633                 fi
1634         echo "Registering cvs repository $repo at root $root"
1635         mr -c "$MR_CONFIG" config "`pwd`" checkout="cvs -d '$root' co -d '$MR_REPO' '$repo'"
1636 hg_register = 
1637         url=`hg showconfig paths.default`
1638         echo "Registering mercurial repo url: $url in $MR_CONFIG"
1639         mr -c "$MR_CONFIG" config "`pwd`" checkout="hg clone '$url' '$MR_REPO'"
1640 darcs_register = 
1641         url=`cat _darcs/prefs/defaultrepo`
1642         echo "Registering darcs repository $url in $MR_CONFIG"
1643         mr -c "$MR_CONFIG" config "`pwd`" checkout="darcs get '$url' '$MR_REPO'"
1644 git_bare_register = 
1645         url="`LC_ALL=C GIT_CONFIG=config git config --get remote.origin.url`" || true
1646         if [ -z "$url" ]; then
1647                 error "cannot determine git url"
1648         fi
1649         echo "Registering git url: $url in $MR_CONFIG"
1650         mr -c "$MR_CONFIG" config "`pwd`" checkout="git clone --bare '$url' '$MR_REPO'"
1651
1652 svn_trusted_checkout = svn co $url $repo
1653 svn_alt_trusted_checkout = svn checkout $url $repo
1654 git_trusted_checkout = git clone $url $repo
1655 bzr_trusted_checkout = bzr clone $url $repo
1656 # cvs: too hard
1657 hg_trusted_checkout = hg clone $url $repo
1658 darcs_trusted_checkout = darcs get $url $repo
1659 git_bare_trusted_checkout = git clone --bare $url $repo
1660
1661
1662 help =
1663         case `uname -s` in
1664                 SunOS)
1665                 SHOWMANFILE="man -f"
1666                 ;;
1667                 Darwin)
1668                 SHOWMANFILE="man"
1669                 ;;
1670                 *)
1671                 SHOWMANFILE="man -l"
1672                 ;;
1673         esac
1674         if [ ! -e "$MR_PATH" ]; then
1675                 error "cannot find program path"
1676         fi
1677         tmp=$(mktemp -t mr.XXXXXXXXXX) || error "mktemp failed"
1678         trap "rm -f $tmp" exit
1679         pod2man -c mr "$MR_PATH" > "$tmp" || error "pod2man failed"
1680         $SHOWMANFILE "$tmp" || error "man failed"
1681 list = true
1682 config = 
1683 bootstrap = 
1684
1685 online =
1686         if [ -s ~/.mrlog ]; then
1687                 info "running offline commands"
1688                 mv -f ~/.mrlog ~/.mrlog.old
1689                 if ! sh -e ~/.mrlog.old; then
1690                         error "offline command failed; left in ~/.mrlog.old"
1691                 fi
1692                 rm -f ~/.mrlog.old
1693         else
1694                 info "no offline commands to run"
1695         fi
1696 offline =
1697         umask 077
1698         touch ~/.mrlog
1699         info "offline mode enabled"
1700 remember =
1701         info "remembering command: 'mr $@'"
1702         command="mr -d '$(pwd)' $MR_SWITCHES"
1703         for w in "$@"; do
1704                 command="$command '$w'"
1705         done
1706         if [ ! -e ~/.mrlog ] || ! grep -q -F "$command" ~/.mrlog; then
1707                 echo "$command" >> ~/.mrlog
1708         fi
1709
1710 ed = echo "A horse is a horse, of course, of course.."
1711 T = echo "I pity the fool."
1712 right = echo "Not found."
1713
1714 # vim:sw=8:sts=0:ts=8:noet