Sort files in the ChangeLog entry.

[svn-wrapper.git] / svn-wrapper.sh

#! /bin/sh
# Simple wrapper around svn featuring auto-ChangeLog entries and emailing.
# $Id$
# Copyright (C) 2006  Benoit Sigoure.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
# USA.

# Quick install: alias svn=path/to/svn-wrapper.sh -- that's all.

 # ------ #
 # README #
 # ------ #

# This script is a wrapper around the svn command-line client for UNIX. It has
# been designed mainly to automagically generate GNU-style ChangeLog entries
# when committing and mail them along with a diff and an optional comment from
# the author to a list of persons or a mailing list. It has been made so that
# it's as much portable as possible and covers as many use-case as possible.
#
# HOWEVER, there will be bugs, there will be cases in which the script doesn't
# wrap properly the svn-cli, etc. In this case, you can try to mail me at
# <tsuna at lrde dot epita dot fr>. Include the revision of the svn-wrapper
# you're using, and full description of what's wrong etc. so I can reproduce
# your problem.
#
# If you feel like, you can try to fix/enhance the script yourself. It only
# requires some basic Shell-scripting skills. Knowing sed might help :)

 # ------------- #
 # DOCUMENTATION #
 # ------------- #

# If you're simply looking for the usage, run svn-wrapper.sh help (or
# svn help if you aliased `svn' on svn-wrapper.sh) as usual.
#
# This script is (hopefully) portable, widely commented and self-contained. Do
# not hesitate to hack it. It might look rather long (because it does a lot of
# things :P) but you should be able to easily locate which part of the code
# you're looking for.
#
# The script begins by defining several functions. Then it really starts where
# the comment "# `main' starts here. #" is placed.
# Some svn commands are hooked (eg, svn st displays colors). Hooks and
# extra commands are defined in functions named svn_<command-name>.

 # ---- #
 # TODO #
 # ---- #

#  * Handle things such as svn ci --force foobar.
#  * svn automerge + automatic fill in branches/README.branches.
#  * Automatic proxy configuration depending on the IP in ifconfig?
#  * Customizable behavior/colors via some ~/.<config>rc file (?)
#  * Automatically recognize svn cp and svn mv instead of writting "New" and
#    "Remove" in the template ChangeLog entry (hard). Pair the and new/remove
#    to prepare a good ChangeLog entry (move to X, copy from X) [even harder].
#    => svn info says whether an item was copied from a given *URL* or not.



# No args, invoke svn...
test $# -lt 1 && exec $SVN

# Default values (the user can export them to override them).
: ${SVN=svn}
: ${EDITOR=vi}
export EDITOR
: ${GPG=gpg}
: ${TMPDIR=/tmp}
export TMPDIR
: ${PAGER=more}
export PAGER
# Override the locale.
LC_ALL='C'
export LC_ALL

# Pitfall: some users might be tempted to export SVN=svn-wrapper.sh for some
# reason. This is just *wrong*. The following is an attempt to save them from
# some troubles.
if [ x`basename "$SVN"` = 'xsvn-wrapper.sh' ]; then
  SVN='svn'
fi

# This code comes (mostly) from Autoconf.
# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  trap "echo SIGINT; rm -f conf$$.sh; exit 130" SIGINT
  echo "#! /bin/sh" >conf$$.sh
  echo  "exit 0"   >>conf$$.sh
  chmod +x conf$$.sh
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
    PATH_SEPARATOR=';'
  else
    PATH_SEPARATOR=:
  fi
  rm -f conf$$.sh
  # "Remove" the trap
  trap 'echo SIGINT; exit 130' SIGINT
fi

version='0.3'
revision=`sed '/^# $Id[:].*$/!d;
               s/.*$Id[:] *//;
               s/ *$ *//;
               s/[^0-9]*\([0-9][0-9]*\).*/\1/' "$0"`
me="$0"

# The `main' really starts after the functions definitions.

  # ---------------- #
  # Helper functions #
  # ---------------- #

set_colors()
{
  red='\e[0;31m';    lred='\e[1;31m'
  green='\e[0;32m';  lgreen='\e[1;32m'
  yellow='\e[0;33m'; lyellow='\e[1;33m'
  blue='\e[0;34m';   lblue='\e[1;34m'
  purple='\e[0;35m'; lpurple='\e[1;35m'
  cyan='\e[0;36m';   lcyan='\e[1;36m'
  grey='\e[0;37m';   lgrey='\e[1;37m'
  white='\e[0;38m';  lwhite='\e[1;38m'
  std='\e[m'
}

set_nocolors()
{
  red='';    lred=''
  green='';  lgreen=''
  yellow=''; lyellow=''
  blue='';   lblue=''
  purple=''; lpurple=''
  cyan='';   lcyan=''
  grey='';   lgrey=''
  white='';  lwhite=''
  std=''
}

# abort err-msg
abort()
{
  echo "svn-wrapper: ${lred}abort${std}: $@" \
  | sed '1!s/^[         ]*/             /' >&2
  exit 1
}

# warn msg
warn()
{
  echo "svn-wrapper: ${lred}warning${std}: $@" \
  | sed '1!s/^[         ]*/             /' >&2
}

# notice msg
notice()
{
  echo "svn-wrapper: ${lyellow}notice${std}: $@" \
  | sed '1!s/^[         ]*/              /' >&2
}

# yesno question
yesno()
{
  echo -n "$@ [y/N] "
  read answer || return 1
  case "$answer" in
    y* | Y*) return 0;;
    *)       return 1;;
  esac
  return 42 # should never happen...
}

# warn_env env-var
warn_env()
{
  warn "cannot find the environment variable $1
        You might consider using \`export $1 <FIXME>\`"
}

# get_unique_file_name file-name
get_unique_file_name()
{
  test -e "$1" || {
    echo "$1" && return 0
  }
  gufn="$1"; i=1
  while test -e "$gufn.$i"; do
    i=`expr $i + 1`
  done
  echo "$gufn.$i"
}

# ensure_not_empty description value
ensure_not_empty()
{
  ene_val=`echo "$2" | tr -d ' \t\n'`
  test x"$ene_val" = x && abort "$1: empty value"
}

# find_prog prog-name
# return true if prog-name is in the PATH
# echo the full path to prog-name on stdout.
# Based on a code from texi2dvi
find_prog()
{
  save_IFS=$IFS
  IFS=$PATH_SEPARATOR
  for dir in $PATH; do
    IFS=$save_IFS
    test x"$dir" = x && continue
    # The basic test for an executable is `test -f $f && test -x $f'.
    # (`test -x' is not enough, because it can also be true for directories.)
    # We have to try this both for $1 and $1.exe.
    #
    # Note: On Cygwin and DJGPP, `test -x' also looks for .exe. On Cygwin,
    # also `test -f' has this enhancement, bot not on DJGPP. (Both are
    # design decisions, so there is little chance to make them consistent.)
    # Thusly, it seems to be difficult to make use of these enhancements.
    #
    if test -f "$dir/$1" && test -x "$dir/$1"; then
      echo "$dir/$1"
      return 0
    elif test -f "$dir/$1.exe" && test -x "$dir/$1.exe"; then
      echo "$dir/$1.exe"
      return 0
    fi
  done
  return 1
}

# require_diffstat
# return true if diffstat is in the PATH
require_diffstat()
{
  if [ x"$require_diffstat_cache" != x ]; then
    return $require_diffstat_cache
  fi
  if (echo | diffstat) >/dev/null 2>/dev/null; then :; else
    warn 'diffstat is not installed on your system or not in your PATH.'
    test -f /etc/debian_version \
    && notice 'you might want to `apt-get install diffstat`.'
    require_diffstat_cache=1
    return 1
  fi
  require_diffstat_cache=0
  return 0
}

# require_mail
# return 0 -> found sendmail
#        1 -> found mail
#        2 -> no mailer found
# The full path to the program found is echo'ed on stdout.
require_mail()
{
  if [ x"$require_mail_cache_rv" != x ]; then
    echo "$require_mail_cache"
    return $require_mail_cache_rv
  fi
  save_PATH="$PATH"
  PATH="${PATH}${PATH_SEPARATOR}/sbin${PATH_SEPARATOR}/usr/sbin${PATH_SEPARATOR}/usr/libexec"
  export PATH
  require_mail_cache=`find_prog sendmail`
  if [ $? -eq 0 ] && [ x"$require_mail_cache" != x ]; then
    echo "$require_mail_cache"
    require_mail_cache_rv=0
    return 0
  fi
  PATH="$save_PATH"
  export PATH
  require_mail_cache=`find_prog mail`
  if [ $? -eq 0 ] && [ x"$require_mail_cache" != x ]; then
    echo "$require_mail_cache"
    require_mail_cache_rv=1
    return 1
  else
    warn 'mail is not installed on your system or not in your PATH.'
    test -f /etc/debian_version \
    && notice 'you might want to:
               # apt-get install mailx
               # dpkg-reconfigure exim'
    require_mail_cache=''
    require_mail_cache_rv=1
    return 1
  fi
  require_mail_cache=''
  require_mail_cache_rv=42
  return 42
}

# my_sendmail mail-file mail-subject mail-to [extra-headers]
# mail-to is a comma-separated list of email addresses.
# extra-headers is an optionnal argument and will be prepended at the
# beginning of the mail headers if the tool used to send mails supports it.
# The mail-file may also contain headers. They must be separated from the body
# of the mail by a blank line.
my_sendmail()
{
  test -f "$1" || abort "my_sendmail: Cannot find the mail file: $1"
  test x"$2" = x && warn 'my_sendmail: Empty subject.'
  test x"$3" = x && abort 'my_sendmail: No recipient specified.'

  extra_headers="Content-type: text/plain
                 X-Mailer: svn-wrapper v$version (r$revision)"
  if test x"$4" != x; then
    extra_headers="$4
$extra_headers"
    # Remove empty lines.
    extra_headers=`echo "$extra_headers" | sed '/^[     ]*$/d;s/^[      ]*//'`
  fi

  test -f ~/.signature && echo '-- ' >>"$1" && \
    cat ~/.signature >>"$1"
  # VCS-compat: handle user option 'sign'.
  if (grep '^sign: false' ~/.vcs) >/dev/null 2>/dev/null; then :; else
    ($GPG -h) >/dev/null 2>/dev/null
    gpg_rv=$?
    if [ -e ~/.gnupg ] || [ -e ~/.gpg ] || [ -e ~/.pgp ] && [ $gpg_rv -lt 42 ]
    then
      if yesno "Sign the mail using $GPG ?"; then
        # GPG sign the mail with the headers stripped.
        cat "$1" | sed '1,/^$/d' | $GPG --clearsign >"$1.asc"
        # Re-paste the headers before the signed body.
        test -f "$1.asc" \
        && cat "$1" | sed '1,/^$/!d' | cat - "$1.asc" >"$1.tmp" \
        && mv -f "$1.tmp" "$1"
        # Cleanup.
        rm -f "$1.tmp" "$1.asc"
      fi
    fi
  fi

  mailer=`require_mail`
  r_mail_rv=$?
  if [ $? -ge 2 ] || [ x"$mailer" = x ]; then
    warn 'my_sendmail: No suitable mailer found.'
    return 1
  fi
  case $r_mail_rv in
    0) # sendmail
       to=`echo "$3" | sed 's/,//g'`
       echo "$extra_headers" | cat - "$1" | $mailer $to;;
    1) # mail
       cat "$1" | $mailer -s "$2" "$3";;
    *) # wtf
       warn 'my_sendmail: Internal error.'; return 42;;
  esac
}

# selfupdate
selfupdate()
{
  my_url='http://www.lrde.epita.fr/~sigoure/svn-wrapper'
  # You can use https if you feel paranoiac.

  echo ">>> Fetching svn-wrapper.sh from $my_url/svn-wrapper.sh"

  # --------------------- #
  # Fetch the new version #
  # --------------------- #

  tmp_me=`get_unique_file_name "$TMPDIR/svn-wrapper.sh"`
  if (wget --help) >/dev/null 2>/dev/null; then
    wget --no-check-certificate "$my_url/svn-wrapper.sh" -O "$tmp_me"
    my_wget='wget'
  else
    curl --help >/dev/null 2>/dev/null
    if [ $? -gt 42 ]; then
      abort 'Cannot find wget or curl.
             How can I download any update without them?'
    fi
    my_wget='curl'
    curl --insecure "$my_url/svn-wrapper.sh" >"$tmp_me"
  fi

  test -r $tmp_me \
    || abort "Cannot find the copy of myself I downloaded in $tmp_me"

  # ---------------------------------------- #
  # Compare versions and update if necessary #
  # ---------------------------------------- #

  my_ver="$revision"
  tmp_ver=`sed '/^# $Id[:].*$/!d;
                s/.*$Id[:] *//;
                s/ *$ *//;
                s/[^0-9]*\([0-9][0-9]*\).*/\1/' "$tmp_me"`
  test x"$tmp_ver" = x && abort "Cannot find the version of $tmp_me"
  if [ "$my_ver" -lt "$tmp_ver" ]; then # There IS an update...
    echo "An update is available, r$tmp_ver (your version is r$my_ver)"

    # See the ChangeLog?
    if yesno "Do you want to see the ChangeLog between r$my_ver and r$tmp_ver?"
    then
      my_chlog=`get_unique_file_name "$TMPDIR/ChangeLog"`
      case $my_wget in
        wget) wget --no-check-certificate "$my_url/ChangeLog" -O "$my_chlog"
        ;;
        curl) curl --insecure "$my_url/ChangeLog" >"$my_chlog"
        ;;
        *) abort 'Should never be here.'
        ;;
      esac
      sed "/^r$my_ver/q" "$my_chlog" | $PAGER
      rm -f "$my_chlog"
    fi

    # Wanna see the diff?
    if yesno "Do you want to see the diff between r$my_ver and r$tmp_ver?"
    then
      (require_diffstat && diff -uw "$me" "$tmp_me" | diffstat;
       echo
       diff -uw "$me" "$tmp_me") | $PAGER
    fi

    # Let's go :)
    if yesno "Overwrite $me (r$my_ver) with $tmp_me (r$tmp_ver)?"; then
      chmod a+x "$tmp_me"
      mv "$tmp_me" "$me" && exit 0
    fi
    rm -f "$tmp_me"
    return 1
  elif [ "$my_ver" -gt "$tmp_ver" ]; then
    echo "Wow, you're more up to date than the master copy :)"
    echo "Your version is r$my_ver and the master copy is r$tmp_ver."
    if yesno 'Downgrade?'; then
      chmod a+x "$tmp_me"
      mv "$tmp_me" "$me" && exit 0
    fi
  else
    echo "You're already up to date [r$my_ver] :)"
  fi
  rm -f "$tmp_me"
}

  # ------------------------------- #
  # Hooks for standard SVN commands #
  # ------------------------------- #

# svn_commit [args...]
# Here is how the commit process goes:
# First we look in the arguments passed to commit:
#   If there are some files or paths, the user wants to commit these only. In
#   this case, we must search for ChangeLogs from these paths. We might find
#   more than one ChangeLog, in this case the user will be prompted to pick up
#   one.
#   Otherwise (no path passed in the command line) the user just wants to
#   commit the current working directory.
# In any case, we schedule "ChangeLog" for commit.
# Alright now that we know which ChangeLog to use, we look in the ChangeLog's
# directory if there is a ",svn-log" file which would mean that a previous
# commit didn't finish successfully. If there is such a file, the user is
# prompted to know whether they want to resume that commit or simply start a
# new one.
# When the user wants to resume a commit, the ",svn-log" file is loaded and we
# retrieve the value of "$@" that was saved in the file.
# Otherwise we build a template ChangeLog entry.
# Then we open the template ChangeLog entry with $EDITOR so that the user
# fills it properly.
# Finally, we commit.
svn_commit()
{
  here=`pwd -P`

  # Check if the user passed some paths to commit explicitly
  # because in this case we must add the ChangeLog to the commit and search
  # the ChangeLog from the dirname of that file.
  i=0; search_from=''; add_changelog=no; extra_files=''
  while [ $i -lt $# ]; do
    arg="$1"
    # If the argument is a valid path: add the ChangeLog in the list of
    # files to commit
    if test -e "$arg"; then
      add_changelog=yes
      if test -d "$arg"; then
        search_from_add="$arg"
      else
        search_from_add=`dirname "$arg"`
      fi
      search_from="$search_from:$search_from_add"
    fi
    shift
    set dummy "$@" "$arg"
    shift
    i=`expr $i + 1`
  done
  if [ $add_changelog = no ]; then
    # There is no path/file in the command line: the user wants to commit the
    # current directory. Make it explicit now:
    extra_files="$here"
  fi
  search_from=`echo "$search_from" | sed 's/^://; s/^$/./'`

  # ----------------- #
  # Find ChangeLog(s) #
  # ----------------- #

  nb_chlogs=0; change_log_dirs=''
  save_IFS=$IFS; IFS=':'
  for dir in $search_from; do
    IFS=$save_IFS
    test -z "$dir" && dir='.'
    # First: come back to the original place
    cd "$here" || abort "Cannot cd to $here"
    cd "$dir"  || continue # Then: Enter $dir (which can be a relative path)
    found=0 
    while [ $found -eq 0 ]; do
      this_chlog_dir=`pwd -P`
      if [ -f ./ChangeLog ]; then
        found=1
        nb_chlogs=`expr $nb_chlogs + 1`
        change_log_dirs="$change_log_dirs:$this_chlog_dir"
      else
        cd ..
      fi
      # Stop searching when in / ... hmz :P
      test x"$this_chlog_dir" = x/ && break
    done # end while: did we find a ChangeLog
  done # end for: find ChangeLogs in $search_from
  if [ $nb_chlogs -gt 0 ]; then
    change_log_dirs=`echo "$change_log_dirs" | sed 's/^://' | tr ':' '\n' \
                     | sort -u`
    nb_chlogs=`echo "$change_log_dirs" | wc -l`
  fi

  # Did we find a ChangeLog? More than one?
  if [ $nb_chlogs -eq 0 ]; then
    if yesno 'svn-wrapper: Error: Cannot find a ChangeLog file!
You might want to create an empty one (eg: `touch ChangeLog` where appropriate)
Do you want to proceed without using a ChangeLog?'; then
      cd "$here"
      $SVN commit "$@"
      return $?
    else
      return 1
    fi
  elif [ $nb_chlogs -gt 1 ]; then
    notice "$nb_chlogs ChangeLogs were found, pick up one:"

    IFS=':'; i=0
    for a_chlog_dir in $change_log_dirs; do
      i=`expr $i + 1`
      echo "$i. $a_chlog_dir/ChangeLog"
    done
    echo -n "Which ChangeLog do you want to use? [1-$i] "
    read chlog_no || abort 'Cannot read answer on stdin.'

    case "$chlog_no" in
      *[^0-9]*) abort "Invalid ChangeLog number: $chlog_no"
    esac
    test "$chlog_no" -le $i || abort "Invalid ChangeLog number: $chlog_no
                                      max value was: $i"
    test "$chlog_no" -ge 1 || abort "Invalid ChangeLog number: $chlog_no
                                     min value was: 1"
    change_log_dir=`echo "$change_log_dirs" | tr ':' '\n' | sed "${chlog_no}!d"`
  else # Only one ChangeLog found
    change_log_dir=$change_log_dirs
    notice "using $change_log_dir/ChangeLog"
  fi

  test -f "$change_log_dir/ChangeLog" \
  || abort "No such file or directory: $change_log_dir/ChangeLog"

  # Now we can safely schedule the ChangeLog for the commit.
  extra_files="$extra_files:$change_log_dir/ChangeLog"

  svn_st_tmp=`$SVN status "$change_log_dir"`

  # Warn for files that are not added in the repos.
  conflicts=`echo "$svn_st_tmp" | sed '/^[^?]/d;
                                       /^?.......*\/[,+]/d;
                                       /^?......[,+]/d'`
  if test x"$conflicts" != x; then
    warn "make sure you don't want to \`svn add'
          any of the following files before committing:"
    echo "$conflicts" | sed "$sed_svn_st_color"
    echo -n 'Type [ENTER] to continue :)' && read chiche_is_gay
  fi

  # Detect unresolved conflicts / missing files.
  conflicts=`echo "$svn_st_tmp" | sed '/^[C!]/!d'`
  test x"$conflicts" != x && abort "there are unresolved conflicts (\`C')
                                    and/or missing files (\`!'):
                                    $conflicts"

  svn_info_tmp=`$SVN info "$change_log_dir"`
  test $? -ne 0 && abort "Failed to get svn info on $change_log_dir"
  repos_root=`echo "$svn_info_tmp" | sed '/^Repository Root: /!d;s///'`
  # It looks like svn <1.3 didn't display a "Repository Root" entry.
  test x"$repos_root" = x && \
    repos_root=`echo "$svn_info_tmp" | sed '/^URL: /!d;s///'`
  cd "$here"

  YYYY=`date '+%Y'`
  MM=`date '+%m'`
  DD=`date '+%d'`
  echo -n 'Please wait... '
  svn_info_tmp=`$SVN info "$repos_root"`
  REV=`echo "$svn_info_tmp" | sed '/^Revision: /!d;s///'`
  test x"$REV" = x && REV=`echo "$svn_info_tmp" \
                           | sed '/^Last Changed Rev: /!d;s///'`
  test x"$REV" = x && abort 'Cannot detect the current revision.'
  REV=`expr $REV + 1`
  echo "next revision: $REV"

  # VCS-compat: handle user option 'new_user'
  new_user='yes'
  grep '^new_user: false' ~/.vcs >/dev/null 2>/dev/null && new_user='no'

  tmp_log="$change_log_dir/,svn-log"
  if [ -f "$tmp_log" ] && yesno "It looks like the last commit did not\
 terminate successfully.
Would you like to resume it?"; then
    echo 'Resuming ...'
    internal_tags=`sed '/^--- Internal stuff, DO NOT change please ---$/,$!d' \
                     "$tmp_log"`
    saved_args=`echo "$internal_tags" | sed '/^args: */!d;s///'`
    extra_files=`echo "$internal_tags" | sed '/^extra_files: */!d;s///'`
    if [ x"$saved_args" != x ]; then
      if [ x"$*" != x ] && [ x"$saved_args" != x"$*" ]; then
        warn "overriding arguments:
              you invoked $me with the following arguments: $@
              they have been replaced by these: $saved_args"
        set dummy $saved_args
        shift
      else
        notice "setting the following arguments: $saved_args"
        set dummy $saved_args
        shift
      fi
    fi
    # Ignore white spaces. Can't svn diff -x -w: svn 1.4 only.
    svn_diff=`svn_diffw "$@"`
    test x"$svn_diff" = x && svn_diff=`$SVN diff "$@"`
    if require_diffstat; then
      svn_diff_stat=`echo "$svn_diff" | diffstat`
    else
      svn_diff_stat='diffstat not available'
    fi

  else # Build the template message.

    # ------------------------------------ #
    # Gather info for the template message #
    # ------------------------------------ #

    projname=`$SVN propget project "$change_log_dir"`
    # Try to be VCS-compatible and find a project name in a *.rb.
    if [ x"$projname" = x ] && [ -d "$change_log_dir/vcs" ]; then
      projname=`sed '/common_commit/!d;s/.*"\(.*\)<%= rev.*/\1/' \
                    "$change_log_dir"/vcs/*.rb`
      test x"$projname" != x && test x$new_user = xyes \
      && notice "VCS-compat: found project name: $projname
                 in " "$change_log_dir"/vcs/*.rb
    fi
    test x"$projname" != x && projname=`echo "$projname" | sed '/[^ ]$/s/$/ /'`

    mailto=`$SVN propget mailto "$change_log_dir"`
    if [ x"$mailto" = x ]; then
      test x$new_user = xyes \
      && warn "no svn property mailto found in $change_log_dir
               You might want to set default email adresses using:
               svn propset mailto 'somebody@mail.com, foobar@example.com'\
               $change_log_dir" >&2
      # Try to be VCS-compatible and find a list of mails in a *.rb.
      if [ -d "$change_log_dir/vcs" ]; then
        mailto=`grep '.@.*\..*' "$change_log_dir"/vcs/*.rb \
               | tr '\n' ' ' \
               | sed 's/^.*[["]\([^["]*@[^]"]*\)[]"].*$/\1/' | xargs`
        test x"$mailto" != x && test x$new_user = xyes \
        && notice "VCS-compat: found mailto: $mailto
                   in " "$change_log_dir"/vcs/*.rb
      fi # end VCS compat
    fi # end guess mailto

    # Ensure that emails are comma-separated.
    mailto=`echo "$mailto" | sed 's/[ ;]/,/g' | tr -s ',' | sed 's/,/, /g'`
    test x"$FULLNAME" = x && FULLNAME='Type Your Name Here' \
    && warn_env FULLNAME
    test x"$EMAIL" = x && EMAIL='your.mail.here@FIXME.com' && warn_env EMAIL

    # --ignore-externals appeared after svn 1.1.1
    my_svn_st=`$SVN status --ignore-externals "$@" \
               || $SVN status "$@" | sed '/^Performing status on external/ {
                                            d;q
                                          }'`

    # Files to put in the ChangeLog entry.
    change_log_files=`echo "$my_svn_st" | sed '
      t dummy_sed_1
      : dummy_sed_1
      s/^M......\(.*\)$/        * \1: ./;       t
      s/^A......\(.*\)$/        * \1: New./;    t
      s/^D......\(.*\)$/        * \1: Remove./; t
      d
    '`
    if [ x"$change_log_files" = x ]; then
      yesno 'Nothing to commit, continue anyway?' || return 1
    fi
    change_log_files=`echo "$change_log_files" | sort`

    svn_diff=`svn_diffw "$@"`
    test x"$svn_diff" = x && svn_diff=`$SVN diff "$@"`
    if require_diffstat; then
      svn_diff_stat=`echo "$svn_diff" | diffstat`
    else
      svn_diff_stat='diffstat not available'
    fi

    # Get any older svn-log out of the way.
    test -f "$tmp_log" && mv "$tmp_log" `get_unique_file_name "$tmp_log"`
    # If we can't get an older svn-log out of the way, find a new name...
    test -f "$tmp_log" && tmp_log=`get_unique_file_name "$tmp_log"`
    if [ x$new_user = no ]; then
      commit_instructions='
Instructions:
 - Fill the ChangeLog entry.
 - If you feel like, write a comment in the "Comment:" section.
   This comment will only appear in the email, not in the ChangeLog.
   By default only the location of the repository is in the comment.
 - Some tags will be replaced. Tags are of the form: <TAG>. Unknown
   tags will be left unchanged.
 - Your ChangeLog entry will be used as commit message for svn.'
    else
      commit_instructions=''
    fi
    echo "\
--You must fill this file correctly to continue--           -*- vcs -*-
Title: 
Subject: ${projname}r<REV>: <TITLE>
From: $FULLNAME <$EMAIL>
To: $mailto

Comment:
  Repository: $repos_root

ChangeLog:

<YYYY>-<MM>-<DD>  $FULLNAME  <$EMAIL>

        <TITLE>
$change_log_files

--This line, and those below, will be ignored--
$commit_instructions
--Preview of the message that will be sent--

Repository: $repos_root
Next revision: $REV
Your comments (if any) will appear here.

ChangeLog:
$YYYY-$MM-$DD  $FULLNAME  <$EMAIL>

        Your ChangeLog entry will appear here.

$svn_diff_stat

$svn_diff" >"$tmp_log"

    echo "
--- Internal stuff, DO NOT change please ---
args: $@" >>"$tmp_log"
    echo "extra_files: $extra_files
vi: ft=diff" >>"$tmp_log"

  fi # end: if svn-log; then resume? else create template
  $EDITOR "$tmp_log"

  # ------------------ #
  # Re-"parse" the log #
  # ------------------ #

  # hmz this section is a bit messy...
  sed_escape='s/@/\\@/' # helper string... !@#$%* escaping \\\\\\...
  sed_eval_tags="s/<MM>/$MM/g; s/<DD>/$DD/g; s/<YYYY>/$YYYY/g; s/<REV>/$REV/g"
  full_log=`sed '/^--This line, and those below, will be ignored--$/,$d;
                 /^--You must fill this/d' "$tmp_log"`
  chlog_entry=`echo "$full_log" | sed '/^ChangeLog:$/,$!d; //d'`
  ensure_not_empty 'ChangeLog entry' "$chlog_entry"
  full_log=`echo "$full_log" | sed '/^ChangeLog:$/,$d'`
  mail_comment=`echo "$full_log" | sed '/^Comment:$/,$!d; //d'`
  full_log=`echo "$full_log" | sed '/^Comment:$/,$d'`
  mail_title=`echo "$full_log" | sed '/^Title: */!d;s///'`
  ensure_not_empty 'commit title' "$mail_title"
  mail_title=`echo "$mail_title" | sed "$sed_eval_tags; $sed_escape"`
  sed_eval_tags="$sed_eval_tags; s@<TITLE>@$mail_title@g"
  mail_comment=`echo "$mail_comment" | sed "$sed_eval_tags"`
  chlog_entry=`echo "$chlog_entry" | sed "$sed_eval_tags; 1{
  /^ *$/d
  }"`
  mail_subject=`echo "$full_log" | sed '/^Subject: */!d;s///'`
  ensure_not_empty 'mail subject' "$mail_subject"
  mail_subject=`echo "$mail_subject" | sed "$sed_eval_tags"`
  mail_to=`echo "$full_log" | sed '/^To:/!d'`
  send_a_mail=yes
  if test x"$mail_to" = x; then
    send_a_mail=no
  else
    mail_to=`echo "$mail_to" | sed 's/^To: *//'`
    ensure_not_empty '"To:" field of the mail' "$mail_to"
  fi
  mail_from=`echo "$full_log" | sed '/^From: */!d;s///'`
  ensure_not_empty '"From:" field of the mail' "$mail_from"

  # Check whether the user passed -m | --message
  i=0; has_message=0
  while [ $i -lt $# ]; do
    arg="$1"
    # This is not really a reliable way of knowing whether -m | --message was
    # passed but hum... Let's assume it'll do :s
    test x"$arg" = 'x-m' && has_message=1
    test x"$arg" = 'x--message' && has_message=1
    shift
    set dummy "$@" "$arg"
    shift
    i=`expr $i + 1`
  done
  if [ $has_message -eq 0 ]; then
    my_message=`echo "$chlog_entry" | grep -v "^$YYYY-$MM-$DD" | sed '1,2 {
    /^ *$/d
    }'`
    set dummy --message "$my_message" "$@"
    shift
  else
    notice 'you are overriding the commit message.'
  fi

  # Are you sure?
  yesno 'Are you sure you want to commit?' || return 1

  # Add the ChangeLog entry
  old_chlog=`get_unique_file_name "$change_log_dir/ChangeLog.old"`
  mv "$change_log_dir/ChangeLog" "$old_chlog" || \
    abort 'Could not backup ChangeLog'
  trap "echo SIGINT; mv \"$old_chlog\" \"$change_log_dir/ChangeLog\";
        exit 130" SIGINT
  echo "$chlog_entry" >"$change_log_dir/ChangeLog"
  echo >>"$change_log_dir/ChangeLog"
  cat "$old_chlog" >>"$change_log_dir/ChangeLog"

  # Add extra files such as cwd or ChangeLog to the commit.
  tmp_sed='s/ /\\ /g' # Escape spaces for the shell.
  extra_files=`echo "$extra_files" | sed "$tmp_sed" | tr ':' '\n'`
  set dummy "$@" $extra_files
  shift

  # --Commit-- finally! :D
  $SVN commit "$@" || {
    svn_commit_rv=$?
    mv "$old_chlog" "$change_log_dir/ChangeLog"
    abort "Commit failed, $SVN returned $svn_commit_rv"
  }
  svn_commit_rv=$?

  mail_file=`get_unique_file_name "$change_log_dir/+mail"`
  echo "\
From: $mail_from
To: $mail_to
Subject: $mail_subject

$mail_comment

ChangeLog:
$chlog_entry

$svn_diff_stat

$svn_diff" | sed 's/^\.$/ ./' >"$mail_file"
    # We change lines with only a `.' because they could mean "end-of-mail"

  # Send the mail
  if test x$send_a_mail = xyes; then
    trap 'echo SIGINT; exec < /dev/null' SIGINT
    my_sendmail "$mail_file" "$mail_subject" "$mail_to" \
                "X-svn-url: $repos_root
                 X-svn-revision: $REV"
  fi # end do we have to send a mail?
  rm -f "$tmp_log"
  rm -f "$old_chlog"
  save_mail_file=`echo "$mail_file" | sed 's/+//'`
  mkdir -p "$change_log_dir/+committed" \
    || warn "Couldn't mkdir -p $change_log_dir/+committed"
  if [ -d "$change_log_dir/vcs" ] \
     || [ -d "$change_log_dir/+committed" ]
  then
    mkdir -p "$change_log_dir/+committed/$REV" \
      && mv "$mail_file" "$change_log_dir/+committed/$REV/mail"
  fi
  return $svn_commit_rv
}

# svn_merge args...
svn_merge()
{
  i=0; src=''; dst=''; rev1=''; rev2=''; r_seen=0
  while [ $i -lt $# ]; do
    arg="$1"
    if test -d "$arg"; then
      if [ x"$src" = x ]; then
        src="$arg"
      elif [ x"$dst" = x ]; then
        dst="$arg"
      fi
    else
      case "$arg" in
        -r*:*) rev1=`echo "$arg" | sed 's/^[^PREVHEAD0-9]*//; s/:.*//'`
               rev2=`echo "$arg" | sed 's/^.*://; s/[^PREVHEAD0-9]*//'`
               ;;
        -r) r_seen=1 ;;
      esac
    fi
    shift
    set dummy "$@" "$arg"
    shift
    i=`expr $i + 1`
  done
  if [ x"$src" = x ]; then
    exec $SVN merge "$@"
  fi
  test x"$dst" = x && dst='.'

  if yesno "Do you want to use the automerge feature for $src ?";
  then :; else
    exec $SVN merge "$@"
  fi
  # FIXME: Incomplete.
}

# svn_automerge src-path dst-path
svn_automerge()
{
  test -f ChangeLog || abort 'You must use automerge in the folder where the
                              ChangeLog is.'
  amerge=`$SVN propget automerge`
  if [ x"$amerge" = x ]; then
    # FIXME: Use svn log --stop-on-copy to detect the original branching.
    :
  fi

  svn_info_tmp=`$SVN info`
  REV=`echo "$svn_info_tmp" | sed '/^Revision: /!d;s///'`
  test x"$REV" = x && REV=`echo "$svn_info_tmp" \
                           | sed '/^Last Changed Rev: /!d;s///'`
  test x"$REV" = x && abort 'Cannot detect the current revision.'

  # FIXME: Incomplete.
  if yesno "Are you sure you want to run:
            $SVN merge -r$amerge:$REV $1 $2 ?"; then
    $SVN merge "-r$amerge:$REV" "$1" "$2"
  fi
}

# svn_diffw [args...]
svn_diffw()
{
  # Ignore white spaces. Can't svn diff -x -w: svn 1.4 only.
  $SVN diff --no-diff-deleted --diff-cmd diff -x -uw "$@"
}

# svn_mail REV [mails...]
svn_mail()
{
  test $# -lt 1 && abort "Not enough arguments provided;
                          Try 'svn help mail' for more info."
  case "$1" in
    PREV)
      REV=`svn_revision || abort 'Cannot get current revision number'`
      test x"$REV" = x && abort 'Cannot get current revision number'
      if [ "$REV" -lt 1 ]; then
        abort 'No previous revision.'
      fi
      REV=`expr "$REV" - 1`
      ;;
    HEAD)
      REV=`svn_revision || abort 'Cannot get current revision number'`
      test x"$REV" = x && abort 'Cannot get current revision number'
      ;;
    *[^0-9]*) abort "Syntax error in revision argument '$1'";;
    *) REV="$1";;
  esac
  shift

  found_committed=0; found=0 
  while [ $found -eq 0 ]; do
    this_chlog_dir=`pwd -P`
    if [ -d ./+committed ]; then
      found_committed=1
      if [ -d ./+committed/$REV ]; then
        found=1
      else
        cd ..
      fi
    else
      cd ..
    fi
    # Stop searching when in / ... hmz :P
    test x`pwd` = x/ && break
  done
  if [ $found -eq 0 ]; then
    if [ $found_committed -eq 0 ]; then
      abort 'Could not find the +committed directory.'
    else
      abort "Could not find the revision $REV in +committed."
    fi
    abort 'Internal error (should never be here).'
  fi

  mail_file=''; subject=''; to=''
  if [ -f ./+committed/$REV/mail ]; then
    # svn-wrapper generated file
    mail_file="./+committed/$REV/mail"
    subject=`sed '/^Subject: /!d;s///' $mail_file | sed '1q'`
    to=`sed '/^To: /!d;s///' $mail_file | sed '1q'`
  elif [ -f ./+committed/$REV/,iform ] && [ -f ./+committed/$REV/,message ]
  then
    # VCS-generated file
    subject=`sed '/^Subject: /!d;s///;s/^"//;s/"$//' ./+committed/$REV/,iform \
             | sed "s/<%= *rev *%>/$REV/g"`
    to=`sed '/^To:/,/^[^-]/!d' ./+committed/$REV/,iform | sed '1d;s/^- //;$d' \
        | xargs | sed 's/  */, /g'`
    mail_file=`get_unique_file_name "$TMPDIR/mail.r$REV"`
    echo "From: $FULLNAME <$EMAIL>
To: $to
Subject: $subject
" >"$mail_file" || abort "Cannot create $mail_file"
    cat ./+committed/$REV/,message >>"$mail_file" \
    || abort "Cannot copy ./+committed/$REV/,message in $mail_file"
  else
    abort "Couldn't find the mail to re-send in `pwd`/+committed/$REV"
  fi
  if [ $# -gt 0 ]; then
    to=`echo "$*" | sed 's/  */, /g'`
  fi

  test x"$to" = x && abort 'Cannot find the list of recipients.
                            Please report this bug.'
  test x"$subject" = x && abort 'Cannot find the subject of the mail.
                                 Please report this bug.'

  if yesno "Re-sending the mail of r$REV
Subject: $subject
To: $to
Are you sure?"; then :; else
    return 1
  fi

  svn_info_tmp=`$SVN info`
  test $? -ne 0 && abort "Failed to get svn info on `pwd`"
  repos_root=`echo "$svn_info_tmp" | sed '/^Repository Root: /!d;s///'`
  # It looks like svn <1.3 didn't display a "Repository Root" entry.
  test x"$repos_root" = x && \
    repos_root=`echo "$svn_info_tmp" | sed '/^URL: /!d;s///'`

  my_sendmail "$mail_file" "$subject" "$to" \
              "X-svn-url: $repos_root
               X-svn-revision: $REV"
}

# svn_version
svn_version()
{
  echo "Using svn-wrapper v$version (C) SIGOURE Benoit [GPL]"
  sed '/^# $Id[:].*$/!d;s/.*$Id[:] *//;s/ *$ *//;s/ \([0-9][0-9]*\)/ (r\1)/' "$me"
}

# has_prop prop-name [path]
# return value: 0 -> path has the property prop-name set.
#               1 -> path has no property prop-name.
#               2 -> svn error.
has_prop()
{
  hp_plist=`$SVN proplist "$2"`
  test $? -ne 0 && return 2
  hp_res=`echo "$hp_plist" | sed "/^ *$1\$/!d"`
  test x"$hp_res" = x && return 1
  return 0
}

# svn_propadd prop-name prop-val [path]
svn_propadd()
{
  test $# -lt 2 \
  && abort 'Not enough arguments provided;
            try `svn help propadd` for more info'
  test $# -gt 3 \
  && abort 'Too many arguments provided;
            try `svn help propadd` for more info'

  path="$3"
  test x"$path" = x && path='.' && set dummy "$@" '.' && shift
  has_prop "$1" "$3" || {
    test $? -eq 2 && return 1 # svn error
    # no property found:
    yesno "'$path' has no property named '$1', do you want to add it?" \
    && $SVN propset "$@"
    return $?
  }

  current_prop_val=`$SVN propget "$1" "$3"`
  test $? -ne 0 && abort "Failed to get the current value of property '$1'."

  $SVN propset "$1" "$current_prop_val
$2" "$3" >/dev/null || abort "Failed to add '$3' in the property '$1'."

  current_prop_val=`$SVN propget "$1" "$3" || echo "$current_prop_val
$2"`
  echo "property '$1' updated on '$path', new value:
$current_prop_val"
}

# svn_propsed prop-name sed-script [path]
svn_propsed()
{
  test $# -lt 2 \
  && abort 'Not enough arguments provided;
            try `svn help propsed` for more info'
  test $# -gt 3 \
  && abort 'Too many arguments provided;
            try `svn help propsed` for more info'

  path="$3"
  test x"$path" = x && path='.'
  has_prop "$1" "$3" || {
    test $? -eq 2 && return 1 # svn error
    # no property found:
    abort "'$path' has no property named '$1'."
  }

  prop_val=`$SVN propget "$1" "$3"`
  test $? -ne 0 && abort "Failed to get the current value of property '$1'."

  prop_val=`echo "$prop_val" | sed "$2"`
  test $? -ne 0 && abort "Failed to run the sed script '$2'."

  $SVN propset "$1" "$prop_val" "$3" >/dev/null \
  || abort "Failed to update the property '$1' with value '$prop_val'."

  new_prop_val=`$SVN propget "$1" "$3" || echo "$prop_val"`
  echo "property '$1' updated on '$path', new value:
$new_prop_val"
}

# svn_revision [args...]
svn_revision()
{
  svn_revision_info_out=`$SVN info "$@"`
  svn_revision_rv=$?
  echo "$svn_revision_info_out" | sed '/^Revision: /!d;s///'
  return $svn_revision_rv
}

# svn_ignore [paths]
svn_ignore()
{
  if [ $# -eq 0 ]; then  # Simply display ignore-list.
    $SVN propget 'svn:ignore'
  elif [ $# -eq 1 ]; then
    if [ -d "$1" ]; then # Display ignore-list.
      $SVN propget 'svn:ignore' "$1"
    else                 # Add in ignore-list.
      svn_propadd 'svn:ignore' `dirname "$1"` `basename "$1"`
    fi
  else                   # Add arguments in svn:ignore.
    # This part is a bit tricky:
    # For each argument, we find all the other arguments with the same dirname
    # $dname and we svn:ignore them all in $dname.
    while [ $# -ne 0 ]; do
      arg="$1"
      dname=`dirname "$1"`
      files=`basename "$1"`
      shift
      j=0; argc=$#
      while [ $j -lt $argc ] && [ $# -ne 0 ]; do
        this_arg="$1"
        shift
        this_dname=`dirname "$this_arg"`
        this_file=`basename "$this_arg"`
        if [ x"$dname" = x"$this_dname" ]; then
          files="$files
$this_file"
        else
          set dummy "$@" "$this_arg"
          shift
        fi
        j=`expr $j + 1`
      done
      svn_propadd 'svn:ignore' "$files" "$dname"
    done
  fi
}

# svn_help
svn_help()
{
  if [ $# -eq 0 ]; then
    svn_version
    $SVN help
    rv=$?
    echo '
Additionnal commands provided by svn-wrapper:
  automerge (amerge, am)
  diffstat (ds)
  diffw (dw)
  ignore
  mail
  propadd (padd, pa)
  propsed (psed)
  revision (rev)
  touch
  selfupdate (selfup)
  version'
    return $rv
  else
    case $1 in
      automerge | auto-merge | amerge | am)
        echo 'automerge (amerge, am): FIXME
usage: automerge FIXME

FIXME' # FIXME
        ;;
      diffstat | ds)
        require_diffstat
        echo 'diffstat (ds): Display the histogram from svn diff-output.'
        $SVN help diff | sed '1d;
                              s/differences*/histogram/;
                              2,35 s/diff/diffstat/g'
        ;;
      diffw | dw)
        echo "diffw (dw): Display the differences without taking whitespaces\
 into account."
 $SVN help diff | sed '1d;
                       2,35 s/diff\([^a-z]\)/diffw\1/g;
                       /--diff-cmd/,/--no-diff-deleted/d'
        ;;
      ignore)
        echo 'ignore: Add some files in the svn:ignore property.
usage: 1. ignore [PATH]
       2. ignore FILE [FILES...] [PATH]

 1. Display the value of svn:ignore property on [PATH].
 2. Add some files in the svn:ignore property of [PATH].

If you want to add directories in the ignore-list, be careful:
    svn ignore foo/ bar/
will add "foo/" in the property svn:ignore within the directory bar!
Instead use:
    svn ignore foo/ bar/ .
(It'\''s somewhat like with mv)

Valid options:
  None.'
        ;;
      mail)
        echo 'mail: Resend the mail of a given commit.
usage: mail REV [emails]

REV must have an email file associated in +committed/REV.
REV can also be PREV or HEAD.

By default the mail is sent to same email addresses as during the original
commit unless more arguments are given.'
        ;;
      propadd | padd | pa)
        echo 'propadd (padd, pa): Add something in the value of a property.
usage: propadd PROPNAME PROPVAL PATH

PROPVAL will be appended at the end of the property PROPNAME.

Valid options:
  None.'
        ;;
      propsed | psed)
        echo 'propsed (psed): Edit a property with sed.
usage: propsed PROPNAME SED-ARGS PATH

eg: svn propsed svn:externals "s/http/https/" .

Valid options:
  None.'
        ;;
      revision | rev)
        echo 'revision (rev): Display the revision number of a local or remote item.'
        $SVN help info | sed '1d;
                              s/information/revision/g;
                              s/revision about/the revision of/g;
                              2,35 s/info/revision/g;
                              /-xml/d'
        ;;
      touch)
        echo 'touch: Touch a file and svn add it.
usage: touch FILE [FILES]...

Valid options:
  None.'
        ;;
      selfupdate | selfup | self-update | self-up)
        echo 'selfupdate (selfup): Attempt to update svn-wrapper.sh
usage: selfupdate

Valid options:
  None.'
        ;;
      version)
        echo 'version: Display the version info of svn and svn-wrapper.
usage: version

Valid options:
  None.'
        ;;
      *) $SVN help "$@";;
    esac
  fi
}

# svn_status [args...]
svn_status()
{
  svn_status_out=`$SVN status "$@"`
  svn_status_rv=$?
  test x"$svn_status_out" = x && return $svn_status_rv
  echo "$svn_status_out" | sed "$sed_svn_st_color"
  return $svn_status_rv
}

# svn_update [args...]
svn_update()
{
  svn_update_out=`$SVN update "$@"`
  svn_update_rv=$?
  echo "$svn_update_out" | sed "$sed_svn_up_colors"
  return $svn_update_rv
}

  # ------------------- #
  # `main' starts here. #
  # ------------------- #

# Define colors if stdout is a tty.
if test -t 1; then
  set_colors
else # stdout isn't a tty => don't print colors.
  set_nocolors
fi

# Consider this as a sed function :P.
sed_svn_st_color="
    t dummy_sed_1
    : dummy_sed_1
    s@^?\\(......\\)+@+\\1+@
    s@^?\\(......\\)\\(.*/\\)+@+\\1\\2+@
    s@^?\\(......\\),@,\\1,@
    s@^?\\(......\\)\\(.*/\\),@,\\1\\2,@
    s/^\\(.\\)C/\\1${lred}C${std}/
    t dummy_sed_2
    : dummy_sed_2
    s/^?/${lred}?${std}/;  t
    s/^M/${lgreen}M${std}/;  t
    s/^A/${lgreen}A${std}/;  t
    s/^X/${lblue}X${std}/;   t
    s/^+/${lyellow}+${std}/; t
    s/^D/${lyellow}D${std}/; t
    s/^,/${lred},${std}/;    t
    s/^C/${lred}C${std}/;    t
    s/^I/${purple}I${std}/;  t
    s/^R/${lblue}R${std}/;   t
    s/^!/${lred}!${std}/;    t
    s/^~/${lwhite}~${std}/;  t"

sed_svn_up_colors="
    t dummy_sed_1
    : dummy_sed_1
    $           q
    /^Updated/  t
    /^Fetching/ t
    /^External/ t
    s/^\\(.\\)C/\\1${lred}C${std}/
    s/^\\(.\\)U/\\1${lgreen}U${std}/
    s/^\\(.\\)D/\\1${lred}D${std}/
    t dummy_sed_2
    : dummy_sed_2
    s/^A/${lgreen}A${std}/;  t
    s/^U/${lgreen}U${std}/;  t
    s/^D/${lyellow}D${std}/; t
    s/^G/${purple}G${std}/;  t
    s/^C/${lred}C${std}/;    t"

# For dev's:
test "x$1" = x--debug && shift && set -x

case "$1" in
  # ------------------------------- #
  # Hooks for standard SVN commands #
  # ------------------------------- #
  commit | ci)
    shift
    svn_commit "$@"
    ;;
  help | \? | h)
    shift
    svn_help "$@"
    ;;
# FIXME: Incomplete
#  merge)
#    shift
#    svn_merge "$@"
#    ;;
  status | stat | st)
    shift
    svn_status "$@"
    ;;
  update | up)
    shift
    svn_update "$@"
    ;;
  # -------------------- #
  # Custom SVN commands  #
  # -------------------- #
  automerge | auto-merge | amerge | am)
    shift
    if [ $# -ne 2 ]; then
      abort "automerge: not enough arguments provided;
             try 'svn help automerge' for more info"
    fi
    svn_automerge "$@"
    ;;
  diffstat | ds)
    shift
    require_diffstat && $SVN diff "$@" | diffstat
    ;;
  diffw | dw)
    shift
    svn_diffw "$@"
    ;;
  ignore)
    shift
    svn_ignore "$@"
    ;;
  mail)
    shift
    svn_mail "$@"
    ;;
  propadd | padd | pa)
    shift
    svn_propadd "$@"
    ;;
  propsed | psed)
    shift
    svn_propsed "$@"
    ;;
  revision | rev)
    shift
    svn_revision "$@"
    ;;
  touch)
    shift
    touch "$@" && svn add "$@"
    ;;
  selfupdate | selfup | self-update | self-up)
    shift
    selfupdate "$@"
    ;;
  version | -version | --version)
    shift
    set dummy '--version' "$@"
    shift
    svn_version
    exec $SVN "$@"
    ;;
  *) exec $SVN "$@"
    ;;
esac