]> 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:

fix uninitialized value
[code/myrepos.git] / mr
1 #!/usr/bin/env perl
2
3 =head1 NAME
4
5 mr - a tool to manage all your version control repos
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] fetch
20
21 B<mr> [options] push
22
23 B<mr> [options] diff
24
25 B<mr> [options] log
26
27 B<mr> [options] grep pattern
28
29 B<mr> [options] run command [param ...]
30
31 B<mr> [options] bootstrap src [directory]
32
33 B<mr> [options] register [repository]
34
35 B<mr> [options] config section ["parameter=[value]" ...]
36
37 B<mr> [options] action [params ...]
38
39 B<mr> [options] [online|offline]
40
41 B<mr> [options] remember action [params ...]
42
43 =head1 DESCRIPTION
44
45 B<mr> is a tool to manage all your version control repos. It can checkout,
46 update, or perform other actions on a set of repositories as if they were
47 one combined repository. It supports any combination of subversion, git,
48 cvs, mercurial, bzr, darcs, fossil and veracity repositories, and support
49 for other version control systems can easily be added.
50
51 B<mr> cds into and operates on all registered repositories at or below your
52 working directory. Or, if you are in a subdirectory of a repository that
53 contains no other registered repositories, it will stay in that directory,
54 and work on only that repository,
55
56 B<mr> is configured by .mrconfig files, which list the repositories. It
57 starts by reading the .mrconfig file in your home directory, and this can
58 in turn chain load .mrconfig files from repositories. It also automatically
59 looks for a .mrconfig file in the current directory, or in one of its
60 parent directories.
61
62 These predefined commands should be fairly familiar to users of any version
63 control system:
64
65 =over 4
66
67 =item checkout (or co)
68
69 Checks out any repositories that are not already checked out.
70
71 =item update
72
73 Updates each repository from its configured remote repository.
74
75 If a repository isn't checked out yet, it will first check it out.
76
77 =item status
78
79 Displays a status report for each repository, showing what
80 uncommitted changes are present in the repository. For distributed version
81 control systems, also shows unpushed local branches.
82
83 =item commit (or ci)
84
85 Commits changes to each repository. (By default, changes are pushed to the
86 remote repository too, when using distributed systems like git. If you
87 don't like this default, you can change it in your .mrconfig, or use record
88 instead.)
89
90 The optional -m parameter allows specifying a commit message.
91
92 =item record
93
94 Records changes to the local repository, but does not push them to the
95 remote repository. Only supported for distributed version control systems.
96
97 The optional -m parameter allows specifying a commit message.
98
99 =item fetch
100
101 Fetches from each repository's remote repository, but does not
102 update the working copy. Only supported for some distributed version
103 control systems.
104
105 =item push
106
107 Pushes committed local changes to the remote repository. A no-op for
108 centralized version control systems.
109
110 =item diff
111
112 Show a diff of uncommitted changes.
113
114 =item log
115
116 Show the commit log.
117
118 =item grep pattern
119
120 Searches for a pattern in each repository using the grep subcommand. Uses
121 ack-grep on VCS that do not have their own.
122
123 =item run command [param ...]
124
125 Runs the specified command in each repository.
126
127 =back
128
129 These commands are also available:
130
131 =over 4
132
133 =item bootstrap src [directory]
134
135 Causes mr to retrieve the source C<src> and use it as a .mrconfig file to
136 checkout the repositories listed in it, into the specified directory.
137
138 B<mr> understands several types of sources:
139
140 =over 4
141
142 =item URL for curl
143
144 C<src> may be an URL understood by B<curl>.
145
146 =item copy via ssh
147
148 To use B<scp> to download, the C<src> may have the form
149 C<ssh://[user@]host:file>.
150
151 =item local file
152
153 You can retrieve the config file by other means and pass its B<path> as C<src>.
154
155 =item standard input
156
157 If source C<src> consists in a single dash C<->, config file is read from
158 standard input.
159
160 =back
161
162 The directory will be created if it does not exist. If no directory is
163 specified, the current directory will be used.
164
165 As a special case, if source C<src> includes a repository named ".", that
166 is checked out into the top of the specified directory.
167
168 =item list (or ls)
169
170 List the repositories that mr will act on.
171
172 =item register
173
174 Register an existing repository in a mrconfig file. By default, the
175 repository in the current directory is registered, or you can specify a
176 directory to register.
177
178 The mrconfig file that is modified is chosen by either the -c option, or by
179 looking for the closest known one at or in a parent of the current directory.
180
181 =item config
182
183 Adds, modifies, removes, or prints a value from a mrconfig file. The next
184 parameter is the name of the section the value is in. To add or modify
185 values, use one or more instances of "parameter=value". Use "parameter=" to
186 remove a parameter. Use just "parameter" to get the value of a parameter.
187
188 For example, to add (or edit) a repository in src/foo:
189
190   mr config src/foo checkout="svn co svn://example.com/foo/trunk foo"
191
192 To show the command that mr uses to update the repository in src/foo:
193
194   mr config src/foo update
195
196 To see the built-in library of shell functions contained in mr:
197
198   mr config DEFAULT lib
199
200 The mrconfig file that is used is chosen by either the -c option, or by
201 looking for the closest known one at or in a parent of the current directory.
202
203 =item offline
204
205 Advises mr that it is in offline mode. Any commands that fail in
206 offline mode will be remembered, and retried when mr is told it's online.
207
208 =item online
209
210 Advices mr that it is in online mode again. Commands that failed while in
211 offline mode will be re-run.
212
213 =item remember
214
215 Remember a command, to be run later when mr re-enters online mode. This
216 implicitly puts mr into offline mode. The command can be any regular mr
217 command. This is useful when you know that a command will fail due to being
218 offline, and so don't want to run it right now at all, but just remember
219 to run it when you go back online.
220
221 =item help
222
223 Displays this help.
224
225 =back
226
227 Actions can be abbreviated to any unambiguous substring, so
228 "mr st" is equivalent to "mr status", and "mr up" is equivalent to "mr
229 update"
230
231 Additional parameters can be passed to most commands, and are passed on
232 unchanged to the underlying version control system. This is mostly useful
233 if the repositories mr will act on all use the same version control
234 system.
235
236 =head1 OPTIONS
237
238 =over 4
239
240 =item -d directory
241
242 =item --directory directory
243
244 Specifies the topmost directory that B<mr> should work in. The default is
245 the current working directory.
246
247 =item -c mrconfig
248
249 =item --config mrconfig
250
251 Use the specified mrconfig file. The default is to use both F<~/.mrconfig>
252 as well as look for a F<.mrconfig> file in the current directory, or in one
253 of its parent directories.
254
255 =item -f
256
257 =item --force
258
259 Force mr to act on repositories that would normally be skipped due to their
260 configuration.
261
262 =item -v
263
264 =item --verbose
265
266 Be verbose.
267
268 =item -m
269
270 =item --minimal
271
272 Minimise output. If a command fails or there is any output then the usual
273 output will be shown.
274
275 =item -q
276
277 =item --quiet
278
279 Be quiet. This suppresses mr's usual output, as well as any output from
280 commands that are run (including stderr output). If a command fails,
281 the output will be shown.
282
283 =item -k
284
285 =item --insecure
286
287 Accept untrusted SSL certificates when bootstrapping.
288
289 =item -s
290
291 =item --stats
292
293 Expand the statistics line displayed at the end to include information
294 about exactly which repositories failed and were skipped, if any.
295
296 =item -i
297
298 =item --interactive
299
300 Interactive mode. If a repository fails to be processed, a subshell will be
301 started which you can use to resolve or investigate the problem. Exit the
302 subshell to continue the mr run.
303
304 =item -n [number]
305
306 =item --no-recurse [number]
307
308 If no number if specified, just operate on the repository for the current
309 directory, do not recurse into deeper repositories.
310
311 If a number is specified, will recurse into repositories at most that many
312 subdirectories deep. For example, with -n 2 it would recurse into ./src/foo,
313 but not ./src/packages/bar.
314
315 =item -j [number]
316
317 =item --jobs [number]
318
319 Run the specified number of jobs in parallel, or an unlimited number of jobs
320 with no number specified. This can greatly speed up operations such as updates.
321 It is not recommended for interactive operations.
322
323 Note that running more than 10 jobs at a time is likely to run afoul of
324 ssh connection limits. Running between 3 and 5 jobs at a time will yield
325 a good speedup in updates without loading the machine too much.
326
327 =item -t
328
329 =item --trust-all
330
331 Trust all mrconfig files even if they are not listed in F<~/.mrtrust>.
332 Use with caution.
333
334 =item -p
335
336 =item --path
337
338 This obsolete flag is ignored.
339
340 =back
341
342 =head1 MRCONFIG FILES
343
344 Here is an example F<.mrconfig> file:
345
346   [src]
347   checkout = svn checkout svn://svn.example.com/src/trunk src
348   chain = true
349
350   [src/linux-2.6]
351   checkout = git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git &&
352         cd linux-2.6 &&
353         git checkout -b mybranch origin/master
354
355 The F<.mrconfig> file uses a variant of the INI file format. Lines
356 starting with "#" are comments. Values can be continued to the
357 following line by indenting the line with whitespace.
358
359 The C<DEFAULT> section allows setting default values for the sections that
360 come after it.
361
362 The C<ALIAS> section allows adding aliases for actions. Each parameter
363 is an alias, and its value is the action to use.
364
365 All other sections add repositories. The section header specifies the
366 directory where the repository is located. This is relative to the directory
367 that contains the mrconfig file, but you can also choose to use absolute
368 paths. (Note that you can use environment variables in section names; they
369 will be passed through the shell for expansion. For example, 
370 C<[$HOSTNAME]>, or C<[${HOSTNAME}foo]>).
371
372 Within a section, each parameter defines a shell command to run to handle a
373 given action. mr contains default handlers for "update", "status",
374 "commit", and other standard actions.
375
376 Normally you only need to specify what to do for "checkout". Here you
377 specify the command to run in order to create a checkout of the repository.
378 The command will be run in the parent directory, and must create the
379 repository's directory. So use C<git clone>, C<svn checkout>, C<bzr branch>
380 or C<bzr checkout> (for a bound branch), etc.
381
382 Note that these shell commands are run in a C<set -e> shell
383 environment, where any additional parameters you pass are available in
384 C<$@>. All commands other than "checkout" are run inside the repository,
385 though not necessarily at the top of it.
386
387 The C<MR_REPO> environment variable is set to the path to the top of the
388 repository. (For the "register" action, "MR_REPO" is instead set to the 
389 basename of the directory that should be created when checking the
390 repository out.)
391
392 The C<MR_CONFIG> environment variable is set to the .mrconfig file
393 that defines the repo being acted on, or, if the repo is not yet in a config
394 file, the F<.mrconfig> file that should be modified to register the repo.
395
396 The C<MR_ACTION> environment variable is set to the command being run
397 (update, checkout, etc).
398
399 A few parameters have special meanings:
400
401 =over 4
402
403 =item skip
404
405 If the "skip" parameter is set and its command returns true, then B<mr>
406 will skip acting on that repository. The command is passed the action
407 name in C<$1>.
408
409 Here are two examples. The first skips the repo unless
410 mr is run by joey. The second uses the hours_since function
411 (included in mr's built-in library) to skip updating the repo unless it's
412 been at least 12 hours since the last update.
413
414   [mystuff]
415   checkout = ...
416   skip = test `whoami` != joey
417
418   [linux]
419   checkout = ...
420   skip = [ "$1" = update ] && ! hours_since "$1" 12
421  
422 Another way to use skip is for a lazy checkout. This makes mr skip
423 operating on a repo unless it already exists. To enable the 
424 repo, you have to explicitly check it out (using "mr --force -d foo checkout").
425
426   [foo]
427   checkout = ...
428   skip = lazy
429
430 =item order
431
432 The "order" parameter can be used to override the default ordering of
433 repositories. The default order value is 10. Use smaller values to make
434 repositories be processed earlier, and larger values to make repositories
435 be processed later.
436
437 Note that if a repository is located in a subdirectory of another
438 repository, ordering it to be processed earlier is not recommended.
439
440 =item chain
441
442 If the "chain" parameter is set and its command returns true, then B<mr>
443 will try to load a F<.mrconfig> file from the root of the repository.
444
445 =item include
446
447 If the "include" parameter is set, its command is ran, and should output
448 additional mrconfig file content. The content is included as if it were
449 part of the including file.
450
451 Unlike all other parameters, this parameter does not need to be placed
452 within a section.
453
454 B<mr> ships several libraries that can be included to add support for
455 additional version control type things (unison, git-svn, git-fake-bare,
456 git-subtree). To include them all, you could use:
457
458   include = cat /usr/share/mr/*
459
460 See the individual files for details.
461
462 =item deleted
463
464 If the "deleted" parameter is set and its command returns true, then
465 B<mr> will treat the repository as deleted. It won't ever actually delete
466 the repository, but it will warn if it sees the repository's directory.
467 This is useful when one mrconfig file is shared among multiple machines,
468 to keep track of and remember to delete old repositories.
469
470 =item lib
471
472 The "lib" parameter can specify some shell code that will be run
473 before each command, this can be a useful way to define shell
474 functions for other commands to use. 
475
476 Unlike most other parameters, this can be specified multiple times, in
477 which case the chunks of shell code are accumulatively concatenated
478 together.
479
480 =item fixups
481
482 If the "fixups" parameter is set, its command is run whenever a repository
483 is checked out, or updated. This provides an easy way to do things
484 like permissions fixups, or other tweaks to the repository content,
485 whenever the repository is changed.
486
487 =item VCS_action
488
489 When looking for a command to run for a given action, mr first looks for
490 a parameter with the same name as the action. If that is not found, it
491 looks for a parameter named "VCS_action" (substituting in the name of the
492 version control system and the action).
493
494 Internally, mr has settings for "git_update", "svn_update", etc. To change
495 the action that is performed for a given version control system, you can
496 override these VCS specific actions. To add a new version control system,
497 you can just add VCS specific actions for it.
498
499 =item pre_ and post_
500
501 If a "pre_action" parameter is set, its command is run before mr performs the
502 specified action. Similarly, "post_action" parameters are run after mr
503 successfully performs the specified action. For example, "pre_commit" is
504 run before committing; "post_update" is run after updating.
505
506 =item _append
507
508 Any parameter can be suffixed with C<_append>, to add an additional value
509 to the existing value of the parameter. In this way, actions 
510 can be constructed accumulatively.
511
512 =item VCS_test
513
514 The name of the version control system is itself determined by
515 running each defined "VCS_test" action, until one succeeds.
516
517 =back
518
519 =head1 UNTRUSTED MRCONFIG FILES
520
521 Since mrconfig files can contain arbitrary shell commands, they can do
522 anything. This flexibility is good, but it also allows a malicious mrconfig
523 file to delete your whole home directory. Such a file might be contained
524 inside a repository that your main F<~/.mrconfig> checks out. To
525 avoid worries about evil commands in a mrconfig file, mr defaults to
526 reading all mrconfig files other than the main F<~/.mrconfig> in untrusted
527 mode. In untrusted mode, mrconfig files are limited to running only known
528 safe commands (like "git clone") in a carefully checked manner.
529
530 To configure mr to trust other mrconfig files, list them in F<~/.mrtrust>.
531 One mrconfig file should be listed per line. Either the full pathname
532 should be listed, or the pathname can start with F<~/> to specify a file
533 relative to your home directory.
534
535 =head1 OFFLINE LOG FILE
536
537 The F<~/.mrlog> file contains commands that mr has remembered to run later,
538 due to being offline. You can delete or edit this file to remove commands,
539 or even to add other commands for 'mr online' to run. If the file is
540 present, mr assumes it is in offline mode.
541
542 =head1 EXTENSIONS
543
544 mr can be extended to support things such as unison and git-svn. Some
545 files providing such extensions are available in F</usr/share/mr/>. See
546 the documentation in the files for details about using them.
547
548 =head1 EXIT STATUS
549
550 mr returns nonzero if a command failed in any of the repositories.
551
552 =head1 AUTHOR
553
554 Copyright 2007-2011 Joey Hess <joey@kitenet.net>
555
556 Licensed under the GNU GPL version 2 or higher.
557
558 http://myrepos.branchable.com/
559
560 =cut
561
562 use warnings;
563 use strict;
564 use Getopt::Long;
565 use Cwd qw(getcwd abs_path);
566
567 # things that can happen when mr runs a command
568 use constant {
569         OK => 0,
570         FAILED => 1,
571         SKIPPED => 2,
572         ABORT => 3,
573 };
574
575 # configurables
576 my $config_overridden=0;
577 my $verbose=0;
578 my $minimal=0;
579 my $quiet=0;
580 my $stats=0;
581 my $force=0;
582 my $insecure=0;
583 my $interactive=0;
584 my $max_depth;
585 my $no_chdir=0;
586 my $jobs=1;
587 my $trust_all=0;
588 my $directory=getcwd();
589 my $terminal=-t STDOUT && eval{require IO::Pty::Easy;IO::Pty::Easy->import();1;};
590
591 my $HOME_MR_CONFIG = "$ENV{HOME}/.mrconfig";
592 $ENV{MR_CONFIG}=find_mrconfig();
593
594 # globals :-(
595 my %config;
596 my %configfiles;
597 my %knownactions;
598 my %alias;
599 my (@ok, @failed, @skipped);
600
601 main();
602
603 sub shellquote {
604         my $i=shift;
605         $i=~s/'/'"'"'/g;
606         return "'$i'";
607 }
608
609 # Runs a shell command using a supplied function.
610 # The lib will be included in the shell command line, and any params
611 # will be available in the shell as $1, $2, etc.
612 my $lastlib;
613 sub runsh {
614         my ($action, $topdir, $subdir, $command, $params, $runner) = @_;
615
616         # optimisation: avoid running the shell for true and false
617         if ($command =~ /^\s*true\s*$/) {
618                 $?=0;
619                 return 0;
620         }
621         elsif ($command =~ /^\s*false\s*$/) {
622                 $?=0;
623                 return 1;
624         }
625         
626         my $quotedparams=join(" ", (map { shellquote($_) } @$params));
627         my $lib=exists $config{$topdir}{$subdir}{lib} ?
628                        $config{$topdir}{$subdir}{lib}."\n" : "";
629         if ($verbose && (! defined $lastlib || $lastlib ne $lib)) {
630                 print "mr library now: >>$lib<<\n";
631                 $lastlib=$lib;
632         }
633         my $shellcode="set -e;".$lib.
634                 "my_sh(){ $command\n }; my_sh $quotedparams";
635         print "mr $action: running $action >>$command<<\n" if $verbose;
636         $runner->($shellcode);
637 }
638
639 my %perl_cache;
640 sub perl {
641         my $id=shift;
642         my $s=shift;
643         if ($s =~ m/^perl:\s+(.*)/s) {
644                 return $perl_cache{$1} if exists $perl_cache{$1};
645                 my $sub=eval "sub {$1}";
646                 if (! defined $sub) {
647                         print STDERR "mr: bad perl code in $id: $@\n";
648                 }
649                 return $perl_cache{$1} = $sub;
650         }
651         return undef;
652 }
653
654 my %vcs;
655 sub vcs_test {
656         my ($action, $dir, $topdir, $subdir) = @_;
657
658         if (exists $vcs{$dir}) {
659                 return $vcs{$dir};
660         }
661
662         my $test="";
663         my %perltest;
664         foreach my $vcs_test (
665                         sort {
666                                 length $a <=> length $b 
667                                           ||
668                                        $a cmp $b
669                         } grep { /_test$/ } keys %{$config{$topdir}{$subdir}}) {
670                 my ($vcs)=$vcs_test =~ /(.*)_test/;
671                 my $p=perl($vcs_test, $config{$topdir}{$subdir}{$vcs_test});
672                 if (defined $p) {
673                         $perltest{$vcs}=$p;
674                 }
675                 else {
676                         $test="my_$vcs_test() {\n$config{$topdir}{$subdir}{$vcs_test}\n}\n".$test;
677                         $test.="if my_$vcs_test; then echo $vcs; fi\n";
678                 }
679         }
680
681         my @vcs;
682         foreach my $vcs (keys %perltest) {
683                 if ($perltest{$vcs}->()) {
684                         push @vcs, $vcs;
685                 }
686         }
687
688         push @vcs, split(/\n/,
689                 runsh("vcs test", $topdir, $subdir, $test, [], sub {
690                         my $sh=shift;
691                         my $ret=`$sh`;
692                         return $ret;
693                 })) if length $test;
694         if (@vcs > 1) {
695                 print STDERR "mr $action: found multiple possible repository types (@vcs) for ".fulldir($topdir, $subdir)."\n";
696                 return undef;
697         }
698         if (! @vcs) {
699                 return $vcs{$dir}=undef;
700         }
701         else {
702                 return $vcs{$dir}=$vcs[0];
703         }
704 }
705         
706 sub findcommand {
707         my ($action, $dir, $topdir, $subdir, $is_checkout) = @_;
708         
709         if (exists $config{$topdir}{$subdir}{$action}) {
710                 return $config{$topdir}{$subdir}{$action};
711         }
712
713         if ($is_checkout) {
714                 return undef;
715         }
716
717         my $vcs=vcs_test(@_);
718
719         if (defined $vcs && 
720             exists $config{$topdir}{$subdir}{$vcs."_".$action}) {
721                 return $config{$topdir}{$subdir}{$vcs."_".$action};
722         }
723         else {
724                 return undef;
725         }
726 }
727
728 sub fulldir {
729         my ($topdir, $subdir) = @_;
730         return $subdir =~ /^\// ? $subdir : $topdir.$subdir;
731 }
732
733 sub terminal_friendly_spawn {
734         my $actionmsg = shift;
735         my $sh = shift;
736         my $quiet = shift;
737         my $minimal = shift;
738         my $output = "";
739         if ($terminal) {
740                 my $pty = IO::Pty::Easy->new;
741                 $pty->spawn($sh);
742                 while ($pty->is_active) {
743                         my $data = $pty->read();
744                         $output .= $data if defined $data;
745                 }
746                 $pty->close;
747         } else {
748                 $output = qx/$sh 2>&1/;
749         }
750         my $ret = $?;
751         if ($quiet && $ret != 0) {
752                 print "$actionmsg\n" if $actionmsg;
753                 print STDERR $output;
754         } elsif (!$quiet && (!$minimal || $output)) {
755                 print "$actionmsg\n" if $actionmsg;
756                 print $output;
757         }
758         return ($ret, $output ? 1 : 0);
759 }
760
761 sub action {
762         my ($action, $dir, $topdir, $subdir, $force_checkout) = @_;
763         my $fulldir=fulldir($topdir, $subdir);
764         my $checkout_dir;
765
766         $ENV{MR_CONFIG}=$configfiles{$topdir};
767         my $is_checkout=($action eq 'checkout');
768         my $is_update=($action =~ /update/);
769
770         ($ENV{MR_REPO}=$dir) =~ s!/$!!;
771         $ENV{MR_ACTION}=$action;
772         
773         foreach my $testname ("skip", "deleted") {
774                 next if $force && $testname eq "skip";
775
776                 my $testcommand=findcommand($testname, $dir, $topdir, $subdir, $is_checkout);
777
778                 if (defined $testcommand) {
779                         my $ret=runsh "$testname test", $topdir, $subdir,
780                                 $testcommand, [$action],
781                                 sub { system(shift()) };
782                         if ($ret != 0) {
783                                 if (($? & 127) == 2) {
784                                         print STDERR "mr $action: interrupted\n";
785                                         return ABORT;
786                                 }
787                                 elsif ($? & 127) {
788                                         print STDERR "mr $action: $testname test received signal ".($? & 127)."\n";
789                                         return ABORT;
790                                 }
791                         }
792                         if ($ret >> 8 == 0) {
793                                 if ($testname eq "deleted") {
794                                         if (-d $dir) {
795                                                 print STDERR "mr error: $dir should be deleted yet still exists\n";
796                                                 return FAILED;
797                                         }
798                                 }
799                                 print "mr $action: skip $dir skipped\n" if $verbose;
800                                 return SKIPPED;
801                         }
802                 }
803         }
804
805         if ($is_checkout) {
806                 $checkout_dir=$dir;
807                 if (! $force_checkout) {
808                         if (-d $dir) {
809                                 print "mr $action: $dir already exists, skipping checkout\n" if $verbose;
810                                 return SKIPPED;
811                         }
812         
813                         $dir=~s/^(.*)\/[^\/]+\/?$/$1/;
814                 }
815         }
816         elsif ($is_update) {
817                 if (! -d $dir) {
818                         return action("checkout", $dir, $topdir, $subdir);
819                 }
820         }
821
822         my $command=findcommand($action, $dir, $topdir, $subdir, $is_checkout);
823
824         if ($is_checkout && ! -d $dir) {
825                 print "mr $action: creating parent directory $dir\n" if $verbose;
826                 system("mkdir", "-p", $dir);
827         }
828
829         if (! $no_chdir && ! chdir($dir)) {
830                 print STDERR "mr $action: failed to chdir to $dir: $!\n";
831                 return FAILED;
832         }
833         elsif (! defined $command) {
834                 my $vcs=vcs_test(@_);
835                 if (! defined $vcs) {
836                         print STDERR "mr $action: unknown repository type and no defined $action command for $fulldir\n";
837                         return FAILED;
838                 }
839                 else {
840                         print STDERR "mr $action: no defined action for $vcs repository $fulldir, skipping\n" unless $minimal;
841                         return SKIPPED;
842                 }
843         }
844         else {
845                 my $actionmsg;
846                 if (! $no_chdir) {
847                         $actionmsg="mr $action: $fulldir";
848                 }
849                 else {
850                         my $s=$directory;
851                         $s=~s/^\Q$fulldir\E\/?//;
852                         $actionmsg="mr $action: $fulldir (in subdir $s)";
853                 }
854                 print "$actionmsg\n" unless $quiet || $minimal;
855
856                 my $hookret=hook("pre_$action", $topdir, $subdir);
857                 return $hookret if $hookret != OK;
858
859                 my ($ret, $out)=runsh $action, $topdir, $subdir,
860                         $command, \@ARGV, sub {
861                                 my $sh=shift;
862                                 if (!$jobs || $jobs > 1 || $quiet || $minimal) {
863                                         return terminal_friendly_spawn($actionmsg, $sh, $quiet, $minimal);
864                                 }
865                                 else {
866                                         system($sh);
867                                 }
868                         };
869                 if ($ret != 0) {
870                         if (($? & 127) == 2) {
871                                 print STDERR "mr $action: interrupted\n";
872                                 return ABORT;
873                         }
874                         elsif ($? & 127) {
875                                 print STDERR "mr $action: received signal ".($? & 127)."\n";
876                                 return ABORT;
877                         }
878                         print STDERR "mr $action: failed ($ret)\n" if $verbose;
879                         if ($ret >> 8 != 0) {
880                                 print STDERR "mr $action: command failed\n";
881                                 if (-e "$ENV{HOME}/.mrlog" && $action ne 'remember') {
882                                         # recreate original command line to
883                                         # remember, and avoid recursing
884                                         my @orig=@ARGV;
885                                         @ARGV=('-n', $action, @orig);
886                                         action("remember", $dir, $topdir, $subdir);
887                                         @ARGV=@orig;
888                                 }
889                         }
890                         elsif ($ret != 0) {
891                                 print STDERR "mr $action: command died ($ret)\n";
892                         }
893                         return FAILED;
894                 }
895                 else {
896                         if ($is_checkout && ! -d $dir) {
897                                 print STDERR "mr $action: $dir missing after checkout\n";;
898                                 return FAILED;
899                         }
900
901                         my ($ret, $hook_out)=hook("post_$action", $topdir, $subdir);
902                         return $ret if $ret != OK;
903                         
904                         if ($is_checkout || $is_update) {
905                                 if ($is_checkout && ! $no_chdir) {
906                                         if (! chdir($checkout_dir)) {
907                                                 print STDERR "mr $action: failed to chdir to $checkout_dir: $!\n";
908                                                 return FAILED;
909                                         }
910                                 }
911                                 my $ret=hook("fixups", $topdir, $subdir);
912                                 return $ret if $ret != OK;
913                         }
914                         
915                         return (OK, $out || $hook_out);
916                 }
917         }
918 }
919
920 sub hook {
921         my ($hook, $topdir, $subdir) = @_;
922
923         my $command=$config{$topdir}{$subdir}{$hook};
924         return OK unless defined $command;
925         my ($ret,$out)=runsh $hook, $topdir, $subdir, $command, [], sub {
926                         my $sh=shift;
927                         if (!$jobs || $jobs > 1 || $quiet || $minimal) {
928                                 return terminal_friendly_spawn(undef, $sh, $quiet, $minimal);
929                         }
930                         else {
931                                 system($sh);
932                         }
933                 };
934         if ($ret != 0) {
935                 if (($? & 127) == 2) {
936                         print STDERR "mr $hook: interrupted\n";
937                         return ABORT;
938                 }
939                 elsif ($? & 127) {
940                         print STDERR "mr $hook: received signal ".($? & 127)."\n";
941                         return ABORT;
942                 }
943                 else {
944                         return FAILED;
945                 }
946         }
947
948         return (OK, $out);
949 }
950
951 # run actions on multiple repos, in parallel
952 sub mrs {
953         my $action=shift;
954         my @repos=@_;
955
956         $| = 1;
957         my @active;
958         my @fhs;
959         my @out;
960         my $running=0;
961         while (@fhs or @repos) {
962                 while ((!$jobs || $running < $jobs) && @repos) {
963                         $running++;
964                         my $repo = shift @repos;
965                         pipe(my $outfh, CHILD_STDOUT);
966                         pipe(my $errfh, CHILD_STDERR);
967                         my $pid;
968                         unless ($pid = fork) {
969                                 die "mr $action: cannot fork: $!" unless defined $pid;
970                                 open(STDOUT, ">&CHILD_STDOUT") || die "mr $action cannot reopen stdout: $!";
971                                 open(STDERR, ">&CHILD_STDERR") || die "mr $action cannot reopen stderr: $!";
972                                 close CHILD_STDOUT;
973                                 close CHILD_STDERR;
974                                 close $outfh;
975                                 close $errfh;
976                                 exit +(action($action, @$repo))[0];
977                         }
978                         close CHILD_STDOUT;
979                         close CHILD_STDERR;
980                         push @active, [$pid, $repo];
981                         push @fhs, [$outfh, $errfh];
982                         push @out, ['',     ''];
983                 }
984                 my ($rin, $rout) = ('','');
985                 my $nfound;
986                 foreach my $fh (@fhs) {
987                         next unless defined $fh;
988                         vec($rin, fileno($fh->[0]), 1) = 1 if defined $fh->[0];
989                         vec($rin, fileno($fh->[1]), 1) = 1 if defined $fh->[1];
990                 }
991                 $nfound = select($rout=$rin, undef, undef, 1);
992                 foreach my $channel (0, 1) {
993                         foreach my $i (0..$#fhs) {
994                                 next unless defined $fhs[$i];
995                                 my $fh = $fhs[$i][$channel];
996                                 next unless defined $fh;
997                                 if (vec($rout, fileno($fh), 1) == 1) {
998                                         my $r = '';
999                                         if (sysread($fh, $r, 1024) == 0) {
1000                                                 close($fh);
1001                                                 $fhs[$i][$channel] = undef;
1002                                                 if (! defined $fhs[$i][0] &&
1003                                                     ! defined $fhs[$i][1]) {
1004                                                         waitpid($active[$i][0], 0);
1005                                                         print STDOUT $out[$i][0];
1006                                                         print STDERR $out[$i][1];
1007                                                         record($active[$i][1], $? >> 8, $out[$i][0] || $out[$i][1]);
1008                                                         splice(@fhs, $i, 1);
1009                                                         splice(@active, $i, 1);
1010                                                         splice(@out, $i, 1);
1011                                                         $running--;
1012                                                 }
1013                                         }
1014                                         $out[$i][$channel] .= $r;
1015                                 }
1016                         }
1017                 }
1018         }
1019 }
1020
1021 sub record {
1022         my $dir=shift()->[0];
1023         my $ret=shift;
1024         my $out=shift;
1025
1026         if ($ret == OK) {
1027                 push @ok, $dir;
1028                 print "\n" unless $quiet || ($minimal && !$out);
1029         }
1030         elsif ($ret == FAILED) {
1031                 if ($interactive) {
1032                         chdir($dir) unless $no_chdir;
1033                         print STDERR "mr: Starting interactive shell. Exit shell to continue.\n";
1034                         system((getpwuid($<))[8], "-i");
1035                 }
1036                 push @failed, $dir;
1037                 print "\n";
1038         }
1039         elsif ($ret == SKIPPED) {
1040                 push @skipped, $dir;
1041         }
1042         elsif ($ret == ABORT) {
1043                 exit 1;
1044         }
1045         else {
1046                 die "unknown exit status $ret";
1047         }
1048 }
1049
1050 sub showstats {
1051         my $action=shift;
1052         if (! @ok && ! @failed && ! @skipped) {
1053                 die "mr $action: no repositories found to work on\n";
1054         }
1055         print "mr $action: finished (".join("; ",
1056                 showstat($#ok+1, "ok", "ok"),
1057                 showstat($#failed+1, "failed", "failed"),
1058                 showstat($#skipped+1, "skipped", "skipped"),
1059         ).")\n" unless $quiet || $minimal;
1060         if ($stats) {
1061                 if (@skipped) {
1062                         print "mr $action: (skipped: ".join(" ", @skipped).")\n" unless $quiet || $minimal;
1063                 }
1064                 if (@failed) {
1065                         print STDERR "mr $action: (failed: ".join(" ", @failed).")\n";
1066                 }
1067         }
1068 }
1069
1070 sub showstat {
1071         my $count=shift;
1072         my $singular=shift;
1073         my $plural=shift;
1074         if ($count) {
1075                 return "$count ".($count > 1 ? $plural : $singular);
1076         }
1077         return;
1078 }
1079
1080 # an ordered list of repos
1081 sub repolist {
1082         my @list;
1083         foreach my $topdir (sort keys %config) {
1084                 foreach my $subdir (sort keys %{$config{$topdir}}) {
1085                         push @list, {
1086                                 topdir => $topdir,
1087                                 subdir => $subdir,
1088                                 order => $config{$topdir}{$subdir}{order},
1089                         };
1090                 }
1091         }
1092         return sort {
1093                 $a->{order}  <=> $b->{order}
1094                              ||
1095                 $a->{topdir} cmp $b->{topdir}
1096                              ||
1097                 $a->{subdir} cmp $b->{subdir}
1098         } @list;
1099 }
1100
1101 sub repodir {
1102         my $repo=shift;
1103         my $topdir=$repo->{topdir};
1104         my $subdir=$repo->{subdir};
1105         my $ret=($subdir =~/^\//) ? $subdir : $topdir.$subdir;
1106         $ret=~s/\/\.$//;
1107         return $ret;
1108 }
1109
1110 # Figure out which repos to act on.  Returns a list of array refs
1111 # in the format:
1112 #
1113 #   [ "$full_repo_path/", "$mr_config_path/", $section_header ]
1114 sub selectrepos {
1115         my @repos;
1116         foreach my $repo (repolist()) {
1117                 my $topdir=$repo->{topdir};
1118                 my $subdir=$repo->{subdir};
1119
1120                 next if $subdir eq 'DEFAULT';
1121                 my $dir=repodir($repo);
1122                 my $d=$directory;
1123                 $dir.="/" unless $dir=~/\/$/;
1124                 $d.="/" unless $d=~/\/$/;
1125                 next if $dir ne $d && $dir !~ /^\Q$d\E/;
1126                 if (defined $max_depth) {
1127                         my @a=split('/', $dir);
1128                         my @b=split('/', $d);
1129                         do { } while (@a && @b && shift(@a) eq shift(@b));
1130                         next if @a > $max_depth || @b > $max_depth;
1131                 }
1132                 push @repos, [$dir, $topdir, $subdir];
1133         }
1134         if (! @repos) {
1135                 # fallback to find a leaf repo
1136                 foreach my $repo (reverse repolist()) {
1137                         my $topdir=$repo->{topdir};
1138                         my $subdir=$repo->{subdir};
1139                         
1140                         next if $subdir eq 'DEFAULT';
1141                         my $dir=repodir($repo);
1142                         my $d=$directory;
1143                         $dir.="/" unless $dir=~/\/$/;
1144                         $d.="/" unless $d=~/\/$/;
1145                         if ($d=~/^\Q$dir\E/) {
1146                                 push @repos, [$dir, $topdir, $subdir];
1147                                 last;
1148                         }
1149                 }
1150                 $no_chdir=1;
1151         }
1152         return @repos;
1153 }
1154
1155 sub expandenv {
1156         my $val=shift;
1157         
1158
1159         if ($val=~/\$/) {
1160                 $val=`echo "$val"`;
1161                 chomp $val;
1162         }
1163         
1164         return $val;
1165 }
1166
1167 my %trusted;
1168 sub is_trusted_config {
1169         my $config=shift; # must be abs_pathed already
1170
1171         # We always trust ~/.mrconfig.
1172         return 1 if $config eq abs_path($HOME_MR_CONFIG);
1173
1174         return 1 if $trust_all;
1175
1176         my $trustfile=$ENV{HOME}."/.mrtrust";
1177
1178         if (! %trusted) {
1179                 $trusted{$HOME_MR_CONFIG}=1;
1180                 if (open (TRUST, "<", $trustfile)) {
1181                         while (<TRUST>) {
1182                                 chomp;
1183                                 s/^~\//$ENV{HOME}\//;
1184                                 my $d=abs_path($_);
1185                                 $trusted{$d}=1 if defined $d;
1186                         }
1187                         close TRUST;
1188                 }
1189         }
1190
1191         return $trusted{$config};
1192 }
1193
1194
1195 sub is_trusted_repo {
1196         my $repo=shift;
1197         
1198         # Tightly limit what is allowed in a repo name.
1199         # No ../, no absolute paths, and no unusual filenames
1200         # that might try to escape to the shell.
1201         return $repo =~ /^[-_.+\/A-Za-z0-9]+$/ &&
1202                $repo !~ /\.\./ && $repo !~ /^\//;
1203 }
1204
1205 sub is_trusted_checkout {
1206         my $command=shift;
1207         
1208         # To determine if the command is safe, compare it with the
1209         # *_trusted_checkout config settings. Those settings are
1210         # templates for allowed commands, so make sure that each word
1211         # of the command matches the corresponding word of the template.
1212         
1213         my @words;
1214         foreach my $word (split(' ', $command)) {
1215                 # strip quoting
1216                 if ($word=~/^'(.*)'$/) {
1217                         $word=$1;
1218                 }
1219                 elsif ($word=~/^"(.*)"$/) {
1220                         $word=$1;
1221                 }
1222
1223                 push @words, $word;
1224         }
1225
1226         foreach my $key (grep { /_trusted_checkout$/ }
1227                          keys %{$config{''}{DEFAULT}}) {
1228                 my @twords=split(' ', $config{''}{DEFAULT}{$key});
1229                 next if @words > @twords;
1230
1231                 my $match=1;
1232                 my $url;
1233                 for (my $c=0; $c < @twords && $match; $c++) {
1234                         if ($twords[$c] eq '$url') {
1235                                 # Match all the typical characters found in
1236                                 # urls, plus @ which svn can use. Note
1237                                 # that the "url" might also be a local
1238                                 # directory.
1239                                 $match=(
1240                                         defined $words[$c] &&
1241                                         $words[$c] =~ /^[-_.+:@\/A-Za-z0-9]+$/
1242                                 );
1243                                 $url=$words[$c];
1244                         }
1245                         elsif ($twords[$c] eq '$repo') {
1246                                 # If a repo is not specified, assume it
1247                                 # will be the last path component of the
1248                                 # url, or something derived from it, and
1249                                 # check that.
1250                                 if (! defined $words[$c] && defined $url) {
1251                                         ($words[$c])=$url=~/\/([^\/]+)\/?$/;
1252                                 }
1253
1254                                 $match=(
1255                                         defined $words[$c] &&
1256                                         is_trusted_repo($words[$c])
1257                                 );
1258                         }
1259                         elsif (defined $words[$c] && $words[$c]=~/^($twords[$c])$/) {
1260                                 $match=1;
1261                         }
1262                         else {
1263                                 $match=0;
1264                         }
1265                 }
1266                 return 1 if $match;
1267         }
1268
1269         return 0;
1270 }
1271
1272 my %loaded;
1273 sub loadconfig {
1274         my $f=shift;
1275         my $dir=shift;
1276         my $bootstrap_src=shift;
1277
1278         my @toload;
1279
1280         my $in;
1281         my $trusted;
1282         if (ref $f eq 'GLOB') {
1283                 $dir="";
1284                 $in=$f;
1285                 $trusted=1;
1286         }
1287         else {
1288                 my $absf=abs_path($f);
1289                 if ($loaded{$absf}) {
1290                         return;
1291                 }
1292                 $loaded{$absf}=1;
1293
1294                 $trusted=is_trusted_config($absf);
1295
1296                 if (! defined $dir) {
1297                         ($dir)=$f=~/^(.*\/)[^\/]+$/;
1298                         if (! defined $dir) {
1299                                 $dir=".";
1300                         }
1301                 }
1302
1303                 $dir=abs_path($dir)."/";
1304                 
1305                 if (! exists $configfiles{$dir}) {
1306                         $configfiles{$dir}=$f;
1307                 }
1308
1309                 # copy in defaults from first parent
1310                 my $parent=$dir;
1311                 while ($parent=~s/^(.*\/)[^\/]+\/?$/$1/) {
1312                         if ($parent eq '/') {
1313                                 $parent="";
1314                         }
1315                         if (exists $config{$parent} &&
1316                             exists $config{$parent}{DEFAULT}) {
1317                                 $config{$dir}{DEFAULT}={ %{$config{$parent}{DEFAULT}} };
1318                                 last;
1319                         }
1320                 }
1321                 
1322                 if (! -e $f) {
1323                         return;
1324                 }
1325
1326                 print "mr: loading config $f\n" if $verbose;
1327                 open($in, "<", $f) || die "mr: open $f: $!\n";
1328         }
1329         my @lines=<$in>;
1330         close $in unless ref $f eq 'GLOB';
1331
1332         my $section;
1333
1334         # Keep track of the current line in the config file;
1335         # when a file is included track the current line from the include.
1336         my $lineno=0;
1337         my $included=undef;
1338
1339         my $line;
1340         my $nextline = sub {
1341                 if ($included) {
1342                         $included--;
1343                 }
1344                 else {
1345                         $included=undef;
1346                         $lineno++;
1347                 }
1348                 $line=shift @lines;
1349                 chomp $line;
1350                 return $line;
1351         };
1352         my $lineerror = sub {
1353                 my $msg=shift;
1354                 if (defined $included) {
1355                         die "mr: $msg at $f line $lineno, included line: $line\n";
1356                 }
1357                 else {
1358                         die "mr: $msg at $f line $lineno\n";
1359                 }
1360         };
1361         my $trusterror = sub {
1362                 my $msg=shift;
1363         
1364                 if (defined $bootstrap_src) {
1365                         die "mr: $msg in untrusted $bootstrap_src line $lineno\n".
1366                                 "(To trust this url, --trust-all can be used; but please use caution;\n".
1367                                 "this can allow arbitrary code execution!)\n";
1368                 }
1369                 else {
1370                         die "mr: $msg in untrusted $f line $lineno\n".
1371                                 "(To trust this file, list it in ~/.mrtrust.)\n";
1372                 }
1373         };
1374
1375         while (@lines) {
1376                 $_=$nextline->();
1377
1378                 next if /^\s*\#/ || /^\s*$/;
1379
1380                 if (! $trusted && /[[:cntrl:]]/) {
1381                         $trusterror->("illegal control character");
1382                 }
1383
1384                 if (/^\[([^\]]*)\]\s*$/) {
1385                         $section=$1;
1386
1387                         if (! $trusted) {
1388                                 if (! is_trusted_repo($section) ||
1389                                     $section eq 'ALIAS' ||
1390                                     $section eq 'DEFAULT') {
1391                                         $trusterror->("illegal section \"[$section]\"");
1392                                 }
1393                         }
1394                         $section=expandenv($section) if $trusted;
1395                         if ($section ne 'ALIAS' &&
1396                             ! exists $config{$dir}{$section} &&
1397                             exists $config{$dir}{DEFAULT}) {
1398                                 # copy in defaults
1399                                 $config{$dir}{$section}={ %{$config{$dir}{DEFAULT}} };
1400                         }
1401                 }
1402                 elsif (/^(\w+)\s*=\s*(.*)/) {
1403                         my $parameter=$1;
1404                         my $value=$2;
1405
1406                         # continued value
1407                         while (@lines && $lines[0]=~/^\s(.+)/) {
1408                                 $value.="\n$1";
1409                                 chomp $value;
1410                                 $nextline->();
1411                         }
1412
1413                         if (! $trusted) {
1414                                 # Untrusted files can only contain a few
1415                                 # settings in specific known-safe formats.
1416                                 if ($parameter eq 'checkout') {
1417                                         if (! is_trusted_checkout($value)) {
1418                                                 $trusterror->("illegal checkout command \"$value\"");
1419                                         }
1420                                 }
1421                                 elsif ($parameter eq 'order') {
1422                                         # not interpreted as a command, so
1423                                         # safe.
1424                                 }
1425                                 elsif ($value eq 'true' || $value eq 'false') {
1426                                         # skip=true , deleted=true etc are
1427                                         # safe.
1428                                 }
1429                                 else {
1430                                         $trusterror->("illegal setting \"$parameter=$value\"");
1431                                 }
1432                         }
1433
1434                         if ($parameter eq "include") {
1435                                 print "mr: including output of \"$value\"\n" if $verbose;
1436                                 my @inc=`$value`;
1437                                 if ($?) {
1438                                         print STDERR "mr: include command exited nonzero ($?)\n";
1439                                 }
1440                                 $included += @inc;
1441                                 unshift @lines, @inc;
1442                                 next;
1443                         }
1444
1445                         if (! defined $section) {
1446                                 $lineerror->("parameter ($parameter) not in section");
1447                         }
1448                         if ($section eq 'ALIAS') {
1449                                 $alias{$parameter}=$value;
1450                         }
1451                         elsif ($parameter eq 'lib' or $parameter =~ s/_append$//) {
1452                                 $config{$dir}{$section}{$parameter}.="\n".$value."\n";
1453                         }
1454                         else {
1455                                 $config{$dir}{$section}{$parameter}=$value;
1456                                 if ($parameter =~ /.*_(.*)/) {
1457                                         $knownactions{$1}=1;
1458                                 }
1459                                 else {
1460                                         $knownactions{$parameter}=1;
1461                                 }
1462                                 if ($parameter eq 'chain' &&
1463                                     length $dir && $section ne "DEFAULT") {
1464                                         my $chaindir="$section";
1465                                         if ($chaindir !~ m!^/!) {
1466                                                 $chaindir=$dir.$chaindir;
1467                                         }
1468                                         if (-e "$chaindir/.mrconfig") {
1469                                                 my $ret=system($value);
1470                                                 if ($ret != 0) {
1471                                                         if (($? & 127) == 2) {
1472                                                                 print STDERR "mr: chain test interrupted\n";
1473                                                                 exit 2;
1474                                                         }
1475                                                         elsif ($? & 127) {
1476                                                                 print STDERR "mr: chain test received signal ".($? & 127)."\n";
1477                                                         }
1478                                                 }
1479                                                 else {
1480                                                         push @toload, ["$chaindir/.mrconfig", $chaindir];
1481                                                 }
1482                                         }
1483                                 }
1484                         }
1485                 }
1486                 else {
1487                         $lineerror->("parse error");
1488                 }
1489         }
1490
1491         foreach my $c (@toload) {
1492                 loadconfig(@$c);
1493         }
1494 }
1495
1496 sub startingconfig {
1497         %alias=%config=%configfiles=%knownactions=%loaded=();
1498         my $datapos=tell(DATA);
1499         loadconfig(\*DATA);
1500         seek(DATA,$datapos,0); # rewind
1501 }
1502
1503 sub modifyconfig {
1504         my $f=shift;
1505         # the section to modify or add
1506         my $targetsection=shift;
1507         # fields to change in the section
1508         # To remove a field, set its value to "".
1509         my %changefields=@_;
1510
1511         my @lines;
1512         my @out;
1513
1514         if (-e $f) {
1515                 open(my $in, "<", $f) || die "mr: open $f: $!\n";
1516                 @lines=<$in>;
1517                 close $in;
1518         }
1519
1520         my $formatfield=sub {
1521                 my $field=shift;
1522                 my @value=split(/\n/, shift);
1523
1524                 return "$field = ".shift(@value)."\n".
1525                         join("", map { "\t$_\n" } @value);
1526         };
1527         my $addfields=sub {
1528                 my @blanks;
1529                 while ($out[$#out] =~ /^\s*$/) {
1530                         unshift @blanks, pop @out;
1531                 }
1532                 foreach my $field (sort keys %changefields) {
1533                         if (length $changefields{$field}) {
1534                                 push @out, "$field = $changefields{$field}\n";
1535                                 delete $changefields{$field};
1536                         }
1537                 }
1538                 push @out, @blanks;
1539         };
1540
1541         my $section;
1542         while (@lines) {
1543                 $_=shift(@lines);
1544
1545                 if (/^\s*\#/ || /^\s*$/) {
1546                         push @out, $_;
1547                 }
1548                 elsif (/^\[([^\]]*)\]\s*$/) {
1549                         if (defined $section && 
1550                             $section eq $targetsection) {
1551                                 $addfields->();
1552                         }
1553
1554                         $section=expandenv($1);
1555
1556                         push @out, $_;
1557                 }
1558                 elsif (/^(\w+)\s*=\s(.*)/) {
1559                         my $parameter=$1;
1560                         my $value=$2;
1561
1562                         # continued value
1563                         while (@lines && $lines[0]=~/^\s(.+)/) {
1564                                 shift(@lines);
1565                                 $value.="\n$1";
1566                                 chomp $value;
1567                         }
1568
1569                         if ($section eq $targetsection) {
1570                                 if (exists $changefields{$parameter}) {
1571                                         if (length $changefields{$parameter}) {
1572                                                 $value=$changefields{$parameter};
1573                                         }
1574                                         delete $changefields{$parameter};
1575                                 }
1576                         }
1577
1578                         push @out, $formatfield->($parameter, $value);
1579                 }
1580         }
1581
1582         if (defined $section && 
1583             $section eq $targetsection) {
1584                 $addfields->();
1585         }
1586         elsif (%changefields) {
1587                 push @out, "\n[$targetsection]\n";
1588                 foreach my $field (sort keys %changefields) {
1589                         if (length $changefields{$field}) {
1590                                 push @out, $formatfield->($field, $changefields{$field});
1591                         }
1592                 }
1593         }
1594
1595         open(my $out, ">", $f) || die "mr: write $f: $!\n";
1596         print $out @out;
1597         close $out;     
1598 }
1599
1600 sub dispatch {
1601         my $action=shift;
1602
1603         # actions that do not operate on all repos
1604         if ($action eq 'config') {
1605                 config(@ARGV);
1606         }
1607         elsif ($action eq 'register') {
1608                 register(@ARGV);
1609         }
1610         elsif ($action eq 'bootstrap') {
1611                 bootstrap();
1612         }
1613         elsif ($action eq 'remember' ||
1614                $action eq 'offline' ||
1615                $action eq 'online') {
1616                 my @repos=selectrepos;
1617                 action($action, @{$repos[0]}) if @repos;
1618                 exit 0;
1619         }
1620
1621         if (!$jobs || $jobs > 1) {
1622                 mrs($action, selectrepos());
1623         }
1624         else {
1625                 foreach my $repo (selectrepos()) {
1626                         record($repo, action($action, @$repo));
1627                 }
1628         }
1629 }
1630
1631 sub help {
1632         my $help=q#
1633                 case `uname -s` in
1634                         SunOS)
1635                         SHOWMANFILE="man -f"
1636                         ;;
1637                         Darwin)
1638                         SHOWMANFILE="man"
1639                         ;;
1640                         *)
1641                         SHOWMANFILE="man"
1642                         ;;
1643                 esac
1644                 if [ ! -e "$MR_PATH" ]; then
1645                         error "cannot find program path"
1646                 fi
1647                 tmp=$(mktemp -t mr.XXXXXXXXXX) || error "mktemp failed"
1648                 trap "rm -f $tmp" exit
1649                 pod2man -c mr "$MR_PATH" > "$tmp" || error "pod2man failed"
1650                 $SHOWMANFILE "$tmp" || error "man failed"
1651         #;
1652         exec($help) || die "exec: $!";
1653 }
1654
1655 sub config {
1656         if (@_ < 2) {
1657                 die "mr config: not enough parameters\n";
1658         }
1659         my $section=shift;
1660         if ($section=~/^\//) {
1661                 # try to convert to a path relative to the config file
1662                 my ($dir)=$ENV{MR_CONFIG}=~/^(.*\/)[^\/]+$/;
1663                 $dir=abs_path($dir);
1664                 $dir.="/" unless $dir=~/\/$/;
1665                 if ($section=~/^\Q$dir\E(.*)/) {
1666                         $section=$1;
1667                 }
1668         }
1669         my %changefields;
1670         foreach (@_) {
1671                 if (/^([^=]+)=(.*)$/) {
1672                         $changefields{$1}=$2;
1673                 }
1674                 else {
1675                         my $found=0;
1676                         foreach my $topdir (sort keys %config) {
1677                                 if (exists $config{$topdir}{$section} &&
1678                                     exists $config{$topdir}{$section}{$_}) {
1679                                         print $config{$topdir}{$section}{$_}."\n";
1680                                         $found=1;
1681                                         last if $section eq 'DEFAULT';
1682                                 }
1683                         }
1684                         if (! $found) {
1685                                 die "mr config: $section $_ not set\n";
1686                         }
1687                 }
1688         }
1689         modifyconfig($ENV{MR_CONFIG}, $section, %changefields) if %changefields;
1690         exit 0;
1691 }
1692
1693 sub register {
1694         if ($config_overridden) {
1695                 # Find the directory that the specified config file is
1696                 # located in.
1697                 ($directory)=abs_path($ENV{MR_CONFIG})=~/^(.*\/)[^\/]+$/;
1698         }
1699         else {
1700                 # Find the closest known mrconfig file to the current
1701                 # directory.
1702                 $directory.="/" unless $directory=~/\/$/;
1703                 my $foundconfig=0;
1704                 foreach my $topdir (reverse sort keys %config) {
1705                         next unless length $topdir;
1706                         if ($directory=~/^\Q$topdir\E/) {
1707                                 $ENV{MR_CONFIG}=$configfiles{$topdir};
1708                                 $directory=$topdir;
1709                                 $foundconfig=1;
1710                                 last;
1711                         }
1712                 }
1713                 if (! $foundconfig) {
1714                         $directory=""; # no config file, use builtin
1715                 }
1716         }
1717         if (@ARGV) {
1718                 my $subdir=shift @ARGV;
1719                 if (! chdir($subdir)) {
1720                         print STDERR "mr register: failed to chdir to $subdir: $!\n";
1721                 }
1722         }
1723
1724         $ENV{MR_REPO}=getcwd();
1725         my $command=findcommand("register", $ENV{MR_REPO}, $directory, 'DEFAULT', 0);
1726         if (! defined $command) {
1727                 die "mr register: unknown repository type\n";
1728         }
1729
1730         $ENV{MR_REPO}=~s/.*\/(.*)/$1/;
1731         $command="set -e; ".$config{$directory}{DEFAULT}{lib}."\n".
1732                 "my_action(){ $command\n }; my_action ".
1733                 join(" ", map { s/\\/\\\\/g; s/"/\"/g; '"'.$_.'"' } @ARGV);
1734         print "mr register: running >>$command<<\n" if $verbose;
1735         exec($command) || die "exec: $!";
1736 }
1737
1738 sub bootstrap {
1739         eval q{use File::Copy};
1740         die $@ if $@;
1741
1742         my $src=shift @ARGV;
1743         my $dir=shift @ARGV || ".";
1744         
1745         if (! defined $src || ! length $src) {
1746                 die "mr: bootstrap requires source\n";
1747         }
1748
1749         # Retrieve config file.
1750         eval q{use File::Temp};
1751         die $@ if $@;
1752         my $tmpconfig=File::Temp->new();
1753         if ($src =~ m!^[\w\d]+://!) {
1754                 # Download the config file to a temporary location.
1755                 my @downloader;
1756                 if ($src =~ m!^ssh://(.*)!) {
1757                         @downloader = ("scp", $1, $tmpconfig);
1758                 }
1759                 else {
1760                         @downloader = ("curl", "-A", "mr", "-L", "-s", $src, "-o", $tmpconfig);
1761                         push(@downloader, "-k") if $insecure;
1762                 }
1763                 my $status = system(@downloader);
1764                 die "mr bootstrap: invalid SSL certificate for $src (consider -k)\n"
1765                         if $downloader[0] eq 'curl' && $status >> 8 == 60;
1766                 die "mr bootstrap: download of $src failed\n" if $status != 0;
1767         }
1768         elsif ($src eq '-') {
1769                 # Config file is read from stdin.
1770                 copy(\*STDIN, $tmpconfig) || die "stdin: $!";
1771         }
1772         else {
1773                 # Config file is local.
1774                 die "mr bootstrap: cannot read file '$src'"
1775                         unless -r $src;
1776                 copy($src, $tmpconfig) || die "copy: $!";
1777         }
1778
1779         # Sanity check on destination directory.
1780         if (! -e $dir) {
1781                 system("mkdir", "-p", $dir);
1782         }
1783         chdir($dir) || die "chdir $dir: $!";
1784
1785         # Special case to handle checkout of the "." repo, which 
1786         # would normally be skipped.
1787         my $topdir=abs_path(".")."/";
1788         my @repo=($topdir, $topdir, ".");
1789         loadconfig($tmpconfig, $topdir, $src);
1790         record(\@repo, action("checkout", @repo, 1))
1791                 if exists $config{$topdir}{"."}{"checkout"};
1792
1793         if (-e ".mrconfig") {
1794                 print STDERR "mr bootstrap: .mrconfig file already exists, not overwriting with $src\n";
1795         }
1796         else {
1797                 move($tmpconfig, ".mrconfig") || die "rename: $!";
1798         }
1799
1800         # Reload the config file (in case we got a different version)
1801         # and checkout everything else.
1802         startingconfig();
1803         loadconfig(".mrconfig");
1804         dispatch("checkout");
1805         @skipped=grep { abs_path($_) ne abs_path($topdir) } @skipped;
1806         showstats("bootstrap");
1807         exitstats();
1808 }
1809
1810 # alias expansion and command stemming
1811 sub expandaction {
1812         my $action=shift;
1813         if (exists $alias{$action}) {
1814                 $action=$alias{$action};
1815         }
1816         if (! exists $knownactions{$action}) {
1817                 my @matches = grep { /^\Q$action\E/ }
1818                         keys %knownactions, keys %alias;
1819                 if (@matches == 1) {
1820                         $action=$matches[0];
1821                 }
1822                 elsif (@matches == 0) {
1823                         die "mr: unknown action \"$action\" (known actions: ".
1824                                 join(", ", sort keys %knownactions).")\n";
1825                 }
1826                 else {
1827                         die "mr: ambiguous action \"$action\" (matches: ".
1828                                 join(", ", @matches).")\n";
1829                 }
1830         }
1831         return $action;
1832 }
1833
1834 sub find_mrconfig {
1835         my $dir=getcwd();
1836         while (length $dir) {
1837                 if (-e "$dir/.mrconfig") {
1838                         return "$dir/.mrconfig";
1839                 }
1840                 $dir=~s/\/[^\/]*$//;
1841         }
1842         return $HOME_MR_CONFIG;
1843 }
1844
1845 sub getopts {
1846         my @saved=@ARGV;
1847         Getopt::Long::Configure("bundling", "no_permute");
1848         my $result=GetOptions(
1849                 "d|directory=s" => sub { $directory=abs_path($_[1]) },
1850                 "c|config=s" => sub { $ENV{MR_CONFIG}=$_[1]; $config_overridden=1 },
1851                 "p|path" => sub { }, # now default, ignore
1852                 "f|force" => \$force,
1853                 "v|verbose" => \$verbose,
1854                 "m|minimal" => \$minimal,
1855                 "q|quiet" => \$quiet,
1856                 "s|stats" => \$stats,
1857                 "k|insecure" => \$insecure,
1858                 "i|interactive" => \$interactive,
1859                 "n|no-recurse:i" => \$max_depth,
1860                 "j|jobs:i" => \$jobs,
1861                 "t|trust-all" => \$trust_all,
1862         );
1863         if (! $result || @ARGV < 1) {
1864                 die("Usage: mr [options] action [params ...]\n".
1865                     "(Use mr help for man page.)\n");
1866         }
1867         
1868         $ENV{MR_SWITCHES}="";
1869         foreach my $option (@saved) {
1870                 last if $option eq $ARGV[0];
1871                 $ENV{MR_SWITCHES}.="$option ";
1872         }
1873 }
1874
1875 sub init {
1876         $SIG{INT}=sub {
1877                 print STDERR "mr: interrupted\n";
1878                 exit 2;
1879         };
1880         
1881         # This can happen if it's run in a directory that was removed
1882         # or other strangeness.
1883         if (! defined $directory) {
1884                 die("mr: failed to determine working directory\n");
1885         }
1886         # Make sure MR_CONFIG is an absolute path, but don't use abs_path since
1887         # the config file might be a symlink to elsewhere, and the directory it's
1888         # in is significant.
1889         if ($ENV{MR_CONFIG} !~ /^\//) {
1890                 $ENV{MR_CONFIG}=getcwd()."/".$ENV{MR_CONFIG};
1891         }
1892         # Try to set MR_PATH to the path to the program.
1893         eval {
1894                 use FindBin qw($Bin $Script);
1895                 $ENV{MR_PATH}=$Bin."/".$Script;
1896         };
1897 }
1898         
1899 sub exitstats {
1900         if (@failed) {
1901                 exit 1;
1902         }
1903         else {
1904                 exit 0;
1905         }
1906 }
1907
1908 sub main {
1909         getopts();
1910         init();
1911         help(@ARGV) if $ARGV[0] eq 'help';
1912
1913         startingconfig();
1914         loadconfig($HOME_MR_CONFIG);
1915         loadconfig($ENV{MR_CONFIG});
1916         #use Data::Dumper; print Dumper(\%config);
1917         
1918         my $action=expandaction(shift @ARGV);
1919         dispatch($action);
1920
1921         showstats($action);
1922         exitstats();
1923 }
1924
1925 # Finally, some useful actions that mr knows about by default.
1926 # These can be overridden in ~/.mrconfig.
1927 __DATA__
1928 [ALIAS]
1929 co = checkout
1930 ci = commit
1931 ls = list
1932
1933 [DEFAULT]
1934 order = 10
1935 lib =
1936         error() {
1937                 echo "mr: $@" >&2
1938                 exit 1
1939         }
1940         warning() {
1941                 echo "mr (warning): $@" >&2
1942         }
1943         info() {
1944                 echo "mr: $@" >&2
1945         }
1946         hours_since() {
1947                 if [ -z "$1" ] || [ -z "$2" ]; then
1948                         error "mr: usage: hours_since action num"
1949                 fi
1950                 for dir in .git .svn .bzr CVS .hg _darcs _FOSSIL_; do
1951                         if [ -e "$MR_REPO/$dir" ]; then
1952                                 flagfile="$MR_REPO/$dir/.mr_last$1"
1953                                 break
1954                         fi
1955                 done
1956                 if [ -z "$flagfile" ]; then
1957                         error "cannot determine flag filename"
1958                 fi
1959                 delta=`perl -wle 'print -f shift() ? int((-M _) * 24) : 9999' "$flagfile"`
1960                 if [ "$delta" -lt "$2" ]; then
1961                         return 1
1962                 else
1963                         touch "$flagfile"
1964                         return 0
1965                 fi
1966         }
1967         is_bzr_checkout() {
1968                 LANG=C bzr info | egrep -q '^Checkout'
1969         }
1970         lazy() {
1971                 if [ -d "$MR_REPO" ]; then
1972                         return 1
1973                 else
1974                         return 0
1975                 fi
1976         }
1977
1978 svn_test = perl: -d "$ENV{MR_REPO}/.svn"
1979 git_test = perl: -e "$ENV{MR_REPO}/.git"
1980 bzr_test = perl: -d "$ENV{MR_REPO}/.bzr"
1981 cvs_test = perl: -d "$ENV{MR_REPO}/CVS"
1982 hg_test  = perl: -d "$ENV{MR_REPO}/.hg"
1983 darcs_test = perl: -d "$ENV{MR_REPO}/_darcs"
1984 fossil_test = perl: -f "$ENV{MR_REPO}/_FOSSIL_"
1985 git_bare_test = perl: 
1986         -d "$ENV{MR_REPO}/refs/heads" && -d "$ENV{MR_REPO}/refs/tags" &&
1987         -d "$ENV{MR_REPO}/objects" && -f "$ENV{MR_REPO}/config" &&
1988         `GIT_CONFIG="$ENV{MR_REPO}"/config git config --get core.bare` =~ /true/
1989 vcsh_test = perl:
1990         -d "$ENV{MR_REPO}/refs/heads" && -d "$ENV{MR_REPO}/refs/tags" &&
1991         -d "$ENV{MR_REPO}/objects" && -f "$ENV{MR_REPO}/config" &&
1992         `GIT_CONFIG="$ENV{MR_REPO}"/config git config --get vcsh.vcsh` =~ /true/
1993 veracity_test  = perl: -d "$ENV{MR_REPO}/.sgdrawer"
1994
1995 svn_update = svn update "$@"
1996 git_update = git pull "$@"
1997 bzr_update = 
1998         if is_bzr_checkout; then
1999                 bzr update "$@"
2000         else
2001                 bzr merge --pull "$@"
2002         fi
2003 cvs_update = cvs -q update "$@"
2004 hg_update  = hg pull "$@"; hg update "$@"
2005 darcs_update = darcs pull -a "$@"
2006 fossil_update = fossil pull "$@"
2007 vcsh_update = vcsh run "$MR_REPO" git pull "$@"
2008 veracity_update = vv pull "$@" && vv update "$@"
2009
2010 git_fetch = git fetch --all --prune --tags
2011 git_svn_fetch = git svn fetch
2012 darcs_fetch = darcs fetch
2013 hg_fetch = hg pull
2014
2015 svn_status = svn status "$@"
2016 git_status = git status -s "$@" || true; git --no-pager log --branches --not --remotes --simplify-by-decoration --decorate --oneline || true
2017 bzr_status = bzr status --short "$@"; bzr missing
2018 cvs_status = cvs -q status | grep -E '^(File:.*Status:|\?)' | grep -v 'Status: Up-to-date'
2019 hg_status  = hg status "$@"; hg summary --quiet | grep -v 'parent: 0:'
2020 darcs_status = darcs whatsnew -ls "$@" || true
2021 fossil_status = fossil changes "$@"
2022 vcsh_status = vcsh run "$MR_REPO" git -c status.relativePaths=false status -s "$@" || true
2023 veracity_status = vv status "$@"
2024
2025 svn_commit = svn commit "$@"
2026 git_commit = git commit -a "$@" && git push --all
2027 bzr_commit = 
2028         if is_bzr_checkout; then
2029                 bzr commit "$@"
2030         else
2031                 bzr commit "$@" && bzr push
2032         fi
2033 cvs_commit = cvs commit "$@"
2034 hg_commit  = hg commit "$@" && hg push
2035 darcs_commit = darcs record -a "$@" && darcs push -a
2036 fossil_commit = fossil commit "$@"
2037 vcsh_commit = vcsh run "$MR_REPO" git commit -a "$@" && vcsh run "$MR_REPO" git push --all
2038 veracity_commit = vv commit "$@" && vv push
2039
2040 git_record = git commit -a "$@"
2041 bzr_record =
2042         if is_bzr_checkout; then
2043                 bzr commit --local "$@"
2044         else
2045                 bzr commit "$@"
2046         fi
2047 hg_record  = hg commit "$@"
2048 darcs_record = darcs record -a "$@"
2049 fossil_record = fossil commit "$@"
2050 vcsh_record = vcsh run "$MR_REPO" git commit -a "$@"
2051 veracity_record = vv commit "$@"
2052
2053 svn_push = :
2054 git_push = git push "$@"
2055 bzr_push = bzr push "$@"
2056 cvs_push = :
2057 hg_push = hg push "$@"
2058 darcs_push = darcs push -a "$@"
2059 fossil_push = fossil push "$@"
2060 vcsh_push = vcsh run "$MR_REPO" git push "$@"
2061 veracity_push = vv push "$@"
2062
2063 svn_diff = svn diff "$@"
2064 git_diff = git diff "$@"
2065 bzr_diff = bzr diff "$@"
2066 cvs_diff = cvs -q diff "$@"
2067 hg_diff  = hg diff "$@"
2068 darcs_diff = darcs diff -u "$@"
2069 fossil_diff = fossil diff "$@"
2070 vcsh_diff = vcsh run "$MR_REPO" git diff "$@"
2071 veracity_diff = vv diff "$@"
2072
2073 svn_log = svn log "$@"
2074 git_log = git log "$@"
2075 bzr_log = bzr log "$@"
2076 cvs_log = cvs log "$@"
2077 hg_log  = hg log "$@"
2078 darcs_log = darcs changes "$@"
2079 git_bare_log = git log "$@"
2080 fossil_log = fossil timeline "$@"
2081 vcsh_log = vcsh run "$MR_REPO" git log "$@"
2082 veracity_log = vv log "$@"
2083
2084 hg_grep = hg grep "$@"
2085 cvs_grep = ack-grep "$@"
2086 svn_grep = ack-grep "$@"
2087 git_svn_grep = git grep "$@"
2088 git_grep = git grep "$@"
2089 bzr_grep = ack-grep "$@"
2090
2091 run = "$@"
2092
2093 svn_register =
2094         url=`LC_ALL=C svn info . | grep -i '^URL:' | cut -d ' ' -f 2`
2095         if [ -z "$url" ]; then
2096                 error "cannot determine svn url"
2097         fi
2098         echo "Registering svn url: $url in $MR_CONFIG"
2099         mr -c "$MR_CONFIG" config "`pwd`" checkout="svn co '$url' '$MR_REPO'"
2100 git_register = 
2101         url="`LC_ALL=C git config --get remote.origin.url`" || true
2102         if [ -z "$url" ]; then
2103                 error "cannot determine git url"
2104         fi
2105         echo "Registering git url: $url in $MR_CONFIG"
2106         mr -c "$MR_CONFIG" config "`pwd`" checkout="git clone '$url' '$MR_REPO'"
2107 bzr_register =
2108         url="`LC_ALL=C bzr info . | egrep -i 'checkout of branch|parent branch' | awk '{print $NF}' | head -n 1`"
2109         if [ -z "$url" ]; then
2110                 error "cannot determine bzr url"
2111         fi
2112         echo "Registering bzr url: $url in $MR_CONFIG"
2113         mr -c "$MR_CONFIG" config "`pwd`" checkout="bzr branch '$url' '$MR_REPO'"
2114 cvs_register =
2115         repo=`cat CVS/Repository`
2116         root=`cat CVS/Root`
2117         if [ -z "$root" ]; then
2118                 error "cannot determine cvs root"
2119                 fi
2120         echo "Registering cvs repository $repo at root $root"
2121         mr -c "$MR_CONFIG" config "`pwd`" checkout="cvs -d '$root' co -d '$MR_REPO' '$repo'"
2122 hg_register = 
2123         url=`hg showconfig paths.default`
2124         echo "Registering mercurial repo url: $url in $MR_CONFIG"
2125         mr -c "$MR_CONFIG" config "`pwd`" checkout="hg clone '$url' '$MR_REPO'"
2126 darcs_register = 
2127         url=`cat _darcs/prefs/defaultrepo`
2128         echo "Registering darcs repository $url in $MR_CONFIG"
2129         mr -c "$MR_CONFIG" config "`pwd`" checkout="darcs get '$url' '$MR_REPO'"
2130 git_bare_register = 
2131         url="`LC_ALL=C GIT_CONFIG=config git config --get remote.origin.url`" || true
2132         if [ -z "$url" ]; then
2133                 error "cannot determine git url"
2134         fi
2135         echo "Registering git url: $url in $MR_CONFIG"
2136         mr -c "$MR_CONFIG" config "`pwd`" checkout="git clone --bare '$url' '$MR_REPO'"
2137 vcsh_register =
2138         url="`LC_ALL=C vcsh run "$MR_REPO" git config --get remote.origin.url`" || true
2139         if [ -z "$url" ]; then
2140                 error "cannot determine git url"
2141         fi
2142         echo "Registering git url: $url in $MR_CONFIG"
2143         mr -c "$MR_CONFIG" config "`pwd`" checkout="vcsh clone '$url' '$MR_REPO'"
2144 fossil_register =
2145         url=`fossil remote-url`
2146         repo=`fossil info | grep repository | sed -e 's/repository:*.//g' -e 's/ //g'`
2147         echo "Registering fossil repository $url in $MR_CONFIG"
2148         mr -c "$MR_CONFIG" config "`pwd`" checkout="mkdir -p '$MR_REPO' && cd '$MR_REPO' && fossil open '$repo'"
2149 veracity_register =
2150         url=`vv config | grep sync_targets | sed -e 's/sync_targets:*.//g' -e 's/ //g'`
2151         repo=`vv repo info | grep repository | sed -e 's/Current repository:*.//g' -e 's/ //g'`
2152         echo "Registering veracity repository $url in $MR_CONFIG"
2153         mr -c "$MR_CONFIG" config "`pwd`" checkout="mkdir -p '$MR_REPO' && cd '$MR_REPO' && vv checkout '$repo'"
2154
2155 svn_trusted_checkout = svn co $url $repo
2156 svn_alt_trusted_checkout = svn checkout $url $repo
2157 git_trusted_checkout = git clone $url $repo
2158 bzr_trusted_checkout = bzr checkout|clone|branch|get $url $repo
2159 # cvs: too hard
2160 hg_trusted_checkout = hg clone $url $repo
2161 darcs_trusted_checkout = darcs get $url $repo
2162 git_bare_trusted_checkout = git clone --bare $url $repo
2163 vcsh_old_trusted_checkout = vcsh run "$MR_REPO" git clone $url $repo
2164 vcsh_trusted_checkout = vcsh clone $url $repo
2165 # fossil: messy to do
2166 veracity_trusted_checkout = vv clone $url $repo
2167
2168
2169 list = true
2170 config = 
2171 bootstrap = 
2172
2173 online =
2174         if [ -s ~/.mrlog ]; then
2175                 info "running offline commands"
2176                 mv -f ~/.mrlog ~/.mrlog.old
2177                 if ! sh -e ~/.mrlog.old; then
2178                         error "offline command failed; left in ~/.mrlog.old"
2179                 fi
2180                 rm -f ~/.mrlog.old
2181         else
2182                 info "no offline commands to run"
2183         fi
2184 offline =
2185         umask 077
2186         touch ~/.mrlog
2187         info "offline mode enabled"
2188 remember =
2189         info "remembering command: 'mr $@'"
2190         command="mr -d '$(pwd)' $MR_SWITCHES"
2191         for w in "$@"; do
2192                 command="$command '$w'"
2193         done
2194         if [ ! -e ~/.mrlog ] || ! grep -q -F "$command" ~/.mrlog; then
2195                 echo "$command" >> ~/.mrlog
2196         fi
2197
2198 ed = echo "A horse is a horse, of course, of course.."
2199 T = echo "I pity the fool."
2200 right = echo "Not found."
2201
2202 # vim:sw=8:sts=0:ts=8:noet
2203 # Local variables:
2204 # indent-tabs-mode: t
2205 # cperl-indent-level: 8
2206 # End: