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

e29e3679bd75aa9a11a9e2b44d1d9f286a65e63d
[code/myrepos.git] / mr
1 #!/usr/bin/perl
2
3 #man{{{
4
5 =head1 NAME
6
7 mr - a Multiple Repository management tool
8
9 =head1 SYNOPSIS
10
11 B<mr> [options] checkout
12
13 B<mr> [options] update
14
15 B<mr> [options] status
16
17 B<mr> [options] commit [-m "message"]
18
19 B<mr> [options] diff
20
21 B<mr> [options] log
22
23 B<mr> [options] register [repository]
24
25 B<mr> [options] config section [parameter=[value] ...]
26
27 B<mr> [options] action [params ...]
28
29 =head1 DESCRIPTION
30
31 B<mr> is a Multiple Repository management tool. It
32 can checkout, update, or perform other actions on
33 a set of repositories as if they were one combined respository. It
34 supports any combination of subversion, git, cvs, and bzr repositories, 
35 and support for other revision control systems can easily be added.
36
37 B<mr> cds into and operates on all registered repsitories at or below your
38 working directory. Or, if you are in a subdirectory of a repository that
39 contains no other registered repositories, it will stay in that directory,
40 and work on only that repository,
41
42 These predefined commands should be fairly familiar to users of any revision
43 control system:
44
45 =over 4
46
47 =item checkout (or co)
48
49 Checks out any repositories that are not already checked out.
50
51 =item update
52
53 Updates each repository from its configured remote repository.
54
55 If a repository isn't checked out yet, it will first check it out.
56
57 =item status
58
59 Displays a status report for each repository, showing what
60 uncommitted changes are present in the repository.
61
62 =item commit (or ci)
63
64 Commits changes to each repository. (By default, changes are pushed to the
65 remote repository too, when using distributed systems like git.)
66
67 The optional -m parameter allows specifying a commit message.
68
69 =item diff
70
71 Show a diff of uncommitted changes.
72
73 =item log
74
75 Show the commit log.
76
77 =back
78
79 These commands are also available:
80
81 =over 4
82
83 =item list (or ls)
84
85 List the repositories that mr will act on.
86
87 =item register
88
89 Register an existing repository in the mrconfig file. By default, the
90 epository in the current directory is registered, or you can specify a
91 directory to register.
92
93 =item config
94
95 Adds, modifies, removes, or prints a value from the mrconfig file. The next
96 parameter is the name of the section the value is in. To add or modify
97 values, use one or more instances of "parameter=value". Use "parameter=" to
98 remove a parameter. Use just "parameter" to get the value of a parameter.
99
100 For example, to add (or edit) a repository in src/foo:
101
102   mr config src/foo checkout="svn co svn://example.com/foo/trunk foo"
103
104 To show the command that mr uses to update the repository in src/foo:
105
106   mr config src/foo update
107
108 =item help
109
110 Displays this help.
111
112 =back
113
114 Actions can be abbreviated to any unambiguous subsctring, so
115 "mr st" is equivilant to "mr status", and "mr up" is equivilant to "mr
116 update"
117
118 Additional parameters can be passed to most commands, and are passed on
119 unchanged to the underlying revision control system. This is mostly useful
120 if the repositories mr will act on all use the same revision control
121 system.
122
123 =head1 OPTIONS
124
125 =over 4
126
127 =item -d directory
128
129 Specifies the topmost directory that B<mr> should work in. The default is
130 the current working directory.
131
132 =item -c mrconfig
133
134 Use the specified mrconfig file, instead of looking for one in your home
135 directory.
136
137 =item -v
138
139 Be verbose.
140
141 =back
142
143 =head1 FILES
144
145 B<mr> is configured by .mrconfig files. It starts by reading the .mrconfig
146 file in your home directory, and this can in turn chain load .mrconfig files
147 from repositories.
148
149 Here is an example .mrconfig file:
150
151   [src]
152   checkout = svn co svn://svn.example.com/src/trunk src
153   chain = true
154
155   [src/linux-2.6]
156   checkout = git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git &&
157         cd linux-2.6 &&
158         git checkout -b mybranch origin/master
159
160 The .mrconfig file uses a variant of the INI file format. Lines starting with
161 "#" are comments. Values can be continued to the following line by
162 indenting the line with whitespace.
163
164 The "DEFAULT" section allows setting default values for the sections that
165 come after it.
166
167 The "ALIAS" section allows adding aliases for actions. Each parameter
168 is an alias, and its value is the action to use.
169
170 All other sections add repositories. The section header specifies the
171 directory where the repository is located. This is relative to the directory
172 that contains the mrconfig file, but you can also choose to use absolute
173 paths.
174
175 Within a section, each parameter defines a shell command to run to handle a
176 given action. mr contains default handlers for the "update", "status", and
177 "commit" actions, so normally you only need to specify what to do for
178 "checkout".
179
180 Note that these shell commands are run in a "set -e" shell
181 environment, where any additional parameters you pass are available in
182 "$@". The "checkout" command is run in the parent of the repository
183 directory, since the repository isn't checked out yet. All other commands
184 are run inside the repository, though not necessarily at the top of it.
185 The "MR_REPO" environment variable is set to the path to the top of the
186 repository.
187
188 A few parameters have special meanings:
189
190 =over 4
191
192 =item skip
193
194 If the "skip" parameter is set and its command returns nonzero, then B<mr>
195 will skip acting on that repository. The command is passed the action
196 name in $1.
197
198 Here are two examples. The first skips the repo unless
199 mr is run by joey. The second uses the hours_since function
200 (included in mr's built-in library) to skip updating the repo unless it's
201 been at least 12 hours since the last update.
202
203   skip = test $(whoami) != joey
204   skip = [ "$1" = update ] && [ $(hours_since "$1") -lt 12 ]
205
206 =item chain
207
208 If the "chain" parameter is set and its command returns nonzero, then B<mr>
209 will try to load a .mrconfig file from the root of the repository. (You
210 should avoid chaining from repositories with untrusted committers.)
211
212 =item deleted
213
214 If the "deleted" parameter is set and its command returns nonzero, then
215 B<mr> will treat the repository as deleted. It won't ever actually delete
216 the repository, but it will warn if it sees the repsoitory's directory.
217 This is useful when one mrconfig file is shared amoung multiple machines,
218 to keep track of and remember to delete old repositories.
219
220 =item lib
221
222 The "lib" parameter can specify some shell code that will be run before each
223 command, this can be a useful way to define shell functions for other commands
224 to use.
225
226 =back
227
228 =head1 AUTHOR
229
230 Copyright 2007 Joey Hess <joey@kitenet.net>
231
232 Licensed under the GNU GPL version 2 or higher.
233
234 http://kitenet.net/~joey/code/mr/
235
236 =cut
237
238 #}}}
239
240 use warnings;
241 use strict;
242 use Getopt::Long;
243 use Cwd qw(getcwd abs_path);
244
245 my $directory=getcwd();
246 my $config="$ENV{HOME}/.mrconfig";
247 my $verbose=0;
248 my %config;
249 my %knownactions;
250 my %alias;
251
252 Getopt::Long::Configure("no_permute");
253 my $result=GetOptions(
254         "d|directory=s" => sub { $directory=abs_path($_[1]) },
255         "c|config=s" => \$config,
256         "verbose" => \$verbose,
257 );
258 if (! $result || @ARGV < 1) {
259         die("Usage: mr [-d directory] action [params ...]\n".
260             "(Use mr help for man page.)\n");
261
262 }
263
264 loadconfig(\*DATA);
265 loadconfig($config);
266 #use Data::Dumper;
267 #print Dumper(\%config);
268
269 eval {
270         use FindBin qw($Bin $Script);
271         $ENV{MR_PATH}=$Bin."/".$Script;
272 };
273
274 # alias expansion and command stemming
275 my $action=shift @ARGV;
276 if (exists $alias{$action}) {
277         $action=$alias{$action};
278 }
279 if (! exists $knownactions{$action}) {
280         my @matches = grep { /^\Q$action\E/ }
281                 keys %knownactions, keys %alias;
282         if (@matches == 1) {
283                 $action=$matches[0];
284         }
285         elsif (@matches == 0) {
286                 die "mr: unknown action \"$action\" (known actions: ".
287                         join(", ", sort keys %knownactions).")\n";
288         }
289         else {
290                 die "mr: ambiguous action \"$action\" (matches: ".
291                         join(", ", @matches).")\n";
292         }
293 }
294
295 if ($action eq 'help') {
296         exec($config{''}{DEFAULT}{$action}) || die "exec: $!";
297 }
298 elsif ($action eq 'config') {
299         if (@ARGV < 2) {
300                 die "mr config: not enough parameters\n";
301         }
302         my $section=shift;
303         if ($section=~/^\//) {
304                 # try to convert to a path relative to $config's dir
305                 my ($dir)=$config=~/^(.*\/)[^\/]+$/;
306                 if ($section=~/^\Q$dir\E(.*)/) {
307                         $section=$1;
308                 }
309         }
310         my %changefields;
311         foreach (@ARGV) {
312                 if (/^([^=]+)=(.*)$/) {
313                         $changefields{$1}=$2;
314                 }
315                 else {
316                         my $found=0;
317                         foreach my $topdir (sort keys %config) {
318                                 if (exists $config{$topdir}{$section} &&
319                                     exists $config{$topdir}{$section}{$_}) {
320                                         print $config{$topdir}{$section}{$_}."\n";
321                                         $found=1;
322                                 }
323                         }
324                         if (! $found) {
325                                 die "mr $action: $section $_ not set\n";
326                         }
327                 }
328         }
329         modifyconfig($config, $section, %changefields) if %changefields;
330         exit 0;
331 }
332 elsif ($action eq 'register') {
333         my $command="set -e; ".$config{''}{DEFAULT}{lib}."\n".
334                 "my_action(){ $config{''}{DEFAULT}{$action}\n }; my_action ".
335                 join(" ", map { s/\//\/\//g; s/"/\"/g; '"'.$_.'"' } @ARGV);
336         print STDERR "mr $action: running >>$command<<\n" if $verbose;
337         exec($command) || die "exec: $!";
338 }
339
340 # work out what repos to act on
341 my @repos;
342 my $nochdir=0;
343 foreach my $topdir (sort keys %config) {
344         foreach my $subdir (sort keys %{$config{$topdir}}) {
345                 next if $subdir eq 'DEFAULT';
346                 my $dir=($subdir =~/^\//) ? $subdir : $topdir.$subdir;
347                 my $d=$directory;
348                 $dir.="/" unless $dir=~/\/$/;
349                 $d.="/" unless $d=~/\/$/;
350                 next if $dir ne $directory && $dir !~ /^\Q$directory\E/;
351                 push @repos, [$dir, $topdir, $subdir];
352         }
353 }
354 if (! @repos) {
355         # fallback to find a leaf repo
356         LEAF: foreach my $topdir (reverse sort keys %config) {
357                 foreach my $subdir (reverse sort keys %{$config{$topdir}}) {
358                         next if $subdir eq 'DEFAULT';
359                         my $dir=($subdir =~/^\//) ? $subdir : $topdir.$subdir;
360                         my $d=$directory;
361                         $dir.="/" unless $dir=~/\/$/;
362                         $d.="/" unless $d=~/\/$/;
363                         if ($d=~/^\Q$dir\E/) {
364                                 push @repos, [$dir, $topdir, $subdir];
365                                 last LEAF;
366                         }
367                 }
368         }
369         $nochdir=1;
370 }
371
372 my (@failed, @ok, @skipped);
373 foreach my $repo (@repos) {
374         action($action, @$repo);
375 }
376
377 sub action { #{{{
378         my ($action, $dir, $topdir, $subdir) = @_;
379         
380         my $lib= exists $config{$topdir}{$subdir}{lib} ?
381                         $config{$topdir}{$subdir}{lib}."\n" : "";
382
383         if (exists $config{$topdir}{$subdir}{deleted}) {
384                 if (! -d $dir) {
385                         return;
386                 }
387                 else {
388                         my $test="set -e;".$lib.$config{$topdir}{$subdir}{deleted};
389                         print "mr $action: running deleted test >>$test<<\n" if $verbose;
390                         my $ret=system($test);
391                         if ($ret >> 8 == 0) {
392                                 print STDERR "mr error: $dir should be deleted yet still exists\n\n";
393                                 push @failed, $dir;
394                                 return;
395                         }
396                 }
397         }
398
399         if ($action eq 'checkout') {
400                 if (-d $dir) {
401                         print "mr $action: $dir already exists, skipping checkout\n" if $verbose;
402                         push @skipped, $dir;
403                         return;
404                 }
405                 $dir=~s/^(.*)\/[^\/]+\/?$/$1/;
406         }
407         elsif ($action eq 'update') {
408                 if (! -d $dir) {
409                         return action("checkout", $dir, $topdir, $subdir);
410                 }
411         }
412         
413         $ENV{MR_REPO}=$dir;
414
415         if (exists $config{$topdir}{$subdir}{skip}) {
416                 my $test="set -e;".$lib.
417                         "my_action(){ $config{$topdir}{$subdir}{skip}\n }; my_action '$action'";
418                 print "mr $action: running skip test >>$test<<\n" if $verbose;
419                 my $ret=system($test);
420                 if ($ret >> 8 == 0) {
421                         print "mr $action: $dir skipped per config file\n" if $verbose;
422                         push @skipped, $dir;
423                         return;
424                 }
425         }
426         
427         if (! $nochdir && ! chdir($dir)) {
428                 print STDERR "mr $action: failed to chdir to $dir: $!\n";
429                 push @failed, $dir;
430         }
431         elsif (! exists $config{$topdir}{$subdir}{$action}) {
432                 print STDERR "mr $action: no defined $action command for $topdir$subdir, skipping\n";
433                 push @skipped, $dir;
434         }
435         else {
436                 if (! $nochdir) {
437                         print "mr $action: $topdir$subdir\n";
438                 }
439                 else {
440                         print "mr $action: $topdir$subdir (in subdir $directory)\n";
441                 }
442                 my $command="set -e; ".$lib.
443                         "my_action(){ $config{$topdir}{$subdir}{$action}\n }; my_action ".
444                         join(" ", map { s/\//\/\//g; s/"/\"/g; '"'.$_.'"' } @ARGV);
445                 print STDERR "mr $action: running >>$command<<\n" if $verbose;
446                 my $ret=system($command);
447                 if ($ret != 0) {
448                         print STDERR "mr $action: failed ($ret)\n" if $verbose;
449                         push @failed, $dir;
450                         if ($ret >> 8 != 0) {
451                                 print STDERR "mr $action: command failed\n";
452                         }
453                         elsif ($ret != 0) {
454                                 print STDERR "mr $action: command died ($ret)\n";
455                         }
456                 }
457                 else {
458                         push @ok, $dir;
459                 }
460
461                 print "\n";
462         }
463 } #}}}
464
465 sub showstat { #{{{
466         my $count=shift;
467         my $singular=shift;
468         my $plural=shift;
469         if ($count) {
470                 return "$count ".($count > 1 ? $plural : $singular);
471         }
472         return;
473 } #}}}
474 if (! @ok && ! @failed && ! @skipped) {
475         die "mr $action: no repositories found to work on\n";
476 }
477 print "mr $action: finished (".join("; ",
478         showstat($#ok+1, "ok", "ok"),
479         showstat($#failed+1, "failed", "failed"),
480         showstat($#skipped+1, "skipped", "skipped"),
481 ).")\n";
482 if (@failed) {
483         exit 1;
484 }
485 elsif (! @ok && @skipped) {
486         exit 1;
487 }
488 exit 0;
489
490 my %loaded;
491 sub loadconfig { #{{{
492         my $f=shift;
493
494         my @toload;
495
496         my $in;
497         my $dir;
498         if (ref $f eq 'GLOB') {
499                 $dir="";
500                 $in=$f; 
501         }
502         else {
503                 if (! -e $f) {
504                         return;
505                 }
506
507                 my $absf=abs_path($f);
508                 if ($loaded{$absf}) {
509                         return;
510                 }
511                 $loaded{$absf}=1;
512
513                 ($dir)=$f=~/^(.*\/)[^\/]+$/;
514                 if (! defined $dir) {
515                         $dir=".";
516                 }
517                 $dir=abs_path($dir)."/";
518
519                 # copy in defaults from first parent
520                 my $parent=$dir;
521                 while ($parent=~s/^(.*)\/[^\/]+\/?$/$1/) {
522                         if (exists $config{$parent} &&
523                             exists $config{$parent}{DEFAULT}) {
524                                 $config{$dir}{DEFAULT}={ %{$config{$parent}{DEFAULT}} };
525                                 last;
526                         }
527                 }
528                 
529                 print "mr: loading config $f\n" if $verbose;
530                 open($in, "<", $f) || die "mr: open $f: $!\n";
531         }
532         my @lines=<$in>;
533         close $in;
534
535         my $section;
536         my $line=0;
537         while (@lines) {
538                 $_=shift @lines;
539                 $line++;
540                 chomp;
541                 next if /^\s*\#/ || /^\s*$/;
542                 if (/^\[([^\]]*)\]\s*$/) {
543                         $section=$1;
544                 }
545                 elsif (/^(\w+)\s*=\s*(.*)/) {
546                         my $parameter=$1;
547                         my $value=$2;
548
549                         # continued value
550                         while (@lines && $lines[0]=~/^\s(.+)/) {
551                                 shift(@lines);
552                                 $line++;
553                                 $value.="\n$1";
554                                 chomp $value;
555                         }
556
557                         if (! defined $section) {
558                                 die "$f line $.: parameter ($parameter) not in section\n";
559                         }
560                         if ($section ne 'ALIAS' &&
561                             ! exists $config{$dir}{$section} &&
562                             exists $config{$dir}{DEFAULT}) {
563                                 # copy in defaults
564                                 $config{$dir}{$section}={ %{$config{$dir}{DEFAULT}} };
565                         }
566                         if ($section eq 'ALIAS') {
567                                 $alias{$parameter}=$value;
568                         }
569                         elsif ($parameter eq 'lib') {
570                                 $config{$dir}{$section}{lib}.=$value."\n";
571                         }
572                         else {
573                                 $config{$dir}{$section}{$parameter}=$value;
574                                 $knownactions{$parameter}=1;
575                                 if ($parameter eq 'chain' &&
576                                     length $dir && $section ne "DEFAULT" &&
577                                     -e $dir.$section."/.mrconfig" &&
578                                     system($value) >> 8 == 0) {
579                                         push @toload, $dir.$section."/.mrconfig";
580                                 }
581                         }
582                 }
583                 else {
584                         die "$f line $line: parse error\n";
585                 }
586         }
587
588         foreach (@toload) {
589                 loadconfig($_);
590         }
591 } #}}}
592
593 sub modifyconfig { #{{{
594         my $f=shift;
595         # the section to modify or add
596         my $targetsection=shift;
597         # fields to change in the section
598         # To remove a field, set its value to "".
599         my %changefields=@_;
600
601         my @lines;
602         my @out;
603
604         if (-e $f) {
605                 open(my $in, "<", $f) || die "mr: open $f: $!\n";
606                 @lines=<$in>;
607                 close $in;
608         }
609
610         my $formatfield=sub {
611                 my $field=shift;
612                 my @value=split(/\n/, shift);
613
614                 return "$field = ".shift(@value)."\n".
615                         join("", map { "\t$_\n" } @value);
616         };
617         my $addfields=sub {
618                 my @blanks;
619                 while ($out[$#out] =~ /^\s*$/) {
620                         unshift @blanks, pop @out;
621                 }
622                 foreach my $field (sort keys %changefields) {
623                         if (length $changefields{$field}) {
624                                 push @out, "$field = $changefields{$field}\n";
625                                 delete $changefields{$field};
626                         }
627                 }
628                 push @out, @blanks;
629         };
630
631         my $section;
632         while (@lines) {
633                 $_=shift(@lines);
634
635                 if (/^\s*\#/ || /^\s*$/) {
636                         push @out, $_;
637                 }
638                 elsif (/^\[([^\]]*)\]\s*$/) {
639                         if (defined $section && 
640                             $section eq $targetsection) {
641                                 $addfields->();
642                         }
643
644                         $section=$1;
645
646                         push @out, $_;
647                 }
648                 elsif (/^(\w+)\s*=\s(.*)/) {
649                         my $parameter=$1;
650                         my $value=$2;
651
652                         # continued value
653                         while (@lines && $lines[0]=~/^\s(.+)/) {
654                                 shift(@lines);
655                                 $value.="\n$1";
656                                 chomp $value;
657                         }
658
659                         if ($section eq $targetsection) {
660                                 if (exists $changefields{$parameter}) {
661                                         if (length $changefields{$parameter}) {
662                                                 $value=$changefields{$parameter};
663                                         }
664                                         delete $changefields{$parameter};
665                                 }
666                         }
667
668                         push @out, $formatfield->($parameter, $value);
669                 }
670         }
671
672         if (defined $section && 
673             $section eq $targetsection) {
674                 $addfields->();
675         }
676         elsif (%changefields) {
677                 push @out, "\n[$targetsection]\n";
678                 foreach my $field (sort keys %changefields) {
679                         if (length $changefields{$field}) {
680                                 push @out, $formatfield->($field, $changefields{$field});
681                         }
682                 }
683         }
684
685         open(my $out, ">", $f) || die "mr: write $f: $!\n";
686         print $out @out;
687         close $out;     
688 } #}}}
689
690 # Finally, some useful actions that mr knows about by default.
691 # These can be overridden in ~/.mrconfig.
692 #DATA{{{
693 __DATA__
694 [ALIAS]
695 co = checkout
696 ci = commit
697 ls = list
698
699 [DEFAULT]
700 lib =
701         error() {
702                 echo "mr: $@" >&2
703                 exit 1
704         }
705         hours_since() {
706                 for dir in .git .svn .bzr CVS; do
707                         if [ -e "$MR_REPO/$dir" ]; then
708                                 flagfile="$MR_REPO/$dir/.mr_last$1"
709                                 break
710                         fi
711                 done
712                 if [ -z "$flagfile" ]; then
713                         error "cannot determine flag filename"
714                 fi
715                 perl -wle 'print -f shift() ? int((-M _) * 24) : 9999' "$flagfile"
716                 touch "$flagfile"
717         }
718
719 update =
720         if [ -d "$MR_REPO"/.svn ]; then
721                 svn update "$@"
722         elif [ -d "$MR_REPO"/.git ]; then
723                 git pull origin master "$@"
724         elif [ -d "$MR_REPO"/.bzr ]; then
725                 bzr merge "$@"
726         elif [ -d "$MR_REPO"/CVS ]; then
727                 cvs update "$@"
728         else
729                 error "unknown repo type"
730         fi
731 status =
732         if [ -d "$MR_REPO"/.svn ]; then
733                 svn status "$@"
734         elif [ -d "$MR_REPO"/.git ]; then
735                 git status "$@" || true
736         elif [ -d "$MR_REPO"/.bzr ]; then
737                 bzr status "$@"
738         elif [ -d "$MR_REPO"/CVS ]; then
739                 cvs status "$@"
740         else
741                 error "unknown repo type"
742         fi
743 commit =
744         if [ -d "$MR_REPO"/.svn ]; then
745                 svn commit "$@"
746         elif [ -d "$MR_REPO"/.git ]; then
747                 git commit -a "$@" && git push --all
748         elif [ -d "$MR_REPO"/.bzr ]; then
749                 bzr commit "$@" && bzr push
750         elif [ -d "$MR_REPO"/CVS ]; then
751                 cvs commit "$@"
752         else
753                 error "unknown repo type"
754         fi
755 diff =
756         if [ -d "$MR_REPO"/.svn ]; then
757                 svn diff "$@"
758         elif [ -d "$MR_REPO"/.git ]; then
759                 git diff "$@"
760         elif [ -d "$MR_REPO"/.bzr ]; then
761                 bzr diff "$@"
762         elif [ -d "$MR_REPO"/CVS ]; then
763                 cvs diff "$@"
764         else
765                 error "unknown repo type"
766         fi
767 log =
768         if [ -d "$MR_REPO"/.svn ]; then
769                 svn log"$@"
770         elif [ -d "$MR_REPO"/.git ]; then
771                 git log "$@"
772         elif [ -d "$MR_REPO"/.bzr ]; then
773                 bzr log "$@"
774         elif [ -d "$MR_REPO"/CVS ]; then
775                 cvs log "$@"
776         else
777                 error "unknown repo type"
778         fi
779 register =
780         if [ -n "$1" ]; then
781                 cd "$1"
782         fi
783         basedir="$(basename $(pwd))"
784         if [ -d .svn ]; then
785                 url=$(LANG=C svn info . | grep -i ^URL: | cut -d ' ' -f 2)
786                 if [ -z "$url" ]; then
787                         error "cannot determine svn url"
788                 fi
789                 echo "Registering svn url: $url"
790                 mr config "$(pwd)" checkout="svn co $url $basedir"
791         elif [ -d .git ]; then
792                 url=$(LANG=C git-config --get remote.origin.url)
793                 if [ -z "$url" ]; then
794                         error "cannot determine git url"
795                 fi
796                 echo "Registering git url: $url"
797                 mr config "$(pwd)" checkout="git clone $url $basedir"
798         elif [ -d .bzr ]; then
799                 url=$(cat .bzr/branch/parent)
800                 if [ -z "$url" ]; then
801                         error "cannot determine bzr url"
802                 fi
803                 echo "Registering bzr url: $url"
804                 mr config "$(pwd)" checkout="bzr clone $url $basedir"
805         else
806                 error "unable to register this repo type"
807         fi
808 help =
809         if [ ! -e "$MR_PATH" ]; then
810                 error "cannot find program path"
811         fi
812         (pod2man -c mr "$MR_PATH" | man -l -) || error "pod2man or man failed"
813 list = true
814 config = 
815
816 ed = echo "A horse is a horse, of course, of course.."
817 T = echo "I pity the fool."
818 right = echo "Not found."
819 #}}}