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

adc05464671b0644be5e04b2b8167c6b89202cb6
[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 ($parent eq '/') {
523                                 $parent="";
524                         }
525                         if (exists $config{$parent} &&
526                             exists $config{$parent}{DEFAULT}) {
527                                 $config{$dir}{DEFAULT}={ %{$config{$parent}{DEFAULT}} };
528                                 last;
529                         }
530                 }
531                 
532                 print "mr: loading config $f\n" if $verbose;
533                 open($in, "<", $f) || die "mr: open $f: $!\n";
534         }
535         my @lines=<$in>;
536         close $in;
537
538         my $section;
539         my $line=0;
540         while (@lines) {
541                 $_=shift @lines;
542                 $line++;
543                 chomp;
544                 next if /^\s*\#/ || /^\s*$/;
545                 if (/^\[([^\]]*)\]\s*$/) {
546                         $section=$1;
547                 }
548                 elsif (/^(\w+)\s*=\s*(.*)/) {
549                         my $parameter=$1;
550                         my $value=$2;
551
552                         # continued value
553                         while (@lines && $lines[0]=~/^\s(.+)/) {
554                                 shift(@lines);
555                                 $line++;
556                                 $value.="\n$1";
557                                 chomp $value;
558                         }
559
560                         if (! defined $section) {
561                                 die "$f line $.: parameter ($parameter) not in section\n";
562                         }
563                         if ($section ne 'ALIAS' &&
564                             ! exists $config{$dir}{$section} &&
565                             exists $config{$dir}{DEFAULT}) {
566                                 # copy in defaults
567                                 $config{$dir}{$section}={ %{$config{$dir}{DEFAULT}} };
568                         }
569                         if ($section eq 'ALIAS') {
570                                 $alias{$parameter}=$value;
571                         }
572                         elsif ($parameter eq 'lib') {
573                                 $config{$dir}{$section}{lib}.=$value."\n";
574                         }
575                         else {
576                                 $config{$dir}{$section}{$parameter}=$value;
577                                 $knownactions{$parameter}=1;
578                                 if ($parameter eq 'chain' &&
579                                     length $dir && $section ne "DEFAULT" &&
580                                     -e $dir.$section."/.mrconfig" &&
581                                     system($value) >> 8 == 0) {
582                                         push @toload, $dir.$section."/.mrconfig";
583                                 }
584                         }
585                 }
586                 else {
587                         die "$f line $line: parse error\n";
588                 }
589         }
590
591         foreach (@toload) {
592                 loadconfig($_);
593         }
594 } #}}}
595
596 sub modifyconfig { #{{{
597         my $f=shift;
598         # the section to modify or add
599         my $targetsection=shift;
600         # fields to change in the section
601         # To remove a field, set its value to "".
602         my %changefields=@_;
603
604         my @lines;
605         my @out;
606
607         if (-e $f) {
608                 open(my $in, "<", $f) || die "mr: open $f: $!\n";
609                 @lines=<$in>;
610                 close $in;
611         }
612
613         my $formatfield=sub {
614                 my $field=shift;
615                 my @value=split(/\n/, shift);
616
617                 return "$field = ".shift(@value)."\n".
618                         join("", map { "\t$_\n" } @value);
619         };
620         my $addfields=sub {
621                 my @blanks;
622                 while ($out[$#out] =~ /^\s*$/) {
623                         unshift @blanks, pop @out;
624                 }
625                 foreach my $field (sort keys %changefields) {
626                         if (length $changefields{$field}) {
627                                 push @out, "$field = $changefields{$field}\n";
628                                 delete $changefields{$field};
629                         }
630                 }
631                 push @out, @blanks;
632         };
633
634         my $section;
635         while (@lines) {
636                 $_=shift(@lines);
637
638                 if (/^\s*\#/ || /^\s*$/) {
639                         push @out, $_;
640                 }
641                 elsif (/^\[([^\]]*)\]\s*$/) {
642                         if (defined $section && 
643                             $section eq $targetsection) {
644                                 $addfields->();
645                         }
646
647                         $section=$1;
648
649                         push @out, $_;
650                 }
651                 elsif (/^(\w+)\s*=\s(.*)/) {
652                         my $parameter=$1;
653                         my $value=$2;
654
655                         # continued value
656                         while (@lines && $lines[0]=~/^\s(.+)/) {
657                                 shift(@lines);
658                                 $value.="\n$1";
659                                 chomp $value;
660                         }
661
662                         if ($section eq $targetsection) {
663                                 if (exists $changefields{$parameter}) {
664                                         if (length $changefields{$parameter}) {
665                                                 $value=$changefields{$parameter};
666                                         }
667                                         delete $changefields{$parameter};
668                                 }
669                         }
670
671                         push @out, $formatfield->($parameter, $value);
672                 }
673         }
674
675         if (defined $section && 
676             $section eq $targetsection) {
677                 $addfields->();
678         }
679         elsif (%changefields) {
680                 push @out, "\n[$targetsection]\n";
681                 foreach my $field (sort keys %changefields) {
682                         if (length $changefields{$field}) {
683                                 push @out, $formatfield->($field, $changefields{$field});
684                         }
685                 }
686         }
687
688         open(my $out, ">", $f) || die "mr: write $f: $!\n";
689         print $out @out;
690         close $out;     
691 } #}}}
692
693 # Finally, some useful actions that mr knows about by default.
694 # These can be overridden in ~/.mrconfig.
695 #DATA{{{
696 __DATA__
697 [ALIAS]
698 co = checkout
699 ci = commit
700 ls = list
701
702 [DEFAULT]
703 lib =
704         error() {
705                 echo "mr: $@" >&2
706                 exit 1
707         }
708         hours_since() {
709                 for dir in .git .svn .bzr CVS; do
710                         if [ -e "$MR_REPO/$dir" ]; then
711                                 flagfile="$MR_REPO/$dir/.mr_last$1"
712                                 break
713                         fi
714                 done
715                 if [ -z "$flagfile" ]; then
716                         error "cannot determine flag filename"
717                 fi
718                 perl -wle 'print -f shift() ? int((-M _) * 24) : 9999' "$flagfile"
719                 touch "$flagfile"
720         }
721
722 update =
723         if [ -d "$MR_REPO"/.svn ]; then
724                 svn update "$@"
725         elif [ -d "$MR_REPO"/.git ]; then
726                 git pull origin master "$@"
727         elif [ -d "$MR_REPO"/.bzr ]; then
728                 bzr merge "$@"
729         elif [ -d "$MR_REPO"/CVS ]; then
730                 cvs update "$@"
731         else
732                 error "unknown repo type"
733         fi
734 status =
735         if [ -d "$MR_REPO"/.svn ]; then
736                 svn status "$@"
737         elif [ -d "$MR_REPO"/.git ]; then
738                 git status "$@" || true
739         elif [ -d "$MR_REPO"/.bzr ]; then
740                 bzr status "$@"
741         elif [ -d "$MR_REPO"/CVS ]; then
742                 cvs status "$@"
743         else
744                 error "unknown repo type"
745         fi
746 commit =
747         if [ -d "$MR_REPO"/.svn ]; then
748                 svn commit "$@"
749         elif [ -d "$MR_REPO"/.git ]; then
750                 git commit -a "$@" && git push --all
751         elif [ -d "$MR_REPO"/.bzr ]; then
752                 bzr commit "$@" && bzr push
753         elif [ -d "$MR_REPO"/CVS ]; then
754                 cvs commit "$@"
755         else
756                 error "unknown repo type"
757         fi
758 diff =
759         if [ -d "$MR_REPO"/.svn ]; then
760                 svn diff "$@"
761         elif [ -d "$MR_REPO"/.git ]; then
762                 git diff "$@"
763         elif [ -d "$MR_REPO"/.bzr ]; then
764                 bzr diff "$@"
765         elif [ -d "$MR_REPO"/CVS ]; then
766                 cvs diff "$@"
767         else
768                 error "unknown repo type"
769         fi
770 log =
771         if [ -d "$MR_REPO"/.svn ]; then
772                 svn log"$@"
773         elif [ -d "$MR_REPO"/.git ]; then
774                 git log "$@"
775         elif [ -d "$MR_REPO"/.bzr ]; then
776                 bzr log "$@"
777         elif [ -d "$MR_REPO"/CVS ]; then
778                 cvs log "$@"
779         else
780                 error "unknown repo type"
781         fi
782 register =
783         if [ -n "$1" ]; then
784                 cd "$1"
785         fi
786         basedir="$(basename $(pwd))"
787         if [ -d .svn ]; then
788                 url=$(LANG=C svn info . | grep -i ^URL: | cut -d ' ' -f 2)
789                 if [ -z "$url" ]; then
790                         error "cannot determine svn url"
791                 fi
792                 echo "Registering svn url: $url"
793                 mr config "$(pwd)" checkout="svn co $url $basedir"
794         elif [ -d .git ]; then
795                 url=$(LANG=C git-config --get remote.origin.url)
796                 if [ -z "$url" ]; then
797                         error "cannot determine git url"
798                 fi
799                 echo "Registering git url: $url"
800                 mr config "$(pwd)" checkout="git clone $url $basedir"
801         elif [ -d .bzr ]; then
802                 url=$(cat .bzr/branch/parent)
803                 if [ -z "$url" ]; then
804                         error "cannot determine bzr url"
805                 fi
806                 echo "Registering bzr url: $url"
807                 mr config "$(pwd)" checkout="bzr clone $url $basedir"
808         else
809                 error "unable to register this repo type"
810         fi
811 help =
812         if [ ! -e "$MR_PATH" ]; then
813                 error "cannot find program path"
814         fi
815         (pod2man -c mr "$MR_PATH" | man -l -) || error "pod2man or man failed"
816 list = true
817 config = 
818
819 ed = echo "A horse is a horse, of course, of course.."
820 T = echo "I pity the fool."
821 right = echo "Not found."
822 #}}}