]> git.madduck.net Git - code/vcsh.git/blob - vcsh

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:

83bb2676c92809550e228a1975f5e529cb9847c1
[code/vcsh.git] / vcsh
1 #!/bin/sh
2
3 # This program is licensed under the GNU GPL version 2 or later.
4 # (c) Richard "RichiH" Hartmann <richih@debian.org>, 2011-2014
5 # For details, see LICENSE. To submit patches, you have to agree to
6 # license your code under the GNU GPL version 2 or later.
7
8 # While the following is not legally binding, the author would like to
9 # explain the choice of GPLv2+ over GPLv3+.
10 # The author prefers GPLv3+ over GPLv2+ but feels it's better to maintain
11 # full compatibility's with Git. In case Git ever changes its licensing terms,
12 # which is admittedly extremely unlikely to the point of being impossible,
13 # this software will most likely follow suit.
14
15 # This should always be the first line of code to facilitate debugging
16 [ -n "$VCSH_DEBUG" ] && set -vx
17
18
19 # If '.git-HEAD' is appended to the version, you are seeing an unreleased
20 # version of vcsh; the master branch is supposed to be clean at all times
21 # so you can most likely just use it nonetheless
22 VERSION='1.20141009'
23 SELF=$(basename $0)
24
25 fatal() {
26         echo "$SELF: fatal: $1" >&2
27         exit $2
28 }
29
30 # We need to run getops as soon as possible so we catch -d and other
31 # options that will modify our behaviour.
32 # Commands are handled at the end of this script.
33 while getopts "c:dvr" flag; do
34         if [ x"$1" = x'-d' ] || [ x"$1" = x'--debug' ]; then
35                 set -vx
36                 VCSH_DEBUG=1
37                 echo "debug mode on"
38                 echo "$SELF $VERSION"
39         elif [ x"$1" = x'-v' ]; then
40                 VCSH_VERBOSE=1
41                 echo "verbose mode on"
42                 echo "$SELF $VERSION"
43         elif [ x"$1" = x'-r' ]; then
44                 VCSH_OPTION_RECURSIVE=1
45         elif [ x"$1" = x'-c' ]; then
46                 VCSH_OPTION_CONFIG=$OPTARG
47         fi
48         shift 1
49 done
50
51 source_all() {
52         # Source file even if it's in $PWD and does not have any slashes in it
53         case $1 in
54                 */*) . "$1";;
55                 *)   . "$PWD/$1";;
56         esac;
57 }
58
59
60 # Read configuration and set defaults if anything's not set
61 [ -n "$VCSH_DEBUG" ]                  && set -vx
62 : ${XDG_CONFIG_HOME:="$HOME/.config"}
63
64 # Read configuration files if there are any
65 [ -r "/etc/vcsh/config" ]             && . "/etc/vcsh/config"
66 [ -r "$XDG_CONFIG_HOME/vcsh/config" ] && . "$XDG_CONFIG_HOME/vcsh/config"
67 if [ -n "$VCSH_OPTION_CONFIG" ]; then
68         # Source $VCSH_OPTION_CONFIG if it can be read and is in $PWD of $PATH
69         if [ -r "$VCSH_OPTION_CONFIG" ]; then
70                 source_all "$VCSH_OPTION_CONFIG"
71         else
72                 fatal "Can not read configuration file '$VCSH_OPTION_CONFIG'" 1
73         fi
74 fi
75 [ -n "$VCSH_DEBUG" ]                  && set -vx
76
77 # Read defaults
78 : ${VCSH_REPO_D:="$XDG_CONFIG_HOME/vcsh/repo.d"}
79 : ${VCSH_HOOK_D:="$XDG_CONFIG_HOME/vcsh/hooks-enabled"}
80 : ${VCSH_BASE:="$HOME"}
81 : ${VCSH_GITIGNORE:=exact}
82 : ${VCSH_GITATTRIBUTES:=none}
83 : ${VCSH_WORKTREE:=absolute}
84
85 if [ ! "x$VCSH_GITIGNORE" = 'xexact' ] && [ ! "x$VCSH_GITIGNORE" = 'xnone' ] && [ ! "x$VCSH_GITIGNORE" = 'xrecursive' ]; then
86         fatal "'\$VCSH_GITIGNORE' must equal 'exact', 'none', or 'recursive'" 1
87 fi
88
89 if [ ! "x$VCSH_WORKTREE" = 'xabsolute' ] && [ ! "x$VCSH_WORKTREE" = 'xrelative' ]; then
90         fatal "'\$VCSH_WORKTREE' must equal 'absolute', or 'relative'" 1
91 fi
92
93
94 help() {
95         echo "usage: $SELF <options> <command>
96
97    options:
98    -c <file>            Source file
99    -d                   Enable debug mode
100    -v                   Enable verbose mode
101
102    commands:
103    clone <remote> \\
104          [<repo>]       Clone from an existing repository
105    commit               Commit in all repositories
106    delete <repo>        Delete an existing repository
107    enter <repo>         Enter repository; spawn new instance of \$SHELL
108    help                 Display this help text
109    init <repo>          Initialize a new repository
110    list                 List all repositories
111    list-tracked         List all files tracked by vcsh
112    list-tracked-by \\
113         <repo>          List files tracked by a repository
114    pull                 Pull from all vcsh remotes
115    push                 Push to vcsh remotes
116    rename <repo> \\
117           <newname>     Rename repository
118    run <repo> \\
119        <command>        Use this repository
120    status [<repo>]      Show statuses of all/one vcsh repositories
121    upgrade <repo>       Upgrade repository to currently recommended settings
122    version              Print version information
123    which <substring>    Find substring in name of any tracked file
124    write-gitignore \\
125    <repo>               Write .gitignore.d/<repo> via git ls-files
126
127    <repo> <git command> Shortcut to run git commands directly
128    <repo>               Shortcut to enter repository" >&2
129 }
130
131 debug() {
132         [ -n "$VCSH_DEBUG" ] && echo "$SELF: debug: $@"
133 }
134
135 verbose() {
136         if [ -n "$VCSH_DEBUG" ] || [ -n "$VCSH_VERBOSE" ]; then echo "$SELF: verbose: $@"; fi
137 }
138
139 error() {
140         echo "$SELF: error: $1" >&2
141 }
142
143 info() {
144         echo "$SELF: info: $1"
145 }
146
147 clone() {
148         hook pre-clone
149         init
150         git remote add origin "$GIT_REMOTE"
151         git config branch.master.remote origin
152         git config branch.master.merge  refs/heads/master
153         if [ $(git ls-remote origin master 2> /dev/null | wc -l ) -lt 1 ]; then
154                 info "remote is empty, not merging anything"
155                 exit
156         fi
157         git fetch
158         hook pre-merge
159         git ls-tree -r --name-only origin/master | (while read object; do
160                 [ -e "$object" ] &&
161                         error "'$object' exists." &&
162                         VCSH_CONFLICT=1
163         done
164         [ x"$VCSH_CONFLICT" = x'1' ]) &&
165                 fatal "will stop after fetching and not try to merge!
166   Once this situation has been resolved, run 'vcsh $VCSH_REPO_NAME pull' to finish cloning." 17
167         git merge origin/master
168         hook post-merge
169         hook post-clone
170         retire
171         hook post-clone-retired
172 }
173
174 commit() {
175         hook pre-commit
176         for VCSH_REPO_NAME in $(list); do
177                 echo "$VCSH_REPO_NAME: "
178                 GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
179                 use
180                 git commit --untracked-files=no --quiet
181                 VCSH_COMMAND_RETURN_CODE=$?
182                 echo
183         done
184         hook post-commit
185 }
186
187 delete() {
188         cd "$VCSH_BASE" || fatal "could not enter '$VCSH_BASE'" 11
189         use
190         info "This operation WILL DESTROY DATA!"
191         files=$(git ls-files)
192         echo "These files will be deleted:
193
194 $files
195
196 AGAIN, THIS WILL DELETE YOUR DATA!
197 To continue, type 'Yes, do as I say'"
198         read answer
199         [ "x$answer" = 'xYes, do as I say' ] || exit 16
200         for file in $files; do
201                 rm -f $file || info "could not delete '$file', continuing with deletion"
202         done
203         rm -rf "$GIT_DIR" || error "could not delete '$GIT_DIR'"
204 }
205
206 enter() {
207         hook pre-enter
208         use
209         $SHELL
210         hook post-enter
211 }
212
213 git_dir_exists() {
214         [ -d "$GIT_DIR" ] || fatal "no repository found for '$VCSH_REPO_NAME'" 12
215 }
216
217 hook() {
218         for hook in "$VCSH_HOOK_D/$1"* "$VCSH_HOOK_D/$VCSH_REPO_NAME.$1"*; do
219                 [ -x "$hook" ] || continue
220                 verbose "executing '$hook'"
221                 "$hook"
222         done
223 }
224
225 init() {
226         hook pre-init
227         [ ! -e "$GIT_DIR" ] || fatal "'$GIT_DIR' exists" 10
228         mkdir -p "$VCSH_BASE" || fatal "could not create '$VCSH_BASE'" 50
229         cd "$VCSH_BASE" || fatal "could not enter '$VCSH_BASE'" 11
230         git init --shared=0600
231         upgrade
232         hook post-init
233 }
234
235 list() {
236         for repo in "$VCSH_REPO_D"/*.git; do
237                 [ -d "$repo" ] && [ -r "$repo" ] && echo "$(basename "$repo" .git)"
238         done
239 }
240
241 get_files() {
242         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
243         git ls-files
244 }
245
246 list_tracked() {
247         for VCSH_REPO_NAME in $(list); do
248                 get_files
249         done | sed "s,^,$(printf '%s\n' "$VCSH_BASE/" | \
250             sed 's/[,\&]/\\&/g')," | sort -u
251 }
252
253 list_tracked_by() {
254         use
255         git ls-files | sed "s,^,$(printf '%s\n' "$VCSH_BASE/" | \
256             sed 's/[,\&]/\\&/g')," | sort -u
257 }
258
259 pull() {
260         hook pre-pull
261         for VCSH_REPO_NAME in $(list); do
262                 printf '%s: ' "$VCSH_REPO_NAME"
263                 GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
264                 use
265                 git pull
266                 VCSH_COMMAND_RETURN_CODE=$?
267                 echo
268         done
269         hook post-pull
270 }
271
272 push() {
273         hook pre-push
274         for VCSH_REPO_NAME in $(list); do
275                 printf '%s: ' "$VCSH_REPO_NAME"
276                 GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
277                 use
278                 git push
279                 VCSH_COMMAND_RETURN_CODE=$?
280                 echo
281         done
282         hook post-push
283 }
284
285 retire() {
286         unset VCSH_DIRECTORY
287 }
288
289 list_untracked() {
290         command -v 'comm' >/dev/null 2>&1 || fatal "Could not find 'comm'"
291
292         temp_file_others=$(mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX") || fatal 'Could not create temp file'
293         temp_file_untracked=$(mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX") || fatal 'Could not create temp file'
294         temp_file_untracked_copy=$(mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX") || fatal 'Could not create temp file'
295
296         [ -z "$VCSH_OPTION_RECURSIVE" ] && directory_opt="--directory"
297
298         for VCSH_REPO_NAME in $(list); do
299                 export GIT_DIR="$VCSH_REPO_D/$VCSH_REPO_NAME.git"
300                 git ls-files --others "$directory_opt" | (
301                         while read line; do
302                                 echo "$line"
303                                 directory_component="$(echo "$line" | cut -d'/' -f1)"
304                                 [ -d "$directory_component" ] && printf '%s/\n' "$directory_component"
305                         done
306                         ) | sort -u > $temp_file_others
307                 if [ -z "$ran_once" ]; then
308                         ran_once=1
309                         cp $temp_file_others $temp_file_untracked || fatal 'Could not copy temp file'
310                 fi
311                 cp $temp_file_untracked $temp_file_untracked_copy || fatal 'Could not copy temp file'
312                 comm -12 --nocheck-order $temp_file_others $temp_file_untracked_copy > $temp_file_untracked
313         done
314         cat $temp_file_untracked
315
316         unset directory_opt directory_component
317         rm -f $temp_file_others $temp_file_untracked $temp_file_untracked_copy || fatal 'Could not delete temp files'
318 }
319
320 rename() {
321         git_dir_exists
322         [ -d "$GIT_DIR_NEW" ] && fatal "'$GIT_DIR_NEW' exists" 54
323         mv -f "$GIT_DIR" "$GIT_DIR_NEW" || fatal "Could not mv '$GIT_DIR' '$GIT_DIR_NEW'" 52
324
325         # Now that the repository has been renamed, we need to fix up its configuration
326         # Overwrite old name..
327         GIT_DIR=$GIT_DIR_NEW
328         VCSH_REPO_NAME=$VCSH_REPO_NAME_NEW
329         # ..and clobber all old configuration
330         upgrade
331 }
332
333 run() {
334         hook pre-run
335         use
336         "$@"
337         VCSH_COMMAND_RETURN_CODE=$?
338         hook post-run
339 }
340
341 status() {
342         if [ -n "$VCSH_REPO_NAME" ]; then
343                 GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
344                 use
345                 git status --short --untracked-files='no'
346                 VCSH_COMMAND_RETURN_CODE=$?
347         else
348                 for VCSH_REPO_NAME in $(list); do
349                         echo "$VCSH_REPO_NAME:"
350                         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
351                         use
352                         git status --short --untracked-files='no'
353                         VCSH_COMMAND_RETURN_CODE=$?
354                         echo
355                 done
356         fi
357 }
358
359 upgrade() {
360         hook pre-upgrade
361         # fake-bare repositories are not bare, actually. Set this to false
362         # because otherwise Git complains "fatal: core.bare and core.worktree
363         # do not make sense"
364         git config core.bare false
365         # core.worktree may be absolute or relative to $GIT_DIR, depending on
366         # user preference
367         if [ ! "x$VCSH_WORKTREE" = 'xabsolute' ]; then
368                 git config core.worktree "$(cd "$GIT_DIR" && GIT_WORK_TREE=$VCSH_BASE git rev-parse --show-cdup)"
369         elif [ ! "x$VCSH_WORKTREE" = 'xrelative' ]; then
370                 git config core.worktree "$VCSH_BASE"
371         fi
372         [ ! "x$VCSH_GITIGNORE" = 'xnone' ] && git config core.excludesfile ".gitignore.d/$VCSH_REPO_NAME"
373         [ ! "x$VCSH_GITATTRIBUTES" = 'xnone' ] && git config core.attributesfile ".gitattributes.d/$VCSH_REPO_NAME"
374         git config vcsh.vcsh 'true'
375         use
376         [ -e "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME" ] && git add -f "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME"
377         [ -e "$VCSH_BASE/.gitattributes.d/$VCSH_REPO_NAME" ] && git add -f "$VCSH_BASE/.gitattributes.d/$VCSH_REPO_NAME"
378         hook post-upgrade
379 }
380
381 use() {
382         git_dir_exists
383         VCSH_DIRECTORY=$VCSH_REPO_NAME; export VCSH_DIRECTORY
384 }
385
386 which() {
387         for VCSH_REPO_NAME in $(list); do
388                 for VCSH_FILE in $(get_files); do
389                         echo "$VCSH_FILE" | grep -q "$VCSH_COMMAND_PARAMETER" && echo "$VCSH_REPO_NAME: $VCSH_FILE"
390                 done
391         done | sort -u
392 }
393
394 write_gitignore() {
395         # Don't do anything if the user does not want to write gitignore
396         if [ "x$VCSH_GITIGNORE" = 'xnone' ]; then
397                 info "Not writing gitignore as '\$VCSH_GITIGNORE' is set to 'none'"
398                 exit
399         fi
400
401         use
402         cd "$VCSH_BASE" || fatal "could not enter '$VCSH_BASE'" 11
403         OLDIFS=$IFS
404         IFS=$(printf '\n\t')
405         gitignores=$(for file in $(git ls-files); do
406                 while true; do
407                         echo "$file"; new=${file%/*}
408                         [ x"$file" = x"$new" ] && break
409                         file=$new
410                 done;
411         done | sort -u)
412
413         # Contrary to GNU mktemp, mktemp on BSD/OSX requires a template for temp files
414         # Using a template makes GNU mktemp default to $PWD and not #TMPDIR for tempfile location
415         # To make every OS happy, set full path explicitly
416         tempfile=$(mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX") || fatal "could not create tempfile: '${tempfile}'" 51
417
418         echo '*' > "$tempfile" || fatal "could not write to '$tempfile'" 57
419         for gitignore in $gitignores; do
420                 echo "$gitignore" | sed 's@^@!/@' >> "$tempfile" || fatal "could not write to '$tempfile'" 57
421                 if [ "x$VCSH_GITIGNORE" = 'xrecursive' ] && [ -d "$gitignore" ]; then
422                         { echo "$gitignore/*" | sed 's@^@!/@' >> "$tempfile" || fatal "could not write to '$tempfile'" 57; }
423                 fi
424         done
425         IFS=$OLDIFS
426         if diff -N "$tempfile" "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME" > /dev/null; then
427                 rm -f "$tempfile" || error "could not delete '$tempfile'"
428                 exit
429         fi
430         if [ -e "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME" ]; then
431                 info "'$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME' differs from new data, moving it to '$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME.bak'"
432                 mv -f "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME" "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME.bak" ||
433                         fatal "could not move '$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME' to '$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME.bak'" 53
434         fi
435         mv -f "$tempfile" "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME" ||
436                 fatal "could not move '$tempfile' to '$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME'" 53
437 }
438
439 debug $(git version)
440
441 if [ ! "x$VCSH_GITIGNORE" = 'xexact' ] && [ ! "x$VCSH_GITIGNORE" = 'xnone' ] && [ ! "x$VCSH_GITIGNORE" = 'xrecursive' ]; then
442         fatal "'\$VCSH_GITIGNORE' must equal 'exact', 'none', or 'recursive'" 1
443 fi
444
445 VCSH_COMMAND=$1; export VCSH_COMMAND
446
447 case $VCSH_COMMAND in
448         clon|clo|cl) VCSH_COMMAND=clone;;
449         commi|comm|com|co) VCSH_COMMAND=commit;;
450         delet|dele|del|de) VCSH_COMMAND=delete;;
451         ente|ent|en) VCSH_COMMAND=enter;;
452         hel|he) VCSH_COMMAND=help;;
453         ini|in) VCSH_COMMAND=init;;
454         pul) VCSH_COMMAND=pull;;
455         pus) VCSH_COMMAND=push;;
456         renam|rena|ren|re) VCSH_COMMAND=rename;;
457         ru) VCSH_COMMAND=run;;
458         statu|stat|sta|st) VCSH_COMMAND=status;;
459         upgrad|upgra|upgr|up) VCSH_COMMAND=upgrade;;
460         versio|versi|vers|ver|ve) VCSH_COMMAND=version;;
461         which|whi|wh) VCSH_COMMAND=which;;
462         write|writ|wri|wr) VCSH_COMMAND=write-gitignore;;
463 esac    
464
465 if [ x"$VCSH_COMMAND" = x'clone' ]; then
466         [ -z "$2" ] && fatal "$VCSH_COMMAND: please specify a remote" 1
467         GIT_REMOTE="$2"
468         [ -n "$3" ] && VCSH_REPO_NAME=$3 || VCSH_REPO_NAME=$(basename "${GIT_REMOTE#*:}" .git)
469         [ -z "$VCSH_REPO_NAME" ] && fatal "$VCSH_COMMAND: could not determine repository name" 1
470         export VCSH_REPO_NAME
471         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
472 elif [ "$VCSH_COMMAND" = 'version' ]; then
473         echo "$SELF $VERSION"
474         git version
475         exit
476 elif [ x"$VCSH_COMMAND" = x'which' ]; then
477         [ -z "$2" ] && fatal "$VCSH_COMMAND: please specify a filename" 1
478         [ -n "$3" ] && fatal "$VCSH_COMMAND: too many parameters" 1
479         VCSH_COMMAND_PARAMETER=$2; export VCSH_COMMAND_PARAMETER
480 elif [ x"$VCSH_COMMAND" = x'delete' ]           ||
481      [ x"$VCSH_COMMAND" = x'enter' ]            ||
482      [ x"$VCSH_COMMAND" = x'init' ]             ||
483      [ x"$VCSH_COMMAND" = x'list-tracked-by' ]  ||
484      [ x"$VCSH_COMMAND" = x'rename' ]           ||
485      [ x"$VCSH_COMMAND" = x'run' ]              ||
486      [ x"$VCSH_COMMAND" = x'upgrade' ]          ||
487      [ x"$VCSH_COMMAND" = x'write-gitignore' ]; then
488         [ -z "$2" ]                                     && fatal "$VCSH_COMMAND: please specify repository to work on" 1
489         [ x"$VCSH_COMMAND" = x'rename' ] && [ -z "$3" ] && fatal "$VCSH_COMMAND: please specify a target name" 1
490         [ x"$VCSH_COMMAND" = x'run'    ] && [ -z "$3" ] && fatal "$VCSH_COMMAND: please specify a command" 1
491         VCSH_REPO_NAME=$2; export VCSH_REPO_NAME
492         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
493         [ x"$VCSH_COMMAND" = x'rename' ] && { VCSH_REPO_NAME_NEW=$3; export VCSH_REPO_NAME_NEW;
494                                               GIT_DIR_NEW=$VCSH_REPO_D/$VCSH_REPO_NAME_NEW.git; export GIT_DIR_NEW; }
495         [ x"$VCSH_COMMAND" = x'run' ]    && shift 2
496 elif [ x"$VCSH_COMMAND" = x'commit' ] ||
497      [ x"$VCSH_COMMAND" = x'list'   ] ||
498      [ x"$VCSH_COMMAND" = x'list-tracked' ] ||
499      [ x"$VCSH_COMMAND" = x'list-untracked' ] ||
500      [ x"$VCSH_COMMAND" = x'pull'   ] ||
501      [ x"$VCSH_COMMAND" = x'push'   ]; then
502         :
503 elif [ x"$VCSH_COMMAND" = x'status' ]; then
504         VCSH_REPO_NAME=$2; export VCSH_REPO_NAME
505 elif [ -n "$2" ]; then
506         VCSH_COMMAND='run'; export VCSH_COMMAND
507         VCSH_REPO_NAME=$1; export VCSH_REPO_NAME
508         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
509         [ -d "$GIT_DIR" ] || { help; exit 1; }
510         shift 1
511         set -- "git" "$@"
512 elif [ -n "$VCSH_COMMAND" ]; then
513         VCSH_COMMAND='enter'; export VCSH_COMMAND
514         VCSH_REPO_NAME=$1; export VCSH_REPO_NAME
515         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
516         [ -d "$GIT_DIR" ] || { help; exit 1; }
517 else
518         # $1 is empty, or 'help'
519         help && exit
520 fi
521
522 # Did we receive a directory instead of a name?
523 # Mangle the input to fit normal operation.
524 if echo "$VCSH_REPO_NAME" | grep -q '/'; then
525         GIT_DIR=$VCSH_REPO_NAME; export GIT_DIR
526         VCSH_REPO_NAME=$(basename "$VCSH_REPO_NAME" .git); export VCSH_REPO_NAME
527 fi
528
529 check_dir() {
530         check_directory="$1"
531         if [ ! -d "$check_directory" ]; then
532                 if [ -e "$check_directory" ]; then
533                         fatal "'$check_directory' exists but is not a directory" 13
534                 else
535                         verbose "attempting to create '$check_directory'"
536                         mkdir -p "$check_directory" || fatal "could not create '$check_directory'" 50
537                 fi
538         fi
539 }
540
541 check_dir "$VCSH_REPO_D"
542 [ ! "x$VCSH_GITIGNORE" = 'xnone' ] && check_dir "$VCSH_BASE/.gitignore.d"
543 [ ! "x$VCSH_GITATTRIBUTES" = 'xnone' ] && check_dir "$VCSH_BASE/.gitattributes.d"
544
545 verbose "$VCSH_COMMAND begin"
546 VCSH_COMMAND=$(echo "$VCSH_COMMAND" | sed 's/-/_/g'); export VCSH_COMMAND
547 hook pre-command
548 $VCSH_COMMAND "$@"
549 hook post-command
550 verbose "$VCSH_COMMAND end, exiting"
551 exit $VCSH_COMMAND_RETURN_CODE