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