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

vcsh: Use BSD/OS X compatible `mktemp`
[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 command_exists() {
290         command -v "$1" >/dev/null 2>&1 || fatal "Could not find '$1' command"
291 }
292
293 list_untracked() {
294         command_exists comm
295
296         temp_file_others=$(mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX") || fatal 'Could not create temp file'
297         temp_file_untracked=$(mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX") || fatal 'Could not create temp file'
298         temp_file_untracked_copy=$(mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX") || fatal 'Could not create temp file'
299
300         [ -z "$VCSH_OPTION_RECURSIVE" ] && directory_opt="--directory"
301
302         for VCSH_REPO_NAME in $(list); do
303                 export GIT_DIR="$VCSH_REPO_D/$VCSH_REPO_NAME.git"
304                 git ls-files --others "$directory_opt" | (
305                         while read line; do
306                                 echo "$line"
307                                 directory_component="$(echo "$line" | cut -d'/' -f1)"
308                                 [ -d "$directory_component" ] && printf '%s/\n' "$directory_component"
309                         done
310                         ) | sort -u > $temp_file_others
311                 if [ -z "$ran_once" ]; then
312                         ran_once=1
313                         cp $temp_file_others $temp_file_untracked || fatal 'Could not copy temp file'
314                 fi
315                 cp $temp_file_untracked $temp_file_untracked_copy || fatal 'Could not copy temp file'
316                 comm -12 --nocheck-order $temp_file_others $temp_file_untracked_copy > $temp_file_untracked
317         done
318         cat $temp_file_untracked
319
320         unset directory_opt directory_component
321         rm -f $temp_file_others $temp_file_untracked $temp_file_untracked_copy || fatal 'Could not delete temp files'
322 }
323
324 rename() {
325         git_dir_exists
326         [ -d "$GIT_DIR_NEW" ] && fatal "'$GIT_DIR_NEW' exists" 54
327         mv -f "$GIT_DIR" "$GIT_DIR_NEW" || fatal "Could not mv '$GIT_DIR' '$GIT_DIR_NEW'" 52
328
329         # Now that the repository has been renamed, we need to fix up its configuration
330         # Overwrite old name..
331         GIT_DIR=$GIT_DIR_NEW
332         VCSH_REPO_NAME=$VCSH_REPO_NAME_NEW
333         # ..and clobber all old configuration
334         upgrade
335 }
336
337 run() {
338         hook pre-run
339         use
340         "$@"
341         VCSH_COMMAND_RETURN_CODE=$?
342         hook post-run
343 }
344
345 status() {
346         if [ -n "$VCSH_REPO_NAME" ]; then
347                 GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
348                 use
349                 git status --short --untracked-files='no'
350                 VCSH_COMMAND_RETURN_CODE=$?
351         else
352                 for VCSH_REPO_NAME in $(list); do
353                         echo "$VCSH_REPO_NAME:"
354                         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
355                         use
356                         git status --short --untracked-files='no'
357                         VCSH_COMMAND_RETURN_CODE=$?
358                         echo
359                 done
360         fi
361 }
362
363 upgrade() {
364         hook pre-upgrade
365         # fake-bare repositories are not bare, actually. Set this to false
366         # because otherwise Git complains "fatal: core.bare and core.worktree
367         # do not make sense"
368         git config core.bare false
369         # core.worktree may be absolute or relative to $GIT_DIR, depending on
370         # user preference
371         if [ ! "x$VCSH_WORKTREE" = 'xabsolute' ]; then
372                 git config core.worktree "$(cd "$GIT_DIR" && GIT_WORK_TREE=$VCSH_BASE git rev-parse --show-cdup)"
373         elif [ ! "x$VCSH_WORKTREE" = 'xrelative' ]; then
374                 git config core.worktree "$VCSH_BASE"
375         fi
376         [ ! "x$VCSH_GITIGNORE" = 'xnone' ] && git config core.excludesfile ".gitignore.d/$VCSH_REPO_NAME"
377         [ ! "x$VCSH_GITATTRIBUTES" = 'xnone' ] && git config core.attributesfile ".gitattributes.d/$VCSH_REPO_NAME"
378         git config vcsh.vcsh 'true'
379         use
380         [ -e "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME" ] && git add -f "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME"
381         [ -e "$VCSH_BASE/.gitattributes.d/$VCSH_REPO_NAME" ] && git add -f "$VCSH_BASE/.gitattributes.d/$VCSH_REPO_NAME"
382         hook post-upgrade
383 }
384
385 use() {
386         git_dir_exists
387         VCSH_DIRECTORY=$VCSH_REPO_NAME; export VCSH_DIRECTORY
388 }
389
390 which() {
391         for VCSH_REPO_NAME in $(list); do
392                 for VCSH_FILE in $(get_files); do
393                         echo "$VCSH_FILE" | grep -q "$VCSH_COMMAND_PARAMETER" && echo "$VCSH_REPO_NAME: $VCSH_FILE"
394                 done
395         done | sort -u
396 }
397
398 write_gitignore() {
399         # Don't do anything if the user does not want to write gitignore
400         if [ "x$VCSH_GITIGNORE" = 'xnone' ]; then
401                 info "Not writing gitignore as '\$VCSH_GITIGNORE' is set to 'none'"
402                 exit
403         fi
404
405         use
406         cd "$VCSH_BASE" || fatal "could not enter '$VCSH_BASE'" 11
407         OLDIFS=$IFS
408         IFS=$(printf '\n\t')
409         gitignores=$(for file in $(git ls-files); do
410                 while true; do
411                         echo "$file"; new=${file%/*}
412                         [ x"$file" = x"$new" ] && break
413                         file=$new
414                 done;
415         done | sort -u)
416
417         # Contrary to GNU mktemp, mktemp on BSD/OSX requires a template for temp files
418         # Using a template makes GNU mktemp default to $PWD and not #TMPDIR for tempfile location
419         # To make every OS happy, set full path explicitly
420         tempfile=$(mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX") || fatal "could not create tempfile: '${tempfile}'" 51
421
422         echo '*' > "$tempfile" || fatal "could not write to '$tempfile'" 57
423         for gitignore in $gitignores; do
424                 echo "$gitignore" | sed 's@^@!/@' >> "$tempfile" || fatal "could not write to '$tempfile'" 57
425                 if [ "x$VCSH_GITIGNORE" = 'xrecursive' ] && [ -d "$gitignore" ]; then
426                         { echo "$gitignore/*" | sed 's@^@!/@' >> "$tempfile" || fatal "could not write to '$tempfile'" 57; }
427                 fi
428         done
429         IFS=$OLDIFS
430         if diff -N "$tempfile" "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME" > /dev/null; then
431                 rm -f "$tempfile" || error "could not delete '$tempfile'"
432                 exit
433         fi
434         if [ -e "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME" ]; then
435                 info "'$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME' differs from new data, moving it to '$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME.bak'"
436                 mv -f "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME" "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME.bak" ||
437                         fatal "could not move '$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME' to '$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME.bak'" 53
438         fi
439         mv -f "$tempfile" "$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME" ||
440                 fatal "could not move '$tempfile' to '$VCSH_BASE/.gitignore.d/$VCSH_REPO_NAME'" 53
441 }
442
443 debug $(git version)
444
445 if [ ! "x$VCSH_GITIGNORE" = 'xexact' ] && [ ! "x$VCSH_GITIGNORE" = 'xnone' ] && [ ! "x$VCSH_GITIGNORE" = 'xrecursive' ]; then
446         fatal "'\$VCSH_GITIGNORE' must equal 'exact', 'none', or 'recursive'" 1
447 fi
448
449 VCSH_COMMAND=$1; export VCSH_COMMAND
450
451 case $VCSH_COMMAND in
452         clon|clo|cl) VCSH_COMMAND=clone;;
453         commi|comm|com|co) VCSH_COMMAND=commit;;
454         delet|dele|del|de) VCSH_COMMAND=delete;;
455         ente|ent|en) VCSH_COMMAND=enter;;
456         hel|he) VCSH_COMMAND=help;;
457         ini|in) VCSH_COMMAND=init;;
458         pul) VCSH_COMMAND=pull;;
459         pus) VCSH_COMMAND=push;;
460         renam|rena|ren|re) VCSH_COMMAND=rename;;
461         ru) VCSH_COMMAND=run;;
462         statu|stat|sta|st) VCSH_COMMAND=status;;
463         upgrad|upgra|upgr|up) VCSH_COMMAND=upgrade;;
464         versio|versi|vers|ver|ve) VCSH_COMMAND=version;;
465         which|whi|wh) VCSH_COMMAND=which;;
466         write|writ|wri|wr) VCSH_COMMAND=write-gitignore;;
467 esac    
468
469 if [ x"$VCSH_COMMAND" = x'clone' ]; then
470         [ -z "$2" ] && fatal "$VCSH_COMMAND: please specify a remote" 1
471         GIT_REMOTE="$2"
472         [ -n "$3" ] && VCSH_REPO_NAME=$3 || VCSH_REPO_NAME=$(basename "${GIT_REMOTE#*:}" .git)
473         [ -z "$VCSH_REPO_NAME" ] && fatal "$VCSH_COMMAND: could not determine repository name" 1
474         export VCSH_REPO_NAME
475         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
476 elif [ "$VCSH_COMMAND" = 'version' ]; then
477         echo "$SELF $VERSION"
478         git version
479         exit
480 elif [ x"$VCSH_COMMAND" = x'which' ]; then
481         [ -z "$2" ] && fatal "$VCSH_COMMAND: please specify a filename" 1
482         [ -n "$3" ] && fatal "$VCSH_COMMAND: too many parameters" 1
483         VCSH_COMMAND_PARAMETER=$2; export VCSH_COMMAND_PARAMETER
484 elif [ x"$VCSH_COMMAND" = x'delete' ]           ||
485      [ x"$VCSH_COMMAND" = x'enter' ]            ||
486      [ x"$VCSH_COMMAND" = x'init' ]             ||
487      [ x"$VCSH_COMMAND" = x'list-tracked-by' ]  ||
488      [ x"$VCSH_COMMAND" = x'rename' ]           ||
489      [ x"$VCSH_COMMAND" = x'run' ]              ||
490      [ x"$VCSH_COMMAND" = x'upgrade' ]          ||
491      [ x"$VCSH_COMMAND" = x'write-gitignore' ]; then
492         [ -z "$2" ]                                     && fatal "$VCSH_COMMAND: please specify repository to work on" 1
493         [ x"$VCSH_COMMAND" = x'rename' ] && [ -z "$3" ] && fatal "$VCSH_COMMAND: please specify a target name" 1
494         [ x"$VCSH_COMMAND" = x'run'    ] && [ -z "$3" ] && fatal "$VCSH_COMMAND: please specify a command" 1
495         VCSH_REPO_NAME=$2; export VCSH_REPO_NAME
496         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
497         [ x"$VCSH_COMMAND" = x'rename' ] && { VCSH_REPO_NAME_NEW=$3; export VCSH_REPO_NAME_NEW;
498                                               GIT_DIR_NEW=$VCSH_REPO_D/$VCSH_REPO_NAME_NEW.git; export GIT_DIR_NEW; }
499         [ x"$VCSH_COMMAND" = x'run' ]    && shift 2
500 elif [ x"$VCSH_COMMAND" = x'commit' ] ||
501      [ x"$VCSH_COMMAND" = x'list'   ] ||
502      [ x"$VCSH_COMMAND" = x'list-tracked' ] ||
503      [ x"$VCSH_COMMAND" = x'list-untracked' ] ||
504      [ x"$VCSH_COMMAND" = x'pull'   ] ||
505      [ x"$VCSH_COMMAND" = x'push'   ]; then
506         :
507 elif [ x"$VCSH_COMMAND" = x'status' ]; then
508         VCSH_REPO_NAME=$2; export VCSH_REPO_NAME
509 elif [ -n "$2" ]; then
510         VCSH_COMMAND='run'; export VCSH_COMMAND
511         VCSH_REPO_NAME=$1; export VCSH_REPO_NAME
512         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
513         [ -d "$GIT_DIR" ] || { help; exit 1; }
514         shift 1
515         set -- "git" "$@"
516 elif [ -n "$VCSH_COMMAND" ]; then
517         VCSH_COMMAND='enter'; export VCSH_COMMAND
518         VCSH_REPO_NAME=$1; export VCSH_REPO_NAME
519         GIT_DIR=$VCSH_REPO_D/$VCSH_REPO_NAME.git; export GIT_DIR
520         [ -d "$GIT_DIR" ] || { help; exit 1; }
521 else
522         # $1 is empty, or 'help'
523         help && exit
524 fi
525
526 # Did we receive a directory instead of a name?
527 # Mangle the input to fit normal operation.
528 if echo "$VCSH_REPO_NAME" | grep -q '/'; then
529         GIT_DIR=$VCSH_REPO_NAME; export GIT_DIR
530         VCSH_REPO_NAME=$(basename "$VCSH_REPO_NAME" .git); export VCSH_REPO_NAME
531 fi
532
533 check_dir() {
534         check_directory="$1"
535         if [ ! -d "$check_directory" ]; then
536                 if [ -e "$check_directory" ]; then
537                         fatal "'$check_directory' exists but is not a directory" 13
538                 else
539                         verbose "attempting to create '$check_directory'"
540                         mkdir -p "$check_directory" || fatal "could not create '$check_directory'" 50
541                 fi
542         fi
543 }
544
545 check_dir "$VCSH_REPO_D"
546 [ ! "x$VCSH_GITIGNORE" = 'xnone' ] && check_dir "$VCSH_BASE/.gitignore.d"
547 [ ! "x$VCSH_GITATTRIBUTES" = 'xnone' ] && check_dir "$VCSH_BASE/.gitattributes.d"
548
549 verbose "$VCSH_COMMAND begin"
550 VCSH_COMMAND=$(echo "$VCSH_COMMAND" | sed 's/-/_/g'); export VCSH_COMMAND
551 hook pre-command
552 $VCSH_COMMAND "$@"
553 hook post-command
554 verbose "$VCSH_COMMAND end, exiting"
555 exit $VCSH_COMMAND_RETURN_CODE