Remove trailing spaces

contrib/bash_completion

@@ -1,502 +1,502 b''
 # bash completion for the Mercurial distributed SCM
 
 # Docs:
 #
 # If you source this file from your .bashrc, bash should be able to
 # complete a command line that uses hg with all the available commands
 # and options and sometimes even arguments.
 #
 # Mercurial allows you to define additional commands through extensions.
 # Bash should be able to automatically figure out the name of these new
 # commands and their options.  See below for how to define _hg_opt_foo
 # and _hg_cmd_foo functions to fine-tune the completion for option and
 # non-option arguments, respectively.
 #
 #
 # Notes about completion for specific commands:
 #
 # - the completion function for the email command from the patchbomb
 #   extension will try to call _hg_emails to get a list of e-mail
 #   addresses.  It's up to the user to define this function.  For
 #   example, put the addresses of the lists that you usually patchbomb
 #   in ~/.patchbomb-to and the addresses that you usually use to send
 #   the patchbombs in ~/.patchbomb-from and use something like this:
 #
 #      _hg_emails()
 #      {
 #          if [ -r ~/.patchbomb-$1 ]; then
 #              cat ~/.patchbomb-$1
 #          fi
 #      }
-# 
+#
 #
 # Writing completion functions for additional commands:
 #
 # If it exists, the function _hg_cmd_foo will be called without
 # arguments to generate the completion candidates for the hg command
 # "foo".  If the command receives some arguments that aren't options
 # even though they start with a "-", you can define a function called
 # _hg_opt_foo to generate the completion candidates.  If _hg_opt_foo
 # doesn't return 0, regular completion for options is attempted.
 #
 # In addition to the regular completion variables provided by bash,
 # the following variables are also set:
 # - $hg - the hg program being used (e.g. /usr/bin/hg)
 # - $cmd - the name of the hg command being completed
 # - $cmd_index - the index of $cmd in $COMP_WORDS
 # - $cur - the current argument being completed
 # - $prev - the argument before $cur
 # - $global_args - "|"-separated list of global options that accept
 #                  an argument (e.g. '--cwd|-R|--repository')
 # - $canonical - 1 if we canonicalized $cmd before calling the function
 #                0 otherwise
-# 
+#
 
 shopt -s extglob
 
 _hg_commands()
 {
     local commands
     commands="$("$hg" debugcomplete "$cur" 2>/dev/null)" || commands=""
     COMPREPLY=(${COMPREPLY[@]:-} $(compgen -W '$commands' -- "$cur"))
 }
 
 _hg_paths()
 {
     local paths="$("$hg" paths 2>/dev/null | sed -e 's/ = .*$//')"
     COMPREPLY=(${COMPREPLY[@]:-} $(compgen -W '$paths' -- "$cur"))
 }
 
 _hg_repos()
 {
     local i
     for i in $(compgen -d -- "$cur"); do
 	test ! -d "$i"/.hg || COMPREPLY=(${COMPREPLY[@]:-} "$i")
     done
 }
 
 _hg_status()
 {
     local files="$("$hg" status -n$1 . 2>/dev/null)"
     COMPREPLY=(${COMPREPLY[@]:-} $(compgen -W '$files' -- "$cur"))
 }
 
 _hg_tags()
 {
     local tags="$("$hg" tags -q 2>/dev/null)"
     local IFS=$'\n'
     COMPREPLY=(${COMPREPLY[@]:-} $(compgen -W '$tags' -- "$cur"))
 }
 
 # this is "kind of" ugly...
 _hg_count_non_option()
 {
     local i count=0
     local filters="$1"
 
     for ((i=1; $i<=$COMP_CWORD; i++)); do
 	if [[ "${COMP_WORDS[i]}" != -* ]]; then
 	    if [[ ${COMP_WORDS[i-1]} == @($filters|$global_args) ]]; then
 		continue
 	    fi
 	    count=$(($count + 1))
 	fi
     done
 
     echo $(($count - 1))
 }
 
 _hg()
 {
     local cur prev cmd cmd_index opts i
     # global options that receive an argument
     local global_args='--cwd|-R|--repository'
     local hg="$1"
     local canonical=0
 
     COMPREPLY=()
     cur="$2"
     prev="$3"
 
     # searching for the command
     # (first non-option argument that doesn't follow a global option that
     #  receives an argument)
     for ((i=1; $i<=$COMP_CWORD; i++)); do
 	if [[ ${COMP_WORDS[i]} != -* ]]; then
 	    if [[ ${COMP_WORDS[i-1]} != @($global_args) ]]; then
 		cmd="${COMP_WORDS[i]}"
 		cmd_index=$i
 		break
 	    fi
 	fi
     done
 
     if [[ "$cur" == -* ]]; then
 	if [ "$(type -t "_hg_opt_$cmd")" = function ] && "_hg_opt_$cmd"; then
 	    return
 	fi
 
 	opts=$("$hg" debugcomplete --options "$cmd" 2>/dev/null)
 
 	COMPREPLY=(${COMPREPLY[@]:-} $(compgen -W '$opts' -- "$cur"))
 	return
     fi
 
     # global options
     case "$prev" in
 	-R|--repository)
 	    _hg_paths
 	    _hg_repos
 	    return
 	;;
 	--cwd)
 	    # Stick with default bash completion
 	    return
 	;;
     esac
 
     if [ -z "$cmd" ] || [ $COMP_CWORD -eq $i ]; then
 	_hg_commands
 	return
     fi
 
     # try to generate completion candidates for whatever command the user typed
     local help
     if _hg_command_specific; then
 	return
     fi
 
     # canonicalize the command name and try again
     help=$("$hg" help "$cmd" 2>/dev/null)
     if [ $? -ne 0 ]; then
 	# Probably either the command doesn't exist or it's ambiguous
 	return
     fi
     cmd=${help#hg }
     cmd=${cmd%%[$' \n']*}
     canonical=1
     _hg_command_specific
 }
 
 _hg_command_specific()
 {
     if [ "$(type -t "_hg_cmd_$cmd")" = function ]; then
 	"_hg_cmd_$cmd"
 	return 0
     fi
 
     if [ "$cmd" != status ] && [ "$prev" = -r ] || [ "$prev" == --rev ]; then
 	if [ $canonical = 1 ]; then
 	    _hg_tags
 	    return 0
 	elif [[ status != "$cmd"* ]]; then
 	    _hg_tags
 	    return 0
 	else
 	    return 1
 	fi
     fi
 
     case "$cmd" in
 	help)
 	    _hg_commands
 	;;
 	export)
 	    if _hg_ext_mq_patchlist qapplied && [ "${COMPREPLY[*]}" ]; then
 		return 0
 	    fi
 	    _hg_tags
 	;;
 	manifest|update)
 	    _hg_tags
 	;;
 	pull|push|outgoing|incoming)
 	    _hg_paths
 	    _hg_repos
 	;;
 	paths)
 	    _hg_paths
 	;;
 	add)
 	    _hg_status "u"
 	;;
 	commit)
 	    _hg_status "mar"
 	;;
 	remove)
 	    _hg_status "d"
 	;;
 	forget)
 	    _hg_status "a"
 	;;
 	diff)
 	    _hg_status "mar"
 	;;
 	revert)
 	    _hg_status "mard"
 	;;
 	clone)
 	    local count=$(_hg_count_non_option)
 	    if [ $count = 1 ]; then
 		_hg_paths
 	    fi
 	    _hg_repos
 	;;
 	debugindex|debugindexdot)
 	    COMPREPLY=(${COMPREPLY[@]:-} $(compgen -f -X "!*.i" -- "$cur"))
 	;;
 	debugdata)
 	    COMPREPLY=(${COMPREPLY[@]:-} $(compgen -f -X "!*.d" -- "$cur"))
 	;;
 	*)
 	    return 1
 	;;
     esac
 
     return 0
 }
 
 complete -o bashdefault -o default -F _hg hg 2>/dev/null \
     || complete -o default -F _hg hg
 
 
 # Completion for commands provided by extensions
 
 # mq
 _hg_ext_mq_patchlist()
 {
     local patches
     patches=$("$hg" $1 2>/dev/null)
     if [ $? -eq 0 ] && [ "$patches" ]; then
 	COMPREPLY=(${COMPREPLY[@]:-} $(compgen -W '$patches' -- "$cur"))
 	return 0
     fi
     return 1
 }
 
 _hg_ext_mq_queues()
 {
     local root=$("$hg" root 2>/dev/null)
     local n
     for n in $(cd "$root"/.hg && compgen -d -- "$cur"); do
 	# I think we're usually not interested in the regular "patches" queue
 	# so just filter it.
 	if [ "$n" != patches ] && [ -e "$root/.hg/$n/series" ]; then
 	    COMPREPLY=(${COMPREPLY[@]:-} "$n")
 	fi
     done
 }
 
 _hg_cmd_qpop()
 {
     if [[ "$prev" = @(-n|--name) ]]; then
 	_hg_ext_mq_queues
 	return
     fi
     _hg_ext_mq_patchlist qapplied
 }
 
 _hg_cmd_qpush()
 {
     if [[ "$prev" = @(-n|--name) ]]; then
 	_hg_ext_mq_queues
 	return
     fi
     _hg_ext_mq_patchlist qunapplied
 }
 
 _hg_cmd_qdelete()
 {
     local qcmd=qunapplied
     if [[ "$prev" = @(-r|--rev) ]]; then
 	qcmd=qapplied
     fi
     _hg_ext_mq_patchlist $qcmd
 }
 
 _hg_cmd_qsave()
 {
     if [[ "$prev" = @(-n|--name) ]]; then
 	_hg_ext_mq_queues
 	return
     fi
 }
 
 _hg_cmd_strip()
 {
     _hg_tags
 }
 
 _hg_cmd_qcommit()
 {
     local root=$("$hg" root 2>/dev/null)
     # this is run in a sub-shell, so we can't use _hg_status
     local files=$(cd "$root/.hg/patches" 2>/dev/null &&
                   "$hg" status -nmar 2>/dev/null)
     COMPREPLY=(${COMPREPLY[@]:-} $(compgen -W '$files' -- "$cur"))
 }
 
 _hg_cmd_qfold()
 {
     _hg_ext_mq_patchlist qunapplied
 }
 
 _hg_cmd_qrename()
 {
     _hg_ext_mq_patchlist qseries
 }
 
 _hg_cmd_qheader()
 {
     _hg_ext_mq_patchlist qseries
 }
 
 _hg_cmd_qclone()
 {
     local count=$(_hg_count_non_option)
     if [ $count = 1 ]; then
 	_hg_paths
     fi
     _hg_repos
 }
 
 _hg_ext_mq_guards()
 {
     "$hg" qselect --series 2>/dev/null | sed -e 's/^.//'
 }
 
 _hg_cmd_qselect()
 {
     local guards=$(_hg_ext_mq_guards)
     COMPREPLY=(${COMPREPLY[@]:-} $(compgen -W '$guards' -- "$cur"))
 }
 
 _hg_cmd_qguard()
 {
     local prefix=''
 
     if [[ "$cur" == +* ]]; then
 	prefix=+
     elif [[ "$cur" == -* ]]; then
 	prefix=-
     fi
     local ncur=${cur#[-+]}
 
     if ! [ "$prefix" ]; then
 	_hg_ext_mq_patchlist qseries
 	return
     fi
 
     local guards=$(_hg_ext_mq_guards)
     COMPREPLY=(${COMPREPLY[@]:-} $(compgen -P $prefix -W '$guards' -- "$ncur"))
 }
 
 _hg_opt_qguard()
 {
     local i
     for ((i=cmd_index+1; i<=COMP_CWORD; i++)); do
 	if [[ ${COMP_WORDS[i]} != -* ]]; then
 	    if [[ ${COMP_WORDS[i-1]} != @($global_args) ]]; then
 		_hg_cmd_qguard
 		return 0
 	    fi
 	elif [ "${COMP_WORDS[i]}" = -- ]; then
 	    _hg_cmd_qguard
 	    return 0
 	fi
     done
     return 1
 }
 
 
 # hbisect
 _hg_cmd_bisect()
 {
     local i subcmd
 
     # find the sub-command
     for ((i=cmd_index+1; i<=COMP_CWORD; i++)); do
 	if [[ ${COMP_WORDS[i]} != -* ]]; then
 	    if [[ ${COMP_WORDS[i-1]} != @($global_args) ]]; then
 		subcmd="${COMP_WORDS[i]}"
 		break
 	    fi
 	fi
     done
 
     if [ -z "$subcmd" ] || [ $COMP_CWORD -eq $i ] || [ "$subcmd" = help ]; then
-	COMPREPLY=(${COMPREPLY[@]:-} 
+	COMPREPLY=(${COMPREPLY[@]:-}
 		   $(compgen -W 'bad good help init next reset' -- "$cur"))
 	return
     fi
 
     case "$subcmd" in
 	good|bad)
 	    _hg_tags
 	    ;;
     esac
 
     return
 }
 
 
 # patchbomb
 _hg_cmd_email()
 {
     case "$prev" in
 	-c|--cc|-t|--to|-f|--from|--bcc)
-	    # we need an e-mail address. let the user provide a function 
+	    # we need an e-mail address. let the user provide a function
 	    # to get them
 	    if [ "$(type -t _hg_emails)" = function ]; then
 		local arg=to
 		if [[ "$prev" == @(-f|--from) ]]; then
 		    arg=from
 		fi
 		local addresses=$(_hg_emails $arg)
 		COMPREPLY=(${COMPREPLY[@]:-}
 			   $(compgen -W '$addresses' -- "$cur"))
 	    fi
 	    return
 	    ;;
 	-m|--mbox)
 	    # fallback to standard filename completion
 	    return
 	    ;;
 	-s|--subject)
 	    # free form string
 	    return
 	    ;;
     esac
 
     _hg_tags
     return
 }
 
 
 # gpg
 _hg_cmd_sign()
 {
     _hg_tags
 }
 
 
 # transplant
 _hg_cmd_transplant()
 {
     case "$prev" in
 	-s|--source)
 	    _hg_paths
 	    _hg_repos
 	    return
 	    ;;
 	--filter)
 	    # standard filename completion
 	    return
 	    ;;
     esac
 
     # all other transplant options values and command parameters are revisions
     _hg_tags
     return
 }
 

contrib/hgdiff

@@ -1,105 +1,105 b''
 #!/usr/bin/env python
 
 import os, sys, struct, stat
 import difflib
 import re
 from optparse import OptionParser
 from mercurial.bdiff import bdiff, blocks
 from mercurial.mdiff import bunidiff, diffopts
 
 VERSION="0.3"
 usage = "usage: %prog [options] file1 file2"
 parser = OptionParser(usage=usage)
 
 parser.add_option("-d", "--difflib", action="store_true", default=False)
 parser.add_option('-x', '--count', default=1)
 parser.add_option('-c', '--context', type="int", default=3)
 parser.add_option('-p', '--show-c-function', action="store_true", default=False)
-parser.add_option('-w', '--ignore-all-space', action="store_true", 
+parser.add_option('-w', '--ignore-all-space', action="store_true",
                   default=False)
 
 (options, args) = parser.parse_args()
 
 if not args:
     parser.print_help()
     sys.exit(1)
 
 # simple utility function to put all the
 # files from a directory tree into a dict
 def buildlist(names, top):
     tlen = len(top)
     for root, dirs, files in os.walk(top):
         l = root[tlen + 1:]
         for x in files:
             p = os.path.join(root, x)
             st = os.lstat(p)
             if stat.S_ISREG(st.st_mode):
                 names[os.path.join(l, x)] = (st.st_dev, st.st_ino)
 
 def diff_files(file1, file2):
     if file1 == None:
         b = file(file2).read().splitlines(1)
         l1 = "--- %s\n" % (file2)
         l2 = "+++ %s\n" % (file2)
         l3 = "@@ -0,0 +1,%d @@\n" % len(b)
         l = [l1, l2, l3] + ["+" + e for e in b]
     elif file2 == None:
         a = file(file1).read().splitlines(1)
         l1 = "--- %s\n" % (file1)
         l2 = "+++ %s\n" % (file1)
         l3 = "@@ -1,%d +0,0 @@\n" % len(a)
         l = [l1, l2, l3] + ["-" + e for e in a]
     else:
         t1 = file(file1).read()
         t2 = file(file2).read()
         l1 = t1.splitlines(1)
         l2 = t2.splitlines(1)
         if options.difflib:
             l = difflib.unified_diff(l1, l2, file1, file2)
         else:
             l = bunidiff(t1, t2, l1, l2, file1, file2,
                          diffopts(context=options.context,
                                   showfunc=options.show_c_function,
                                   ignorews=options.ignore_all_space))
     for x in l:
         if x[-1] != '\n':
             x += "\n\ No newline at end of file\n"
         print x,
 
 file1 = args[0]
 file2 = args[1]
 
 if os.path.isfile(file1) and os.path.isfile(file2):
     diff_files(file1, file2)
 elif os.path.isdir(file1):
     if not os.path.isdir(file2):
         sys.stderr.write("file types don't match\n")
         sys.exit(1)
 
     d1 = {}
     d2 = {}
 
     buildlist(d1, file1)
     buildlist(d2, file2)
     keys = d1.keys()
     keys.sort()
     for x in keys:
         if x not in d2:
             f2 = None
         else:
             f2 = os.path.join(file2, x)
             st1 = d1[x]
             st2 = d2[x]
             del d2[x]
             if st1[0] == st2[0] and st1[1] == st2[1]:
                 sys.stderr.write("%s is a hard link\n" % x)
                 continue
         x = os.path.join(file1, x)
         diff_files(x, f2)
     keys = d2.keys()
     keys.sort()
     for x in keys:
         f1 = None
         x = os.path.join(file2, x)
         diff_files(f1, x)
 

contrib/hgsh/hgsh.c

@@ -1,439 +1,439 b''
 /*
  * hgsh.c - restricted login shell for mercurial
  *
  * Copyright 2006 Vadim Gelfer <[e-mail]>
  *
  * This software may be used and distributed according to the terms of the
  * GNU General Public License, incorporated herein by reference.
  *
  * this program is login shell for dedicated mercurial user account. it
  * only allows few actions:
  *
  * 1. run hg in server mode on specific repository. no other hg commands
  * are allowed. we try to verify that repo to be accessed exists under
  * given top-level directory.
  *
  * 2. (optional) forward ssh connection from firewall/gateway machine to
  * "real" mercurial host, to let users outside intranet pull and push
  * changes through firewall.
  *
  * 3. (optional) run normal shell, to allow to "su" to mercurial user, use
  * "sudo" to run programs as that user, or run cron jobs as that user.
  *
  * only tested on linux yet. patches for non-linux systems welcome.
  */
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE /* for asprintf */
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sysexits.h>
 #include <unistd.h>
 
 /*
  * user config.
  *
  * if you see a hostname below, just use first part of hostname. example,
  * if you have host named foo.bar.com, use "foo".
  */
 
 /*
  * HG_GATEWAY: hostname of gateway/firewall machine that people outside your
  * intranet ssh into if they need to ssh to other machines. if you do not
  * have such machine, set to NULL.
  */
 #ifndef HG_GATEWAY
 #define HG_GATEWAY     "gateway"
 #endif
 
 /*
  * HG_HOST: hostname of mercurial server. if any machine is allowed, set to
  * NULL.
  */
 #ifndef HG_HOST
 #define HG_HOST         "mercurial"
 #endif
 
 /*
  * HG_USER: username to log in from HG_GATEWAY to HG_HOST. if gateway and
  * host username are same, set to NULL.
  */
 #ifndef HG_USER
 #define HG_USER         "hg"
 #endif
 
 /*
  * HG_ROOT: root of tree full of mercurial repos. if you do not want to
  * validate location of repo when someone is try to access, set to NULL.
  */
 #ifndef HG_ROOT
 #define HG_ROOT         "/home/hg/repos"
 #endif
 
 /*
  * HG: path to the mercurial executable to run.
  */
 #ifndef HG
 #define HG              "/home/hg/bin/hg"
 #endif
 
 /*
  * HG_SHELL: shell to use for actions like "sudo" and "su" access to
  * mercurial user, and cron jobs. if you want to make these things
  * impossible, set to NULL.
  */
 #ifndef HG_SHELL
 #define HG_SHELL        NULL
 // #define HG_SHELL        "/bin/bash"
 #endif
 
 /*
  * HG_HELP: some way for users to get support if they have problem. if they
  * should not get helpful message, set to NULL.
  */
 #ifndef HG_HELP
 #define HG_HELP         "please contact [e-mail] for help."
 #endif
 
 /*
  * SSH: path to ssh executable to run, if forwarding from HG_GATEWAY to
  * HG_HOST. if you want to use rsh instead (why?), you need to modify
  * arguments it is called with. see forward_through_gateway.
  */
 #ifndef SSH
 #define SSH             "/usr/bin/ssh"
 #endif
 
 /*
  * tell whether to print command that is to be executed. useful for
  * debugging. should not interfere with mercurial operation, since
  * mercurial only cares about stdin and stdout, and this prints to stderr.
  */
 static const int debug = 0;
 
 static void print_cmdline(int argc, char **argv)
 {
     FILE *fp = stderr;
     int i;
 
     fputs("command: ", fp);
 
     for (i = 0; i < argc; i++) {
         char *spc = strpbrk(argv[i], " \t\r\n");
         if (spc) {
             fputc('\'', fp);
         }
         fputs(argv[i], fp);
         if (spc) {
             fputc('\'', fp);
         }
         if (i < argc - 1) {
             fputc(' ', fp);
         }
     }
     fputc('\n', fp);
     fflush(fp);
 }
 
 static void usage(const char *reason, int exitcode)
 {
     char *hg_help = HG_HELP;
 
     if (reason) {
         fprintf(stderr, "*** Error: %s.\n", reason);
     }
     fprintf(stderr, "*** This program has been invoked incorrectly.\n");
     if (hg_help) {
         fprintf(stderr, "*** %s\n", hg_help);
     }
     exit(exitcode ? exitcode : EX_USAGE);
 }
 
 /*
  * run on gateway host to make another ssh connection, to "real" mercurial
  * server. it sends its command line unmodified to far end.
  *
  * never called if HG_GATEWAY is NULL.
  */
 static void forward_through_gateway(int argc, char **argv)
 {
     char *ssh = SSH;
     char *hg_host = HG_HOST;
     char *hg_user = HG_USER;
     char **nargv = alloca((10 + argc) * sizeof(char *));
     int i = 0, j;
 
     nargv[i++] = ssh;
     nargv[i++] = "-q";
     nargv[i++] = "-T";
     nargv[i++] = "-x";
     if (hg_user) {
         nargv[i++] = "-l";
         nargv[i++] = hg_user;
     }
     nargv[i++] = hg_host;
 
     /*
      * sshd called us with added "-c", because it thinks we are a shell.
      * drop it if we find it.
      */
     j = 1;
     if (j < argc && strcmp(argv[j], "-c") == 0) {
         j++;
     }
 
     for (; j < argc; i++, j++) {
         nargv[i] = argv[j];
     }
     nargv[i] = NULL;
 
     if (debug) {
         print_cmdline(i, nargv);
     }
 
     execv(ssh, nargv);
     perror(ssh);
     exit(EX_UNAVAILABLE);
 }
 
 /*
  * run shell. let administrator "su" to mercurial user's account to do
  * administrative works.
  *
  * never called if HG_SHELL is NULL.
  */
 static void run_shell(int argc, char **argv)
 {
     char *hg_shell = HG_SHELL;
     char **nargv;
     char *c;
     int i;
 
     nargv = alloca((argc + 3) * sizeof(char *));
     c = strrchr(hg_shell, '/');
 
     /* tell "real" shell it is login shell, if needed. */
 
     if (argv[0][0] == '-' && c) {
         nargv[0] = strdup(c);
         if (nargv[0] == NULL) {
             perror("malloc");
             exit(EX_OSERR);
         }
         nargv[0][0] = '-';
     } else {
         nargv[0] = hg_shell;
     }
 
     for (i = 1; i < argc; i++) {
         nargv[i] = argv[i];
     }
     nargv[i] = NULL;
 
     if (debug) {
         print_cmdline(i, nargv);
     }
 
     execv(hg_shell, nargv);
     perror(hg_shell);
     exit(EX_OSFILE);
 }
 
 enum cmdline {
     hg_init,
     hg_serve,
 };
 
-    
+
 /*
  * attempt to verify that a directory is really a hg repo, by testing
  * for the existence of a subdirectory.
  */
 static int validate_repo(const char *repo_root, const char *subdir)
 {
     char *abs_path;
     struct stat st;
     int ret;
 
     if (asprintf(&abs_path, "%s.hg/%s", repo_root, subdir) == -1) {
 	ret = -1;
 	goto bail;
     }
 
     /* verify that we really are looking at valid repo. */
 
     if (stat(abs_path, &st) == -1) {
 	ret = 0;
     } else {
 	ret = 1;
     }
 
 bail:
     return ret;
 }
 
 /*
  * paranoid wrapper, runs hg executable in server mode.
  */
 static void serve_data(int argc, char **argv)
 {
     char *hg_root = HG_ROOT;
     char *repo, *repo_root;
     enum cmdline cmd;
     char *nargv[6];
     size_t repolen;
     int i;
 
     /*
      * check argv for looking okay. we should be invoked with argv
      * resembling like this:
      *
      *   hgsh
      *   -c
      *   hg -R some/path serve --stdio
      *
      * the "-c" is added by sshd, because it thinks we are login shell.
      */
 
     if (argc != 3) {
         goto badargs;
     }
 
     if (strcmp(argv[1], "-c") != 0) {
         goto badargs;
     }
 
     if (sscanf(argv[2], "hg init %as", &repo) == 1) {
 	cmd = hg_init;
     }
     else if (sscanf(argv[2], "hg -R %as serve --stdio", &repo) == 1) {
 	cmd = hg_serve;
     } else {
         goto badargs;
     }
 
     repolen = repo ? strlen(repo) : 0;
 
     if (repolen == 0) {
         goto badargs;
     }
 
     if (hg_root) {
         if (asprintf(&repo_root, "%s/%s/", hg_root, repo) == -1) {
             goto badargs;
         }
 
         /*
          * attempt to stop break out from inside the repository tree. could
          * do something more clever here, because e.g. we could traverse a
          * symlink that looks safe, but really breaks us out of tree.
          */
 
         if (strstr(repo_root, "/../") != NULL) {
             goto badargs;
         }
 
 	/* only hg init expects no repo. */
 
 	if (cmd != hg_init) {
 	    int valid;
-	    
+
 	    valid = validate_repo(repo_root, "data");
 
 	    if (valid == -1) {
 		goto badargs;
 	    }
-	    
+
 	    if (valid == 0) {
 		valid = validate_repo(repo_root, "store");
 
 		if (valid == -1) {
 		    goto badargs;
 		}
 	    }
-	    
+
 	    if (valid == 0) {
 		perror(repo);
 		exit(EX_DATAERR);
 	    }
 	}
 
         if (chdir(hg_root) == -1) {
             perror(hg_root);
             exit(EX_SOFTWARE);
         }
     }
 
     i = 0;
 
     switch (cmd) {
     case hg_serve:
 	nargv[i++] = HG;
 	nargv[i++] = "-R";
 	nargv[i++] = repo;
 	nargv[i++] = "serve";
 	nargv[i++] = "--stdio";
 	break;
     case hg_init:
 	nargv[i++] = HG;
 	nargv[i++] = "init";
 	nargv[i++] = repo;
 	break;
     }
-    
+
     nargv[i] = NULL;
 
     if (debug) {
         print_cmdline(i, nargv);
     }
 
     execv(HG, nargv);
     perror(HG);
     exit(EX_UNAVAILABLE);
 
 badargs:
     /* print useless error message. */
 
     usage("invalid arguments", EX_DATAERR);
 }
 
 int main(int argc, char **argv)
 {
     char host[1024];
     char *c;
 
     if (gethostname(host, sizeof(host)) == -1) {
         perror("gethostname");
         exit(EX_OSERR);
     }
 
     if ((c = strchr(host, '.')) != NULL) {
         *c = '\0';
     }
 
     if (getenv("SSH_CLIENT")) {
         char *hg_gateway = HG_GATEWAY;
         char *hg_host = HG_HOST;
 
         if (hg_gateway && strcmp(host, hg_gateway) == 0) {
             forward_through_gateway(argc, argv);
         }
 
         if (hg_host && strcmp(host, hg_host) != 0) {
             usage("invoked on unexpected host", EX_USAGE);
         }
 
         serve_data(argc, argv);
     } else if (HG_SHELL) {
         run_shell(argc, argv);
     } else {
         usage("invalid arguments", EX_DATAERR);
     }
 
     return 0;
 }

contrib/mercurial.el

@@ -1,1274 +1,1274 b''
 ;;; mercurial.el --- Emacs support for the Mercurial distributed SCM
 
 ;; Copyright (C) 2005, 2006 Bryan O'Sullivan
 
 ;; Author: Bryan O'Sullivan <[e-mail]>
 
 ;; mercurial.el is free software; you can redistribute it and/or
 ;; modify it under the terms of version 2 of the GNU General Public
 ;; License as published by the Free Software Foundation.
 
 ;; mercurial.el 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 mercurial.el, GNU Emacs, or XEmacs; see the file COPYING
 ;; (`C-h C-l').  If not, write to the Free Software Foundation, Inc.,
 ;; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 ;;; Commentary:
 
 ;; mercurial.el builds upon Emacs's VC mode to provide flexible
 ;; integration with the Mercurial distributed SCM tool.
 
 ;; To get going as quickly as possible, load mercurial.el into Emacs and
 ;; type `C-c h h'; this runs hg-help-overview, which prints a helpful
 ;; usage overview.
 
 ;; Much of the inspiration for mercurial.el comes from Rajesh
 ;; Vaidheeswarran's excellent p4.el, which does an admirably thorough
 ;; job for the commercial Perforce SCM product.  In fact, substantial
 ;; chunks of code are adapted from p4.el.
 
 ;; This code has been developed under XEmacs 21.5, and may not work as
 ;; well under GNU Emacs (albeit tested under 21.4).  Patches to
 ;; enhance the portability of this code, fix bugs, and add features
 ;; are most welcome.  You can clone a Mercurial repository for this
 ;; package from http://www.serpentine.com/hg/hg-emacs
 
 ;; Please send problem reports and suggestions to [e-mail].
 
 
 ;;; Code:
 
 (eval-when-compile (require 'cl))
 (require 'diff-mode)
 (require 'easymenu)
 (require 'executable)
 (require 'vc)
 
 (defmacro hg-feature-cond (&rest clauses)
   "Test CLAUSES for feature at compile time.
 Each clause is (FEATURE BODY...)."
   (dolist (x clauses)
     (let ((feature (car x))
 	  (body (cdr x)))
       (when (or (eq feature t)
 		(featurep feature))
 	(return (cons 'progn body))))))
 
 
 ;;; XEmacs has view-less, while GNU Emacs has view.  Joy.
 
 (hg-feature-cond
  (xemacs (require 'view-less))
  (t (require 'view)))
 
 
 ;;; Variables accessible through the custom system.
 
 (defgroup mercurial nil
   "Mercurial distributed SCM."
   :group 'tools)
 
 (defcustom hg-binary
     (or (executable-find "hg")
 	(dolist (path '("~/bin/hg" "/usr/bin/hg" "/usr/local/bin/hg"))
 	  (when (file-executable-p path)
 	    (return path))))
   "The path to Mercurial's hg executable."
   :type '(file :must-match t)
   :group 'mercurial)
 
 (defcustom hg-mode-hook nil
   "Hook run when a buffer enters hg-mode."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom hg-commit-mode-hook nil
   "Hook run when a buffer is created to prepare a commit."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom hg-pre-commit-hook nil
   "Hook run before a commit is performed.
 If you want to prevent the commit from proceeding, raise an error."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom hg-log-mode-hook nil
   "Hook run after a buffer is filled with log information."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom hg-global-prefix "\C-ch"
   "The global prefix for Mercurial keymap bindings."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom hg-commit-allow-empty-message nil
   "Whether to allow changes to be committed with empty descriptions."
   :type 'boolean
   :group 'mercurial)
 
 (defcustom hg-commit-allow-empty-file-list nil
   "Whether to allow changes to be committed without any modified files."
   :type 'boolean
   :group 'mercurial)
 
 (defcustom hg-rev-completion-limit 100
   "The maximum number of revisions that hg-read-rev will offer to complete.
 This affects memory usage and performance when prompting for revisions
 in a repository with a lot of history."
   :type 'integer
   :group 'mercurial)
 
 (defcustom hg-log-limit 50
   "The maximum number of revisions that hg-log will display."
   :type 'integer
   :group 'mercurial)
 
 (defcustom hg-update-modeline t
   "Whether to update the modeline with the status of a file after every save.
 Set this to nil on platforms with poor process management, such as Windows."
   :type 'boolean
   :group 'mercurial)
 
 (defcustom hg-incoming-repository "default"
   "The repository from which changes are pulled from by default.
 This should be a symbolic repository name, since it is used for all
 repository-related commands."
   :type 'string
   :group 'mercurial)
 
 (defcustom hg-outgoing-repository "default-push"
   "The repository to which changes are pushed to by default.
 This should be a symbolic repository name, since it is used for all
 repository-related commands."
   :type 'string
   :group 'mercurial)
 
 
 ;;; Other variables.
 
 (defvar hg-mode nil
   "Is this file managed by Mercurial?")
 (make-variable-buffer-local 'hg-mode)
 (put 'hg-mode 'permanent-local t)
 
 (defvar hg-status nil)
 (make-variable-buffer-local 'hg-status)
 (put 'hg-status 'permanent-local t)
 
 (defvar hg-prev-buffer nil)
 (make-variable-buffer-local 'hg-prev-buffer)
 (put 'hg-prev-buffer 'permanent-local t)
 
 (defvar hg-root nil)
 (make-variable-buffer-local 'hg-root)
 (put 'hg-root 'permanent-local t)
 
 (defvar hg-view-mode nil)
 (make-variable-buffer-local 'hg-view-mode)
 (put 'hg-view-mode 'permanent-local t)
 
 (defvar hg-view-file-name nil)
 (make-variable-buffer-local 'hg-view-file-name)
 (put 'hg-view-file-name 'permanent-local t)
 
 (defvar hg-output-buffer-name "*Hg*"
   "The name to use for Mercurial output buffers.")
 
 (defvar hg-file-history nil)
 (defvar hg-repo-history nil)
 (defvar hg-rev-history nil)
 (defvar hg-repo-completion-table nil)	; shut up warnings
 
 
 ;;; Random constants.
 
 (defconst hg-commit-message-start
   "--- Enter your commit message.  Type `C-c C-c' to commit. ---\n")
 
 (defconst hg-commit-message-end
   "--- Files in bold will be committed.  Click to toggle selection. ---\n")
 
 (defconst hg-state-alist
   '((?M . modified)
     (?A . added)
     (?R . removed)
     (?! . deleted)
     (?C . normal)
     (?I . ignored)
     (?? . nil)))
 
 ;;; hg-mode keymap.
 
 (defvar hg-prefix-map
   (let ((map (make-sparse-keymap)))
     (hg-feature-cond (xemacs (set-keymap-name map 'hg-prefix-map))) ; XEmacs
     (set-keymap-parent map vc-prefix-map)
     (define-key map "=" 'hg-diff)
     (define-key map "c" 'hg-undo)
     (define-key map "g" 'hg-annotate)
     (define-key map "i" 'hg-add)
     (define-key map "l" 'hg-log)
     (define-key map "n" 'hg-commit-start)
     ;; (define-key map "r" 'hg-update)
     (define-key map "u" 'hg-revert-buffer)
     (define-key map "~" 'hg-version-other-window)
     map)
   "This keymap overrides some default vc-mode bindings.")
 
 (defvar hg-mode-map
   (let ((map (make-sparse-keymap)))
     (define-key map "\C-xv" hg-prefix-map)
     map))
 
 (add-minor-mode 'hg-mode 'hg-mode hg-mode-map)
 
 
 ;;; Global keymap.
 
 (defvar hg-global-map
   (let ((map (make-sparse-keymap)))
     (define-key map "," 'hg-incoming)
     (define-key map "." 'hg-outgoing)
     (define-key map "<" 'hg-pull)
     (define-key map "=" 'hg-diff-repo)
     (define-key map ">" 'hg-push)
     (define-key map "?" 'hg-help-overview)
     (define-key map "A" 'hg-addremove)
     (define-key map "U" 'hg-revert)
     (define-key map "a" 'hg-add)
     (define-key map "c" 'hg-commit-start)
     (define-key map "f" 'hg-forget)
     (define-key map "h" 'hg-help-overview)
     (define-key map "i" 'hg-init)
     (define-key map "l" 'hg-log-repo)
     (define-key map "r" 'hg-root)
     (define-key map "s" 'hg-status)
     (define-key map "u" 'hg-update)
     map))
 
 (global-set-key hg-global-prefix hg-global-map)
 
 ;;; View mode keymap.
 
 (defvar hg-view-mode-map
   (let ((map (make-sparse-keymap)))
     (hg-feature-cond (xemacs (set-keymap-name map 'hg-view-mode-map))) ; XEmacs
     (define-key map (hg-feature-cond (xemacs [button2])
 				     (t [mouse-2]))
       'hg-buffer-mouse-clicked)
     map))
 
 (add-minor-mode 'hg-view-mode "" hg-view-mode-map)
 
 
 ;;; Commit mode keymaps.
 
 (defvar hg-commit-mode-map
   (let ((map (make-sparse-keymap)))
     (define-key map "\C-c\C-c" 'hg-commit-finish)
     (define-key map "\C-c\C-k" 'hg-commit-kill)
     (define-key map "\C-xv=" 'hg-diff-repo)
     map))
 
 (defvar hg-commit-mode-file-map
   (let ((map (make-sparse-keymap)))
     (define-key map (hg-feature-cond (xemacs [button2])
 				     (t [mouse-2]))
       'hg-commit-mouse-clicked)
     (define-key map " " 'hg-commit-toggle-file)
     (define-key map "\r" 'hg-commit-toggle-file)
     map))
 
 
 ;;; Convenience functions.
 
 (defsubst hg-binary ()
   (if hg-binary
       hg-binary
     (error "No `hg' executable found!")))
 
 (defsubst hg-replace-in-string (str regexp newtext &optional literal)
   "Replace all matches in STR for REGEXP with NEWTEXT string.
 Return the new string.  Optional LITERAL non-nil means do a literal
 replacement.
 
 This function bridges yet another pointless impedance gap between
 XEmacs and GNU Emacs."
   (hg-feature-cond
    (xemacs (replace-in-string str regexp newtext literal))
    (t (replace-regexp-in-string regexp newtext str nil literal))))
 
 (defsubst hg-strip (str)
   "Strip leading and trailing blank lines from a string."
   (hg-replace-in-string (hg-replace-in-string str "[\r\n][ \t\r\n]*\\'" "")
 			"\\`[ \t\r\n]*[\r\n]" ""))
 
 (defsubst hg-chomp (str)
   "Strip trailing newlines from a string."
   (hg-replace-in-string str "[\r\n]+\\'" ""))
 
 (defun hg-run-command (command &rest args)
   "Run the shell command COMMAND, returning (EXIT-CODE . COMMAND-OUTPUT).
 The list ARGS contains a list of arguments to pass to the command."
   (let* (exit-code
 	 (output
 	  (with-output-to-string
 	    (with-current-buffer
 		standard-output
 	      (setq exit-code
 		    (apply 'call-process command nil t nil args))))))
     (cons exit-code output)))
 
 (defun hg-run (command &rest args)
   "Run the Mercurial command COMMAND, returning (EXIT-CODE . COMMAND-OUTPUT)."
   (apply 'hg-run-command (hg-binary) command args))
 
 (defun hg-run0 (command &rest args)
   "Run the Mercurial command COMMAND, returning its output.
 If the command does not exit with a zero status code, raise an error."
   (let ((res (apply 'hg-run-command (hg-binary) command args)))
     (if (not (eq (car res) 0))
 	(error "Mercurial command failed %s - exit code %s"
 	       (cons command args)
 	       (car res))
       (cdr res))))
 
 (defmacro hg-do-across-repo (path &rest body)
   (let ((root-name (make-symbol "root-"))
 	(buf-name (make-symbol "buf-")))
     `(let ((,root-name (hg-root ,path)))
        (save-excursion
 	 (dolist (,buf-name (buffer-list))
 	   (set-buffer ,buf-name)
 	   (when (and hg-status (equal (hg-root buffer-file-name) ,root-name))
 	     ,@body))))))
 
 (put 'hg-do-across-repo 'lisp-indent-function 1)
 
 (defun hg-sync-buffers (path)
   "Sync buffers visiting PATH with their on-disk copies.
 If PATH is not being visited, but is under the repository root, sync
 all buffers visiting files in the repository."
   (let ((buf (find-buffer-visiting path)))
     (if buf
 	(with-current-buffer buf
 	  (vc-buffer-sync))
       (hg-do-across-repo path
 	(vc-buffer-sync)))))
 
 (defun hg-buffer-commands (pnt)
   "Use the properties of a character to do something sensible."
   (interactive "d")
   (let ((rev (get-char-property pnt 'rev))
 	(file (get-char-property pnt 'file)))
     (cond
      (file
       (find-file-other-window file))
      (rev
       (hg-diff hg-view-file-name rev rev))
      ((message "I don't know how to do that yet")))))
 
 (defsubst hg-event-point (event)
   "Return the character position of the mouse event EVENT."
   (hg-feature-cond (xemacs (event-point event))
 		   (t (posn-point (event-start event)))))
 
 (defsubst hg-event-window (event)
   "Return the window over which mouse event EVENT occurred."
   (hg-feature-cond (xemacs (event-window event))
 		   (t (posn-window (event-start event)))))
 
 (defun hg-buffer-mouse-clicked (event)
   "Translate the mouse clicks in a HG log buffer to character events.
 These are then handed off to `hg-buffer-commands'.
 
 Handle frickin' frackin' gratuitous event-related incompatibilities."
   (interactive "e")
   (select-window (hg-event-window event))
   (hg-buffer-commands (hg-event-point event)))
 
 (defsubst hg-abbrev-file-name (file)
   "Portable wrapper around abbreviate-file-name."
   (hg-feature-cond (xemacs (abbreviate-file-name file t))
 		   (t (abbreviate-file-name file))))
 
 (defun hg-read-file-name (&optional prompt default)
   "Read a file or directory name, or a pattern, to use with a command."
   (save-excursion
     (while hg-prev-buffer
       (set-buffer hg-prev-buffer))
     (let ((path (or default
                     (buffer-file-name)
                     (expand-file-name default-directory))))
       (if (or (not path) current-prefix-arg)
           (expand-file-name
            (eval (list* 'read-file-name
                         (format "File, directory or pattern%s: "
                                 (or prompt ""))
                         (and path (file-name-directory path))
                         nil nil
                         (and path (file-name-nondirectory path))
                         (hg-feature-cond
 			 (xemacs (cons (quote 'hg-file-history) nil))
 			 (t nil)))))
         path))))
 
 (defun hg-read-number (&optional prompt default)
   "Read a integer value."
   (save-excursion
     (if (or (not default) current-prefix-arg)
         (string-to-number
          (eval (list* 'read-string
-                      (or prompt "") 
+                      (or prompt "")
                       (if default (cons (format "%d" default) nil) nil))))
       default)))
 
 (defun hg-read-config ()
   "Return an alist of (key . value) pairs of Mercurial config data.
 Each key is of the form (section . name)."
   (let (items)
     (dolist (line (split-string (hg-chomp (hg-run0 "debugconfig")) "\n") items)
       (string-match "^\\([^=]*\\)=\\(.*\\)" line)
       (let* ((left (substring line (match-beginning 1) (match-end 1)))
 	     (right (substring line (match-beginning 2) (match-end 2)))
 	     (key (split-string left "\\."))
 	     (value (hg-replace-in-string right "\\\\n" "\n" t)))
 	(setq items (cons (cons (cons (car key) (cadr key)) value) items))))))
 
 (defun hg-config-section (section config)
   "Return an alist of (name . value) pairs for SECTION of CONFIG."
   (let (items)
     (dolist (item config items)
       (when (equal (caar item) section)
 	(setq items (cons (cons (cdar item) (cdr item)) items))))))
 
 (defun hg-string-starts-with (sub str)
   "Indicate whether string STR starts with the substring or character SUB."
   (if (not (stringp sub))
       (and (> (length str) 0) (equal (elt str 0) sub))
     (let ((sub-len (length sub)))
       (and (<= sub-len (length str))
 	   (string= sub (substring str 0 sub-len))))))
 
 (defun hg-complete-repo (string predicate all)
   "Attempt to complete a repository name.
 We complete on either symbolic names from Mercurial's config or real
 directory names from the file system.  We do not penalise URLs."
   (or (if all
 	  (all-completions string hg-repo-completion-table predicate)
 	(try-completion string hg-repo-completion-table predicate))
       (let* ((str (expand-file-name string))
 	     (dir (file-name-directory str))
 	     (file (file-name-nondirectory str)))
 	(if all
 	    (let (completions)
 	      (dolist (name (delete "./" (file-name-all-completions file dir))
 			    completions)
 		(let ((path (concat dir name)))
 		  (when (file-directory-p path)
 		    (setq completions (cons name completions))))))
 	  (let ((comp (file-name-completion file dir)))
 	    (if comp
 		(hg-abbrev-file-name (concat dir comp))))))))
 
 (defun hg-read-repo-name (&optional prompt initial-contents default)
   "Read the location of a repository."
   (save-excursion
     (while hg-prev-buffer
       (set-buffer hg-prev-buffer))
     (let (hg-repo-completion-table)
       (if current-prefix-arg
 	  (progn
 	    (dolist (path (hg-config-section "paths" (hg-read-config)))
 	      (setq hg-repo-completion-table
 		    (cons (cons (car path) t) hg-repo-completion-table))
 	      (unless (hg-string-starts-with (hg-feature-cond
 					      (xemacs directory-sep-char)
 					      (t ?/))
 					     (cdr path))
 		(setq hg-repo-completion-table
 		      (cons (cons (cdr path) t) hg-repo-completion-table))))
 	    (completing-read (format "Repository%s: " (or prompt ""))
 			     'hg-complete-repo
 			     nil
 			     nil
 			     initial-contents
 			     'hg-repo-history
 			     default))
 	default))))
 
 (defun hg-read-rev (&optional prompt default)
   "Read a revision or tag, offering completions."
   (save-excursion
     (while hg-prev-buffer
       (set-buffer hg-prev-buffer))
     (let ((rev (or default "tip")))
       (if current-prefix-arg
 	  (let ((revs (split-string
 		       (hg-chomp
 			(hg-run0 "-q" "log" "-l"
 				 (format "%d" hg-rev-completion-limit)))
 		       "[\n:]")))
 	    (dolist (line (split-string (hg-chomp (hg-run0 "tags")) "\n"))
 	      (setq revs (cons (car (split-string line "\\s-")) revs)))
 	    (completing-read (format "Revision%s (%s): "
 				     (or prompt "")
 				     (or default "tip"))
 			     (map 'list 'cons revs revs)
 			     nil
 			     nil
 			     nil
 			     'hg-rev-history
 			     (or default "tip")))
 	rev))))
 
 (defun hg-parents-for-mode-line (root)
   "Format the parents of the working directory for the mode line."
   (let ((parents (split-string (hg-chomp
 				(hg-run0 "--cwd" root "parents" "--template"
 					 "{rev}\n")) "\n")))
     (mapconcat 'identity parents "+")))
 
 (defun hg-buffers-visiting-repo (&optional path)
   "Return a list of buffers visiting the repository containing PATH."
   (let ((root-name (hg-root (or path (buffer-file-name))))
 	bufs)
     (save-excursion
       (dolist (buf (buffer-list) bufs)
 	(set-buffer buf)
 	(let ((name (buffer-file-name)))
 	  (when (and hg-status name (equal (hg-root name) root-name))
 	    (setq bufs (cons buf bufs))))))))
 
 (defun hg-update-mode-lines (path)
   "Update the mode lines of all buffers visiting the same repository as PATH."
   (let* ((root (hg-root path))
 	 (parents (hg-parents-for-mode-line root)))
     (save-excursion
       (dolist (info (hg-path-status
 		     root
 		     (mapcar
 		      (function
 		       (lambda (buf)
 			 (substring (buffer-file-name buf) (length root))))
 		      (hg-buffers-visiting-repo root))))
 	(let* ((name (car info))
 	       (status (cdr info))
 	       (buf (find-buffer-visiting (concat root name))))
 	  (when buf
 	    (set-buffer buf)
 	    (hg-mode-line-internal status parents)))))))
-  
+
 
 ;;; View mode bits.
 
 (defun hg-exit-view-mode (buf)
   "Exit from hg-view-mode.
 We delete the current window if entering hg-view-mode split the
 current frame."
   (when (and (eq buf (current-buffer))
 	     (> (length (window-list)) 1))
     (delete-window))
   (when (buffer-live-p buf)
     (kill-buffer buf)))
 
 (defun hg-view-mode (prev-buffer &optional file-name)
   (goto-char (point-min))
   (set-buffer-modified-p nil)
   (toggle-read-only t)
   (hg-feature-cond (xemacs (view-minor-mode prev-buffer 'hg-exit-view-mode))
 		   (t (view-mode-enter nil 'hg-exit-view-mode)))
   (setq hg-view-mode t)
   (setq truncate-lines t)
   (when file-name
-    (setq hg-view-file-name 
+    (setq hg-view-file-name
 	  (hg-abbrev-file-name file-name))))
 
 (defun hg-file-status (file)
   "Return status of FILE, or nil if FILE does not exist or is unmanaged."
   (let* ((s (hg-run "status" file))
 	 (exit (car s))
 	 (output (cdr s)))
     (if (= exit 0)
 	(let ((state (and (>= (length output) 2)
 			  (= (aref output 1) ? )
 			  (assq (aref output 0) hg-state-alist))))
 	  (if state
 	      (cdr state)
 	    'normal)))))
 
 (defun hg-path-status (root paths)
   "Return status of PATHS in repo ROOT as an alist.
 Each entry is a pair (FILE-NAME . STATUS)."
   (let ((s (apply 'hg-run "--cwd" root "status" "-marduc" paths))
 	result)
     (dolist (entry (split-string (hg-chomp (cdr s)) "\n") (nreverse result))
       (let (state name)
 	(cond ((= (aref entry 1) ? )
 	       (setq state (assq (aref entry 0) hg-state-alist)
 		     name (substring entry 2)))
 	      ((string-match "\\(.*\\): " entry)
 	       (setq name (match-string 1 entry))))
 	(setq result (cons (cons name state) result))))))
 
 (defmacro hg-view-output (args &rest body)
   "Execute BODY in a clean buffer, then quickly display that buffer.
 If the buffer contains one line, its contents are displayed in the
 minibuffer.  Otherwise, the buffer is displayed in view-mode.
 ARGS is of the form (BUFFER-NAME &optional FILE), where BUFFER-NAME is
 the name of the buffer to create, and FILE is the name of the file
 being viewed."
   (let ((prev-buf (make-symbol "prev-buf-"))
 	(v-b-name (car args))
 	(v-m-rest (cdr args)))
     `(let ((view-buf-name ,v-b-name)
 	   (,prev-buf (current-buffer)))
        (get-buffer-create view-buf-name)
        (kill-buffer view-buf-name)
        (get-buffer-create view-buf-name)
        (set-buffer view-buf-name)
        (save-excursion
 	 ,@body)
        (case (count-lines (point-min) (point-max))
 	 ((0)
 	  (kill-buffer view-buf-name)
 	  (message "(No output)"))
 	 ((1)
 	  (let ((msg (hg-chomp (buffer-substring (point-min) (point-max)))))
 	    (kill-buffer view-buf-name)
 	    (message "%s" msg)))
 	 (t
 	  (pop-to-buffer view-buf-name)
 	  (setq hg-prev-buffer ,prev-buf)
 	  (hg-view-mode ,prev-buf ,@v-m-rest))))))
 
 (put 'hg-view-output 'lisp-indent-function 1)
 
 ;;; Context save and restore across revert and other operations.
 
 (defun hg-position-context (pos)
   "Return information to help find the given position again."
   (let* ((end (min (point-max) (+ pos 98))))
     (list pos
 	  (buffer-substring (max (point-min) (- pos 2)) end)
 	  (- end pos))))
 
 (defun hg-buffer-context ()
   "Return information to help restore a user's editing context.
 This is useful across reverts and merges, where a context is likely
 to have moved a little, but not really changed."
   (let ((point-context (hg-position-context (point)))
 	(mark-context (let ((mark (mark-marker)))
 			(and mark (hg-position-context mark)))))
     (list point-context mark-context)))
 
 (defun hg-find-context (ctx)
   "Attempt to find a context in the given buffer.
 Always returns a valid, hopefully sane, position."
   (let ((pos (nth 0 ctx))
 	(str (nth 1 ctx))
 	(fixup (nth 2 ctx)))
     (save-excursion
       (goto-char (max (point-min) (- pos 15000)))
       (if (and (not (equal str ""))
 	       (search-forward str nil t))
 	  (- (point) fixup)
 	(max pos (point-min))))))
 
 (defun hg-restore-context (ctx)
   "Attempt to restore the user's editing context."
   (let ((point-context (nth 0 ctx))
 	(mark-context (nth 1 ctx)))
     (goto-char (hg-find-context point-context))
     (when mark-context
       (set-mark (hg-find-context mark-context)))))
 
 
 ;;; Hooks.
 
 (defun hg-mode-line-internal (status parents)
   (setq hg-status status
 	hg-mode (and status (concat " Hg:"
 				    parents
 				    (cdr (assq status
 					       '((normal . "")
 						 (removed . "r")
 						 (added . "a")
 						 (deleted . "!")
 						 (modified . "m"))))))))
-  
+
 (defun hg-mode-line (&optional force)
   "Update the modeline with the current status of a file.
 An update occurs if optional argument FORCE is non-nil,
 hg-update-modeline is non-nil, or we have not yet checked the state of
 the file."
   (let ((root (hg-root)))
     (when (and root (or force hg-update-modeline (not hg-mode)))
       (let ((status (hg-file-status buffer-file-name))
 	    (parents (hg-parents-for-mode-line root)))
 	(hg-mode-line-internal status parents)
 	status))))
 
 (defun hg-mode (&optional toggle)
   "Minor mode for Mercurial distributed SCM integration.
 
 The Mercurial mode user interface is based on that of VC mode, so if
 you're already familiar with VC, the same keybindings and functions
 will generally work.
 
 Below is a list of many common SCM tasks.  In the list, `G/L\'
 indicates whether a key binding is global (G) to a repository or
 local (L) to a file.  Many commands take a prefix argument.
 
 SCM Task                              G/L  Key Binding  Command Name
 --------                              ---  -----------  ------------
 Help overview (what you are reading)  G    C-c h h      hg-help-overview
 
 Tell Mercurial to manage a file       G    C-c h a      hg-add
 Commit changes to current file only   L    C-x v n      hg-commit-start
 Undo changes to file since commit     L    C-x v u      hg-revert-buffer
 
 Diff file vs last checkin             L    C-x v =      hg-diff
 
 View file change history              L    C-x v l      hg-log
 View annotated file                   L    C-x v a      hg-annotate
 
 Diff repo vs last checkin             G    C-c h =      hg-diff-repo
 View status of files in repo          G    C-c h s      hg-status
 Commit all changes                    G    C-c h c      hg-commit-start
 
 Undo all changes since last commit    G    C-c h U      hg-revert
 View repo change history              G    C-c h l      hg-log-repo
 
 See changes that can be pulled        G    C-c h ,      hg-incoming
 Pull changes                          G    C-c h <      hg-pull
 Update working directory after pull   G    C-c h u      hg-update
 See changes that can be pushed        G    C-c h .      hg-outgoing
 Push changes                          G    C-c h >      hg-push"
   (unless vc-make-backup-files
     (set (make-local-variable 'backup-inhibited) t))
   (run-hooks 'hg-mode-hook))
 
 (defun hg-find-file-hook ()
   (ignore-errors
     (when (hg-mode-line)
       (hg-mode))))
 
 (add-hook 'find-file-hooks 'hg-find-file-hook)
 
 (defun hg-after-save-hook ()
   (ignore-errors
     (let ((old-status hg-status))
       (hg-mode-line)
       (if (and (not old-status) hg-status)
 	  (hg-mode)))))
 
 (add-hook 'after-save-hook 'hg-after-save-hook)
 
 
 ;;; User interface functions.
 
 (defun hg-help-overview ()
   "This is an overview of the Mercurial SCM mode for Emacs.
 
 You can find the source code, license (GPL v2), and credits for this
 code by typing `M-x find-library mercurial RET'."
   (interactive)
   (hg-view-output ("Mercurial Help Overview")
     (insert (documentation 'hg-help-overview))
     (let ((pos (point)))
       (insert (documentation 'hg-mode))
       (goto-char pos)
       (end-of-line 1)
       (delete-region pos (point)))
     (let ((hg-root-dir (hg-root)))
       (if (not hg-root-dir)
 	  (error "error: %s: directory is not part of a Mercurial repository."
 		 default-directory)
 	(cd hg-root-dir)))))
 
 (defun hg-fix-paths ()
   "Fix paths reported by some Mercurial commands."
   (save-excursion
     (goto-char (point-min))
     (while (re-search-forward " \\.\\.." nil t)
       (replace-match " " nil nil))))
 
 (defun hg-add (path)
   "Add PATH to the Mercurial repository on the next commit.
 With a prefix argument, prompt for the path to add."
   (interactive (list (hg-read-file-name " to add")))
   (let ((buf (current-buffer))
 	(update (equal buffer-file-name path)))
     (hg-view-output (hg-output-buffer-name)
       (apply 'call-process (hg-binary) nil t nil (list "add" path))
       (hg-fix-paths)
       (goto-char (point-min))
       (cd (hg-root path)))
     (when update
       (unless vc-make-backup-files
 	(set (make-local-variable 'backup-inhibited) t))
       (with-current-buffer buf
 	(hg-mode-line)))))
 
 (defun hg-addremove ()
   (interactive)
   (error "not implemented"))
 
 (defun hg-annotate ()
   (interactive)
   (error "not implemented"))
 
 (defun hg-commit-toggle-file (pos)
   "Toggle whether or not the file at POS will be committed."
   (interactive "d")
   (save-excursion
     (goto-char pos)
     (let ((face (get-text-property pos 'face))
 	  (inhibit-read-only t)
 	  bol)
       (beginning-of-line)
       (setq bol (+ (point) 4))
       (end-of-line)
       (if (eq face 'bold)
 	  (progn
 	    (remove-text-properties bol (point) '(face nil))
 	    (message "%s will not be committed"
 		     (buffer-substring bol (point))))
 	(add-text-properties bol (point) '(face bold))
 	(message "%s will be committed"
 		 (buffer-substring bol (point)))))))
 
 (defun hg-commit-mouse-clicked (event)
   "Toggle whether or not the file at POS will be committed."
   (interactive "@e")
   (hg-commit-toggle-file (hg-event-point event)))
 
 (defun hg-commit-kill ()
   "Kill the commit currently being prepared."
   (interactive)
   (when (or (not (buffer-modified-p)) (y-or-n-p "Really kill this commit? "))
     (let ((buf hg-prev-buffer))
       (kill-buffer nil)
       (switch-to-buffer buf))))
 
 (defun hg-commit-finish ()
   "Finish preparing a commit, and perform the actual commit.
 The hook hg-pre-commit-hook is run before anything else is done.  If
 the commit message is empty and hg-commit-allow-empty-message is nil,
 an error is raised.  If the list of files to commit is empty and
 hg-commit-allow-empty-file-list is nil, an error is raised."
   (interactive)
   (let ((root hg-root))
     (save-excursion
       (run-hooks 'hg-pre-commit-hook)
       (goto-char (point-min))
       (search-forward hg-commit-message-start)
       (let (message files)
 	(let ((start (point)))
 	  (goto-char (point-max))
 	  (search-backward hg-commit-message-end)
 	  (setq message (hg-strip (buffer-substring start (point)))))
 	(when (and (= (length message) 0)
 		   (not hg-commit-allow-empty-message))
 	  (error "Cannot proceed - commit message is empty"))
 	(forward-line 1)
 	(beginning-of-line)
 	(while (< (point) (point-max))
 	  (let ((pos (+ (point) 4)))
 	    (end-of-line)
 	    (when (eq (get-text-property pos 'face) 'bold)
 	      (end-of-line)
 	      (setq files (cons (buffer-substring pos (point)) files))))
 	  (forward-line 1))
 	(when (and (= (length files) 0)
 		   (not hg-commit-allow-empty-file-list))
 	  (error "Cannot proceed - no files to commit"))
 	(setq message (concat message "\n"))
 	(apply 'hg-run0 "--cwd" hg-root "commit" "-m" message files))
       (let ((buf hg-prev-buffer))
 	(kill-buffer nil)
 	(switch-to-buffer buf))
       (hg-update-mode-lines root))))
 
 (defun hg-commit-mode ()
   "Mode for describing a commit of changes to a Mercurial repository.
 This involves two actions: describing the changes with a commit
 message, and choosing the files to commit.
 
 To describe the commit, simply type some text in the designated area.
 
 By default, all modified, added and removed files are selected for
 committing.  Files that will be committed are displayed in bold face\;
 those that will not are displayed in normal face.
 
 To toggle whether a file will be committed, move the cursor over a
 particular file and hit space or return.  Alternatively, middle click
 on the file.
 
 Key bindings
 ------------
 \\[hg-commit-finish]		proceed with commit
 \\[hg-commit-kill]		kill commit
 
 \\[hg-diff-repo]		view diff of pending changes"
   (interactive)
   (use-local-map hg-commit-mode-map)
   (set-syntax-table text-mode-syntax-table)
   (setq local-abbrev-table text-mode-abbrev-table
 	major-mode 'hg-commit-mode
 	mode-name "Hg-Commit")
   (set-buffer-modified-p nil)
   (setq buffer-undo-list nil)
   (run-hooks 'text-mode-hook 'hg-commit-mode-hook))
 
 (defun hg-commit-start ()
   "Prepare a commit of changes to the repository containing the current file."
   (interactive)
   (while hg-prev-buffer
     (set-buffer hg-prev-buffer))
   (let ((root (hg-root))
 	(prev-buffer (current-buffer))
 	modified-files)
     (unless root
       (error "Cannot commit outside a repository!"))
     (hg-sync-buffers root)
     (setq modified-files (hg-chomp (hg-run0 "--cwd" root "status" "-arm")))
     (when (and (= (length modified-files) 0)
 	       (not hg-commit-allow-empty-file-list))
       (error "No pending changes to commit"))
     (let* ((buf-name (format "*Mercurial: Commit %s*" root)))
       (pop-to-buffer (get-buffer-create buf-name))
       (when (= (point-min) (point-max))
 	(set (make-local-variable 'hg-root) root)
 	(setq hg-prev-buffer prev-buffer)
 	(insert "\n")
 	(let ((bol (point)))
 	  (insert hg-commit-message-end)
 	  (add-text-properties bol (point) '(face bold-italic)))
 	(let ((file-area (point)))
 	  (insert modified-files)
 	  (goto-char file-area)
 	  (while (< (point) (point-max))
 	    (let ((bol (point)))
 	      (forward-char 1)
 	      (insert "  ")
 	      (end-of-line)
 	      (add-text-properties (+ bol 4) (point)
 				   '(face bold mouse-face highlight)))
 	    (forward-line 1))
 	  (goto-char file-area)
 	  (add-text-properties (point) (point-max)
 			       `(keymap ,hg-commit-mode-file-map))
 	  (goto-char (point-min))
 	  (insert hg-commit-message-start)
 	  (add-text-properties (point-min) (point) '(face bold-italic))
 	  (insert "\n\n")
 	  (forward-line -1)
 	  (save-excursion
 	    (goto-char (point-max))
 	    (search-backward hg-commit-message-end)
 	    (add-text-properties (match-beginning 0) (point-max)
 				 '(read-only t))
 	    (goto-char (point-min))
 	    (search-forward hg-commit-message-start)
 	    (add-text-properties (match-beginning 0) (match-end 0)
 				 '(read-only t)))
 	  (hg-commit-mode)
           (cd root))))))
 
 (defun hg-diff (path &optional rev1 rev2)
   "Show the differences between REV1 and REV2 of PATH.
 When called interactively, the default behaviour is to treat REV1 as
 the \"parent\" revision, REV2 as the current edited version of the file, and
 PATH as the file edited in the current buffer.
 With a prefix argument, prompt for all of these."
   (interactive (list (hg-read-file-name " to diff")
                      (let ((rev1 (hg-read-rev " to start with" 'parent)))
 		       (and (not (eq rev1 'parent)) rev1))
 		     (let ((rev2 (hg-read-rev " to end with" 'working-dir)))
 		       (and (not (eq rev2 'working-dir)) rev2))))
   (hg-sync-buffers path)
   (let ((a-path (hg-abbrev-file-name path))
         ;; none revision is specified explicitly
         (none (and (not rev1) (not rev2)))
         ;; only one revision is specified explicitly
-        (one (or (and (or (equal rev1 rev2) (not rev2)) rev1) 
+        (one (or (and (or (equal rev1 rev2) (not rev2)) rev1)
                  (and (not rev1) rev2)))
 	diff)
     (hg-view-output ((cond
 		      (none
 		       (format "Mercurial: Diff against parent of %s" a-path))
 		      (one
 		       (format "Mercurial: Diff of rev %s of %s" one a-path))
 		      (t
 		       (format "Mercurial: Diff from rev %s to %s of %s"
 			       rev1 rev2 a-path))))
       (cond
-       (none 
+       (none
         (call-process (hg-binary) nil t nil "diff" path))
        (one
         (call-process (hg-binary) nil t nil "diff" "-r" one path))
        (t
         (call-process (hg-binary) nil t nil "diff" "-r" rev1 "-r" rev2 path)))
       (diff-mode)
       (setq diff (not (= (point-min) (point-max))))
       (font-lock-fontify-buffer)
       (cd (hg-root path)))
     diff))
 
 (defun hg-diff-repo (path &optional rev1 rev2)
   "Show the differences between REV1 and REV2 of repository containing PATH.
 When called interactively, the default behaviour is to treat REV1 as
 the \"parent\" revision, REV2 as the current edited version of the file, and
 PATH as the `hg-root' of the current buffer.
 With a prefix argument, prompt for all of these."
   (interactive (list (hg-read-file-name " to diff")
                      (let ((rev1 (hg-read-rev " to start with" 'parent)))
 		       (and (not (eq rev1 'parent)) rev1))
 		     (let ((rev2 (hg-read-rev " to end with" 'working-dir)))
 		       (and (not (eq rev2 'working-dir)) rev2))))
   (hg-diff (hg-root path) rev1 rev2))
 
 (defun hg-forget (path)
   "Lose track of PATH, which has been added, but not yet committed.
 This will prevent the file from being incorporated into the Mercurial
 repository on the next commit.
 With a prefix argument, prompt for the path to forget."
   (interactive (list (hg-read-file-name " to forget")))
   (let ((buf (current-buffer))
 	(update (equal buffer-file-name path)))
     (hg-view-output (hg-output-buffer-name)
       (apply 'call-process (hg-binary) nil t nil (list "forget" path))
       ;; "hg forget" shows pathes relative NOT TO ROOT BUT TO REPOSITORY
       (hg-fix-paths)
       (goto-char (point-min))
       (cd (hg-root path)))
     (when update
       (with-current-buffer buf
         (when (local-variable-p 'backup-inhibited)
           (kill-local-variable 'backup-inhibited))
 	(hg-mode-line)))))
 
 (defun hg-incoming (&optional repo)
   "Display changesets present in REPO that are not present locally."
   (interactive (list (hg-read-repo-name " where changes would come from")))
   (hg-view-output ((format "Mercurial: Incoming from %s to %s"
 			   (hg-abbrev-file-name (hg-root))
 			   (hg-abbrev-file-name
 			    (or repo hg-incoming-repository))))
     (call-process (hg-binary) nil t nil "incoming"
 		  (or repo hg-incoming-repository))
     (hg-log-mode)
     (cd (hg-root))))
 
 (defun hg-init ()
   (interactive)
   (error "not implemented"))
 
 (defun hg-log-mode ()
   "Mode for viewing a Mercurial change log."
   (goto-char (point-min))
   (when (looking-at "^searching for changes.*$")
     (delete-region (match-beginning 0) (match-end 0)))
   (run-hooks 'hg-log-mode-hook))
 
 (defun hg-log (path &optional rev1 rev2 log-limit)
   "Display the revision history of PATH.
 History is displayed between REV1 and REV2.
 Number of displayed changesets is limited to LOG-LIMIT.
 REV1 defaults to the tip, while REV2 defaults to 0.
 LOG-LIMIT defaults to `hg-log-limit'.
 With a prefix argument, prompt for each parameter."
   (interactive (list (hg-read-file-name " to log")
                      (hg-read-rev " to start with"
                                   "tip")
                      (hg-read-rev " to end with"
 				  "0")
                      (hg-read-number "Output limited to: "
                                      hg-log-limit)))
   (let ((a-path (hg-abbrev-file-name path))
         (r1 (or rev1 "tip"))
         (r2 (or rev2 "0"))
         (limit (format "%d" (or log-limit hg-log-limit))))
     (hg-view-output ((if (equal r1 r2)
                          (format "Mercurial: Log of rev %s of %s" rev1 a-path)
-                       (format 
+                       (format
                         "Mercurial: at most %s log(s) from rev %s to %s of %s"
                         limit r1 r2 a-path)))
       (eval (list* 'call-process (hg-binary) nil t nil
                    "log"
                    "-r" (format "%s:%s" r1 r2)
                    "-l" limit
                    (if (> (length path) (length (hg-root path)))
                        (cons path nil)
                      nil)))
       (hg-log-mode)
       (cd (hg-root path)))))
 
 (defun hg-log-repo (path &optional rev1 rev2 log-limit)
   "Display the revision history of the repository containing PATH.
 History is displayed between REV1 and REV2.
 Number of displayed changesets is limited to LOG-LIMIT,
 REV1 defaults to the tip, while REV2 defaults to 0.
 LOG-LIMIT defaults to `hg-log-limit'.
 With a prefix argument, prompt for each parameter."
   (interactive (list (hg-read-file-name " to log")
                      (hg-read-rev " to start with"
                                   "tip")
-                     (hg-read-rev " to end with" 
+                     (hg-read-rev " to end with"
 				  "0")
                      (hg-read-number "Output limited to: "
                                      hg-log-limit)))
   (hg-log (hg-root path) rev1 rev2 log-limit))
 
 (defun hg-outgoing (&optional repo)
   "Display changesets present locally that are not present in REPO."
   (interactive (list (hg-read-repo-name " where changes would go to" nil
 					hg-outgoing-repository)))
   (hg-view-output ((format "Mercurial: Outgoing from %s to %s"
 			   (hg-abbrev-file-name (hg-root))
 			   (hg-abbrev-file-name
 			    (or repo hg-outgoing-repository))))
     (call-process (hg-binary) nil t nil "outgoing"
 		  (or repo hg-outgoing-repository))
     (hg-log-mode)
     (cd (hg-root))))
 
 (defun hg-pull (&optional repo)
   "Pull changes from repository REPO.
 This does not update the working directory."
   (interactive (list (hg-read-repo-name " to pull from")))
   (hg-view-output ((format "Mercurial: Pull to %s from %s"
 			   (hg-abbrev-file-name (hg-root))
 			   (hg-abbrev-file-name
 			    (or repo hg-incoming-repository))))
     (call-process (hg-binary) nil t nil "pull"
 		  (or repo hg-incoming-repository))
     (cd (hg-root))))
 
 (defun hg-push (&optional repo)
   "Push changes to repository REPO."
   (interactive (list (hg-read-repo-name " to push to")))
   (hg-view-output ((format "Mercurial: Push from %s to %s"
 			   (hg-abbrev-file-name (hg-root))
 			   (hg-abbrev-file-name
 			    (or repo hg-outgoing-repository))))
     (call-process (hg-binary) nil t nil "push"
 		  (or repo hg-outgoing-repository))
     (cd (hg-root))))
 
 (defun hg-revert-buffer-internal ()
   (let ((ctx (hg-buffer-context)))
     (message "Reverting %s..." buffer-file-name)
     (hg-run0 "revert" buffer-file-name)
     (revert-buffer t t t)
     (hg-restore-context ctx)
     (hg-mode-line)
     (message "Reverting %s...done" buffer-file-name)))
 
 (defun hg-revert-buffer ()
   "Revert current buffer's file back to the latest committed version.
 If the file has not changed, nothing happens.  Otherwise, this
 displays a diff and asks for confirmation before reverting."
   (interactive)
   (let ((vc-suppress-confirm nil)
 	(obuf (current-buffer))
 	diff)
     (vc-buffer-sync)
     (unwind-protect
 	(setq diff (hg-diff buffer-file-name))
       (when diff
 	(unless (yes-or-no-p "Discard changes? ")
 	  (error "Revert cancelled")))
       (when diff
 	(let ((buf (current-buffer)))
 	  (delete-window (selected-window))
 	  (kill-buffer buf))))
     (set-buffer obuf)
     (when diff
       (hg-revert-buffer-internal))))
 
 (defun hg-root (&optional path)
   "Return the root of the repository that contains the given path.
 If the path is outside a repository, return nil.
 When called interactively, the root is printed.  A prefix argument
 prompts for a path to check."
   (interactive (list (hg-read-file-name)))
   (if (or path (not hg-root))
       (let ((root (do ((prev nil dir)
 		       (dir (file-name-directory
                              (or
                               path
                               buffer-file-name
                               (expand-file-name default-directory)))
 			    (file-name-directory (directory-file-name dir))))
 		      ((equal prev dir))
 		    (when (file-directory-p (concat dir ".hg"))
 		      (return dir)))))
 	(when (interactive-p)
 	  (if root
 	      (message "The root of this repository is `%s'." root)
 	    (message "The path `%s' is not in a Mercurial repository."
 		     (hg-abbrev-file-name path))))
 	root)
     hg-root))
 
 (defun hg-cwd (&optional path)
   "Return the current directory of PATH within the repository."
   (do ((stack nil (cons (file-name-nondirectory
 			 (directory-file-name dir))
 			stack))
        (prev nil dir)
        (dir (file-name-directory (or path buffer-file-name
 				     (expand-file-name default-directory)))
 	    (file-name-directory (directory-file-name dir))))
       ((equal prev dir))
     (when (file-directory-p (concat dir ".hg"))
       (let ((cwd (mapconcat 'identity stack "/")))
 	(unless (equal cwd "")
 	  (return (file-name-as-directory cwd)))))))
 
 (defun hg-status (path)
   "Print revision control status of a file or directory.
 With prefix argument, prompt for the path to give status for.
 Names are displayed relative to the repository root."
   (interactive (list (hg-read-file-name " for status" (hg-root))))
   (let ((root (hg-root)))
     (hg-view-output ((format "Mercurial: Status of %s in %s"
 			     (let ((name (substring (expand-file-name path)
 						    (length root))))
 			       (if (> (length name) 0)
 				   name
 				 "*"))
 			     (hg-abbrev-file-name root)))
       (apply 'call-process (hg-binary) nil t nil
 	     (list "--cwd" root "status" path))
       (cd (hg-root path)))))
 
 (defun hg-undo ()
   (interactive)
   (error "not implemented"))
 
 (defun hg-update ()
   (interactive)
   (error "not implemented"))
 
 (defun hg-version-other-window ()
   (interactive)
   (error "not implemented"))
 
 
 (provide 'mercurial)
 
 
 ;;; Local Variables:
 ;;; prompt-to-byte-compile: nil
 ;;; end:

contrib/mq.el

@@ -1,410 +1,410 b''
 ;;; mq.el --- Emacs support for Mercurial Queues
 
 ;; Copyright (C) 2006 Bryan O'Sullivan
 
 ;; Author: Bryan O'Sullivan <[e-mail]>
 
 ;; mq.el is free software; you can redistribute it and/or modify it
 ;; under the terms of version 2 of the GNU General Public License as
 ;; published by the Free Software Foundation.
 
 ;; mq.el 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 mq.el, GNU Emacs, or XEmacs; see the file COPYING (`C-h
 ;; C-l').  If not, write to the Free Software Foundation, Inc., 59
 ;; Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 (require 'mercurial)
 
 
 (defcustom mq-mode-hook nil
   "Hook run when a buffer enters mq-mode."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom mq-global-prefix "\C-cq"
   "The global prefix for Mercurial Queues keymap bindings."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom mq-edit-mode-hook nil
   "Hook run after a buffer is populated to edit a patch description."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom mq-edit-finish-hook nil
   "Hook run before a patch description is finished up with."
   :type 'sexp
   :group 'mercurial)
 
 (defcustom mq-signoff-address nil
   "Address with which to sign off on a patch."
   :type 'string
   :group 'mercurial)
 
 
 ;;; Internal variables.
 
 (defvar mq-mode nil
   "Is this file managed by MQ?")
 (make-variable-buffer-local 'mq-mode)
 (put 'mq-mode 'permanent-local t)
 
 (defvar mq-patch-history nil)
 
 (defvar mq-top-patch '(nil))
 
 (defvar mq-prev-buffer nil)
 (make-variable-buffer-local 'mq-prev-buffer)
 (put 'mq-prev-buffer 'permanent-local t)
 
 
 ;;; Global keymap.
 
 (defvar mq-global-map (make-sparse-keymap))
 (fset 'mq-global-map mq-global-map)
 (global-set-key mq-global-prefix 'mq-global-map)
 (define-key mq-global-map "." 'mq-push)
 (define-key mq-global-map ">" 'mq-push-all)
 (define-key mq-global-map "," 'mq-pop)
 (define-key mq-global-map "<" 'mq-pop-all)
 (define-key mq-global-map "=" 'mq-diff)
 (define-key mq-global-map "r" 'mq-refresh)
 (define-key mq-global-map "e" 'mq-refresh-edit)
 (define-key mq-global-map "i" 'mq-new)
 (define-key mq-global-map "n" 'mq-next)
 (define-key mq-global-map "o" 'mq-signoff)
 (define-key mq-global-map "p" 'mq-previous)
 (define-key mq-global-map "s" 'mq-edit-series)
 (define-key mq-global-map "t" 'mq-top)
 
 (add-minor-mode 'mq-mode 'mq-mode)
 
 
 ;;; Refresh edit mode keymap.
 
 (defvar mq-edit-mode-map (make-sparse-keymap))
 (define-key mq-edit-mode-map "\C-c\C-c" 'mq-edit-finish)
 (define-key mq-edit-mode-map "\C-c\C-k" 'mq-edit-kill)
 (define-key mq-edit-mode-map "\C-c\C-s" 'mq-signoff)
 
 
 ;;; Helper functions.
 
 (defun mq-read-patch-name (&optional source prompt force)
   "Read a patch name to use with a command.
 May return nil, meaning \"use the default\"."
   (let ((patches (split-string
 		  (hg-chomp (hg-run0 (or source "qseries"))) "\n")))
     (when force
       (completing-read (format "Patch%s: " (or prompt ""))
 		       (map 'list 'cons patches patches)
 		       nil
 		       nil
 		       nil
 		       'mq-patch-history))))
 
 (defun mq-refresh-buffers (root)
   (save-excursion
     (dolist (buf (hg-buffers-visiting-repo root))
       (when (not (verify-visited-file-modtime buf))
 	(set-buffer buf)
 	(let ((ctx (hg-buffer-context)))
 	  (message "Refreshing %s..." (buffer-name))
 	  (revert-buffer t t t)
 	  (hg-restore-context ctx)
 	  (message "Refreshing %s...done" (buffer-name))))))
   (hg-update-mode-lines root)
   (mq-update-mode-lines root))
 
 (defun mq-last-line ()
   (goto-char (point-max))
   (beginning-of-line)
   (when (looking-at "^$")
     (forward-line -1))
   (let ((bol (point)))
     (end-of-line)
     (let ((line (buffer-substring bol (point))))
       (when (> (length line) 0)
 	line))))
-  
+
 (defun mq-push (&optional patch)
   "Push patches until PATCH is reached.
 If PATCH is nil, push at most one patch."
   (interactive (list (mq-read-patch-name "qunapplied" " to push"
 					 current-prefix-arg)))
   (let ((root (hg-root))
 	(prev-buf (current-buffer))
 	last-line ok)
     (unless root
       (error "Cannot push outside a repository!"))
     (hg-sync-buffers root)
     (let ((buf-name (format "MQ: Push %s" (or patch "next patch"))))
       (kill-buffer (get-buffer-create buf-name))
       (split-window-vertically)
       (other-window 1)
       (switch-to-buffer (get-buffer-create buf-name))
       (cd root)
       (message "Pushing...")
       (setq ok (= 0 (apply 'call-process (hg-binary) nil t t "qpush"
 			   (if patch (list patch))))
 	    last-line (mq-last-line))
       (let ((lines (count-lines (point-min) (point-max))))
 	(if (or (<= lines 1)
 		(and (equal lines 2) (string-match "Now at:" last-line)))
 	    (progn
 	      (kill-buffer (current-buffer))
 	      (delete-window))
 	  (hg-view-mode prev-buf))))
     (mq-refresh-buffers root)
     (sit-for 0)
     (when last-line
       (if ok
 	  (message "Pushing... %s" last-line)
 	(error "Pushing... %s" last-line)))))
-  
+
 (defun mq-push-all ()
   "Push patches until all are applied."
   (interactive)
   (mq-push "-a"))
 
 (defun mq-pop (&optional patch)
   "Pop patches until PATCH is reached.
 If PATCH is nil, pop at most one patch."
   (interactive (list (mq-read-patch-name "qapplied" " to pop to"
 					 current-prefix-arg)))
   (let ((root (hg-root))
 	last-line ok)
     (unless root
       (error "Cannot pop outside a repository!"))
     (hg-sync-buffers root)
     (set-buffer (generate-new-buffer "qpop"))
     (cd root)
     (message "Popping...")
     (setq ok (= 0 (apply 'call-process (hg-binary) nil t t "qpop"
 			 (if patch (list patch))))
 	  last-line (mq-last-line))
     (kill-buffer (current-buffer))
     (mq-refresh-buffers root)
     (sit-for 0)
     (when last-line
       (if ok
 	  (message "Popping... %s" last-line)
 	(error "Popping... %s" last-line)))))
-  
+
 (defun mq-pop-all ()
   "Push patches until none are applied."
   (interactive)
   (mq-pop "-a"))
 
 (defun mq-refresh-internal (root &rest args)
   (hg-sync-buffers root)
   (let ((patch (mq-patch-info "qtop")))
     (message "Refreshing %s..." patch)
     (let ((ret (apply 'hg-run "qrefresh" args)))
       (if (equal (car ret) 0)
 	  (message "Refreshing %s... done." patch)
 	(error "Refreshing %s... %s" patch (hg-chomp (cdr ret)))))))
 
 (defun mq-refresh (&optional git)
   "Refresh the topmost applied patch.
 With a prefix argument, generate a git-compatible patch."
   (interactive "P")
   (let ((root (hg-root)))
     (unless root
       (error "Cannot refresh outside of a repository!"))
     (apply 'mq-refresh-internal root (if git '("--git")))))
 
 (defun mq-patch-info (cmd &optional msg)
   (let* ((ret (hg-run cmd))
 	 (info (hg-chomp (cdr ret))))
     (if (equal (car ret) 0)
 	(if msg
 	    (message "%s patch: %s" msg info)
 	  info)
       (error "%s" info))))
 
 (defun mq-top ()
   "Print the name of the topmost applied patch."
   (interactive)
   (mq-patch-info "qtop" "Top"))
 
 (defun mq-next ()
   "Print the name of the next patch to be pushed."
   (interactive)
   (mq-patch-info "qnext" "Next"))
 
 (defun mq-previous ()
   "Print the name of the first patch below the topmost applied patch.
 This would become the active patch if popped to."
   (interactive)
   (mq-patch-info "qprev" "Previous"))
 
 (defun mq-edit-finish ()
   "Finish editing the description of this patch, and refresh the patch."
   (interactive)
   (unless (equal (mq-patch-info "qtop") mq-top)
     (error "Topmost patch has changed!"))
   (hg-sync-buffers hg-root)
   (run-hooks 'mq-edit-finish-hook)
   (mq-refresh-internal hg-root "-m" (buffer-substring (point-min) (point-max)))
   (let ((buf mq-prev-buffer))
     (kill-buffer nil)
     (switch-to-buffer buf)))
-  
+
 (defun mq-edit-kill ()
   "Kill the edit currently being prepared."
   (interactive)
   (when (or (not (buffer-modified-p)) (y-or-n-p "Really kill this edit? "))
     (let ((buf mq-prev-buffer))
       (kill-buffer nil)
       (switch-to-buffer buf))))
 
 (defun mq-get-top (root)
   (let ((entry (assoc root mq-top-patch)))
     (if entry
         (cdr entry))))
 
 (defun mq-set-top (root patch)
   (let ((entry (assoc root mq-top-patch)))
     (if entry
         (if patch
             (setcdr entry patch)
           (setq mq-top-patch (delq entry mq-top-patch)))
       (setq mq-top-patch (cons (cons root patch) mq-top-patch)))))
 
 (defun mq-update-mode-lines (root)
   (let ((cwd default-directory))
     (cd root)
     (condition-case nil
         (mq-set-top root (mq-patch-info "qtop"))
       (error (mq-set-top root nil)))
     (cd cwd))
   (let ((patch (mq-get-top root)))
     (save-excursion
       (dolist (buf (hg-buffers-visiting-repo root))
         (set-buffer buf)
         (if mq-mode
             (setq mq-mode (or (and patch (concat " MQ:" patch)) " MQ")))))))
 	
 (defun mq-mode (&optional arg)
   "Minor mode for Mercurial repositories with an MQ patch queue"
   (interactive "i")
   (cond ((hg-root)
          (setq mq-mode (if (null arg) (not mq-mode)
                          arg))
          (mq-update-mode-lines (hg-root))))
   (run-hooks 'mq-mode-hook))
 
 (defun mq-edit-mode ()
   "Mode for editing the description of a patch.
 
 Key bindings
 ------------
 \\[mq-edit-finish]	use this description
 \\[mq-edit-kill]	abandon this description"
   (interactive)
   (use-local-map mq-edit-mode-map)
   (set-syntax-table text-mode-syntax-table)
   (setq local-abbrev-table text-mode-abbrev-table
 	major-mode 'mq-edit-mode
 	mode-name "MQ-Edit")
   (set-buffer-modified-p nil)
   (setq buffer-undo-list nil)
   (run-hooks 'text-mode-hook 'mq-edit-mode-hook))
-  
+
 (defun mq-refresh-edit ()
   "Refresh the topmost applied patch, editing the patch description."
   (interactive)
   (while mq-prev-buffer
     (set-buffer mq-prev-buffer))
   (let ((root (hg-root))
 	(prev-buffer (current-buffer))
 	(patch (mq-patch-info "qtop")))
     (hg-sync-buffers root)
     (let ((buf-name (format "*MQ: Edit description of %s*" patch)))
       (switch-to-buffer (get-buffer-create buf-name))
       (when (= (point-min) (point-max))
 	(set (make-local-variable 'hg-root) root)
 	(set (make-local-variable 'mq-top) patch)
 	(setq mq-prev-buffer prev-buffer)
 	(insert (hg-run0 "qheader"))
 	(goto-char (point-min)))
       (mq-edit-mode)
       (cd root)))
   (message "Type `C-c C-c' to finish editing and refresh the patch."))
 
 (defun mq-new (name)
   "Create a new empty patch named NAME.
 The patch is applied on top of the current topmost patch.
 With a prefix argument, forcibly create the patch even if the working
 directory is modified."
   (interactive (list (mq-read-patch-name "qseries" " to create" t)))
   (message "Creating patch...")
   (let ((ret (if current-prefix-arg
 		 (hg-run "qnew" "-f" name)
 	       (hg-run "qnew" name))))
     (if (equal (car ret) 0)
 	(progn
 	  (hg-update-mode-lines (buffer-file-name))
 	  (message "Creating patch... done."))
       (error "Creating patch... %s" (hg-chomp (cdr ret))))))
 
 (defun mq-edit-series ()
   "Edit the MQ series file directly."
   (interactive)
   (let ((root (hg-root)))
     (unless root
       (error "Not in an MQ repository!"))
     (find-file (concat root ".hg/patches/series"))))
 
 (defun mq-diff (&optional git)
   "Display a diff of the topmost applied patch.
 With a prefix argument, display a git-compatible diff."
   (interactive "P")
   (hg-view-output ((format "MQ: Diff of %s" (mq-patch-info "qtop")))
     (if git
 	(call-process (hg-binary) nil t nil "qdiff" "--git")
     (call-process (hg-binary) nil t nil "qdiff"))
     (diff-mode)
     (font-lock-fontify-buffer)))
 
 (defun mq-signoff ()
   "Sign off on the current patch, in the style used by the Linux kernel.
 If the variable mq-signoff-address is non-nil, it will be used, otherwise
 the value of the ui.username item from your hgrc will be used."
   (interactive)
   (let ((was-editing (eq major-mode 'mq-edit-mode))
 	signed)
     (unless was-editing
       (mq-refresh-edit))
     (save-excursion
       (let* ((user (or mq-signoff-address
 		       (hg-run0 "debugconfig" "ui.username")))
 	     (signoff (concat "Signed-off-by: " user)))
 	(if (search-forward signoff nil t)
 	    (message "You have already signed off on this patch.")
 	  (goto-char (point-max))
 	  (let ((case-fold-search t))
 	    (if (re-search-backward "^Signed-off-by: " nil t)
 		(forward-line 1)
 	      (insert "\n")))
 	  (insert signoff)
 	  (message "%s" signoff)
 	  (setq signed t))))
     (unless was-editing
       (if signed
 	  (mq-edit-finish)
 	(mq-edit-kill)))))
 
 
 (provide 'mq)
 
 
 ;;; Local Variables:
 ;;; prompt-to-byte-compile: nil
 ;;; end:

contrib/simplemerge

@@ -1,562 +1,562 b''
 #!/usr/bin/env python
 # Copyright (C) 2004, 2005 Canonical Ltd
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 
 # mbp: "you know that thing where cvs gives you conflict markers?"
 # s: "i hate that."
 
 from mercurial import demandimport
 demandimport.enable()
 
 from mercurial import util, mdiff, fancyopts
 from mercurial.i18n import _
 
 
 class CantReprocessAndShowBase(Exception):
     pass
-    
+
 
 def warn(message):
     sys.stdout.flush()
     sys.stderr.write(message)
     sys.stderr.flush()
 
 
 def intersect(ra, rb):
     """Given two ranges return the range where they intersect or None.
 
     >>> intersect((0, 10), (0, 6))
     (0, 6)
     >>> intersect((0, 10), (5, 15))
     (5, 10)
     >>> intersect((0, 10), (10, 15))
     >>> intersect((0, 9), (10, 15))
     >>> intersect((0, 9), (7, 15))
     (7, 9)
     """
     assert ra[0] <= ra[1]
     assert rb[0] <= rb[1]
-    
+
     sa = max(ra[0], rb[0])
     sb = min(ra[1], rb[1])
     if sa < sb:
         return sa, sb
     else:
         return None
 
 
 def compare_range(a, astart, aend, b, bstart, bend):
     """Compare a[astart:aend] == b[bstart:bend], without slicing.
     """
     if (aend-astart) != (bend-bstart):
         return False
     for ia, ib in zip(xrange(astart, aend), xrange(bstart, bend)):
         if a[ia] != b[ib]:
             return False
     else:
         return True
-        
+
 
 
 
 class Merge3Text(object):
     """3-way merge of texts.
 
     Given strings BASE, OTHER, THIS, tries to produce a combined text
     incorporating the changes from both BASE->OTHER and BASE->THIS."""
     def __init__(self, basetext, atext, btext, base=None, a=None, b=None):
         self.basetext = basetext
         self.atext = atext
         self.btext = btext
         if base is None:
             base = mdiff.splitnewlines(basetext)
         if a is None:
             a = mdiff.splitnewlines(atext)
         if b is None:
             b = mdiff.splitnewlines(btext)
         self.base = base
         self.a = a
         self.b = b
 
 
 
     def merge_lines(self,
                     name_a=None,
                     name_b=None,
                     name_base=None,
                     start_marker='<<<<<<<',
                     mid_marker='=======',
                     end_marker='>>>>>>>',
                     base_marker=None,
                     reprocess=False):
         """Return merge in cvs-like form.
         """
         self.conflicts = False
         newline = '\n'
         if len(self.a) > 0:
             if self.a[0].endswith('\r\n'):
                 newline = '\r\n'
             elif self.a[0].endswith('\r'):
                 newline = '\r'
         if base_marker and reprocess:
             raise CantReprocessAndShowBase()
         if name_a:
             start_marker = start_marker + ' ' + name_a
         if name_b:
             end_marker = end_marker + ' ' + name_b
         if name_base and base_marker:
             base_marker = base_marker + ' ' + name_base
         merge_regions = self.merge_regions()
         if reprocess is True:
             merge_regions = self.reprocess_merge_regions(merge_regions)
         for t in merge_regions:
             what = t[0]
             if what == 'unchanged':
                 for i in range(t[1], t[2]):
                     yield self.base[i]
             elif what == 'a' or what == 'same':
                 for i in range(t[1], t[2]):
                     yield self.a[i]
             elif what == 'b':
                 for i in range(t[1], t[2]):
                     yield self.b[i]
             elif what == 'conflict':
                 self.conflicts = True
                 yield start_marker + newline
                 for i in range(t[3], t[4]):
                     yield self.a[i]
                 if base_marker is not None:
                     yield base_marker + newline
                     for i in range(t[1], t[2]):
                         yield self.base[i]
                 yield mid_marker + newline
                 for i in range(t[5], t[6]):
                     yield self.b[i]
                 yield end_marker + newline
             else:
                 raise ValueError(what)
-        
-        
+
+
 
 
 
     def merge_annotated(self):
         """Return merge with conflicts, showing origin of lines.
 
-        Most useful for debugging merge.        
+        Most useful for debugging merge.
         """
         for t in self.merge_regions():
             what = t[0]
             if what == 'unchanged':
                 for i in range(t[1], t[2]):
                     yield 'u | ' + self.base[i]
             elif what == 'a' or what == 'same':
                 for i in range(t[1], t[2]):
                     yield what[0] + ' | ' + self.a[i]
             elif what == 'b':
                 for i in range(t[1], t[2]):
                     yield 'b | ' + self.b[i]
             elif what == 'conflict':
                 yield '<<<<\n'
                 for i in range(t[3], t[4]):
                     yield 'A | ' + self.a[i]
                 yield '----\n'
                 for i in range(t[5], t[6]):
                     yield 'B | ' + self.b[i]
                 yield '>>>>\n'
             else:
                 raise ValueError(what)
-        
-        
+
+
 
 
 
     def merge_groups(self):
         """Yield sequence of line groups.  Each one is a tuple:
 
         'unchanged', lines
              Lines unchanged from base
 
         'a', lines
              Lines taken from a
 
         'same', lines
              Lines taken from a (and equal to b)
 
         'b', lines
              Lines taken from b
 
         'conflict', base_lines, a_lines, b_lines
              Lines from base were changed to either a or b and conflict.
         """
         for t in self.merge_regions():
             what = t[0]
             if what == 'unchanged':
                 yield what, self.base[t[1]:t[2]]
             elif what == 'a' or what == 'same':
                 yield what, self.a[t[1]:t[2]]
             elif what == 'b':
                 yield what, self.b[t[1]:t[2]]
             elif what == 'conflict':
                 yield (what,
                        self.base[t[1]:t[2]],
                        self.a[t[3]:t[4]],
                        self.b[t[5]:t[6]])
             else:
                 raise ValueError(what)
 
 
     def merge_regions(self):
         """Return sequences of matching and conflicting regions.
 
         This returns tuples, where the first value says what kind we
         have:
 
         'unchanged', start, end
              Take a region of base[start:end]
 
         'same', astart, aend
              b and a are different from base but give the same result
 
         'a', start, end
              Non-clashing insertion from a[start:end]
 
         Method is as follows:
 
         The two sequences align only on regions which match the base
         and both descendents.  These are found by doing a two-way diff
         of each one against the base, and then finding the
         intersections between those regions.  These "sync regions"
         are by definition unchanged in both and easily dealt with.
 
         The regions in between can be in any of three cases:
         conflicted, or changed on only one side.
         """
 
         # section a[0:ia] has been disposed of, etc
         iz = ia = ib = 0
-        
+
         for zmatch, zend, amatch, aend, bmatch, bend in self.find_sync_regions():
             #print 'match base [%d:%d]' % (zmatch, zend)
-            
+
             matchlen = zend - zmatch
             assert matchlen >= 0
             assert matchlen == (aend - amatch)
             assert matchlen == (bend - bmatch)
-            
+
             len_a = amatch - ia
             len_b = bmatch - ib
             len_base = zmatch - iz
             assert len_a >= 0
             assert len_b >= 0
             assert len_base >= 0
 
             #print 'unmatched a=%d, b=%d' % (len_a, len_b)
 
             if len_a or len_b:
                 # try to avoid actually slicing the lists
                 equal_a = compare_range(self.a, ia, amatch,
                                         self.base, iz, zmatch)
                 equal_b = compare_range(self.b, ib, bmatch,
                                         self.base, iz, zmatch)
                 same = compare_range(self.a, ia, amatch,
                                      self.b, ib, bmatch)
 
                 if same:
                     yield 'same', ia, amatch
                 elif equal_a and not equal_b:
                     yield 'b', ib, bmatch
                 elif equal_b and not equal_a:
                     yield 'a', ia, amatch
                 elif not equal_a and not equal_b:
                     yield 'conflict', iz, zmatch, ia, amatch, ib, bmatch
                 else:
                     raise AssertionError("can't handle a=b=base but unmatched")
 
                 ia = amatch
                 ib = bmatch
             iz = zmatch
 
             # if the same part of the base was deleted on both sides
             # that's OK, we can just skip it.
 
-                
+
             if matchlen > 0:
                 assert ia == amatch
                 assert ib == bmatch
                 assert iz == zmatch
-                
+
                 yield 'unchanged', zmatch, zend
                 iz = zend
                 ia = aend
                 ib = bend
-    
+
 
     def reprocess_merge_regions(self, merge_regions):
         """Where there are conflict regions, remove the agreed lines.
 
-        Lines where both A and B have made the same changes are 
+        Lines where both A and B have made the same changes are
         eliminated.
         """
         for region in merge_regions:
             if region[0] != "conflict":
                 yield region
                 continue
             type, iz, zmatch, ia, amatch, ib, bmatch = region
             a_region = self.a[ia:amatch]
             b_region = self.b[ib:bmatch]
             matches = mdiff.get_matching_blocks(''.join(a_region),
                                                 ''.join(b_region))
             next_a = ia
             next_b = ib
             for region_ia, region_ib, region_len in matches[:-1]:
                 region_ia += ia
                 region_ib += ib
                 reg = self.mismatch_region(next_a, region_ia, next_b,
                                            region_ib)
                 if reg is not None:
                     yield reg
                 yield 'same', region_ia, region_len+region_ia
                 next_a = region_ia + region_len
                 next_b = region_ib + region_len
             reg = self.mismatch_region(next_a, amatch, next_b, bmatch)
             if reg is not None:
                 yield reg
 
 
     def mismatch_region(next_a, region_ia,  next_b, region_ib):
         if next_a < region_ia or next_b < region_ib:
             return 'conflict', None, None, next_a, region_ia, next_b, region_ib
     mismatch_region = staticmethod(mismatch_region)
-            
+
 
     def find_sync_regions(self):
         """Return a list of sync regions, where both descendents match the base.
 
         Generates a list of (base1, base2, a1, a2, b1, b2).  There is
         always a zero-length sync region at the end of all the files.
         """
 
         ia = ib = 0
         amatches = mdiff.get_matching_blocks(self.basetext, self.atext)
         bmatches = mdiff.get_matching_blocks(self.basetext, self.btext)
         len_a = len(amatches)
         len_b = len(bmatches)
 
         sl = []
 
         while ia < len_a and ib < len_b:
             abase, amatch, alen = amatches[ia]
             bbase, bmatch, blen = bmatches[ib]
 
             # there is an unconflicted block at i; how long does it
             # extend?  until whichever one ends earlier.
             i = intersect((abase, abase+alen), (bbase, bbase+blen))
             if i:
                 intbase = i[0]
                 intend = i[1]
                 intlen = intend - intbase
 
                 # found a match of base[i[0], i[1]]; this may be less than
                 # the region that matches in either one
                 assert intlen <= alen
                 assert intlen <= blen
                 assert abase <= intbase
                 assert bbase <= intbase
 
                 asub = amatch + (intbase - abase)
                 bsub = bmatch + (intbase - bbase)
                 aend = asub + intlen
                 bend = bsub + intlen
 
                 assert self.base[intbase:intend] == self.a[asub:aend], \
                        (self.base[intbase:intend], self.a[asub:aend])
 
                 assert self.base[intbase:intend] == self.b[bsub:bend]
 
                 sl.append((intbase, intend,
                            asub, aend,
                            bsub, bend))
 
             # advance whichever one ends first in the base text
             if (abase + alen) < (bbase + blen):
                 ia += 1
             else:
                 ib += 1
-            
+
         intbase = len(self.base)
         abase = len(self.a)
         bbase = len(self.b)
         sl.append((intbase, intbase, abase, abase, bbase, bbase))
 
         return sl
 
 
 
     def find_unconflicted(self):
         """Return a list of ranges in base that are not conflicted."""
         am = mdiff.get_matching_blocks(self.basetext, self.atext)
         bm = mdiff.get_matching_blocks(self.basetext, self.btext)
 
         unc = []
 
         while am and bm:
             # there is an unconflicted block at i; how long does it
             # extend?  until whichever one ends earlier.
             a1 = am[0][0]
             a2 = a1 + am[0][2]
             b1 = bm[0][0]
             b2 = b1 + bm[0][2]
             i = intersect((a1, a2), (b1, b2))
             if i:
                 unc.append(i)
 
             if a2 < b2:
                 del am[0]
             else:
                 del bm[0]
-                
+
         return unc
 
 
 # bzr compatible interface, for the tests
 class Merge3(Merge3Text):
     """3-way merge of texts.
 
     Given BASE, OTHER, THIS, tries to produce a combined text
     incorporating the changes from both BASE->OTHER and BASE->THIS.
     All three will typically be sequences of lines."""
     def __init__(self, base, a, b):
         basetext = '\n'.join([i.strip('\n') for i in base] + [''])
         atext = '\n'.join([i.strip('\n') for i in a] + [''])
         btext = '\n'.join([i.strip('\n') for i in b] + [''])
         if util.binary(basetext) or util.binary(atext) or util.binary(btext):
             raise util.Abort(_("don't know how to merge binary files"))
         Merge3Text.__init__(self, basetext, atext, btext, base, a, b)
 
 
 def simplemerge(local, base, other, **opts):
     def readfile(filename):
         f = open(filename, "rb")
         text = f.read()
         f.close()
         if util.binary(text):
             msg = _("%s looks like a binary file.") % filename
             if not opts.get('text'):
                 raise util.Abort(msg)
             elif not opts.get('quiet'):
                 warn(_('warning: %s\n') % msg)
         return text
 
     name_a = local
     name_b = other
     labels = opts.get('label', [])
     if labels:
         name_a = labels.pop(0)
     if labels:
         name_b = labels.pop(0)
     if labels:
         raise util.Abort(_("can only specify two labels."))
 
     localtext = readfile(local)
     basetext = readfile(base)
     othertext = readfile(other)
 
     orig = local
     local = os.path.realpath(local)
     if not opts.get('print'):
         opener = util.opener(os.path.dirname(local))
         out = opener(os.path.basename(local), "w", atomictemp=True)
     else:
         out = sys.stdout
 
     reprocess = not opts.get('no_minimal')
 
     m3 = Merge3Text(basetext, localtext, othertext)
     for line in m3.merge_lines(name_a=name_a, name_b=name_b,
                                reprocess=reprocess):
         out.write(line)
 
     if not opts.get('print'):
         out.rename()
 
     if m3.conflicts:
         if not opts.get('quiet'):
             warn(_("warning: conflicts during merge.\n"))
         return 1
 
 options = [('L', 'label', [], _('labels to use on conflict markers')),
            ('a', 'text', None, _('treat all files as text')),
            ('p', 'print', None,
             _('print results instead of overwriting LOCAL')),
            ('', 'no-minimal', None,
             _('do not try to minimize conflict regions')),
            ('h', 'help', None, _('display help and exit')),
            ('q', 'quiet', None, _('suppress output'))]
 
 usage = _('''simplemerge [OPTS] LOCAL BASE OTHER
 
     Simple three-way file merge utility with a minimal feature set.
-    
+
     Apply to LOCAL the changes necessary to go from BASE to OTHER.
-    
+
     By default, LOCAL is overwritten with the results of this operation.
 ''')
 
 def showhelp():
     sys.stdout.write(usage)
     sys.stdout.write('\noptions:\n')
 
     out_opts = []
     for shortopt, longopt, default, desc in options:
         out_opts.append(('%2s%s' % (shortopt and '-%s' % shortopt,
                                     longopt and ' --%s' % longopt),
                          '%s' % desc))
     opts_len = max([len(opt[0]) for opt in out_opts])
     for first, second in out_opts:
         sys.stdout.write(' %-*s  %s\n' % (opts_len, first, second))
 
 class ParseError(Exception):
     """Exception raised on errors in parsing the command line."""
 
 def main(argv):
     try:
         opts = {}
         try:
             args = fancyopts.fancyopts(argv[1:], options, opts)
         except fancyopts.getopt.GetoptError, e:
             raise ParseError(e)
         if opts['help']:
             showhelp()
             return 0
         if len(args) != 3:
                 raise ParseError(_('wrong number of arguments'))
         return simplemerge(*args, **opts)
     except ParseError, e:
         sys.stdout.write("%s: %s\n" % (sys.argv[0], e))
         showhelp()
         return 1
     except util.Abort, e:
         sys.stderr.write("abort: %s\n" % e)
         return 255
     except KeyboardInterrupt:
         return 255
 
 if __name__ == '__main__':
     import sys
     import os
     sys.exit(main(sys.argv))

contrib/vim/hg-menu.vim

@@ -1,93 +1,93 b''
 " vim600: set foldmethod=marker:
 " =============================================================================
 "  Name Of File: hg-menu.vim
 "   Description: Interface to Mercurial Version Control.
 "        Author: Steve Borho (modified Jeff Lanzarotta's RCS script)
 "          Date: Wednesday, October 5, 2005
 "       Version: 0.1.0
 "     Copyright: None.
 "         Usage: These command and gui menu displays useful hg functions
 " Configuration: Your hg executable must be in your path.
 " =============================================================================
- 
+
 " Section: Init {{{1
 if exists("loaded_hg_menu")
   finish
 endif
 let loaded_hg_menu = 1
 
 " Section: Menu Options {{{1
 if has("gui")
 "  amenu H&G.Commit\ File<Tab>,ci :!hg commit %<CR>:e!<CR>
 "  amenu H&G.Commit\ All<Tab>,call :!hg commit<CR>:e!<CR>
 "  amenu H&G.-SEP1-        <nul>
   amenu H&G.Add<Tab>\\add :!hg add %<CR><CR>
   amenu H&G.Forget\ Add<Tab>\\fgt :!hg forget %<CR><CR>
   amenu H&G.Show\ Differences<Tab>\\diff :call ShowResults("FileDiff", "hg\ diff")<CR><CR>
   amenu H&G.Revert\ to\ Last\ Version<Tab>\\revert :!hg revert %<CR>:e!<CR>
   amenu H&G.Show\ History<Tab>\\log :call ShowResults("FileLog", "hg\ log")<CR><CR>
   amenu H&G.Annotate<Tab>\\an :call ShowResults("annotate", "hg\ annotate")<CR><CR>
   amenu H&G.-SEP1-        <nul>
   amenu H&G.Repo\ Status<Tab>\\stat :call ShowResults("RepoStatus", "hg\ status")<CR><CR>
   amenu H&G.Pull<Tab>\\pull :!hg pull<CR>:e!<CR>
   amenu H&G.Update<Tab>\\upd :!hg update<CR>:e!<CR>
 endif
 
 " Section: Mappings {{{1
 if(v:version >= 600)
   " The default Leader is \ 'backslash'
   map <Leader>add       :!hg add %<CR><CR>
   map <Leader>fgt       :!hg forget %<CR><CR>
   map <Leader>diff      :call ShowResults("FileDiff", "hg\ diff")<CR><CR>
   map <Leader>revert    :!hg revert %<CR>:e!<CR>
   map <Leader>log       :call ShowResults("FileLog", "hg\ log")<CR><CR>
   map <Leader>an        :call ShowResults("annotate", "hg\ annotate")<CR><CR>
   map <Leader>stat      :call ShowResults("RepoStatus", "hg\ status")<CR><CR>
   map <Leader>upd       :!hg update<CR>:e!<CR>
   map <Leader>pull      :!hg pull<CR>:e!<CR>
 else
   " pre 6.0, the default Leader was a comma
   map ,add          :!hg add %<CR><CR>
   map ,fgt          :!hg forget %<CR><CR>
   map ,diff         :call ShowResults("FileDiff", "hg\ diff")<CR><CR>
   map ,revert       :!hg revert<CR>:e!<CR>
   map ,log          :call ShowResults("FileLog", "hg\ log")<CR><CR>
   map ,an           :call ShowResults("annotate", "hg\ annotate")<CR><CR>
   map ,stat         :call ShowResults("RepoStatus", "hg\ status")<CR><CR>
   map ,upd          :!hg update<CR>:e!<CR>
   map ,pull         :!hg pull<CR>:e!<CR>
 endif
 
 " Section: Functions {{{1
 " Show the log results of the current file with a revision control system.
 function! ShowResults(bufferName, cmdName)
   " Modify the shortmess option:
   " A  don't give the "ATTENTION" message when an existing swap file is
   "    found.
   set shortmess+=A
 
   " Get the name of the current buffer.
   let currentBuffer = bufname("%")
 
   " If a buffer with the name rlog exists, delete it.
   if bufexists(a:bufferName)
     execute 'bd! ' a:bufferName
   endif
 
   " Create a new buffer.
   execute 'new ' a:bufferName
 
   " Execute the command.
   execute 'r!' a:cmdName ' ' currentBuffer
 
   " Make is so that the file can't be edited.
   setlocal nomodified
   setlocal nomodifiable
   setlocal readonly
 
   " Go to the beginning of the buffer.
   execute "normal 1G"
 
   " Restore the shortmess option.
   set shortmess-=A
 endfunction

contrib/win32/ReadMe.html

@@ -1,112 +1,112 b''
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
   <head>
     <title>Mercurial for Windows</title>
-    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" >  
+    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" >
     <style type="text/css">
       <!--
       .indented
       {
       padding-left: 10pt;
       }
       -->
     </style>
   </head>
 
   <body>
     <h1>Mercurial for Windows</h1>
 
     <p>Welcome to Mercurial for Windows!</p>
 
     <p>Mercurial is a command-line application.  You must run it from
       the Windows command prompt (or if you're hard core, a <a
       href="http://www.mingw.org/">MinGW</a> shell).</p>
-    
+
     <p><div class="indented"><i>Note: the standard <a
       href="http://www.mingw.org/">MinGW</a> msys startup script uses
       rxvt which has problems setting up standard input and output.
       Running bash directly works correctly.</i></div>
 
     <p>For documentation, please visit the <a
       href="http://www.selenic.com/mercurial">Mercurial web site</a>.
       You can also download a free book, <a
       href="http://hgbook.red-bean.com/">Distributed revision control
       with Mercurial</a>.</p>
 
     <p>By default, Mercurial installs to <tt>C:\Mercurial</tt>.  The
       Mercurial command is called <tt>hg.exe</tt>.</p>
 
     <h1>Testing Mercurial after you've installed it</h1>
 
     <p>The easiest way to check that Mercurial is installed properly is to
       just type the following at the command prompt:</p>
 
     <pre>
 hg
 </pre>
 
     <p>This command should print a useful help message.  If it does,
       other Mercurial commands should work fine for you.</p>
 
     <h1>Configuration notes</h1>
 	<h4>Default editor</h4>
 	The default editor for commit messages is 'notepad'. You can set the EDITOR
     (or HGEDITOR) environment variable to specify your preference or set it in
     mercurial.ini:
     <pre>
 [ui]
 editor = whatever
 </pre>
 
 	<h4>Configuring a Merge program</h4>
-	It should be emphasized that Mercurial by itself doesn't attempt to do a 
+	It should be emphasized that Mercurial by itself doesn't attempt to do a
 	Merge at the file level, neither does it make any attempt to Resolve the conflicts.
 
-    By default, Mercurial will use the merge program defined by the HGMERGE environment 
+    By default, Mercurial will use the merge program defined by the HGMERGE environment
     variable, or uses the one defined in the mercurial.ini file. (see <a href="http://www.selenic.com/mercurial/wiki/index.cgi/MergeProgram">MergeProgram</a> on the Mercurial Wiki for more information)
 
     <h1>Reporting problems</h1>
 
     <p>Before you report any problems, please consult the <a
 	href="http://www.selenic.com/mercurial">Mercurial web site</a> and
       see if your question is already in our list of <a
 	href="http://www.selenic.com/mercurial/wiki/index.cgi/FAQ">Frequently
 	Answered Questions</a> (the "FAQ").
 
     <p>If you cannot find an answer to your question, please feel
       free to send mail to the Mercurial mailing list, at <a
 	href="mailto:[e-mail]">[e-mail]</a>.
       <b>Remember</b>, the more useful information you include in your
       report, the easier it will be for us to help you!</p>
 
     <p>If you are IRC-savvy, that's usually the fastest way to get
       help.  Go to <tt>#mercurial</tt> on
       <tt>irc.freenode.net</tt>.</p>
 
     <h1>Author and copyright information</h1>
 
     <p>Mercurial was written by <a href="http://www.selenic.com">Matt
 	Mackall</a>, and is maintained by Matt and a team of
 	volunteers.</p>
 
     <p>The Windows installer was written by <a
 	href="http://www.serpentine.com/blog">Bryan
 	O'Sullivan</a>.</p>
 
     <p>Mercurial is Copyright 2005-2007 Matt Mackall and others.
 	See the <tt>Contributors.txt</tt> file for a list of contributors.</p>
 
     <p>Mercurial is free software; you can redistribute it and/or
       modify it under the terms of the <a
 	href="http://www.gnu.org/copyleft/gpl.html">GNU General Public
 	License</a> as published by the Free Software Foundation; either
       version 2 of the License, or (at your option) any later
       version.</p>
 
     <p>Mercurial is distributed in the hope that it will be useful,
       but <b>without any warranty</b>; without even the implied
       warranty of <b>merchantability</b> or <b>fitness for a
       particular purpose</b>.  See the GNU General Public License for
       more details.</p>
   </body>
 </html>

contrib/win32/mercurial.ini

@@ -1,41 +1,41 b''
 ; System-wide Mercurial config file.  To override these settings on a
 ; per-user basis, please edit the following file instead, where
 ; USERNAME is your Windows user name:
 ;   C:\Documents and Settings\USERNAME\Mercurial.ini
 
-[ui] 
+[ui]
 editor = notepad
 
 ; By default, we try to encode and decode all files that do not
 ; contain ASCII NUL characters.  What this means is that we try to set
 ; line endings to Windows style on update, and to Unix style on
 ; commit.  This lets us cooperate with Linux and Unix users, so
 ; everybody sees files with their native line endings.
 
 [extensions]
 ; The win32text extension is available and installed by default.  It
 ; provides built-in Python hooks to perform line ending conversions.
 ; This is normally much faster than running an external program.
 hgext.win32text =
 
 
 [encode]
 ; Encode files that don't contain NUL characters.
 
 ; ** = cleverencode:
 
 ; Alternatively, you can explicitly specify each file extension that
 ; you want encoded (any you omit will be left untouched), like this:
 
 ; *.txt = dumbencode:
 
 
 [decode]
 ; Decode files that don't contain NUL characters.
 
 ; ** = cleverdecode:
 
 ; Alternatively, you can explicitly specify each file extension that
 ; you want decoded (any you omit will be left untouched), like this:
 
 ; **.txt = dumbdecode:

contrib/win32/win32-build.txt

@@ -1,71 +1,71 b''
 The standalone Windows installer for Mercurial is built in a somewhat
 jury-rigged fashion.
 
 It has the following prerequisites, at least as I build it:
 
   Python for Windows
       http://www.python.org/ftp/python/2.4.3/python-2.4.3.msi
 
   MinGW
       http://www.mingw.org/
 
   Python for Windows Extensions
       http://sourceforge.net/projects/pywin32/
 
   mfc71.dll (just download, don't install)
       http://starship.python.net/crew/mhammond/win32/
 
   The py2exe distutils extension
       http://sourceforge.net/projects/py2exe/
 
   Inno Setup
       http://www.jrsoftware.org/isinfo.php
 
   ISTool - optional
       http://www.istool.org/default.aspx/
 
   add_path (you need only add_path.exe in the zip file)
       http://www.barisione.org/apps.html#add_path
 
 And, of course, Mercurial itself.
 
 Once you have all this installed and built, clone a copy of the
 Mercurial repository you want to package, and name the repo
 C:\hg\hg-release.
 
 In a shell, build a standalone copy of the hg.exe program:
 
-  python setup.py build -c mingw32 
+  python setup.py build -c mingw32
   python setup.py py2exe -b 1
 
 Note: the previously suggested combined command of "python setup.py build -c
 mingw32 py2exe -b 1" doesn't work correctly anymore as it doesn't include the
 extensions in the mercurial subdirectory.
 
 If you want to create a file named setup.cfg with the contents:
 
 [build]
 compiler=mingw32
 
 you can skip the first build step.
 
 Copy mfc71.dll and add_path.exe into the dist directory that just got created.
 
 If you use ISTool, you open the C:\hg\hg-release\contrib\win32\mercurial.iss
 file and type Ctrl-F9 to compile the installer file.
 
 Otherwise you run the Inno Setup compiler.  Assuming it's on the path you run:
 
   iscc contrib\win32\mercurial.iss
 
 The actual installer will be in the C:\hg\hg-release\Output directory.
 
 To automate the steps above you may want to create a batchfile based on the
 following:
 
   echo [build] > setup.cfg
   echo compiler=mingw32 >> setup.cfg
   python setup.py py2exe -b 1
   iscc contrib\win32\mercurial.iss
 
 and run it from the root of the hg repository (c:\hg\hg-release).

doc/hgrc.5.txt

@@ -1,579 +1,579 b''
 HGRC(5)
 =======
 Bryan O'Sullivan <[e-mail]>
 
 NAME
 ----
 hgrc - configuration files for Mercurial
 
 SYNOPSIS
 --------
 
 The Mercurial system uses a set of configuration files to control
 aspects of its behaviour.
 
 FILES
 -----
 
 Mercurial reads configuration data from several files, if they exist.
 The names of these files depend on the system on which Mercurial is
 installed.
 
 (Unix)    <install-root>/etc/mercurial/hgrc.d/*.rc::
 (Unix)    <install-root>/etc/mercurial/hgrc::
     Per-installation configuration files, searched for in the
     directory where Mercurial is installed.  For example, if installed
     in /shared/tools, Mercurial will look in
     /shared/tools/etc/mercurial/hgrc.  Options in these files apply to
     all Mercurial commands executed by any user in any directory.
 
 (Unix)    /etc/mercurial/hgrc.d/*.rc::
 (Unix)    /etc/mercurial/hgrc::
 (Windows) C:\Mercurial\Mercurial.ini::
     Per-system configuration files, for the system on which Mercurial
     is running.  Options in these files apply to all Mercurial
     commands executed by any user in any directory.  Options in these
     files override per-installation options.
 
 (Unix)    $HOME/.hgrc::
 (Windows) C:\Documents and Settings\USERNAME\Mercurial.ini::
 (Windows) $HOME\Mercurial.ini::
     Per-user configuration file, for the user running Mercurial.
     Options in this file apply to all Mercurial commands executed by
     any user in any directory.  Options in this file override
     per-installation and per-system options.
     On Windows system, one of these is chosen exclusively according
     to definition of HOME environment variable.
 
 (Unix, Windows) <repo>/.hg/hgrc::
     Per-repository configuration options that only apply in a
     particular repository.  This file is not version-controlled, and
     will not get transferred during a "clone" operation.  Options in
     this file override options in all other configuration files.
     On Unix, most of this file will be ignored if it doesn't belong
     to a trusted user or to a trusted group.  See the documentation
     for the trusted section below for more details.
 
 SYNTAX
 ------
 
 A configuration file consists of sections, led by a "[section]" header
 and followed by "name: value" entries; "name=value" is also accepted.
 
     [spam]
     eggs=ham
     green=
        eggs
 
 Each line contains one entry.  If the lines that follow are indented,
 they are treated as continuations of that entry.
 
 Leading whitespace is removed from values.  Empty lines are skipped.
 
 The optional values can contain format strings which refer to other
 values in the same section, or values in a special DEFAULT section.
 
 Lines beginning with "#" or ";" are ignored and may be used to provide
 comments.
 
 SECTIONS
 --------
 
 This section describes the different sections that may appear in a
 Mercurial "hgrc" file, the purpose of each section, its possible
 keys, and their possible values.
 
 decode/encode::
   Filters for transforming files on checkout/checkin. This would
   typically be used for newline processing or other
   localization/canonicalization of files.
 
   Filters consist of a filter pattern followed by a filter command.
   Filter patterns are globs by default, rooted at the repository
   root.  For example, to match any file ending in ".txt" in the root
   directory only, use the pattern "*.txt".  To match any file ending
   in ".c" anywhere in the repository, use the pattern "**.c".
 
   The filter command can start with a specifier, either "pipe:" or
   "tempfile:".  If no specifier is given, "pipe:" is used by default.
 
   A "pipe:" command must accept data on stdin and return the
   transformed data on stdout.
 
   Pipe example:
 
     [encode]
     # uncompress gzip files on checkin to improve delta compression
     # note: not necessarily a good idea, just an example
     *.gz = pipe: gunzip
 
     [decode]
     # recompress gzip files when writing them to the working dir (we
     # can safely omit "pipe:", because it's the default)
     *.gz = gzip
 
   A "tempfile:" command is a template.  The string INFILE is replaced
   with the name of a temporary file that contains the data to be
   filtered by the command.  The string OUTFILE is replaced with the
   name of an empty temporary file, where the filtered data must be
   written by the command.
 
   NOTE: the tempfile mechanism is recommended for Windows systems,
   where the standard shell I/O redirection operators often have
   strange effects.  In particular, if you are doing line ending
   conversion on Windows using the popular dos2unix and unix2dos
   programs, you *must* use the tempfile mechanism, as using pipes will
   corrupt the contents of your files.
 
   Tempfile example:
 
     [encode]
     # convert files to unix line ending conventions on checkin
     **.txt = tempfile: dos2unix -n INFILE OUTFILE
 
     [decode]
     # convert files to windows line ending conventions when writing
     # them to the working dir
     **.txt = tempfile: unix2dos -n INFILE OUTFILE
 
 defaults::
-  Use the [defaults] section to define command defaults, i.e. the 
+  Use the [defaults] section to define command defaults, i.e. the
   default options/arguments to pass to the specified commands.
-  
+
   The following example makes 'hg log' run in verbose mode, and
   'hg status' show only the modified files, by default.
-  
+
     [defaults]
     log = -v
     status = -m
-  
-  The actual commands, instead of their aliases, must be used when 
+
+  The actual commands, instead of their aliases, must be used when
   defining command defaults. The command defaults will also be
   applied to the aliases of the commands defined.
 
 diff::
   Settings used when displaying diffs. They are all boolean and
   defaults to False.
   git;;
     Use git extended diff format.
   nodates;;
     Don't include dates in diff headers.
   showfunc;;
     Show which function each change is in.
   ignorews;;
     Ignore white space when comparing lines.
   ignorewsamount;;
     Ignore changes in the amount of white space.
   ignoreblanklines;;
     Ignore changes whose lines are all blank.
 
 email::
   Settings for extensions that send email messages.
   from;;
     Optional.  Email address to use in "From" header and SMTP envelope
     of outgoing messages.
   to;;
     Optional.  Comma-separated list of recipients' email addresses.
   cc;;
     Optional.  Comma-separated list of carbon copy recipients'
     email addresses.
   bcc;;
     Optional.  Comma-separated list of blind carbon copy
     recipients' email addresses.  Cannot be set interactively.
   method;;
     Optional.  Method to use to send email messages.  If value is
     "smtp" (default), use SMTP (see section "[smtp]" for
     configuration).  Otherwise, use as name of program to run that
     acts like sendmail (takes "-f" option for sender, list of
     recipients on command line, message on stdin).  Normally, setting
     this to "sendmail" or "/usr/sbin/sendmail" is enough to use
     sendmail to send messages.
 
   Email example:
 
     [email]
     from = Joseph User <[e-mail]>
     method = /usr/sbin/sendmail
 
 extensions::
   Mercurial has an extension mechanism for adding new features. To
   enable an extension, create an entry for it in this section.
 
   If you know that the extension is already in Python's search path,
   you can give the name of the module, followed by "=", with nothing
   after the "=".
 
   Otherwise, give a name that you choose, followed by "=", followed by
   the path to the ".py" file (including the file name extension) that
   defines the extension.
 
   Example for ~/.hgrc:
 
     [extensions]
     # (the mq extension will get loaded from mercurial's path)
     hgext.mq =
     # (this extension will get loaded from the file specified)
     myfeature = ~/.hgext/myfeature.py
 
 format::
 
   usestore;;
     Enable or disable the "store" repository format which improves
     compatibility with systems that fold case or otherwise mangle
     filenames. Enabled by default. Disabling this option will allow
     you to store longer filenames in some situations at the expense of
     compatibility.
 
 hooks::
   Commands or Python functions that get automatically executed by
   various actions such as starting or finishing a commit. Multiple
   hooks can be run for the same action by appending a suffix to the
   action. Overriding a site-wide hook can be done by changing its
   value or setting it to an empty string.
 
   Example .hg/hgrc:
 
     [hooks]
     # do not use the site-wide hook
     incoming =
     incoming.email = /my/email/hook
     incoming.autobuild = /my/build/hook
 
   Most hooks are run with environment variables set that give added
   useful information.  For each hook below, the environment variables
   it is passed are listed with names of the form "$HG_foo".
 
   changegroup;;
     Run after a changegroup has been added via push, pull or
     unbundle. ID of the first new changeset is in $HG_NODE.  URL from
     which changes came is in $HG_URL.
   commit;;
     Run after a changeset has been created in the local repository.
     ID of the newly created changeset is in $HG_NODE.  Parent
     changeset IDs are in $HG_PARENT1 and $HG_PARENT2.
   incoming;;
     Run after a changeset has been pulled, pushed, or unbundled into
     the local repository.  The ID of the newly arrived changeset is in
     $HG_NODE.  URL that was source of changes came is in $HG_URL.
   outgoing;;
     Run after sending changes from local repository to another.  ID of
     first changeset sent is in $HG_NODE.  Source of operation is in
     $HG_SOURCE; see "preoutgoing" hook for description.
   post-<command>;;
     Run after successful invocations of the associated command. The
     contents of the command line are passed as $HG_ARGS and the result
     code in $HG_RESULT. Hook failure is ignored.
   pre-<command>;;
     Run before executing the associated command. The contents of the
     command line are passed as $HG_ARGS. If the hook returns failure,
     the command doesn't execute and Mercurial returns the failure code.
   prechangegroup;;
     Run before a changegroup is added via push, pull or unbundle.
     Exit status 0 allows the changegroup to proceed.  Non-zero status
     will cause the push, pull or unbundle to fail.  URL from which
     changes will come is in $HG_URL.
   precommit;;
     Run before starting a local commit.  Exit status 0 allows the
     commit to proceed.  Non-zero status will cause the commit to fail.
     Parent changeset IDs are in $HG_PARENT1 and $HG_PARENT2.
   preoutgoing;;
     Run before computing changes to send from the local repository to
     another.  Non-zero status will cause failure.  This lets you
     prevent pull over http or ssh.  Also prevents against local pull,
     push (outbound) or bundle commands, but not effective, since you
     can just copy files instead then.  Source of operation is in
     $HG_SOURCE.  If "serve", operation is happening on behalf of
     remote ssh or http repository.  If "push", "pull" or "bundle",
     operation is happening on behalf of repository on same system.
   pretag;;
     Run before creating a tag.  Exit status 0 allows the tag to be
     created.  Non-zero status will cause the tag to fail.  ID of
     changeset to tag is in $HG_NODE.  Name of tag is in $HG_TAG.  Tag
     is local if $HG_LOCAL=1, in repo if $HG_LOCAL=0.
   pretxnchangegroup;;
     Run after a changegroup has been added via push, pull or unbundle,
     but before the transaction has been committed.  Changegroup is
     visible to hook program.  This lets you validate incoming changes
     before accepting them.  Passed the ID of the first new changeset
     in $HG_NODE.  Exit status 0 allows the transaction to commit.
     Non-zero status will cause the transaction to be rolled back and
     the push, pull or unbundle will fail.  URL that was source of
     changes is in $HG_URL.
   pretxncommit;;
     Run after a changeset has been created but the transaction not yet
     committed.  Changeset is visible to hook program.  This lets you
     validate commit message and changes.  Exit status 0 allows the
     commit to proceed.  Non-zero status will cause the transaction to
     be rolled back.  ID of changeset is in $HG_NODE.  Parent changeset
     IDs are in $HG_PARENT1 and $HG_PARENT2.
   preupdate;;
     Run before updating the working directory.  Exit status 0 allows
     the update to proceed.  Non-zero status will prevent the update.
     Changeset ID of first new parent is in $HG_PARENT1.  If merge, ID
     of second new parent is in $HG_PARENT2.
   tag;;
     Run after a tag is created.  ID of tagged changeset is in
     $HG_NODE.  Name of tag is in $HG_TAG.  Tag is local if
     $HG_LOCAL=1, in repo if $HG_LOCAL=0.
   update;;
     Run after updating the working directory.  Changeset ID of first
     new parent is in $HG_PARENT1.  If merge, ID of second new parent
     is in $HG_PARENT2.  If update succeeded, $HG_ERROR=0.  If update
     failed (e.g. because conflicts not resolved), $HG_ERROR=1.
 
   Note: it is generally better to use standard hooks rather than the
   generic pre- and post- command hooks as they are guaranteed to be
   called in the appropriate contexts for influencing transactions.
   Also, hooks like "commit" will be called in all contexts that
   generate a commit (eg. tag) and not just the commit command.
 
   Note2: Environment variables with empty values may not be passed to
   hooks on platforms like Windows. For instance, $HG_PARENT2 will
   not be available under Windows for non-merge changesets while being
   set to an empty value under Unix-like systems.
 
   The syntax for Python hooks is as follows:
 
     hookname = python:modulename.submodule.callable
 
   Python hooks are run within the Mercurial process.  Each hook is
   called with at least three keyword arguments: a ui object (keyword
   "ui"), a repository object (keyword "repo"), and a "hooktype"
   keyword that tells what kind of hook is used.  Arguments listed as
   environment variables above are passed as keyword arguments, with no
   "HG_" prefix, and names in lower case.
 
   If a Python hook returns a "true" value or raises an exception, this
   is treated as failure of the hook.
 
 http_proxy::
   Used to access web-based Mercurial repositories through a HTTP
   proxy.
   host;;
     Host name and (optional) port of the proxy server, for example
     "myproxy:8000".
   no;;
     Optional.  Comma-separated list of host names that should bypass
     the proxy.
   passwd;;
     Optional.  Password to authenticate with at the proxy server.
   user;;
     Optional.  User name to authenticate with at the proxy server.
 
 smtp::
   Configuration for extensions that need to send email messages.
   host;;
     Host name of mail server, e.g. "mail.example.com".
   port;;
     Optional.  Port to connect to on mail server.  Default: 25.
   tls;;
     Optional.  Whether to connect to mail server using TLS.  True or
     False.  Default: False.
   username;;
     Optional.  User name to authenticate to SMTP server with.
     If username is specified, password must also be specified.
     Default: none.
   password;;
     Optional.  Password to authenticate to SMTP server with.
     If username is specified, password must also be specified.
     Default: none.
   local_hostname;;
     Optional.  It's the hostname that the sender can use to identify itself
     to the MTA.
 
 paths::
   Assigns symbolic names to repositories.  The left side is the
   symbolic name, and the right gives the directory or URL that is the
   location of the repository.  Default paths can be declared by
   setting the following entries.
   default;;
     Directory or URL to use when pulling if no source is specified.
     Default is set to repository from which the current repository
     was cloned.
   default-push;;
     Optional.  Directory or URL to use when pushing if no destination
     is specified.
 
 server::
   Controls generic server settings.
   uncompressed;;
     Whether to allow clients to clone a repo using the uncompressed
     streaming protocol.  This transfers about 40% more data than a
     regular clone, but uses less memory and CPU on both server and
     client.  Over a LAN (100Mbps or better) or a very fast WAN, an
     uncompressed streaming clone is a lot faster (~10x) than a regular
     clone.  Over most WAN connections (anything slower than about
     6Mbps), uncompressed streaming is slower, because of the extra
     data transfer overhead.  Default is False.
 
 trusted::
   For security reasons, Mercurial will not use the settings in
   the .hg/hgrc file from a repository if it doesn't belong to a
   trusted user or to a trusted group.  The main exception is the
   web interface, which automatically uses some safe settings, since
   it's common to serve repositories from different users.
 
   This section specifies what users and groups are trusted.  The
   current user is always trusted.  To trust everybody, list a user
   or a group with name "*".
 
   users;;
     Comma-separated list of trusted users.
   groups;;
     Comma-separated list of trusted groups.
 
 ui::
   User interface controls.
   debug;;
     Print debugging information.  True or False.  Default is False.
   editor;;
     The editor to use during a commit.  Default is $EDITOR or "vi".
   fallbackencoding;;
     Encoding to try if it's not possible to decode the changelog using
     UTF-8.  Default is ISO-8859-1.
   ignore;;
     A file to read per-user ignore patterns from. This file should be in
     the same format as a repository-wide .hgignore file. This option
     supports hook syntax, so if you want to specify multiple ignore
     files, you can do so by setting something like
     "ignore.other = ~/.hgignore2". For details of the ignore file
     format, see the hgignore(5) man page.
   interactive;;
     Allow to prompt the user.  True or False.  Default is True.
   logtemplate;;
     Template string for commands that print changesets.
   merge;;
     The conflict resolution program to use during a manual merge.
     Default is "hgmerge".
   patch;;
     command to use to apply patches. Look for 'gpatch' or 'patch' in PATH if
     unset.
   quiet;;
     Reduce the amount of output printed.  True or False.  Default is False.
   remotecmd;;
     remote command to use for clone/push/pull operations. Default is 'hg'.
   report_untrusted;;
     Warn if a .hg/hgrc file is ignored due to not being owned by a
     trusted user or group.  True or False.  Default is True.
   slash;;
     Display paths using a slash ("/") as the path separator.  This only
     makes a difference on systems where the default path separator is not
     the slash character (e.g. Windows uses the backslash character ("\")).
     Default is False.
   ssh;;
     command to use for SSH connections. Default is 'ssh'.
   strict;;
     Require exact command names, instead of allowing unambiguous
     abbreviations.  True or False.  Default is False.
   style;;
     Name of style to use for command output.
   timeout;;
     The timeout used when a lock is held (in seconds), a negative value
     means no timeout. Default is 600.
   username;;
     The committer of a changeset created when running "commit".
     Typically a person's name and email address, e.g. "Fred Widget
     <[e-mail]>".  Default is $EMAIL or username@hostname.
     If the username in hgrc is empty, it has to be specified manually or
     in a different hgrc file (e.g. $HOME/.hgrc, if the admin set "username ="
     in the system hgrc).
   verbose;;
     Increase the amount of output printed.  True or False.  Default is False.
 
 
 web::
   Web interface configuration.
   accesslog;;
     Where to output the access log. Default is stdout.
   address;;
     Interface address to bind to. Default is all.
   allow_archive;;
     List of archive format (bz2, gz, zip) allowed for downloading.
     Default is empty.
   allowbz2;;
     (DEPRECATED) Whether to allow .tar.bz2 downloading of repo revisions.
     Default is false.
   allowgz;;
     (DEPRECATED) Whether to allow .tar.gz downloading of repo revisions.
     Default is false.
   allowpull;;
     Whether to allow pulling from the repository. Default is true.
   allow_push;;
     Whether to allow pushing to the repository.  If empty or not set,
     push is not allowed.  If the special value "*", any remote user
     can push, including unauthenticated users.  Otherwise, the remote
     user must have been authenticated, and the authenticated user name
     must be present in this list (separated by whitespace or ",").
     The contents of the allow_push list are examined after the
     deny_push list.
   allowzip;;
     (DEPRECATED) Whether to allow .zip downloading of repo revisions.
     Default is false. This feature creates temporary files.
   baseurl;;
     Base URL to use when publishing URLs in other locations, so
     third-party tools like email notification hooks can construct URLs.
     Example: "http://hgserver/repos/"
   contact;;
     Name or email address of the person in charge of the repository.
     Default is "unknown".
   deny_push;;
     Whether to deny pushing to the repository.  If empty or not set,
     push is not denied.  If the special value "*", all remote users
     are denied push.  Otherwise, unauthenticated users are all denied,
     and any authenticated user name present in this list (separated by
     whitespace or ",") is also denied.  The contents of the deny_push
     list are examined before the allow_push list.
   description;;
     Textual description of the repository's purpose or contents.
     Default is "unknown".
   encoding;;
     Character encoding name.
     Example: "UTF-8"
   errorlog;;
     Where to output the error log. Default is stderr.
   hidden;;
     Whether to hide the repository in the hgwebdir index. Default is false.
   ipv6;;
     Whether to use IPv6. Default is false.
   name;;
     Repository name to use in the web interface. Default is current
     working directory.
   maxchanges;;
     Maximum number of changes to list on the changelog. Default is 10.
   maxfiles;;
     Maximum number of files to list per changeset. Default is 10.
   port;;
     Port to listen on. Default is 8000.
   push_ssl;;
     Whether to require that inbound pushes be transported over SSL to
     prevent password sniffing.  Default is true.
   staticurl;;
     Base URL to use for static files. If unset, static files (e.g.
     the hgicon.png favicon) will be served by the CGI script itself.
     Use this setting to serve them directly with the HTTP server.
     Example: "http://hgserver/static/"
   stripes;;
     How many lines a "zebra stripe" should span in multiline output.
     Default is 1; set to 0 to disable.
   style;;
     Which template map style to use.
   templates;;
     Where to find the HTML templates. Default is install path.
 
 
 AUTHOR
 ------
 Bryan O'Sullivan <[e-mail]>.
 
 Mercurial was written by Matt Mackall <[e-mail]>.
 
 SEE ALSO
 --------
 hg(1), hgignore(5)
 
 COPYING
 -------
 This manual page is copyright 2005 Bryan O'Sullivan.
 Mercurial is copyright 2005-2007 Matt Mackall.
 Free use of this software is granted under the terms of the GNU General
 Public License (GPL).

doc/ja/docbook.ja.conf

@@ -1,583 +1,583 b''
 #
 # docbook.conf
 #
 # Asciidoc configuration file.
 # Modified docbook backend for Japanese.
 #
 
 [miscellaneous]
 outfilesuffix=.xml
 # Printable page width in pts.
 pagewidth=380
 pageunits=pt
 
 [attributes]
 basebackend=docbook
 basebackend-docbook=
 
 [replacements]
 # Line break markup is dropped (there is no DocBook line break tag).
 (?m)^(.*)\s\+$=\1
 # Superscripts.
 \^(.+?)\^=<superscript>\1</superscript>
 # Subscripts.
 ~(.+?)~=<subscript>\1</subscript>
 
 [ruler-blockmacro]
 # Only applies to HTML so don't output anything.
 
 [image-inlinemacro]
 <inlinemediaobject>
   <imageobject>
   <imagedata fileref="{target}"{width? contentwidth="{width}pt"}{height? contentdepth="{height}pt"}/>
   </imageobject>
   <textobject><phrase>{1={target}}</phrase></textobject>
 </inlinemediaobject>
 
 [image-blockmacro]
 <figure{id? id="{id}"}><title>{title}</title>
 {title%}<informalfigure{id? id="{id}"}>
 <mediaobject>
   <imageobject>
   <imagedata fileref="{target}"{width? contentwidth="{width}pt"}{height? contentdepth="{height}pt"}/>
   </imageobject>
   <textobject><phrase>{1={target}}</phrase></textobject>
 </mediaobject>
 {title#}</figure>
 {title%}</informalfigure>
 
 [indexterm-inlinemacro]
 # Inline index term.
 # Generate separate index entries for primary, secondary and tertiary
 # descriptions.
 # Primary only.
 {2%}<indexterm>
 {2%}  <primary>{1}</primary>
 {2%}</indexterm>
 # Primary and secondary.
 {2#}{3%}<indexterm>
 {2#}{3%}  <primary>{1}</primary><secondary>{2}</secondary>
 {2#}{3%}</indexterm>
 {2#}{3%}<indexterm>
 {2#}{3%}  <primary>{2}</primary>
 {2#}{3%}</indexterm>
 # Primary, secondary and tertiary.
 {3#}<indexterm>
   <primary>{1}</primary><secondary>{2}</secondary><tertiary>{3}</tertiary>
 {3#}</indexterm>
 {3#}<indexterm>
   <primary>{2}</primary><secondary>{3}</secondary>
 {3#}</indexterm>
 {3#}<indexterm>
   <primary>{3}</primary>
 {3#}</indexterm>
 
 [indexterm2-inlinemacro]
 # Inline index term.
 # Single entry index term that is visible in the primary text flow.
 <indexterm>
   <primary>{1}</primary>
 </indexterm>
 {1}
 
 [footnote-inlinemacro]
 # Inline footnote.
 <footnote><simpara>{0}</simpara></footnote>
 
 [callout-inlinemacro]
 # Inline callout.
 <co id="{coid}"/>
 
 [tags]
 # Bulleted, numbered and labeled list tags.
 ilist=<itemizedlist{id? id="{id}"}>{title?<title>{title}</title>}|</itemizedlist>
 ilistitem=<listitem>|</listitem>
 ilisttext=<simpara>|</simpara>
 olist=<orderedlist{id? id="{id}"}>{title?<title>{title}</title>}|</orderedlist>
 olist2=<orderedlist{id? id="{id}"} numeration="loweralpha">|</orderedlist>
 olistitem=<listitem>|</listitem>
 olisttext=<simpara>|</simpara>
 vlist=<variablelist{id? id="{id}"}>{title?<title>{title}</title>}|</variablelist>
 vlistentry=<varlistentry>|</varlistentry>
 vlistterm=<term>|</term>
 vlisttext=<simpara>|</simpara>
 vlistitem=<listitem>|</listitem>
 # Horizontal labeled list (implemented with two column table).
 # Hardwired column widths to 30%,70% because the current crop of PDF
 # generators do not auto calculate column widths.
 hlist=<{title?table}{title!informaltable}{id? id="{id}"} tabstyle="{style=hlabeledlist}" pgwide="0" frame="none" colsep="0" rowsep="0">{title?<title>{title}</title>}<tgroup cols="2"><colspec colwidth="{1=3}*"/><colspec colwidth="{2=7}*"/><tbody valign="top">|</tbody></tgroup><{title?/table}{title!/informaltable}>
 hlistentry=<row>|</row>
 hlisttext=<simpara>|</simpara>
 hlistterm=<entry><simpara>|</simpara></entry>
 hlistitem=<entry>|</entry>
 
 # Question and Answer list.
 qlist=<qandaset{id? id="{id}"}>{title?<title>{title}</title>}|</qandaset>
 qlistentry=<qandaentry>|</qandaentry>
 qlistterm=<question><simpara>|</simpara></question>
 qlistitem=<answer>|</answer>
 qlisttext=<simpara>|</simpara>
 # Bibliography list.
 blist=|
 blistitem=<bibliomixed>|</bibliomixed>
 blisttext=<bibliomisc>|</bibliomisc>
 # Glossary list.
 glist=|
 glistentry=<glossentry>|</glossentry>
 glistterm=<glossterm>|</glossterm>
 glistitem=<glossdef>|</glossdef>
 glisttext=<simpara>|</simpara>
 # Callout list.
 colist=<calloutlist{id? id="{id}"}>{title?<title>{title}</title>}|</calloutlist>
 colistitem=<callout arearefs="{coids}">|</callout>
 colisttext=<simpara>|</simpara>
 
 # Quoted text
 emphasis=<emphasis>|</emphasis>
 strong=<emphasis role="strong">|</emphasis>
 monospaced=<literal>|</literal>
 quoted={amp}#8220;|{amp}#8221;
 
 # Inline macros
 [http-inlinemacro]
 <ulink url="{name}:{target}">{0={name}:{target}}</ulink>
 [https-inlinemacro]
 <ulink url="{name}:{target}">{0={name}:{target}}</ulink>
 [ftp-inlinemacro]
 <ulink url="{name}:{target}">{0={name}:{target}}</ulink>
 [file-inlinemacro]
 <ulink url="{name}:{target}">{0={name}:{target}}</ulink>
 [mailto-inlinemacro]
 <ulink url="{name}:{target}">{0={target}}</ulink>
 #<email>{target}</email>
 [link-inlinemacro]
 <ulink url="{target}">{0={target}}</ulink>
 # anchor:id[text]
 [anchor-inlinemacro]
 <anchor id="{target}" xreflabel="{0=[{target}]}"/>
 # [[id,text]]
 [anchor2-inlinemacro]
 <anchor id="{1}" xreflabel="{2=[{1}]}"/>
 # [[[id]]]
 [anchor3-inlinemacro]
 <anchor id="{1}" xreflabel="[{1}]"/>[{1}]
 # xref:id[text]
 [xref-inlinemacro]
 <link linkend="{target}">{0}</link>
 {2%}<xref linkend="{target}"/>
 # <<id,text>>
 [xref2-inlinemacro]
 <link linkend="{1}">{2}</link>
 {2%}<xref linkend="{1}"/>
 
 
 # Special word macros
 [emphasizedwords]
 <emphasis>{words}</emphasis>
 [monospacedwords]
 <literal>{words}</literal>
 [strongwords]
 <emphasis role="strong">{words}</emphasis>
 
 # Paragraph substitution.
 [paragraph]
 <formalpara{id? id="{id}"}><title>{title}</title><para>
 {title%}<simpara{id? id="{id}"}>
 |
 {title%}</simpara>
 {title#}</para></formalpara>
 {empty}
 
 [admonitionparagraph]
 <{name}{id? id="{id}"}><simpara>|</simpara></{name}>
 
 [literalparagraph]
 # The literal block employs the same markup.
 template::[literalblock]
 
 [verseparagraph]
 template::[verseblock]
 
 # Delimited blocks.
 [literalblock]
 <example><title>{title}</title>
 <literallayout{id? id="{id}"} class="{font=monospaced}">
 |
 </literallayout>
 {title#}</example>
 
 [listingblock]
 <example><title>{title}</title>
 <screen>
 |
 </screen>
 {title#}</example>
 
 [verseblock]
 <formalpara{id? id="{id}"}><title>{title}</title><para>
 {title%}<literallayout{id? id="{id}"}>
 {title#}<literallayout>
 |
 </literallayout>
 {title#}</para></formalpara>
 
 [sidebarblock]
 <sidebar{id? id="{id}"}>
 <title>{title}</title>
 |
 </sidebar>
 
 [backendblock]
 |
 
 [quoteblock]
 # The epigraph element may be more appropriate than blockquote.
 <blockquote{id? id="{id}"}>
 <title>{title}</title>
 <attribution>
 {attribution}
 <citetitle>{citetitle}</citetitle>
 </attribution>
 |
 </blockquote>
 
 [exampleblock]
 <{title?example}{title!informalexample}{id? id="{id}"}>
 <title>{title}</title>
 |
 </{title?example}{title!informalexample}>
 
 [admonitionblock]
 <{name}{id? id="{id}"}>
 <title>{title}</title>
 |
 </{name}>
 
 # Tables.
 [tabledef-default]
 template=table		
 colspec=<colspec colwidth="{colwidth}{pageunits}" align="{colalign}"/>
 bodyrow=<row>|</row>
 bodydata=<entry>|</entry>
 
 [table]
 <{title?table}{title!informaltable}{id? id="{id}"} pgwide="0"
 frame="{frame=topbot}"
 {grid%rowsep="0" colsep="0"}
 {eval:\{"none":"rowsep=\"0\" colsep=\"0\"", "cols":"rowsep=\"0\" colsep=\"1\"", "all":"rowsep=\"1\" colsep=\"1\"", "rows":"rowsep=\"1\" colsep=\"0\"" \}["{grid}"]}
 >
 <title>{title}</title>
 <tgroup cols="{cols}">
 {colspecs}
 {headrows#}<thead>
 {headrows}
 {headrows#}</thead>
 {footrows#}<tfoot>
 {footrows}
 {footrows#}</tfoot>
 <tbody>
 {bodyrows}
 </tbody>
 </tgroup>
 </{title?table}{title!informaltable}>
 
 [specialsections]
 ifdef::doctype-article[]
 ^Abstract$=sect-abstract
 endif::doctype-article[]
 
 ifdef::doctype-book[]
 ^Colophon$=sect-colophon
 ^Dedication$=sect-dedication
 ^Preface$=sect-preface
 endif::doctype-book[]
 
 ^Index$=sect-index
 ^(Bibliography|References)$=sect-bibliography
 ^Glossary$=sect-glossary
 ^Appendix [A-Z][:.](?P<title>.*)$=sect-appendix
 
 # Special sections.
 [sect-preface]
 <preface{id? id="{id}"}>
 <title>{title}</title>
 |
 </preface>
 
 [sect-index]
 <index{id? id="{id}"}>
 <title>{title}</title>
 |
 </index>
 
 [sect-bibliography]
 <bibliography{id? id="{id}"}>
 <title>{title}</title>
 |
 </bibliography>
 
 [sect-glossary]
 <glossary{id? id="{id}"}>
 <title>{title}</title>
 |
 </glossary>
 
 [sect-appendix]
 <appendix{id? id="{id}"}>
 <title>{title}</title>
 |
 </appendix>
 
 
 [header-declarations]
 <?xml version="1.0" encoding="{encoding}"?>
 <!DOCTYPE {eval:\{"article":"article", "book":"book", "manpage":"refentry"\}["{doctype}"]} PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
 
 #-------------------------
 # article document type
 #-------------------------
 ifdef::doctype-article[]
 
 [header]
 template::[header-declarations]
 
 <article lang="ja">
 {doctitle#}<articleinfo>
     <title>{doctitle}</title>
     <date>{date}</date>
     {authored#}<author>
         <firstname>{firstname}</firstname>
         <othername>{middlename}</othername>
         <surname>{lastname}</surname>
         <affiliation><address><email>{email}</email></address></affiliation>
     {authored#}</author>
 
 # If file named like source document with -revhistory.xml suffix exists
 # include it as the document history, otherwise use current revision.
 {revisionhistory#}{include:{docdir}/{docname}-revhistory.xml}
 {revisionhistory%}<revhistory><revision><revnumber>{revision}</revnumber><date>{date}</date>{revremark?<revremark>{revremark}</revremark>}</revision></revhistory>
 
     <corpname>{companyname}</corpname>
 {doctitle#}</articleinfo>
 
 [footer]
 </article>
 
 [preamble]
 # Untitled elements between header and first section title.
 |
 
 [sect-abstract]
 <abstract{id? id="{id}"}>
 |
 </abstract>
 
 [sect1]
 <section{id? id="{id}"}>
 <title>{title}</title>
 |
 </section>
 
 [sect2]
 <section{id? id="{id}"}>
 <title>{title}</title>
 |
 </section>
 
 [sect3]
 <section{id? id="{id}"}>
 <title>{title}</title>
 |
 </section>
 
 [sect4]
 <section{id? id="{id}"}>
 <title>{title}</title>
 |
 </section>
 
 endif::doctype-article[]
 
 #-------------------------
 # manpage document type
 #-------------------------
 ifdef::doctype-manpage[]
 
 [replacements]
 # The roff format does not substitute special characters so just print them as
 # text.
 \(C\)=(C)
 \(TM\)=(TM)
 
 [header]
 template::[header-declarations]
 <refentry>
 <refmeta>
 <refentrytitle>{mantitle}</refentrytitle>
 <manvolnum>{manvolnum}</manvolnum>
 </refmeta>
 <refnamediv>
     <refname>{manname}</refname>
     <refpurpose>{manpurpose}</refpurpose>
 </refnamediv>
 
 [footer]
 </refentry>
 
 # Section macros
 [sect-synopsis]
 <refsynopsisdiv{id? id="{id}"}>
 |
 </refsynopsisdiv>
 
 [sect1]
 <refsect1{id? id="{id}"}>
 <title>{title}</title>
 |
 </refsect1>
 
 [sect2]
 <refsect2{id? id="{id}"}>
 <title>{title}</title>
 |
 </refsect2>
 
 [sect3]
 <refsect3{id? id="{id}"}>
 <title>{title}</title>
 |
 </refsect3>
 
 endif::doctype-manpage[]
 
 #-------------------------
 # book document type
 #-------------------------
 ifdef::doctype-book[]
 
 [header]
 template::[header-declarations]
 
 <book lang="ja">
 {doctitle#}<bookinfo>
     <title>{doctitle}</title>
     <date>{date}</date>
     {authored#}<author>
         <firstname>{firstname}</firstname>
         <othername>{middlename}</othername>
         <surname>{lastname}</surname>
         <affiliation><address><email>{email}</email></address></affiliation>
     {authored#}</author>
 
 # If file named like source document with -revhistory.xml suffix exists
 # include it as the document history, otherwise use current revision.
 {revisionhistory#}{include:{docdir}/{docname}-revhistory.xml}
 {revisionhistory%}<revhistory><revision><revnumber>{revision}</revnumber><date>{date}</date>{revremark?<revremark>{revremark}</revremark>}</revision></revhistory>
 
     <corpname>{companyname}</corpname>
 {doctitle#}</bookinfo>
 
 [footer]
 </book>
 
 [preamble]
-# Preamble is not allowed in DocBook book so wrap it in a preface. 
+# Preamble is not allowed in DocBook book so wrap it in a preface.
 <preface{id? id="{id}"}>
 <title>Preface</title>
 |
 </preface>
 
 [sect-dedication]
 <dedication{id? id="{id}"}>
 |
 </dedication>
 
 [sect-colophon]
 <colophon{id? id="{id}"}>
 |
 </colophon>
 
 [sect0]
 <part{id? id="{id}"}>
 <title>{title}</title>
 |
 </part>
 
 [sect1]
 <chapter{id? id="{id}"}>
 <title>{title}</title>
 |
 </chapter>
 
 [sect2]
 <section{id? id="{id}"}>
 <title>{title}</title>
 |
 </section>
 
 [sect3]
 <section{id? id="{id}"}>
 <title>{title}</title>
 |
 </section>
 
 [sect4]
 <section{id? id="{id}"}>
 <title>{title}</title>
 |
 </section>
 
 endif::doctype-book[]
 
 ifdef::sgml[]
 #
 # Optional DocBook SGML.
 #
 # Most of the differences between DocBook XML and DocBook SGML boils
 # down to the empty element syntax: SGML does not like the XML empty
 # element <.../> syntax, use <...> instead.
 #
 [miscellaneous]
 outfilesuffix=.sgml
 
 [header-declarations]
 <!DOCTYPE {eval:\{"article":"article", "book":"book", "manpage":"refentry"\}["{doctype}"]} PUBLIC "-//OASIS//DTD DocBook V4.1//EN">
 
 [tabledef-default]
 colspec=<colspec colwidth="{colwidth}{pageunits}" align="{colalign}">
 
 [image-inlinemacro]
 <inlinemediaobject>
   <imageobject>
   <imagedata fileref="{target}"{width? width="{width}pt"}{height? depth="{height}pt"}>
   </imageobject>
   <textobject><phrase>{1={target}}</phrase></textobject>
 </inlinemediaobject>
 
 [image-blockmacro]
 <figure><title>{title}</title>
 {title%}<informalfigure>
 <mediaobject>
   <imageobject>
   <imagedata fileref="{target}"{width? width="{width}pt"}{height? depth="{height}pt"}>
   </imageobject>
   <textobject><phrase>{1={target}}</phrase></textobject>
 </mediaobject>
 {title#}</figure>
 {title%}</informalfigure>
 
 # Inline macros
 [xref-inlinemacro]
 <link linkend="{target}">{0}</link>
 {2%}<xref linkend="{target}">
 [xref2-inlinemacro]
 # <<id,text>>
 <link linkend="{1}">{2}</link>
 {2%}<xref linkend="{1}">
 [anchor-inlinemacro]
 <anchor id="{target}" xreflabel="{0=[{target}]}">
 [anchor2-inlinemacro]
 # [[id,text]]
 <anchor id="{1}" xreflabel="{2=[{1}]}">
 
 endif::sgml[]

doc/ja/hg.1.ja.txt

@@ -1,867 +1,867 b''
 HG(1)
 =====
 Matt Mackall <[e-mail]>
 
 名前
 --
 hg - Mercurial ソースコード管理システム
 
 書式
 --
 'hg' [-v -d -q -y] <command> [command options] [files]
 
 説明
 --
 hg(1) コマンドは Mercurial システムへのコマンドラインインターフェ
 イスを提供します。
 
 オプション
 ----
 
 -R, --repository::
     リポジトリのルートディレクトリを指定します。
 
 --cwd::
     作業ディレクトリを変更します。
 
 -y, --noninteractive::
     プロンプトを出さずに、要求された答えが全て 'yes' であると仮定
     します。
 
 -q, --quiet::
     出力を抑制します。
 
 -v, --verbose::
     さらなる出力を可能にします。
 
 7--debug::
     デバッグ出力を可能にします。
 
 --traceback::
     例外時にトレースバックを表示します。
 
 --time::
     コマンドにどのくらい時間がかかるかを表示します。
 
 --profile::
     コマンドを実行したときのプロファイルを表示します。
 
 --version::
     バージョン情報を表示して終了します。
 
 -h, --help::
     ヘルプを表示して終了します。
 
 コマンドの要素
 -------
 
 files ...::
     1つ以上のファイル名か相対的なパスを表します; パターンマッチン
     グの情報は「ファイル名のパターン」を参照してください。
 
 path::
     ローカルマシン上のパスを表します
 
 revision::
     チェンジセットのリビジョンナンバー, タグ, チェンジセットのハッ
     シュ値のユニークな部分文字列により指定できるチェンジセットを表
     します
 
 repository path::
     ローカルのリポジトリのパス名かリモートのリポジトリの URI を表
     します。URI のプロトコルとしては現在 2 つが利用可能です。
     http:// は高速で、static-http:// は遅いですがウェブのホストに特別
     なサーバを必要としません。
 
 コマンド
 ----
 
 add [options] [files ...]::
     ファイルをバージョン管理下に置きリポジトリに追加することを予定
     します。
 
     ファイルは次にコミット時にリポジトリに追加されます。
 
     ファイル名が与えられなければ、現在のディレクトリとサブディレク
     トリの全てのファイルを追加します。
 
 addremove [options] [files ...]::
     新しいファイルを全て追加し無くなったファイルを全てリポジトリか
     ら取り除きます。
 
     新しいファイルは .hgignore 中のパターンにマッチした場合無視さ
     れます。add のようにこの変更は次のコミット時に効果を持ちます。
 
 annotate [-r <rev> -u -n -c] [files ...]::
     ファイル中の変更を列挙し、各行の原因であるリビジョン id を表示
     します。
 
     このコマンドある変更が生じた際に誰がその変更をしたかを発見する
     のに役に立ちます。
 
     -a オプションが無いと、annotate はバイナリとして検出されたファ
     イルを避けるようになります。-a があると、annotate はとくかく注
     釈を生成し、おそらく望ましくない結果になるでしょう。
 
     オプション:
     -a, --text            全てのファイルをテキストとして扱います
     -I, --include <pat>   与えられたパターンにマッチした名前を含め
                           ます
     -X, --exclude <pat>   与えられたパターンにマッチした名前を除外
                           します
     -r, --revision <rev>  指定されたリビジョンの注釈を生成します
     -u, --user            著者を列挙します
     -c, --changeset       チェンジセットを列挙します
     -n, --number          リビジョンナンバーを列挙します
                           (デフォルト)
 
 bundle <file> <other>::
     (実験的)
 
     他のリポジトリには見付からなかった全てのチェンジセットを集めた、
     圧縮済みチェンジグループファイルを生成します。
 
     このファイルは従来の方法で転送することができ、他のリポジトリに
     unbundle コマンドで適用できます。これは push と pull が使えな
     いか、リポジトリ全体をエクスポートしてしまうことが望ましくない
     ときに便利です。標準のファイル拡張子は ".hg" です。
 
     import/export と違って、これはパーミッション、名前変更のデータ、
     リビジョンの履歴を含めたチェンジセットの内容全てを保存します。
 
 cat [options] <file ...>::
     指定されたファイルを与えられたリビジョンの内容で表示します。リ
     ビジョンが指定されなかった場合は tip が使われます。
 
     出力はファイルに対しても可能です。その場合、ファイル名はフォー
     マット文字列により指定されます。フォーマット規則は export コマ
     ンドと同じですが、さらに次のものが追加されます。
 
     %s   出力されるファイルのベース名
     %d   出力されるファイルのディレクトリ名か、リポジトリのルート
          にいる場合は "."
     %p   出力されるファイルのルートからの相対パス
 
     オプション:
     -I, --include <pat>       与えられたパターンにマッチした名前
                               を含めます
     -X, --exclude <pat>       与えられたパターンにマッチした名前
                               を除外します
     -o, --output <filespec>   整形された名前でファイルに出力しま
                               す
     -r, --rev <rev>           与えられたリビジョンを表示します
 
 clone [-U] <source> [dest]::
     既存のリポジトリのコピーを新しいディレクトリに作成します
 
     コピー先のディレクトリ名が指定されなければ、デフォルトでソース
     のベース名を使用します。
 
     今後の pull に使えるように、コピー元が新しいリポジトリの
     .hg/hgrc に追加されます。
 
     効率のために、コピー元とコピー先が同じファイルシステム上にある
     場合はハードリンクが使われます。
 
     オプションン:
     -U, --noupdate   新しい作業ディレクトリで update を行いません
     -e, --ssh        使用される ssh コマンドを指定します
     --remotecmd      リモート側で実行する hg コマンドを指定します
 
 commit [options] [files...]::
     指定されたファイルの変更をリポジトリにコミットします。
 
     もしファイルのリストが省略されたら、リポジトリのルートから実行
     した"hg status" で報告される全ての変更がコミットされます。
 
     HGEDITOR や EDITOR 環境変数はコミット時のコメントを追加するエ
     ディタを起動するために使われます。
 
     オプション:
 
     -A, --addremove       コミット中に addremove を実行します
     -I, --include <pat>   与えられたパターンにマッチした名前を含め
                           ます
     -X, --exclude <pat>   与えられたパターンにマッチした名前を除外
                           します
     -m, --message <text>  <text> をコミットメッセージとして使いま
                           す
     -l, --logfile <file>  <file> からコミットメッセージを読み込み
                           ます
     -d, --date <datecode> datecode をコミットした日付として記録し
                           ます
     -u, --user <user>     user をコミッタとして記録します。
 
     別名: ci
 
 copy <source ...> <dest>::
     コピー先がコピー元のファイルのコピーを持っていると印を付けます。
     もしコピー先がディレクトリなら、コピーはディレクトリ中に置かれ
     ます。もしコピー先がファイルなら、コピー元は1つのみ指定可能で
     す。
 
     デフォルトでは、このコマンドはファイルがその作業ディレクトリに
     あるものとしてその内容をコピーします。もし --after と一緒に呼
     び出されれば、操作は記録されますが、コピーは実行されません。
 
     このコマンドは次のコミット時に効果を持ちます。
 
     注意: このコマンドは実験的です。リネームされたファイルを適切に
     記録できますが、この情報はマージによってまだ完全には使われませ
     んし、ログで完全に報告されることもありません。
 
     オプション:
     -A, --after           既に発生したコピーを記録します。
     -I, --include <pat>   与えられたパターンにマッチした名前を含め
                           ます
     -X, --exclude <pat>   与えられたパターンにマッチした名前を除外
                           します
     -f, --force           既存の変更されたファイルに無理矢理コピー
                           します
     -p, --parents         コピー先にコピー元のパスを追加します
-    
+
     別名: cp
 
 diff [-a] [-r revision] [-r revision] [files ...]::
     指定されたファイルのリビジョン間の差分を表示します。
 
     ファイル間の差分は unified diff 形式で表示されます。
 
     2つのリビジョンが引数として指定された場合、それらのリビジョン
     間の差分が表示されます。1つのリビジョンしか指定されなければ、
     そのリビジョンは作業ディレクトリと比較されます。そして リビジョ
     ンが指定されなければ、作業ディレクトリのファイルがその親と比較
     されます。
 
     -a オプション無しでは、diff はバイナリファイルを検出したときに
     その差分を生成するのを避けます。-a オプションでは、diff はとに
     かく差分を生成し、恐らく望ましくない結果をもたらすでしょう。
 
     オプション:
     -a, --text           全てのファイルをテキストとして扱います
     -I, --include <pat>  与えられたパターンにマッチした名前を含め
                          ます
     -X, --exclude <pat>  与えられたパターンにマッチした名前を除外
                          します
 
 export [-o filespec] [revision] ...::
     1つ以上のリビジョンのチェンジセットのヘッダと差分を出力します。
 
     チェンジセットのヘッダに表示される情報は: 著者、チェンジセット
     のハッシュ、親、コミット時のコメントです。
 
     出力はファイルに対しても可能です。その場合、ファイル名はフォー
     マット文字列により指定されます。フォーマット規則は下記の通りで
     す:
 
     %%   そのままの "%" 文字
     %H   チェンジセットのハッシュ (40 バイトの 16 進数)
     %N   生成されているパッチの番号
     %R   チェンジセットのリビジョンナンバー
     %b   エクスポートしているリポジトリのメース名
     %h   短い形式のチェンジセットのハッシュ (12 バイトの 16 進数)
     %n   0 で 詰められた 1 から始まる連番
     %r   0 で 詰められたリビジョンナンバー
 
     -a オプション無しでは、diff はバイナリファイルを検出したときに
     その差分を生成するのを避けます。-a オプションでは、diff はとに
     かく差分を生成し、恐らく望ましくない結果をもたらすでしょう。
 
     オプション:
     -a, --text                全てのファイルをテキストとして扱います
     -o, --output <filespec>   整形された名前でファイルに出力します
 
 forget [options] [files]::
     次のコミット時に予定された 'hg add' を取り消します。
 
     オプション:
     -I, --include <pat> 与えられたパターンにマッチした名前を含めま
     -すX, --exclude <pat> 与えられたパターンにマッチした名前を除外
     -します
 
 grep [options] pattern [files]::
     正規表現によりファイルのリビジョンを検索します。
 
     このコマンドは Unix の grep とは違う振舞いをします。これは
     Python/Perl の正規表現だけを受けつけます。これは作業ディレクト
     リではなくリポジトリの履歴を検索します。これは常にマッチしたも
     のが現れたリビジョンナンバーを表示します。
 
     デフォルトでは、grep はマッチしたものが見つかったファイルの最
     初のリビジョンを出力します。マッチ状況の変化("-" はマッチが非
     マッチに、"+" は非マッチがマッチに)を含んだ各リビジョンを表示
     するには、--all フラグを使ってください。
 
     オプション:
     -0, --print0              ファイル名を NUL で終えます。
     -I, --include <pat>       与えられたパターンにマッチした名前
                               を含めます
     -X, --exclude <pat>       与えられたパターンにマッチした名前
                               を除外します
         --all                 マッチした全てのリビジョンを表示し
                               ます
     -i, --ignore-case         マッチのときに英大文字と小文字を区
                               別しないようにします
     -l, --files-with-matches  マッチしたファイル名とリビジョンの
                               みを表示します
     -n, --line-number         マッチした行番号を表示します
     -r, --rev <rev>           指定されたリビジョンの間で検索しま
                               す
     -u, --user                その変更をコミットしたユーザを表示
                               します
 
 heads::
     リポジトリの先頭のチェンジセットを全て表示します。
 
     リポジトリの「先頭」とは子のチェンジセットを持っていないチェン
     ジセットです。それらは大抵開発が行われる場所で、通常 update と
     merge 操作の対象となるところです。
 
 identify::
     レポジトリの現在の状態の短いサマリを表示します。
 
     このサマリはリポジトリの状態を1つまたは2つの親のハッシュ識別子
     を使って識別します。親のハッシュ識別子はもし作業ディレクトリに
     コミットされていない変更があれば後ろに + が付き、更にその後に
     このリビジョンのタグのリストが付きます。
 
     別名: id
 
 import [-p <n> -b <base> -f] <patches>::
     一連のパッチをインポートし、それぞれ個別にコミットします。
 
     作業ディレクトリに未解決の変更があった場合、import は -f フラ
     グが指定されてなければ中断します。
 
     もしパッチがメールのよう(最初の行が "From " か RFC 822 ヘッダ
     のよう) であれば、-f オプションが使われていない限りそれは適用
     されません。インポート機構はメールのヘッダをパースもしなければ
     破棄もしないので、本物のメールをインポートしないようにする「メー
     ルのようなものの」健全性チェックを上書きするためだけに -f を使っ
     てください。
 
     オプション:
     -p, --strip <n>   patch の ディレクトリ除去オプションです。これ
                       は関連する patch のオプションと同じ意味を持ち
                       ます
     -b <path>         パッチを読み込むベースとなるディレクトリを指
                       定します
     -f, --force       未解決でまだコミットされていない変更のチェッ
                       クを省略します
 
     別名: patch
 
 incoming [-p] [source]::
     指定されたリポジトリか、デフォルトで pull するリポジトリ中に見
     つかった新しいチェンジセットを表示します。これらは pull が要求
     されたときにpull されるチェンジセットです。
 
     現在はローカルのリポジトリのみがサポートされています。
 
     オプション:
     -p, --patch           パッチを表示します
 
     別名: in
 
 init [dest]::
     指定されたディレクトリ中に新しいリポジトリを初期化します。指定
     されたディレクトリが存在しない場合は作成されます。
 
     ディレクトリが指定されなければ、現在のディレクトリが使用されま
     す。
 
 locate [options] [files]::
     Mercurial の管理下にあるファイルで名前が指定されたパターンにマッ
     チしたものを全て表示します。
 
     このコマンドは現在のディレクトリとサブディレクトリを検索します。
     リポジトリ全体を検索するには、リポジトリのルートに移動してくだ
     さい。
 
     もしマッチするためのパターンが与えられなければ、このコマンドは
     全てのファイルの名前を表示します。
 
     もしこのコマンドの出力を "xargs" コマンドに送りたいなら、
     "-0" オプションをこのコマンドと "xargs" コマンドの両方で使用し
     てください。これは "xargs" がスペースの入ったファイル名を複数
     のファイル名として扱わないようにします。
 
     オプション:
 
-    -0, --print0         xargs と一緒に使うために、ファイル名を 
+    -0, --print0         xargs と一緒に使うために、ファイル名を
                          NUL で終えます
     -f, --fullpath       ファイルシステムのルートからの完全なパ
                          スを表示します
     -I, --include <pat>  与えられたパターンにマッチした名前を含
                          めます
     -r, --rev <rev>      rev のときのリポジトリを検索します
     -X, --exclude <pat>  与えられたパターンにマッチした名前を除外
                          します
 
 log [-r revision ...] [-p] [files]::
     指定されたファイルかプロジェクト全体のリビジョンの履歴を表示し
     ます。
 
     デフォルトではこのコマンドは次のものを出力します: チェンジセッ
     トのid とハッシュ、タグ、親、ユーザ、日付、各コミットのサマ
     リ。-v スイッチは変更されたファイルやマニフェストのハッシュ、
     メッセージのシグネチャといったより詳しい情報を追加します。
 
     オプション:
     -I, --include <pat>   与えられたパターンにマッチした名前を含め
                           ます
     -X, --exclude <pat>   与えられたパターンにマッチした名前を除外
                           します
     -r, --rev <A>         指定されたリビジョンまたは範囲を表示しま
                           す
     -p, --patch           パッチを表示します
 
     別名: history
 
 manifest [revision]::
     指定されたリビジョンでバージョン管理されているファイルのリスト
     を表示します。
 
     manifest はバージョン管理されているファイルのリストです。もし
     リビジョンが指定されなければ、tip が使われます。
 
 outgoing [-p] [dest]::
     指定された行き先のリポジトリかデフォルトで push するリポジトリ
     中に見付からなかったチェンジセットを表示します。これらは push
     が要求されたときに push されるであろうチェンジセットです。
 
     オプション:
     -p, --patch           パッチを表示します
 
     別名: out
 
 parents::
     作業ディレクトリの親リビジョンを表示します。
 
 paths [NAME]::
     シンボルのパス名である NAME の行き先を表示します。もしシンボル
     名が指定されなければ、利用可能なシンボル名の行き先を表示します。
 
     パス名は /etc/mercurial/hgrc と $HOME/.hgrc の [paths] セクショ
     ンで定義されます。もしリポジトリの内部で実行された場
     合、.hg/hgrc も使用されます。
 
 pull <repository path>::
     リモートのリポジトリの変更をローカルのリポジトリに pull します。
 
     これは指定されたパスや URL にあるリポジトリの全ての変更を見つ
     けて、それらをローカルのリポジトリに追加します。デフォルトでは、
     これは作業ディレクトリのプロジェクトのコピーを更新しません。
 
     有効な URL の次の形式です:
 
       local/filesystem/path
       http://[user@]host[:port][/path]
       https://[user@]host[:port][/path]
       ssh://[user@]host[:port][/path]
 
     SSH は行き先のマシンのシェルアカウントと、リモートのパスにhg
     のコピーが必要になります。SSH を使用すると、パスはデフォルトで
     はリモートのユーザのホームディレクトリの相対パスになります; ファ
     イルシステムのルートからの相対パスであることを指定するには、パ
     スの最初にスラッシュを 2つ使用してください。
 
     オプション:
     -u, --update   pull の後に作業ディレクトリを tip に更新します
     -e, --ssh    使用する ssh コマンドを指定します
     --remotecmd  リモート側で使われる hg コマンドを指定します
 
 push <destination>::
     ローカルのリポジトリの変更を指定された行き先に push します。
 
     これは pull と対称的な操作です。これは現在のリポジトリの変更を
     他のリポジトリへ移すのに役立ちます。もし行き先がローカルであれ
     ば、これはそのディレクトリから現在のディレクトリに対して pull
     するのと同じです。
 
     デフォルトでは、push は実行した結果リモートのヘッドの数が増え
     るならば、実行を拒否します。これはたいていクライアントが push
     する前に sync とmerge を忘れていることを意味します。
 
     有効な URL は次の形式です:
 
       local/filesystem/path
       ssh://[user@]host[:port][/path]
 
     SSH は行き先のマシンのシェルアカウントと、リモートのパスに hg
     のコピーが必要になります。
 
     オプション:
 
     -f, --force  update を強行します
     -e, --ssh    使用される ssh コマンドを指定します
     --remotecmd  リモート側で実行される hg コマンドを指定します
 
 rawcommit [-p -d -u -F -m -l]::
     低レベルのコミットで、ヘルパースクリプト中で使用されます。
 
     このコマンドは通常のユーザに使われることは想定していません。こ
     れは主に他の SCM からインポートするときに便利です。
 
 recover::
     中断された commit や pull から復帰します。
 
     このコマンドは中断された操作からリポジトリの状態を修整しようと
     試みます。これは Mercurial がそうするよう提案したときのみ必要
     でしょう。
 
 remove [options] [files ...]::
     指定されたファイルをリポジトリから削除することを予定します。
 
     このコマンドはファイルを次のコミット時に削除することを予定しま
     す。このコマンドはファイルを現在の枝から取り除くだけで、プロジェ
     クトの履歴全体からは削除しません。もしファイルが作業ディレクト
     リ中にまだ存在していれば、それらは作業ディレクトリから削除され
     ます。
 
     別名: rm
 
 rename <source ...> <dest>::
     コピー先をコピー元のコピーのコピーであると印をつけます; コピー
     元に削除の印をつけます。もしコピー先がディレクトリであれば、コ
     ピーはそのディレクトリ中に置かれます。もしコピー先がファイルな
     ら、コピー元は 1 つのみ指定可能です。
 
     デフォルトでは、このコマンドはファイルがその作業ディレクトリに
     あるものとしてその内容をコピーします。もし --after と一緒に呼
     び出されれば、操作は記録されますが、コピーは実行されません。
 
     このコマンドは次のコミット時に効果を持ちます。
 
     注意: このコマンドは実験的です。リネームされたファイルを適切に
     記録できますが、この情報はマージによってまだ完全には使われませ
     んし、ログで完全に報告されることもありません。
 
     オプション:
     -A, --after        既に発生したリネームを記録します
     -f, --force        既存の変更されたファイルに無理矢理コピーし
                        ます
     -p, --parents      コピー先にコピー元のパスを追加します
 
     別名: mv
 
 revert [names ...]::
     指定されたファイルやディレクトリの未コミットの変更を取り消しま
     す。これは関連したファイルの内容をコミットされてない状態に戻し
     ます。
 
     もしファイルが削除されていれば、再作成されます。もしファイルの
     実行モードが変更されていれば、リセットされます。
 
     ディレクトリが指定された場合、そのディレクトリ中のすべてのファ
     イルとサブディレクトリが元に戻されます。
 
     もし引数が指定されなければ、現在のディレクトリ中の全てのファイ
     ルとサブディレクトリが元の戻されます。
 
     オプション:
     -r, --rev <rev>       元に戻す先のリビジョンを指定します
     -n, --nonrecursive    サブディレクトリを再帰的に辿らないように
                           します
 
 root::
     現在のリポジトリのルートディレクトリを表示します。
 
 serve [options]::
     ローカルの HTTP リポジトリと pull サーバを起動します。
 
     デフォルトでは、サーバはアクセスログを標準出力に、エラーログを
     標準エラー出力に出力します。ファイルにログを取るには "-A" と
     "-E" オプションを使ってください。
 
     オプション:
     -A, --accesslog <file>   アクセスログが出力されるファイルの名前
                              を指定します
     -E, --errorlog <file>    エラーログが出力されるファイルの名前を
                              指定します
     -a, --address <addr>     使用するアドレスを指定します
-    -p, --port <n>           使用するポートを指定します 
+    -p, --port <n>           使用するポートを指定します
                              (デフォルト: 8000)
-    -n, --name <name>        ウェブページで表示する名前を指定します 
+    -n, --name <name>        ウェブページで表示する名前を指定します
                              (デフォルト: working dir)
     -t, --templatedir <path> 使用するウェブの雛型を指定します
     -6, --ipv6               IPv4 に加えて IPv6 も使用します
 
 status [options] [files]::
     作業ディレクトリ中の変更されたファイルを表示します。名前が指定
     されなければ、全てのファイルが表示されます。名前が指定されれば、
     指定された名前にマッチしたファイルのみが表示されます。
 
     ファイルの状態を表示するのに使われる記号:
 
     M = 変更されました
     A = 追加されました
     R = 削除されました
     ? = バージョン管理下にありません
 
     オプション:
 
     -m, --modified       変更されたファイルのみを表示します
     -a, --added          追加されたファイルのみを表示します
     -r, --removed        削除されたファイルのみを表示します
     -u, --unknown        不明な(バージョン管理下にない)ファイルのみ
                          を表示します
     -n, --no-status      状態を示す接頭辞を隠します
     -0, --print0         xargs と一緒に使うために、ファイル名を NUL
                          で終えます
     -I, --include <pat>  与えられたパターンにマッチした名前を含めま
                          す
     -X, --exclude <pat>  与えられたパターンにマッチした名前を除外し
                          ます
 
 tag [-l -m <text> -d <datecode> -u <user>] <name> [revision]::
     特定のリビジョンに <name> を使って名前を付けます。
 
     タグはリポジトリの特定のリビジョンに名前を付けるために使われ、
     そして異なるリビジョンを比較したり、重要な以前のバージョンに戻っ
     たり、リリース等の分岐点に印をつけたりするのに便利です。
 
     もしバージョンが指定されなければ、tip が使われます。
 
     バージョン管理、配布、タグのマージを楽にするために、それらは
     ".hgtags" という名前のファイルに格納され、他のプロジェクトのファ
     イルと同様に扱ったり、必要であれば手で編集できます。
 
     オプション:
     -l, --local           タグをローカルにします
     -m, --message <text>  タグをコミットしたときのログのエントリの
                           メッセージを指定します
     -d, --date <datecode> コミットの日付を指定します
     -u, --user <user>     コミットするユーザを指定します
 
     注意: ローカルのタグはバージョン管理や配布されることはなく、ま
     た.  hg/localtags ファイルに格納されます。もし同じ名前のローカ
     ルのタグと公開されたタグがあれば、ローカルのタグが使われます。
 
 tags::
     リポジトリのタグを列挙します。
 
     これは通常のタグとローカルのタグを両方列挙します。
 
 tip::
     tip のリビジョンを表示します。
 
 unbundle <file>::
     (実験的)
 
     bundle コマンドで生成された、圧縮済みチェンジグループファイル
     を適用します。
 
 undo::
     最後の commit や pull の処理を取り消します。
 
     リポジトリの最後の pull や commit 処理を巻戻し、プロジェクトを
     それより前の状態に戻します。
 
     このコマンドは注意して使ってください。まだ 1回の undo だけで、
     redo はありません。
 
     このコマンドは公開したリポジトリで使われることは想定していませ
     ん。いったん他のユーザから pull で変更が見えるようになれば、ロー
     カルでそれを取り消しても意味がありません。
 
 update [-m -C] [revision]::
     作業ディレクトリを指定されたリビジョンに更新します。
 
     デフォルトでは、更新によりローカルの変更をマージしたり破棄した
     りすることが必要となるとき、update はそれを拒否します。
 
     -m オプションで、マージが実行されます。
 
     -C オプションで、ローカルの変更が失われます。
 
     オプション:
     -m, --merge       枝のマージを許可します
     -C, --clean       ローカルで変更されたファイルを上書きします
 
     別名: up checkout co
 
 verify::
     現在のリポジトリの整合性を検証します。
 
     これはリポジトリの整合性を全面的にチェックし、チェンジログの各
     エントリ、manifest, 管理下のファイルのハッシュとチェックサムを
     検証し、またクロスリンクとインデクスの整合性も検証します。
 
 ファイル名とパターン
 ---------
 
     Mercurial では同時に複数のファイルを識別するのに複数の記法が使
     えます。
 
     デフォルトでは、Mercurial はファイル名をシェルのスタイルの拡張
     glob パターンとして扱います。
 
     別のパターン表記は明示的に指定する必要があります。
 
     パターンマッチングなしの単純なパス名を使うには、パス名を
     "path:" で始めてください。これらのパス名は、現在のリポジトリの
     ルートから完全にマッチしている必要があります。
 
     拡張 glob を使うには、名前を "glob:" で始めてください。glob は
     現在のディレクトリのみに適用されます: "*.c" といった glob は現
     在のディレクトリ中の ".c" で終わるファイルのみにマッチします。
 
     サポートされている glob 文法の拡張はパスの分離記号を越えて全て
     の文字列にマッチする "**" と、"a または b" を意味する "{a,b}"
     です。
 
     Perl/Python の正規表現を使うには、名前を "re:" で始めてくださ
     い。正規表現によるマッチはリポジトリのルートの固定されています。
 
     単純な例:
 
     path:foo/bar   リポジトリのルートにある foo というディレクトリ
                    の bar という名前
     path:path:name "path:name" という名前のファイルまたはディレク
                    トリ
 
     Glob の例:
 
     glob:*.c       現在のディレクトリ中の ".c" で終わる全ての名前
     *.c            現在のディレクトリ中の ".c" で終わる全ての名前
     **.c           現在のディレクトリと全てのサブディレクトリ中の
                     ".c" で終わる全ての名前
     foo/*.c        ディレクトリ foo 中の ".c" で終わる全ての名前
     foo/**.c       ディレクトリ foo とその全てのサブディレクトリ中
                    の ".c" で終わる全ての名前
 
     正規表現の例:
 
     re:.*\.c$      リポジトリ全体の中の ".c" で終わる全ての名前
 
 
 単一のリビジョンの指定法
 -----------
 
     Mercurial では個々のリビジョンを識別するのに複数の記法が使えま
     す。
 
     単純な整数はリビジョンナンバーとして扱われます。負の整数はtip
     からのオフセットとして扱われ、-1 が tip を表します。
 
     40 桁の 16 進数の文字列はユニークなリビジョン識別子として扱わ
     れます。
 
     40 桁より少ない 16 進数の文字列はユニークなリビジョン識別子と
     して扱われ、短い形式の識別子と呼ばれます。短い形式の識別子はそ
     れが完全な長さの識別子の接頭語であるときだけ有効です。
 
     他の文字列は全てタグ名として扱われます。タグはあるリビジョン識
     別子に関連付けられたシンボル名です。タグ名は ":" 文字を含んで
     はいけません。
 
     リビジョン名 "tip" は特別なタグで、常に一番最新のリビジョンを
     指します。
 
 複数のリビジョンの指定法
 -----------
 
     Mercurial が 1つより多くのリビジョンを受けいれるとき、それらは
     別々に指定されるか、連続した範囲として ":" 文字で区切って与え
     られるかもれません。
 
     範囲表記の構文は [BEGIN]:[END] で BEGIN と END はリビジョンの
     識別子です。BEGIN も END も両方とも任意です。もし BEGIN が指定
     されなければ、デフォルトでリビジョンナンバー 0 になります。も
     し END が指定されなければ、デフォルトで tip になります。従って
     範囲 ":" は "全てのリビジョン" を意味します。
 
     もし BEGIN が END より大きければ、リビジョンは逆の順序として扱
     われます。
 
     範囲は閉区間として動作します。これは範囲が 3:5 は 3,4,5 になる
     ことを意味します。同様に、範囲 4:2 は 4,3,2 になります。
 
 環境変数
 ----
 
 HGEDITOR::
     これはコミッチ時に使われるエディタの名前です。デフォルトでは
     EDITOR の値が使われます。
 
     (廃止予定です, .hgrc を使ってください)
 
 HGMERGE::
     merge 時の衝突を解決するのに使われる実行ファイルです。プログラ
     ムは3 つの引数で実行されます: ローカルのファイル、リモートのファ
     イル、1 世代前のファイルです。
 
     デフォルトのプログラムは "hgmerge" で、これは Mercurial によっ
     て提供される常識的な設定のシェルスクリプトです。
 
     (廃止予定です, .hgrc を使ってください)
 
 HGUSER::
     これはコミット時の著者として使われる文字列です。
 
     (廃止予定です, .hgrc を使ってください)
 
 EMAIL::
     もし HGUSER が設定されていなければ、これがコミット時の著者とし
     て使われます。
 
 LOGNAME::
     もし HGUSER も EMAIL も設定されていなければ、コミット時の著者
     としてLOGNAME が('@hostname' を付けた形で)使われます。
 
 EDITOR::
     これは hgmerge スクリプト中で使われるエディタの名前です。もし
     HGEDITOR が設定されていなければ、コミット時のメッセージに使わ
     れます。デフォルトは 'vi' です。
 
 PYTHONPATH::
     これはインポートされるモジュールを見つけるために Python によっ
     て使われ、Mercurial がシステム全体にインストールされていなけれ
     ば、適切に設定される必要があるでしょう。
 
 ファイル
 ----
  .hgignore::
     このファイルは(1行ごとに) hg によって無視されるべきファイルを
     記述した正規表現を含みます。
 
  .hgtags::
     このファイルはリポジトリの内容のタグ付けされたバージョンに一致
     したハッシュ値とテキストのタグ名(それぞれは空白で区切られます)を
     含みます。
 
  /etc/mercurial/hgrc, $HOME/.hgrc, .hg/hgrc::
     このファイルはデフォルトの設定を含みます。.hg/hgrc の値は
     $HOME/.hgrc の設定を上書きし、$HOME/.hgrc の設定はグローバルな
     /etc/mercurial/hgrc の設定を上書きします。これらのファイルの内
     容と書式の詳細については hgrc(5) を参照してください。
 
 バグ
 --
 沢山あるでしょうから、もしバグを見つけたらそれをメーリングリスト
 (下の情報源を参照)に送ってください。
 
 関連項目
 ----
 hgrc(5)
 
 著者
 --
 Matt Mackall <[e-mail]> により書かれました。
 
 情報源
 ---
 http://selenic.com/mercurial[主なウェブサイト]
 
 http://www.serpentine.com/mercurial[Wiki サイト]
 
 http://selenic.com/hg[ソースコードのリポジトリ]
 
 http://selenic.com/mailman/listinfo/mercurial[メーリングリスト]
 
 著作権情報
 -----
 Copyright (C) 2005-2007 Matt Mackall.
 このソフトウェアの自由な使用は GNU 一般公有使用許諾 (GPL) のもとで
 認められます。

doc/ja/hgrc.5.ja.txt

@@ -1,204 +1,204 b''
 HGRC(5)
 =======
 Bryan O'Sullivan <[e-mail]>
 
 名前
 --
 hgrc - Mercurial の設定ファイル
 
 書式
 --
 
 Mercurial システムはその振舞いの正常を制御するのに、一連の設定ファ
 イルを使用します。
 
 ファイル
 ----
 
 Mercurial は 3つのファイルから設定を読みます:
 
 /etc/mercurial/hgrc::
     このグローバルの設定ファイルのオプションは実行したユーザ、ディ
     レクトリを問わず全ての Mercurial コマンドに適用されます。
 
 $HOME/.hgrc::
     ユーザ毎の設定オプションで、ディレクトリを問わず全ての
     Mercurial コマンドに適用されます。このファイルの値はグローバル
     の設定を上書きします。
 
 <repo>/.hg/hgrc::
     リポジトリ毎の設定オプションで、そのリポジトリのみに適用されま
     す。このファイルはバージョン管理されず、 "clone" 操作で転送さ
     れることもありません。このファイルの値はグローバルの設定とユー
     ザ毎の設定を上書きします。
 
 構文
 --
 
 設定ファイルは "[セクション]" ヘッダから始まるセクションと、それに
 続く"名前: 値"のエントリから成ります: "名前=値"も認められます。
 
     [spam]
     eggs=ham
     green=
        eggs
 
 各行は1つのエントリを含みます。もし次の行がインデントされていた場
 合、それは前の行の続きとして扱われます。
 
 先行する空白は値から取り除かれます。空行は読み飛ばされます。
 
 オプションの値は同じセクションや、特別な DEFAULT セクションの別の
 値を参照するフォーマット文字列を含むことができます。
 
 "#" や ";" で始まる行は無視されるので、コメントとして使うことがで
 きます。
 
 セクション
 -----
 
 このセクションは Merucurial の "hgrc" に使うことができる異なったセ
 クションのそれぞれの目的や可能なキー、そして取り得る値について記述
 します。
 
-decode/encode:: 
+decode/encode::
   checkout/checkin でファイルを転送するときのフィルターです。これ
   は典型的には改行を処理したり、他の地域化/標準化に使われるでしょ
   う。
 
   フィルターはフィルターパターンとそれに続くフィルターコマンドから
   なります。コマンドは標準入力からのデータを受け付け、変換したデー
   タを標準出力に返す必要があります。
 
   例:
 
     [encode]
     # delta 圧縮を改善するためにチェックイン時に gzip ファイルを
     # 伸長します
     # 注意: 必ずしも良いアイディアではありません。ただの例です
     *.gz = gunzip
 
     [decode]
     # 作業ディレクトリに書き出すときにファイルを gzip で再圧縮します
     *.gz = gzip
 
 hooks::
   コミットの開始、終了時など様々なアクションで自動的に実行されるコ
   マンドです。
   changegroup;;
     push や pull でチェンジグループが加えられたあとに起動します。
   commit;;
     チェンジセットが作成された後に起動します。新しく作成されたチェ
     ンジセットの ID が渡されます。
   precommit;;
     コミット前に起動します。終了ステータス 0 によりコミットを続行
     します。非ゼロのステータスでコミットは失敗します。
 
 http_proxy::
   HTTP プロキシを通してウェブを使った Mercurial のリポジトリにアク
   セスするのに使われます。
   host;;
-    プロキシサーバのホスト名と(オプションの)ポートで、例えば 
+    プロキシサーバのホスト名と(オプションの)ポートで、例えば
     "myproxy:8000"などです。
   no;;
     オプションです。コンマで区切られたプロキシを通過すべきホスト名
     のリストです。
   passwd;;
     オプションです。プロキシサーバの認証用のパスワードです。
   user;;
     オプションです。プロキシサーバの認証用のユーザ名です。
 
 paths::
   リポジトリにシンボル名を割当てます。左側がシンボル名で、右側がリ
   ポジトリの場所を示すディレクトリや URL です。
 
 ui::
   ユーザインターフェースの設定です。
   debug;;
     デバッグ情報を表示します。True か False を取ります。デフォルト
     では False です。
   editor;;
     コミット中に使用するエディタです。デフォルトは $EDITOR か
     "vi" です。
   interactive;;
     ユーザに対してプロンプトを出すようにします。True か False を取
     ります。デフォルトでは True です。
   merge;;
     手動での merge 中に衝突を解決するために使われるプログラムです。
     デフォルトは "hgmerge" です。
   quiet;;
     表示される出力の量を減らします。True か False を取ります。デフォ
     ルトは False です。
   remotecmd;;
     clone/push/pull 操作で使われるリモートのコマンドです。デフォル
     トは 'hg' です。
   ssh;;
     SSH 接続で使われるコマンドです。デフォルトは 'ssh' です。
   username;;
     コミットを実行したときに作成されるチェンジセットのコミッタです。
     一般的には人名と電子メールアドレスで、例えば "Fred Widget
     <[e-mail]>" などです。デフォルトは $EMAIL か
     username@hostname です。
   verbose;;
     表示される出力の量を増やします。True か False を取ります。デフォ
     ルトは False です。
 
 web::
   ウェブインターフェイスの設定です。
   accesslog;;
     アクセスログの出力先です。デフォルトでは標準出力です。
   address;;
     バインドするインターフェイスアドレスです。デフォルトでは全てで
     す。
   allowbz2;;
     リポジトリのリビジョンから .tar.bz2 をダウンロードさせるかどう
     かです。デフォルトでは false です。
   allowgz;;
     リポジトリのリビジョンから .tar.gz をダウンロードさせるかどう
     かです。デフォルトでは false です。
   allowpull;;
     リポジトリから pull させるかどうかです。デフォルトでは true で
     す。
   allowzip;;
     リポジトリのリビジョンから .zip をダウンロードさせるかどうかで
     す。デフォルトでは false です。この機能は一時ファイルを作成し
     ます。
   description;;
     リポジトリの目的や内容についてのテキストによる説明です。デフォ
     ルトでは"unknown" です。
   errorlog;;
     エラーログの出力先です。デフォルトでは標準エラー出力です。
   ipv6;;
     IPv6 を使うかどうかです。デフォルトでは false です。
   name;;
     ウェブインターフェイスを使うときのリポジトリの名前です。デフォ
     ルトは現在の作業ディレクトリです。
   maxchanges;;
     チェンジログに記載する変更の最大数です。デフォルトでは 10 です。
   maxfiles;;
     チェンジセットに記載するファイルの最大数です。デフォルトでは
     10 です。
   port;;
     リスンするポートです。デフォルト は 8000 です。
   style;;
     使用するテンプレートマップのスタイルです。
   templates;;
     HTML テンプレートの在処です。デフォルトではインストールしたと
     きのパスです。
 
 著者
 --
 Bryan O'Sullivan <[e-mail]>.
 
 Mercurial は Matt Mackall <[e-mail]> により書かれました。
 
 関連項目
 ----
 hg(1)
 
 COPYING
 -------
 このマニュアルの著作権は 2005 Bryan O'Sullivan です。
 Mercurial の著作権は 2005 Matt Mackall です。
 このソフトウェアの自由な使用は GNU 一般公有使用許諾 (GPL) のもとで
 認められます。

hgext/purge.py

@@ -1,168 +1,168 b''
 # Copyright (C) 2006 - Marco Barisione <[e-mail]>
 #
 # This is a small extension for Mercurial (http://www.selenic.com/mercurial)
 # that removes files not known to mercurial
 #
 # This program was inspired by the "cvspurge" script contained in CVS utilities
 # (http://www.red-bean.com/cvsutils/).
 #
 # To enable the "purge" extension put these lines in your ~/.hgrc:
 #  [extensions]
 #  hgext.purge =
 #
 # For help on the usage of "hg purge" use:
 #  hg help purge
 #
 # 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 from mercurial import hg, util
 from mercurial.i18n import _
 import os
 
-def dopurge(ui, repo, dirs=None, act=True, ignored=False, 
+def dopurge(ui, repo, dirs=None, act=True, ignored=False,
             abort_on_err=False, eol='\n',
             force=False, include=None, exclude=None):
     def error(msg):
         if abort_on_err:
             raise util.Abort(msg)
         else:
             ui.warn(_('warning: %s\n') % msg)
 
     def remove(remove_func, name):
         if act:
             try:
                 remove_func(os.path.join(repo.root, name))
             except OSError, e:
                 error(_('%s cannot be removed') % name)
         else:
             ui.write('%s%s' % (name, eol))
 
     directories = []
     files = []
     missing = []
     roots, match, anypats = util.cmdmatcher(repo.root, repo.getcwd(), dirs,
                                             include, exclude)
     for src, f, st in repo.dirstate.statwalk(files=roots, match=match,
                                              ignored=ignored, directories=True):
         if src == 'd':
             directories.append(f)
         elif src == 'm':
             missing.append(f)
         elif src == 'f' and f not in repo.dirstate:
             files.append(f)
 
     _check_missing(ui, repo, missing, force)
 
     directories.sort()
 
     for f in files:
         if f not in repo.dirstate:
             ui.note(_('Removing file %s\n') % f)
             remove(os.remove, f)
 
     for f in directories[::-1]:
         if match(f) and not os.listdir(repo.wjoin(f)):
             ui.note(_('Removing directory %s\n') % f)
             remove(os.rmdir, f)
 
 def _check_missing(ui, repo, missing, force=False):
     """Abort if there is the chance of having problems with name-mangling fs
 
     In a name mangling filesystem (e.g. a case insensitive one)
     dirstate.walk() can yield filenames different from the ones
     stored in the dirstate. This already confuses the status and
     add commands, but with purge this may cause data loss.
 
     To prevent this, _check_missing will abort if there are missing
     files. The force option will let the user skip the check if he
     knows it is safe.
 
     Even with the force option this function will check if any of the
     missing files is still available in the working dir: if so there
     may be some problem with the underlying filesystem, so it
     aborts unconditionally."""
 
     found = [f for f in missing if util.lexists(repo.wjoin(f))]
 
     if found:
         if not ui.quiet:
             ui.warn(_("The following tracked files weren't listed by the "
                       "filesystem, but could still be found:\n"))
             for f in found:
                 ui.warn("%s\n" % f)
             if util.checkfolding(repo.path):
                 ui.warn(_("This is probably due to a case-insensitive "
                           "filesystem\n"))
         raise util.Abort(_("purging on name mangling filesystems is not "
                            "yet fully supported"))
 
     if missing and not force:
         raise util.Abort(_("there are missing files in the working dir and "
                            "purge still has problems with them due to name "
                            "mangling filesystems. "
                            "Use --force if you know what you are doing"))
 
 
 def purge(ui, repo, *dirs, **opts):
     '''removes files not tracked by mercurial
 
     Delete files not known to mercurial, this is useful to test local and
     uncommitted changes in the otherwise clean source tree.
 
     This means that purge will delete:
      - Unknown files: files marked with "?" by "hg status"
      - Ignored files: files usually ignored by Mercurial because they match
        a pattern in a ".hgignore" file
      - Empty directories: in fact Mercurial ignores directories unless they
        contain files under source control managment
     But it will leave untouched:
      - Unmodified tracked files
      - Modified tracked files
      - New files added to the repository (with "hg add")
 
     If directories are given on the command line, only files in these
     directories are considered.
 
     Be careful with purge, you could irreversibly delete some files you
     forgot to add to the repository. If you only want to print the list of
     files that this program would delete use the --print option.
     '''
     act = not opts['print']
     ignored = bool(opts['all'])
     abort_on_err = bool(opts['abort_on_err'])
     eol = opts['print0'] and '\0' or '\n'
     if eol == '\0':
         # --print0 implies --print
         act = False
     force = bool(opts['force'])
     include = opts['include']
     exclude = opts['exclude']
     dopurge(ui, repo, dirs, act, ignored, abort_on_err,
             eol, force, include, exclude)
 
 
 cmdtable = {
     'purge|clean':
         (purge,
          [('a', 'abort-on-err', None, _('abort if an error occurs')),
           ('',  'all', None, _('purge ignored files too')),
           ('f', 'force', None, _('purge even when missing files are detected')),
           ('p', 'print', None, _('print the file names instead of deleting them')),
           ('0', 'print0', None, _('end filenames with NUL, for use with xargs'
                                   ' (implies -p)')),
           ('I', 'include', [], _('include names matching the given patterns')),
           ('X', 'exclude', [], _('exclude names matching the given patterns'))],
          _('hg purge [OPTION]... [DIR]...'))
 }

mercurial/localrepo.py

@@ -1,1945 +1,1945 b''
 # localrepo.py - read/write repository class for mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from node import *
 from i18n import _
 import repo, changegroup
 import changelog, dirstate, filelog, manifest, context
 import re, lock, transaction, tempfile, stat, mdiff, errno, ui
 import os, revlog, time, util, extensions, hook
 
 class localrepository(repo.repository):
     capabilities = ('lookup', 'changegroupsubset')
     supported = ('revlogv1', 'store')
 
     def __del__(self):
         self.transhandle = None
     def __init__(self, parentui, path=None, create=0):
         repo.repository.__init__(self)
         self.path = path
         self.root = os.path.realpath(path)
         self.path = os.path.join(self.root, ".hg")
         self.origroot = path
         self.opener = util.opener(self.path)
         self.wopener = util.opener(self.root)
 
         if not os.path.isdir(self.path):
             if create:
                 if not os.path.exists(path):
                     os.mkdir(path)
                 os.mkdir(self.path)
                 requirements = ["revlogv1"]
                 if parentui.configbool('format', 'usestore', True):
                     os.mkdir(os.path.join(self.path, "store"))
                     requirements.append("store")
                     # create an invalid changelog
                     self.opener("00changelog.i", "a").write(
                         '\0\0\0\2' # represents revlogv2
                         ' dummy changelog to prevent using the old repo layout'
                     )
                 reqfile = self.opener("requires", "w")
                 for r in requirements:
                     reqfile.write("%s\n" % r)
                 reqfile.close()
             else:
                 raise repo.RepoError(_("repository %s not found") % path)
         elif create:
             raise repo.RepoError(_("repository %s already exists") % path)
         else:
             # find requirements
             try:
                 requirements = self.opener("requires").read().splitlines()
             except IOError, inst:
                 if inst.errno != errno.ENOENT:
                     raise
                 requirements = []
         # check them
         for r in requirements:
             if r not in self.supported:
                 raise repo.RepoError(_("requirement '%s' not supported") % r)
 
         # setup store
         if "store" in requirements:
             self.encodefn = util.encodefilename
             self.decodefn = util.decodefilename
             self.spath = os.path.join(self.path, "store")
         else:
             self.encodefn = lambda x: x
             self.decodefn = lambda x: x
             self.spath = self.path
         self.sopener = util.encodedopener(util.opener(self.spath), self.encodefn)
 
         self.ui = ui.ui(parentui=parentui)
         try:
             self.ui.readconfig(self.join("hgrc"), self.root)
             extensions.loadall(self.ui)
         except IOError:
             pass
 
         self.tagscache = None
         self.branchcache = None
         self.nodetagscache = None
         self.filterpats = {}
         self.transhandle = None
 
     def __getattr__(self, name):
         if name == 'changelog':
             self.changelog = changelog.changelog(self.sopener)
             self.sopener.defversion = self.changelog.version
             return self.changelog
         if name == 'manifest':
             self.changelog
             self.manifest = manifest.manifest(self.sopener)
             return self.manifest
         if name == 'dirstate':
             self.dirstate = dirstate.dirstate(self.opener, self.ui, self.root)
             return self.dirstate
         else:
             raise AttributeError, name
 
     def url(self):
         return 'file:' + self.root
 
     def hook(self, name, throw=False, **args):
         return hook.hook(self.ui, self, name, throw, **args)
 
     tag_disallowed = ':\r\n'
 
     def _tag(self, name, node, message, local, user, date, parent=None):
         use_dirstate = parent is None
 
         for c in self.tag_disallowed:
             if c in name:
                 raise util.Abort(_('%r cannot be used in a tag name') % c)
 
         self.hook('pretag', throw=True, node=hex(node), tag=name, local=local)
 
         def writetag(fp, name, munge, prevtags):
             if prevtags and prevtags[-1] != '\n':
                 fp.write('\n')
             fp.write('%s %s\n' % (hex(node), munge and munge(name) or name))
             fp.close()
             self.hook('tag', node=hex(node), tag=name, local=local)
-            
+
         prevtags = ''
         if local:
             try:
                 fp = self.opener('localtags', 'r+')
             except IOError, err:
                 fp = self.opener('localtags', 'a')
             else:
                 prevtags = fp.read()
 
             # local tags are stored in the current charset
             writetag(fp, name, None, prevtags)
             return
 
         if use_dirstate:
             try:
                 fp = self.wfile('.hgtags', 'rb+')
             except IOError, err:
                 fp = self.wfile('.hgtags', 'ab')
             else:
                 prevtags = fp.read()
         else:
             try:
                 prevtags = self.filectx('.hgtags', parent).data()
             except revlog.LookupError:
                 pass
             fp = self.wfile('.hgtags', 'wb')
 
         # committed tags are stored in UTF-8
         writetag(fp, name, util.fromlocal, prevtags)
 
         if use_dirstate and self.dirstate.state('.hgtags') == '?':
             self.add(['.hgtags'])
 
         tagnode = self.commit(['.hgtags'], message, user, date, p1=parent)
 
         self.hook('tag', node=hex(node), tag=name, local=local)
 
         return tagnode
 
     def tag(self, name, node, message, local, user, date):
         '''tag a revision with a symbolic name.
 
         if local is True, the tag is stored in a per-repository file.
         otherwise, it is stored in the .hgtags file, and a new
         changeset is committed with the change.
 
         keyword arguments:
 
         local: whether to store tag in non-version-controlled file
         (default False)
 
         message: commit message to use if committing
 
         user: name of user to use if committing
 
         date: date tuple to use if committing'''
 
         for x in self.status()[:5]:
             if '.hgtags' in x:
                 raise util.Abort(_('working copy of .hgtags is changed '
                                    '(please commit .hgtags manually)'))
 
 
         self._tag(name, node, message, local, user, date)
 
     def tags(self):
         '''return a mapping of tag to node'''
         if self.tagscache:
             return self.tagscache
 
         globaltags = {}
 
         def readtags(lines, fn):
             filetags = {}
             count = 0
 
             def warn(msg):
                 self.ui.warn(_("%s, line %s: %s\n") % (fn, count, msg))
 
             for l in lines:
                 count += 1
                 if not l:
                     continue
                 s = l.split(" ", 1)
                 if len(s) != 2:
                     warn(_("cannot parse entry"))
                     continue
                 node, key = s
                 key = util.tolocal(key.strip()) # stored in UTF-8
                 try:
                     bin_n = bin(node)
                 except TypeError:
                     warn(_("node '%s' is not well formed") % node)
                     continue
                 if bin_n not in self.changelog.nodemap:
                     warn(_("tag '%s' refers to unknown node") % key)
                     continue
 
                 h = []
                 if key in filetags:
                     n, h = filetags[key]
                     h.append(n)
                 filetags[key] = (bin_n, h)
 
             for k, nh in filetags.items():
                 if k not in globaltags:
                     globaltags[k] = nh
                     continue
                 # we prefer the global tag if:
                 #  it supercedes us OR
                 #  mutual supercedes and it has a higher rank
                 # otherwise we win because we're tip-most
                 an, ah = nh
                 bn, bh = globaltags[k]
                 if (bn != an and an in bh and
                     (bn not in ah or len(bh) > len(ah))):
                     an = bn
                 ah.extend([n for n in bh if n not in ah])
                 globaltags[k] = an, ah
 
         # read the tags file from each head, ending with the tip
         f = None
         for rev, node, fnode in self._hgtagsnodes():
             f = (f and f.filectx(fnode) or
                  self.filectx('.hgtags', fileid=fnode))
             readtags(f.data().splitlines(), f)
 
         try:
             data = util.fromlocal(self.opener("localtags").read())
             # localtags are stored in the local character set
             # while the internal tag table is stored in UTF-8
             readtags(data.splitlines(), "localtags")
         except IOError:
             pass
 
         self.tagscache = {}
         for k,nh in globaltags.items():
             n = nh[0]
             if n != nullid:
                 self.tagscache[k] = n
         self.tagscache['tip'] = self.changelog.tip()
 
         return self.tagscache
 
     def _hgtagsnodes(self):
         heads = self.heads()
         heads.reverse()
         last = {}
         ret = []
         for node in heads:
             c = self.changectx(node)
             rev = c.rev()
             try:
                 fnode = c.filenode('.hgtags')
             except revlog.LookupError:
                 continue
             ret.append((rev, node, fnode))
             if fnode in last:
                 ret[last[fnode]] = None
             last[fnode] = len(ret) - 1
         return [item for item in ret if item]
 
     def tagslist(self):
         '''return a list of tags ordered by revision'''
         l = []
         for t, n in self.tags().items():
             try:
                 r = self.changelog.rev(n)
             except:
                 r = -2 # sort to the beginning of the list if unknown
             l.append((r, t, n))
         l.sort()
         return [(t, n) for r, t, n in l]
 
     def nodetags(self, node):
         '''return the tags associated with a node'''
         if not self.nodetagscache:
             self.nodetagscache = {}
             for t, n in self.tags().items():
                 self.nodetagscache.setdefault(n, []).append(t)
         return self.nodetagscache.get(node, [])
 
     def _branchtags(self):
         partial, last, lrev = self._readbranchcache()
 
         tiprev = self.changelog.count() - 1
         if lrev != tiprev:
             self._updatebranchcache(partial, lrev+1, tiprev+1)
             self._writebranchcache(partial, self.changelog.tip(), tiprev)
 
         return partial
 
     def branchtags(self):
         if self.branchcache is not None:
             return self.branchcache
 
         self.branchcache = {} # avoid recursion in changectx
         partial = self._branchtags()
 
         # the branch cache is stored on disk as UTF-8, but in the local
         # charset internally
         for k, v in partial.items():
             self.branchcache[util.tolocal(k)] = v
         return self.branchcache
 
     def _readbranchcache(self):
         partial = {}
         try:
             f = self.opener("branch.cache")
             lines = f.read().split('\n')
             f.close()
         except (IOError, OSError):
             return {}, nullid, nullrev
 
         try:
             last, lrev = lines.pop(0).split(" ", 1)
             last, lrev = bin(last), int(lrev)
             if not (lrev < self.changelog.count() and
                     self.changelog.node(lrev) == last): # sanity check
                 # invalidate the cache
                 raise ValueError('Invalid branch cache: unknown tip')
             for l in lines:
                 if not l: continue
                 node, label = l.split(" ", 1)
                 partial[label.strip()] = bin(node)
         except (KeyboardInterrupt, util.SignalInterrupt):
             raise
         except Exception, inst:
             if self.ui.debugflag:
                 self.ui.warn(str(inst), '\n')
             partial, last, lrev = {}, nullid, nullrev
         return partial, last, lrev
 
     def _writebranchcache(self, branches, tip, tiprev):
         try:
             f = self.opener("branch.cache", "w", atomictemp=True)
             f.write("%s %s\n" % (hex(tip), tiprev))
             for label, node in branches.iteritems():
                 f.write("%s %s\n" % (hex(node), label))
             f.rename()
         except (IOError, OSError):
             pass
 
     def _updatebranchcache(self, partial, start, end):
         for r in xrange(start, end):
             c = self.changectx(r)
             b = c.branch()
             partial[b] = c.node()
 
     def lookup(self, key):
         if key == '.':
             key, second = self.dirstate.parents()
             if key == nullid:
                 raise repo.RepoError(_("no revision checked out"))
             if second != nullid:
                 self.ui.warn(_("warning: working directory has two parents, "
                                "tag '.' uses the first\n"))
         elif key == 'null':
             return nullid
         n = self.changelog._match(key)
         if n:
             return n
         if key in self.tags():
             return self.tags()[key]
         if key in self.branchtags():
             return self.branchtags()[key]
         n = self.changelog._partialmatch(key)
         if n:
             return n
         raise repo.RepoError(_("unknown revision '%s'") % key)
 
     def dev(self):
         return os.lstat(self.path).st_dev
 
     def local(self):
         return True
 
     def join(self, f):
         return os.path.join(self.path, f)
 
     def sjoin(self, f):
         f = self.encodefn(f)
         return os.path.join(self.spath, f)
 
     def wjoin(self, f):
         return os.path.join(self.root, f)
 
     def file(self, f):
         if f[0] == '/':
             f = f[1:]
         return filelog.filelog(self.sopener, f)
 
     def changectx(self, changeid=None):
         return context.changectx(self, changeid)
 
     def workingctx(self):
         return context.workingctx(self)
 
     def parents(self, changeid=None):
         '''
         get list of changectxs for parents of changeid or working directory
         '''
         if changeid is None:
             pl = self.dirstate.parents()
         else:
             n = self.changelog.lookup(changeid)
             pl = self.changelog.parents(n)
         if pl[1] == nullid:
             return [self.changectx(pl[0])]
         return [self.changectx(pl[0]), self.changectx(pl[1])]
 
     def filectx(self, path, changeid=None, fileid=None):
         """changeid can be a changeset revision, node, or tag.
            fileid can be a file revision or node."""
         return context.filectx(self, path, changeid, fileid)
 
     def getcwd(self):
         return self.dirstate.getcwd()
 
     def pathto(self, f, cwd=None):
         return self.dirstate.pathto(f, cwd)
 
     def wfile(self, f, mode='r'):
         return self.wopener(f, mode)
 
     def _link(self, f):
         return os.path.islink(self.wjoin(f))
 
     def _filter(self, filter, filename, data):
         if filter not in self.filterpats:
             l = []
             for pat, cmd in self.ui.configitems(filter):
                 mf = util.matcher(self.root, "", [pat], [], [])[1]
                 l.append((mf, cmd))
             self.filterpats[filter] = l
 
         for mf, cmd in self.filterpats[filter]:
             if mf(filename):
                 self.ui.debug(_("filtering %s through %s\n") % (filename, cmd))
                 data = util.filter(data, cmd)
                 break
 
         return data
 
     def wread(self, filename):
         if self._link(filename):
             data = os.readlink(self.wjoin(filename))
         else:
             data = self.wopener(filename, 'r').read()
         return self._filter("encode", filename, data)
 
     def wwrite(self, filename, data, flags):
         data = self._filter("decode", filename, data)
         if "l" in flags:
             self.wopener.symlink(data, filename)
         else:
             try:
                 if self._link(filename):
                     os.unlink(self.wjoin(filename))
             except OSError:
                 pass
             self.wopener(filename, 'w').write(data)
             util.set_exec(self.wjoin(filename), "x" in flags)
 
     def wwritedata(self, filename, data):
         return self._filter("decode", filename, data)
 
     def transaction(self):
         tr = self.transhandle
         if tr != None and tr.running():
             return tr.nest()
 
         # save dirstate for rollback
         try:
             ds = self.opener("dirstate").read()
         except IOError:
             ds = ""
         self.opener("journal.dirstate", "w").write(ds)
 
         renames = [(self.sjoin("journal"), self.sjoin("undo")),
                    (self.join("journal.dirstate"), self.join("undo.dirstate"))]
         tr = transaction.transaction(self.ui.warn, self.sopener,
                                        self.sjoin("journal"),
                                        aftertrans(renames))
         self.transhandle = tr
         return tr
 
     def recover(self):
         l = self.lock()
         if os.path.exists(self.sjoin("journal")):
             self.ui.status(_("rolling back interrupted transaction\n"))
             transaction.rollback(self.sopener, self.sjoin("journal"))
             self.invalidate()
             return True
         else:
             self.ui.warn(_("no interrupted transaction available\n"))
             return False
 
     def rollback(self, wlock=None, lock=None):
         if not wlock:
             wlock = self.wlock()
         if not lock:
             lock = self.lock()
         if os.path.exists(self.sjoin("undo")):
             self.ui.status(_("rolling back last transaction\n"))
             transaction.rollback(self.sopener, self.sjoin("undo"))
             util.rename(self.join("undo.dirstate"), self.join("dirstate"))
             self.invalidate()
             self.dirstate.invalidate()
         else:
             self.ui.warn(_("no rollback information available\n"))
 
     def invalidate(self):
         for a in "changelog manifest".split():
             if hasattr(self, a):
                 self.__delattr__(a)
         self.tagscache = None
         self.nodetagscache = None
 
     def do_lock(self, lockname, wait, releasefn=None, acquirefn=None,
                 desc=None):
         try:
             l = lock.lock(lockname, 0, releasefn, desc=desc)
         except lock.LockHeld, inst:
             if not wait:
                 raise
             self.ui.warn(_("waiting for lock on %s held by %r\n") %
                          (desc, inst.locker))
             # default to 600 seconds timeout
             l = lock.lock(lockname, int(self.ui.config("ui", "timeout", "600")),
                           releasefn, desc=desc)
         if acquirefn:
             acquirefn()
         return l
 
     def lock(self, wait=1):
         return self.do_lock(self.sjoin("lock"), wait,
                             acquirefn=self.invalidate,
                             desc=_('repository %s') % self.origroot)
 
     def wlock(self, wait=1):
         return self.do_lock(self.join("wlock"), wait, self.dirstate.write,
                             self.dirstate.invalidate,
                             desc=_('working directory of %s') % self.origroot)
 
     def filecommit(self, fn, manifest1, manifest2, linkrev, transaction, changelist):
         """
         commit an individual file as part of a larger transaction
         """
 
         t = self.wread(fn)
         fl = self.file(fn)
         fp1 = manifest1.get(fn, nullid)
         fp2 = manifest2.get(fn, nullid)
 
         meta = {}
         cp = self.dirstate.copied(fn)
         if cp:
             # Mark the new revision of this file as a copy of another
             # file.  This copy data will effectively act as a parent
             # of this new revision.  If this is a merge, the first
             # parent will be the nullid (meaning "look up the copy data")
             # and the second one will be the other parent.  For example:
             #
             # 0 --- 1 --- 3   rev1 changes file foo
             #   \       /     rev2 renames foo to bar and changes it
             #    \- 2 -/      rev3 should have bar with all changes and
             #                      should record that bar descends from
             #                      bar in rev2 and foo in rev1
             #
             # this allows this merge to succeed:
             #
             # 0 --- 1 --- 3   rev4 reverts the content change from rev2
             #   \       /     merging rev3 and rev4 should use bar@rev2
             #    \- 2 --- 4        as the merge base
             #
             meta["copy"] = cp
             if not manifest2: # not a branch merge
                 meta["copyrev"] = hex(manifest1.get(cp, nullid))
                 fp2 = nullid
             elif fp2 != nullid: # copied on remote side
                 meta["copyrev"] = hex(manifest1.get(cp, nullid))
             elif fp1 != nullid: # copied on local side, reversed
                 meta["copyrev"] = hex(manifest2.get(cp))
                 fp2 = fp1
             else: # directory rename
                 meta["copyrev"] = hex(manifest1.get(cp, nullid))
             self.ui.debug(_(" %s: copy %s:%s\n") %
                           (fn, cp, meta["copyrev"]))
             fp1 = nullid
         elif fp2 != nullid:
             # is one parent an ancestor of the other?
             fpa = fl.ancestor(fp1, fp2)
             if fpa == fp1:
                 fp1, fp2 = fp2, nullid
             elif fpa == fp2:
                 fp2 = nullid
 
         # is the file unmodified from the parent? report existing entry
         if fp2 == nullid and not fl.cmp(fp1, t):
             return fp1
 
         changelist.append(fn)
         return fl.add(t, meta, transaction, linkrev, fp1, fp2)
 
     def rawcommit(self, files, text, user, date, p1=None, p2=None, wlock=None, extra={}):
         if p1 is None:
             p1, p2 = self.dirstate.parents()
         return self.commit(files=files, text=text, user=user, date=date,
                            p1=p1, p2=p2, wlock=wlock, extra=extra)
 
     def commit(self, files=None, text="", user=None, date=None,
                match=util.always, force=False, lock=None, wlock=None,
                force_editor=False, p1=None, p2=None, extra={}):
 
         commit = []
         remove = []
         changed = []
         use_dirstate = (p1 is None) # not rawcommit
         extra = extra.copy()
 
         if use_dirstate:
             if files:
                 for f in files:
                     s = self.dirstate.state(f)
                     if s in 'nmai':
                         commit.append(f)
                     elif s == 'r':
                         remove.append(f)
                     else:
                         self.ui.warn(_("%s not tracked!\n") % f)
             else:
                 changes = self.status(match=match)[:5]
                 modified, added, removed, deleted, unknown = changes
                 commit = modified + added
                 remove = removed
         else:
             commit = files
 
         if use_dirstate:
             p1, p2 = self.dirstate.parents()
             update_dirstate = True
         else:
             p1, p2 = p1, p2 or nullid
             update_dirstate = (self.dirstate.parents()[0] == p1)
 
         c1 = self.changelog.read(p1)
         c2 = self.changelog.read(p2)
         m1 = self.manifest.read(c1[0]).copy()
         m2 = self.manifest.read(c2[0])
 
         if use_dirstate:
             branchname = self.workingctx().branch()
             try:
                 branchname = branchname.decode('UTF-8').encode('UTF-8')
             except UnicodeDecodeError:
                 raise util.Abort(_('branch name not in UTF-8!'))
         else:
             branchname = ""
 
         if use_dirstate:
             oldname = c1[5].get("branch") # stored in UTF-8
             if (not commit and not remove and not force and p2 == nullid
                 and branchname == oldname):
                 self.ui.status(_("nothing changed\n"))
                 return None
 
         xp1 = hex(p1)
         if p2 == nullid: xp2 = ''
         else: xp2 = hex(p2)
 
         self.hook("precommit", throw=True, parent1=xp1, parent2=xp2)
 
         if not wlock:
             wlock = self.wlock()
         if not lock:
             lock = self.lock()
         tr = self.transaction()
 
         # check in files
         new = {}
         linkrev = self.changelog.count()
         commit.sort()
         is_exec = util.execfunc(self.root, m1.execf)
         is_link = util.linkfunc(self.root, m1.linkf)
         for f in commit:
             self.ui.note(f + "\n")
             try:
                 new[f] = self.filecommit(f, m1, m2, linkrev, tr, changed)
                 new_exec = is_exec(f)
                 new_link = is_link(f)
                 if not changed or changed[-1] != f:
                     # mention the file in the changelog if some flag changed,
                     # even if there was no content change.
                     old_exec = m1.execf(f)
                     old_link = m1.linkf(f)
                     if old_exec != new_exec or old_link != new_link:
                         changed.append(f)
                 m1.set(f, new_exec, new_link)
             except (OSError, IOError):
                 if use_dirstate:
                     self.ui.warn(_("trouble committing %s!\n") % f)
                     raise
                 else:
                     remove.append(f)
 
         # update manifest
         m1.update(new)
         remove.sort()
         removed = []
 
         for f in remove:
             if f in m1:
                 del m1[f]
                 removed.append(f)
             elif f in m2:
                 removed.append(f)
         mn = self.manifest.add(m1, tr, linkrev, c1[0], c2[0], (new, removed))
 
         # add changeset
         new = new.keys()
         new.sort()
 
         user = user or self.ui.username()
         if not text or force_editor:
             edittext = []
             if text:
                 edittext.append(text)
             edittext.append("")
             edittext.append("HG: user: %s" % user)
             if p2 != nullid:
                 edittext.append("HG: branch merge")
             if branchname:
                 edittext.append("HG: branch %s" % util.tolocal(branchname))
             edittext.extend(["HG: changed %s" % f for f in changed])
             edittext.extend(["HG: removed %s" % f for f in removed])
             if not changed and not remove:
                 edittext.append("HG: no files changed")
             edittext.append("")
             # run editor in the repository root
             olddir = os.getcwd()
             os.chdir(self.root)
             text = self.ui.edit("\n".join(edittext), user)
             os.chdir(olddir)
 
         lines = [line.rstrip() for line in text.rstrip().splitlines()]
         while lines and not lines[0]:
             del lines[0]
         if not lines:
             return None
         text = '\n'.join(lines)
         if branchname:
             extra["branch"] = branchname
         n = self.changelog.add(mn, changed + removed, text, tr, p1, p2,
                                user, date, extra)
         self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
                   parent2=xp2)
         tr.close()
 
         if self.branchcache and "branch" in extra:
             self.branchcache[util.tolocal(extra["branch"])] = n
 
         if use_dirstate or update_dirstate:
             self.dirstate.setparents(n)
             if use_dirstate:
                 self.dirstate.update(new, "n")
                 self.dirstate.forget(removed)
 
         self.hook("commit", node=hex(n), parent1=xp1, parent2=xp2)
         return n
 
     def walk(self, node=None, files=[], match=util.always, badmatch=None):
         '''
         walk recursively through the directory tree or a given
         changeset, finding all files matched by the match
         function
 
         results are yielded in a tuple (src, filename), where src
         is one of:
         'f' the file was found in the directory tree
         'm' the file was only in the dirstate and not in the tree
         'b' file was not found and matched badmatch
         '''
 
         if node:
             fdict = dict.fromkeys(files)
             # for dirstate.walk, files=['.'] means "walk the whole tree".
             # follow that here, too
             fdict.pop('.', None)
             mdict = self.manifest.read(self.changelog.read(node)[0])
             mfiles = mdict.keys()
             mfiles.sort()
             for fn in mfiles:
                 for ffn in fdict:
                     # match if the file is the exact name or a directory
                     if ffn == fn or fn.startswith("%s/" % ffn):
                         del fdict[ffn]
                         break
                 if match(fn):
                     yield 'm', fn
             ffiles = fdict.keys()
             ffiles.sort()
             for fn in ffiles:
                 if badmatch and badmatch(fn):
                     if match(fn):
                         yield 'b', fn
                 else:
                     self.ui.warn(_('%s: No such file in rev %s\n')
                                  % (self.pathto(fn), short(node)))
         else:
             for src, fn in self.dirstate.walk(files, match, badmatch=badmatch):
                 yield src, fn
 
     def status(self, node1=None, node2=None, files=[], match=util.always,
                 wlock=None, list_ignored=False, list_clean=False):
         """return status of files between two nodes or node and working directory
 
         If node1 is None, use the first dirstate parent instead.
         If node2 is None, compare node1 with working directory.
         """
 
         def fcmp(fn, getnode):
             t1 = self.wread(fn)
             return self.file(fn).cmp(getnode(fn), t1)
 
         def mfmatches(node):
             change = self.changelog.read(node)
             mf = self.manifest.read(change[0]).copy()
             for fn in mf.keys():
                 if not match(fn):
                     del mf[fn]
             return mf
 
         modified, added, removed, deleted, unknown = [], [], [], [], []
         ignored, clean = [], []
 
         compareworking = False
         if not node1 or (not node2 and node1 == self.dirstate.parents()[0]):
             compareworking = True
 
         if not compareworking:
             # read the manifest from node1 before the manifest from node2,
             # so that we'll hit the manifest cache if we're going through
             # all the revisions in parent->child order.
             mf1 = mfmatches(node1)
 
         mywlock = False
 
         # are we comparing the working directory?
         if not node2:
             (lookup, modified, added, removed, deleted, unknown,
              ignored, clean) = self.dirstate.status(files, match,
                                                     list_ignored, list_clean)
 
             # are we comparing working dir against its parent?
             if compareworking:
                 if lookup:
                     # do a full compare of any files that might have changed
                     mnode = self.changelog.read(self.dirstate.parents()[0])[0]
                     getnode = lambda fn: (self.manifest.find(mnode, fn)[0] or
                                           nullid)
                     for f in lookup:
                         if fcmp(f, getnode):
                             modified.append(f)
                         else:
                             if list_clean:
                                 clean.append(f)
                             if not wlock and not mywlock:
                                 mywlock = True
                                 try:
                                     wlock = self.wlock(wait=0)
                                 except lock.LockException:
                                     pass
                             if wlock:
                                 self.dirstate.update([f], "n")
             else:
                 # we are comparing working dir against non-parent
                 # generate a pseudo-manifest for the working dir
                 # XXX: create it in dirstate.py ?
                 mf2 = mfmatches(self.dirstate.parents()[0])
                 is_exec = util.execfunc(self.root, mf2.execf)
                 is_link = util.linkfunc(self.root, mf2.linkf)
                 for f in lookup + modified + added:
                     mf2[f] = ""
                     mf2.set(f, is_exec(f), is_link(f))
                 for f in removed:
                     if f in mf2:
                         del mf2[f]
 
             if mywlock and wlock:
                 wlock.release()
         else:
             # we are comparing two revisions
             mf2 = mfmatches(node2)
 
         if not compareworking:
             # flush lists from dirstate before comparing manifests
             modified, added, clean = [], [], []
 
             # make sure to sort the files so we talk to the disk in a
             # reasonable order
             mf2keys = mf2.keys()
             mf2keys.sort()
             getnode = lambda fn: mf1.get(fn, nullid)
             for fn in mf2keys:
                 if mf1.has_key(fn):
                     if (mf1.flags(fn) != mf2.flags(fn) or
                         (mf1[fn] != mf2[fn] and
                          (mf2[fn] != "" or fcmp(fn, getnode)))):
                         modified.append(fn)
                     elif list_clean:
                         clean.append(fn)
                     del mf1[fn]
                 else:
                     added.append(fn)
 
             removed = mf1.keys()
 
         # sort and return results:
         for l in modified, added, removed, deleted, unknown, ignored, clean:
             l.sort()
         return (modified, added, removed, deleted, unknown, ignored, clean)
 
     def add(self, list, wlock=None):
         if not wlock:
             wlock = self.wlock()
         for f in list:
             p = self.wjoin(f)
             try:
                 st = os.lstat(p)
             except:
                 self.ui.warn(_("%s does not exist!\n") % f)
                 continue
             if st.st_size > 10000000:
                 self.ui.warn(_("%s: files over 10MB may cause memory and"
                                " performance problems\n"
                                "(use 'hg revert %s' to unadd the file)\n")
                                % (f, f))
             if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
                 self.ui.warn(_("%s not added: only files and symlinks "
                                "supported currently\n") % f)
             elif self.dirstate.state(f) in 'an':
                 self.ui.warn(_("%s already tracked!\n") % f)
             else:
                 self.dirstate.update([f], "a")
 
     def forget(self, list, wlock=None):
         if not wlock:
             wlock = self.wlock()
         for f in list:
             if self.dirstate.state(f) not in 'ai':
                 self.ui.warn(_("%s not added!\n") % f)
             else:
                 self.dirstate.forget([f])
 
     def remove(self, list, unlink=False, wlock=None):
         if unlink:
             for f in list:
                 try:
                     util.unlink(self.wjoin(f))
                 except OSError, inst:
                     if inst.errno != errno.ENOENT:
                         raise
         if not wlock:
             wlock = self.wlock()
         for f in list:
             if unlink and os.path.exists(self.wjoin(f)):
                 self.ui.warn(_("%s still exists!\n") % f)
             elif self.dirstate.state(f) == 'a':
                 self.dirstate.forget([f])
             elif f not in self.dirstate:
                 self.ui.warn(_("%s not tracked!\n") % f)
             else:
                 self.dirstate.update([f], "r")
 
     def undelete(self, list, wlock=None):
         p = self.dirstate.parents()[0]
         mn = self.changelog.read(p)[0]
         m = self.manifest.read(mn)
         if not wlock:
             wlock = self.wlock()
         for f in list:
             if self.dirstate.state(f) not in  "r":
                 self.ui.warn("%s not removed!\n" % f)
             else:
                 t = self.file(f).read(m[f])
                 self.wwrite(f, t, m.flags(f))
                 self.dirstate.update([f], "n")
 
     def copy(self, source, dest, wlock=None):
         p = self.wjoin(dest)
         if not (os.path.exists(p) or os.path.islink(p)):
             self.ui.warn(_("%s does not exist!\n") % dest)
         elif not (os.path.isfile(p) or os.path.islink(p)):
             self.ui.warn(_("copy failed: %s is not a file or a "
                            "symbolic link\n") % dest)
         else:
             if not wlock:
                 wlock = self.wlock()
             if self.dirstate.state(dest) == '?':
                 self.dirstate.update([dest], "a")
             self.dirstate.copy(source, dest)
 
     def heads(self, start=None):
         heads = self.changelog.heads(start)
         # sort the output in rev descending order
         heads = [(-self.changelog.rev(h), h) for h in heads]
         heads.sort()
         return [n for (r, n) in heads]
 
     def branchheads(self, branch, start=None):
         branches = self.branchtags()
         if branch not in branches:
             return []
         # The basic algorithm is this:
         #
         # Start from the branch tip since there are no later revisions that can
         # possibly be in this branch, and the tip is a guaranteed head.
         #
         # Remember the tip's parents as the first ancestors, since these by
         # definition are not heads.
         #
         # Step backwards from the brach tip through all the revisions. We are
         # guaranteed by the rules of Mercurial that we will now be visiting the
         # nodes in reverse topological order (children before parents).
         #
         # If a revision is one of the ancestors of a head then we can toss it
         # out of the ancestors set (we've already found it and won't be
         # visiting it again) and put its parents in the ancestors set.
         #
         # Otherwise, if a revision is in the branch it's another head, since it
         # wasn't in the ancestor list of an existing head.  So add it to the
         # head list, and add its parents to the ancestor list.
         #
         # If it is not in the branch ignore it.
         #
         # Once we have a list of heads, use nodesbetween to filter out all the
         # heads that cannot be reached from startrev.  There may be a more
         # efficient way to do this as part of the previous algorithm.
 
         set = util.set
         heads = [self.changelog.rev(branches[branch])]
         # Don't care if ancestors contains nullrev or not.
         ancestors = set(self.changelog.parentrevs(heads[0]))
         for rev in xrange(heads[0] - 1, nullrev, -1):
             if rev in ancestors:
                 ancestors.update(self.changelog.parentrevs(rev))
                 ancestors.remove(rev)
             elif self.changectx(rev).branch() == branch:
                 heads.append(rev)
                 ancestors.update(self.changelog.parentrevs(rev))
         heads = [self.changelog.node(rev) for rev in heads]
         if start is not None:
             heads = self.changelog.nodesbetween([start], heads)[2]
         return heads
 
     def branches(self, nodes):
         if not nodes:
             nodes = [self.changelog.tip()]
         b = []
         for n in nodes:
             t = n
             while 1:
                 p = self.changelog.parents(n)
                 if p[1] != nullid or p[0] == nullid:
                     b.append((t, n, p[0], p[1]))
                     break
                 n = p[0]
         return b
 
     def between(self, pairs):
         r = []
 
         for top, bottom in pairs:
             n, l, i = top, [], 0
             f = 1
 
             while n != bottom:
                 p = self.changelog.parents(n)[0]
                 if i == f:
                     l.append(n)
                     f = f * 2
                 n = p
                 i += 1
 
             r.append(l)
 
         return r
 
     def findincoming(self, remote, base=None, heads=None, force=False):
         """Return list of roots of the subsets of missing nodes from remote
 
         If base dict is specified, assume that these nodes and their parents
         exist on the remote side and that no child of a node of base exists
         in both remote and self.
         Furthermore base will be updated to include the nodes that exists
         in self and remote but no children exists in self and remote.
         If a list of heads is specified, return only nodes which are heads
         or ancestors of these heads.
 
         All the ancestors of base are in self and in remote.
         All the descendants of the list returned are missing in self.
         (and so we know that the rest of the nodes are missing in remote, see
         outgoing)
         """
         m = self.changelog.nodemap
         search = []
         fetch = {}
         seen = {}
         seenbranch = {}
         if base == None:
             base = {}
 
         if not heads:
             heads = remote.heads()
 
         if self.changelog.tip() == nullid:
             base[nullid] = 1
             if heads != [nullid]:
                 return [nullid]
             return []
 
         # assume we're closer to the tip than the root
         # and start by examining the heads
         self.ui.status(_("searching for changes\n"))
 
         unknown = []
         for h in heads:
             if h not in m:
                 unknown.append(h)
             else:
                 base[h] = 1
 
         if not unknown:
             return []
 
         req = dict.fromkeys(unknown)
         reqcnt = 0
 
         # search through remote branches
         # a 'branch' here is a linear segment of history, with four parts:
         # head, root, first parent, second parent
         # (a branch always has two parents (or none) by definition)
         unknown = remote.branches(unknown)
         while unknown:
             r = []
             while unknown:
                 n = unknown.pop(0)
                 if n[0] in seen:
                     continue
 
                 self.ui.debug(_("examining %s:%s\n")
                               % (short(n[0]), short(n[1])))
                 if n[0] == nullid: # found the end of the branch
                     pass
                 elif n in seenbranch:
                     self.ui.debug(_("branch already found\n"))
                     continue
                 elif n[1] and n[1] in m: # do we know the base?
                     self.ui.debug(_("found incomplete branch %s:%s\n")
                                   % (short(n[0]), short(n[1])))
                     search.append(n) # schedule branch range for scanning
                     seenbranch[n] = 1
                 else:
                     if n[1] not in seen and n[1] not in fetch:
                         if n[2] in m and n[3] in m:
                             self.ui.debug(_("found new changeset %s\n") %
                                           short(n[1]))
                             fetch[n[1]] = 1 # earliest unknown
                         for p in n[2:4]:
                             if p in m:
                                 base[p] = 1 # latest known
 
                     for p in n[2:4]:
                         if p not in req and p not in m:
                             r.append(p)
                             req[p] = 1
                 seen[n[0]] = 1
 
             if r:
                 reqcnt += 1
                 self.ui.debug(_("request %d: %s\n") %
                             (reqcnt, " ".join(map(short, r))))
                 for p in xrange(0, len(r), 10):
                     for b in remote.branches(r[p:p+10]):
                         self.ui.debug(_("received %s:%s\n") %
                                       (short(b[0]), short(b[1])))
                         unknown.append(b)
 
         # do binary search on the branches we found
         while search:
             n = search.pop(0)
             reqcnt += 1
             l = remote.between([(n[0], n[1])])[0]
             l.append(n[1])
             p = n[0]
             f = 1
             for i in l:
                 self.ui.debug(_("narrowing %d:%d %s\n") % (f, len(l), short(i)))
                 if i in m:
                     if f <= 2:
                         self.ui.debug(_("found new branch changeset %s\n") %
                                           short(p))
                         fetch[p] = 1
                         base[i] = 1
                     else:
                         self.ui.debug(_("narrowed branch search to %s:%s\n")
                                       % (short(p), short(i)))
                         search.append((p, i))
                     break
                 p, f = i, f * 2
 
         # sanity check our fetch list
         for f in fetch.keys():
             if f in m:
                 raise repo.RepoError(_("already have changeset ") + short(f[:4]))
 
         if base.keys() == [nullid]:
             if force:
                 self.ui.warn(_("warning: repository is unrelated\n"))
             else:
                 raise util.Abort(_("repository is unrelated"))
 
         self.ui.debug(_("found new changesets starting at ") +
                      " ".join([short(f) for f in fetch]) + "\n")
 
         self.ui.debug(_("%d total queries\n") % reqcnt)
 
         return fetch.keys()
 
     def findoutgoing(self, remote, base=None, heads=None, force=False):
         """Return list of nodes that are roots of subsets not in remote
 
         If base dict is specified, assume that these nodes and their parents
         exist on the remote side.
         If a list of heads is specified, return only nodes which are heads
         or ancestors of these heads, and return a second element which
         contains all remote heads which get new children.
         """
         if base == None:
             base = {}
             self.findincoming(remote, base, heads, force=force)
 
         self.ui.debug(_("common changesets up to ")
                       + " ".join(map(short, base.keys())) + "\n")
 
         remain = dict.fromkeys(self.changelog.nodemap)
 
         # prune everything remote has from the tree
         del remain[nullid]
         remove = base.keys()
         while remove:
             n = remove.pop(0)
             if n in remain:
                 del remain[n]
                 for p in self.changelog.parents(n):
                     remove.append(p)
 
         # find every node whose parents have been pruned
         subset = []
         # find every remote head that will get new children
         updated_heads = {}
         for n in remain:
             p1, p2 = self.changelog.parents(n)
             if p1 not in remain and p2 not in remain:
                 subset.append(n)
             if heads:
                 if p1 in heads:
                     updated_heads[p1] = True
                 if p2 in heads:
                     updated_heads[p2] = True
 
         # this is the set of all roots we have to push
         if heads:
             return subset, updated_heads.keys()
         else:
             return subset
 
     def pull(self, remote, heads=None, force=False, lock=None):
         mylock = False
         if not lock:
             lock = self.lock()
             mylock = True
 
         try:
             fetch = self.findincoming(remote, force=force)
             if fetch == [nullid]:
                 self.ui.status(_("requesting all changes\n"))
 
             if not fetch:
                 self.ui.status(_("no changes found\n"))
                 return 0
 
             if heads is None:
                 cg = remote.changegroup(fetch, 'pull')
             else:
                 if 'changegroupsubset' not in remote.capabilities:
                     raise util.Abort(_("Partial pull cannot be done because other repository doesn't support changegroupsubset."))
                 cg = remote.changegroupsubset(fetch, heads, 'pull')
             return self.addchangegroup(cg, 'pull', remote.url())
         finally:
             if mylock:
                 lock.release()
 
     def push(self, remote, force=False, revs=None):
         # there are two ways to push to remote repo:
         #
         # addchangegroup assumes local user can lock remote
         # repo (local filesystem, old ssh servers).
         #
         # unbundle assumes local user cannot lock remote repo (new ssh
         # servers, http servers).
 
         if remote.capable('unbundle'):
             return self.push_unbundle(remote, force, revs)
         return self.push_addchangegroup(remote, force, revs)
 
     def prepush(self, remote, force, revs):
         base = {}
         remote_heads = remote.heads()
         inc = self.findincoming(remote, base, remote_heads, force=force)
 
         update, updated_heads = self.findoutgoing(remote, base, remote_heads)
         if revs is not None:
             msng_cl, bases, heads = self.changelog.nodesbetween(update, revs)
         else:
             bases, heads = update, self.changelog.heads()
 
         if not bases:
             self.ui.status(_("no changes found\n"))
             return None, 1
         elif not force:
             # check if we're creating new remote heads
             # to be a remote head after push, node must be either
             # - unknown locally
             # - a local outgoing head descended from update
             # - a remote head that's known locally and not
             #   ancestral to an outgoing head
 
             warn = 0
 
             if remote_heads == [nullid]:
                 warn = 0
             elif not revs and len(heads) > len(remote_heads):
                 warn = 1
             else:
                 newheads = list(heads)
                 for r in remote_heads:
                     if r in self.changelog.nodemap:
                         desc = self.changelog.heads(r, heads)
                         l = [h for h in heads if h in desc]
                         if not l:
                             newheads.append(r)
                     else:
                         newheads.append(r)
                 if len(newheads) > len(remote_heads):
                     warn = 1
 
             if warn:
                 self.ui.warn(_("abort: push creates new remote branches!\n"))
                 self.ui.status(_("(did you forget to merge?"
                                  " use push -f to force)\n"))
                 return None, 1
             elif inc:
                 self.ui.warn(_("note: unsynced remote changes!\n"))
 
 
         if revs is None:
             cg = self.changegroup(update, 'push')
         else:
             cg = self.changegroupsubset(update, revs, 'push')
         return cg, remote_heads
 
     def push_addchangegroup(self, remote, force, revs):
         lock = remote.lock()
 
         ret = self.prepush(remote, force, revs)
         if ret[0] is not None:
             cg, remote_heads = ret
             return remote.addchangegroup(cg, 'push', self.url())
         return ret[1]
 
     def push_unbundle(self, remote, force, revs):
         # local repo finds heads on server, finds out what revs it
         # must push.  once revs transferred, if server finds it has
         # different heads (someone else won commit/push race), server
         # aborts.
 
         ret = self.prepush(remote, force, revs)
         if ret[0] is not None:
             cg, remote_heads = ret
             if force: remote_heads = ['force']
             return remote.unbundle(cg, remote_heads, 'push')
         return ret[1]
 
     def changegroupinfo(self, nodes):
         self.ui.note(_("%d changesets found\n") % len(nodes))
         if self.ui.debugflag:
             self.ui.debug(_("List of changesets:\n"))
             for node in nodes:
                 self.ui.debug("%s\n" % hex(node))
 
     def changegroupsubset(self, bases, heads, source):
         """This function generates a changegroup consisting of all the nodes
         that are descendents of any of the bases, and ancestors of any of
         the heads.
 
         It is fairly complex as determining which filenodes and which
         manifest nodes need to be included for the changeset to be complete
         is non-trivial.
 
         Another wrinkle is doing the reverse, figuring out which changeset in
         the changegroup a particular filenode or manifestnode belongs to."""
 
         self.hook('preoutgoing', throw=True, source=source)
 
         # Set up some initial variables
         # Make it easy to refer to self.changelog
         cl = self.changelog
         # msng is short for missing - compute the list of changesets in this
         # changegroup.
         msng_cl_lst, bases, heads = cl.nodesbetween(bases, heads)
         self.changegroupinfo(msng_cl_lst)
         # Some bases may turn out to be superfluous, and some heads may be
         # too.  nodesbetween will return the minimal set of bases and heads
         # necessary to re-create the changegroup.
 
         # Known heads are the list of heads that it is assumed the recipient
         # of this changegroup will know about.
         knownheads = {}
         # We assume that all parents of bases are known heads.
         for n in bases:
             for p in cl.parents(n):
                 if p != nullid:
                     knownheads[p] = 1
         knownheads = knownheads.keys()
         if knownheads:
             # Now that we know what heads are known, we can compute which
             # changesets are known.  The recipient must know about all
             # changesets required to reach the known heads from the null
             # changeset.
             has_cl_set, junk, junk = cl.nodesbetween(None, knownheads)
             junk = None
             # Transform the list into an ersatz set.
             has_cl_set = dict.fromkeys(has_cl_set)
         else:
             # If there were no known heads, the recipient cannot be assumed to
             # know about any changesets.
             has_cl_set = {}
 
         # Make it easy to refer to self.manifest
         mnfst = self.manifest
         # We don't know which manifests are missing yet
         msng_mnfst_set = {}
         # Nor do we know which filenodes are missing.
         msng_filenode_set = {}
 
         junk = mnfst.index[mnfst.count() - 1] # Get around a bug in lazyindex
         junk = None
 
         # A changeset always belongs to itself, so the changenode lookup
         # function for a changenode is identity.
         def identity(x):
             return x
 
         # A function generating function.  Sets up an environment for the
         # inner function.
         def cmp_by_rev_func(revlog):
             # Compare two nodes by their revision number in the environment's
             # revision history.  Since the revision number both represents the
             # most efficient order to read the nodes in, and represents a
             # topological sorting of the nodes, this function is often useful.
             def cmp_by_rev(a, b):
                 return cmp(revlog.rev(a), revlog.rev(b))
             return cmp_by_rev
 
         # If we determine that a particular file or manifest node must be a
         # node that the recipient of the changegroup will already have, we can
         # also assume the recipient will have all the parents.  This function
         # prunes them from the set of missing nodes.
         def prune_parents(revlog, hasset, msngset):
             haslst = hasset.keys()
             haslst.sort(cmp_by_rev_func(revlog))
             for node in haslst:
                 parentlst = [p for p in revlog.parents(node) if p != nullid]
                 while parentlst:
                     n = parentlst.pop()
                     if n not in hasset:
                         hasset[n] = 1
                         p = [p for p in revlog.parents(n) if p != nullid]
                         parentlst.extend(p)
             for n in hasset:
                 msngset.pop(n, None)
 
         # This is a function generating function used to set up an environment
         # for the inner function to execute in.
         def manifest_and_file_collector(changedfileset):
             # This is an information gathering function that gathers
             # information from each changeset node that goes out as part of
             # the changegroup.  The information gathered is a list of which
             # manifest nodes are potentially required (the recipient may
             # already have them) and total list of all files which were
             # changed in any changeset in the changegroup.
             #
             # We also remember the first changenode we saw any manifest
             # referenced by so we can later determine which changenode 'owns'
             # the manifest.
             def collect_manifests_and_files(clnode):
                 c = cl.read(clnode)
                 for f in c[3]:
                     # This is to make sure we only have one instance of each
                     # filename string for each filename.
                     changedfileset.setdefault(f, f)
                 msng_mnfst_set.setdefault(c[0], clnode)
             return collect_manifests_and_files
 
         # Figure out which manifest nodes (of the ones we think might be part
         # of the changegroup) the recipient must know about and remove them
         # from the changegroup.
         def prune_manifests():
             has_mnfst_set = {}
             for n in msng_mnfst_set:
                 # If a 'missing' manifest thinks it belongs to a changenode
                 # the recipient is assumed to have, obviously the recipient
                 # must have that manifest.
                 linknode = cl.node(mnfst.linkrev(n))
                 if linknode in has_cl_set:
                     has_mnfst_set[n] = 1
             prune_parents(mnfst, has_mnfst_set, msng_mnfst_set)
 
         # Use the information collected in collect_manifests_and_files to say
         # which changenode any manifestnode belongs to.
         def lookup_manifest_link(mnfstnode):
             return msng_mnfst_set[mnfstnode]
 
         # A function generating function that sets up the initial environment
         # the inner function.
         def filenode_collector(changedfiles):
             next_rev = [0]
             # This gathers information from each manifestnode included in the
             # changegroup about which filenodes the manifest node references
             # so we can include those in the changegroup too.
             #
             # It also remembers which changenode each filenode belongs to.  It
             # does this by assuming the a filenode belongs to the changenode
             # the first manifest that references it belongs to.
             def collect_msng_filenodes(mnfstnode):
                 r = mnfst.rev(mnfstnode)
                 if r == next_rev[0]:
                     # If the last rev we looked at was the one just previous,
                     # we only need to see a diff.
                     delta = mdiff.patchtext(mnfst.delta(mnfstnode))
                     # For each line in the delta
                     for dline in delta.splitlines():
                         # get the filename and filenode for that line
                         f, fnode = dline.split('\0')
                         fnode = bin(fnode[:40])
                         f = changedfiles.get(f, None)
                         # And if the file is in the list of files we care
                         # about.
                         if f is not None:
                             # Get the changenode this manifest belongs to
                             clnode = msng_mnfst_set[mnfstnode]
                             # Create the set of filenodes for the file if
                             # there isn't one already.
                             ndset = msng_filenode_set.setdefault(f, {})
                             # And set the filenode's changelog node to the
                             # manifest's if it hasn't been set already.
                             ndset.setdefault(fnode, clnode)
                 else:
                     # Otherwise we need a full manifest.
                     m = mnfst.read(mnfstnode)
                     # For every file in we care about.
                     for f in changedfiles:
                         fnode = m.get(f, None)
                         # If it's in the manifest
                         if fnode is not None:
                             # See comments above.
                             clnode = msng_mnfst_set[mnfstnode]
                             ndset = msng_filenode_set.setdefault(f, {})
                             ndset.setdefault(fnode, clnode)
                 # Remember the revision we hope to see next.
                 next_rev[0] = r + 1
             return collect_msng_filenodes
 
         # We have a list of filenodes we think we need for a file, lets remove
         # all those we now the recipient must have.
         def prune_filenodes(f, filerevlog):
             msngset = msng_filenode_set[f]
             hasset = {}
             # If a 'missing' filenode thinks it belongs to a changenode we
             # assume the recipient must have, then the recipient must have
             # that filenode.
             for n in msngset:
                 clnode = cl.node(filerevlog.linkrev(n))
                 if clnode in has_cl_set:
                     hasset[n] = 1
             prune_parents(filerevlog, hasset, msngset)
 
         # A function generator function that sets up the a context for the
         # inner function.
         def lookup_filenode_link_func(fname):
             msngset = msng_filenode_set[fname]
             # Lookup the changenode the filenode belongs to.
             def lookup_filenode_link(fnode):
                 return msngset[fnode]
             return lookup_filenode_link
 
         # Now that we have all theses utility functions to help out and
         # logically divide up the task, generate the group.
         def gengroup():
             # The set of changed files starts empty.
             changedfiles = {}
             # Create a changenode group generator that will call our functions
             # back to lookup the owning changenode and collect information.
             group = cl.group(msng_cl_lst, identity,
                              manifest_and_file_collector(changedfiles))
             for chnk in group:
                 yield chnk
 
             # The list of manifests has been collected by the generator
             # calling our functions back.
             prune_manifests()
             msng_mnfst_lst = msng_mnfst_set.keys()
             # Sort the manifestnodes by revision number.
             msng_mnfst_lst.sort(cmp_by_rev_func(mnfst))
             # Create a generator for the manifestnodes that calls our lookup
             # and data collection functions back.
             group = mnfst.group(msng_mnfst_lst, lookup_manifest_link,
                                 filenode_collector(changedfiles))
             for chnk in group:
                 yield chnk
 
             # These are no longer needed, dereference and toss the memory for
             # them.
             msng_mnfst_lst = None
             msng_mnfst_set.clear()
 
             changedfiles = changedfiles.keys()
             changedfiles.sort()
             # Go through all our files in order sorted by name.
             for fname in changedfiles:
                 filerevlog = self.file(fname)
                 # Toss out the filenodes that the recipient isn't really
                 # missing.
                 if msng_filenode_set.has_key(fname):
                     prune_filenodes(fname, filerevlog)
                     msng_filenode_lst = msng_filenode_set[fname].keys()
                 else:
                     msng_filenode_lst = []
                 # If any filenodes are left, generate the group for them,
                 # otherwise don't bother.
                 if len(msng_filenode_lst) > 0:
                     yield changegroup.genchunk(fname)
                     # Sort the filenodes by their revision #
                     msng_filenode_lst.sort(cmp_by_rev_func(filerevlog))
                     # Create a group generator and only pass in a changenode
                     # lookup function as we need to collect no information
                     # from filenodes.
                     group = filerevlog.group(msng_filenode_lst,
                                              lookup_filenode_link_func(fname))
                     for chnk in group:
                         yield chnk
                 if msng_filenode_set.has_key(fname):
                     # Don't need this anymore, toss it to free memory.
                     del msng_filenode_set[fname]
             # Signal that no more groups are left.
             yield changegroup.closechunk()
 
             if msng_cl_lst:
                 self.hook('outgoing', node=hex(msng_cl_lst[0]), source=source)
 
         return util.chunkbuffer(gengroup())
 
     def changegroup(self, basenodes, source):
         """Generate a changegroup of all nodes that we have that a recipient
         doesn't.
 
         This is much easier than the previous function as we can assume that
         the recipient has any changenode we aren't sending them."""
 
         self.hook('preoutgoing', throw=True, source=source)
 
         cl = self.changelog
         nodes = cl.nodesbetween(basenodes, None)[0]
         revset = dict.fromkeys([cl.rev(n) for n in nodes])
         self.changegroupinfo(nodes)
 
         def identity(x):
             return x
 
         def gennodelst(revlog):
             for r in xrange(0, revlog.count()):
                 n = revlog.node(r)
                 if revlog.linkrev(n) in revset:
                     yield n
 
         def changed_file_collector(changedfileset):
             def collect_changed_files(clnode):
                 c = cl.read(clnode)
                 for fname in c[3]:
                     changedfileset[fname] = 1
             return collect_changed_files
 
         def lookuprevlink_func(revlog):
             def lookuprevlink(n):
                 return cl.node(revlog.linkrev(n))
             return lookuprevlink
 
         def gengroup():
             # construct a list of all changed files
             changedfiles = {}
 
             for chnk in cl.group(nodes, identity,
                                  changed_file_collector(changedfiles)):
                 yield chnk
             changedfiles = changedfiles.keys()
             changedfiles.sort()
 
             mnfst = self.manifest
             nodeiter = gennodelst(mnfst)
             for chnk in mnfst.group(nodeiter, lookuprevlink_func(mnfst)):
                 yield chnk
 
             for fname in changedfiles:
                 filerevlog = self.file(fname)
                 nodeiter = gennodelst(filerevlog)
                 nodeiter = list(nodeiter)
                 if nodeiter:
                     yield changegroup.genchunk(fname)
                     lookup = lookuprevlink_func(filerevlog)
                     for chnk in filerevlog.group(nodeiter, lookup):
                         yield chnk
 
             yield changegroup.closechunk()
 
             if nodes:
                 self.hook('outgoing', node=hex(nodes[0]), source=source)
 
         return util.chunkbuffer(gengroup())
 
     def addchangegroup(self, source, srctype, url):
         """add changegroup to repo.
 
         return values:
         - nothing changed or no source: 0
         - more heads than before: 1+added heads (2..n)
         - less heads than before: -1-removed heads (-2..-n)
         - number of heads stays the same: 1
         """
         def csmap(x):
             self.ui.debug(_("add changeset %s\n") % short(x))
             return cl.count()
 
         def revmap(x):
             return cl.rev(x)
 
         if not source:
             return 0
 
         self.hook('prechangegroup', throw=True, source=srctype, url=url)
 
         changesets = files = revisions = 0
 
         tr = self.transaction()
 
         # write changelog data to temp files so concurrent readers will not see
         # inconsistent view
         cl = self.changelog
         cl.delayupdate()
         oldheads = len(cl.heads())
 
         # pull off the changeset group
         self.ui.status(_("adding changesets\n"))
         cor = cl.count() - 1
         chunkiter = changegroup.chunkiter(source)
         if cl.addgroup(chunkiter, csmap, tr, 1) is None:
             raise util.Abort(_("received changelog group is empty"))
         cnr = cl.count() - 1
         changesets = cnr - cor
 
         # pull off the manifest group
         self.ui.status(_("adding manifests\n"))
         chunkiter = changegroup.chunkiter(source)
         # no need to check for empty manifest group here:
         # if the result of the merge of 1 and 2 is the same in 3 and 4,
         # no new manifest will be created and the manifest group will
         # be empty during the pull
         self.manifest.addgroup(chunkiter, revmap, tr)
 
         # process the files
         self.ui.status(_("adding file changes\n"))
         while 1:
             f = changegroup.getchunk(source)
             if not f:
                 break
             self.ui.debug(_("adding %s revisions\n") % f)
             fl = self.file(f)
             o = fl.count()
             chunkiter = changegroup.chunkiter(source)
             if fl.addgroup(chunkiter, revmap, tr) is None:
                 raise util.Abort(_("received file revlog group is empty"))
             revisions += fl.count() - o
             files += 1
 
         # make changelog see real files again
         cl.finalize(tr)
 
         newheads = len(self.changelog.heads())
         heads = ""
         if oldheads and newheads != oldheads:
             heads = _(" (%+d heads)") % (newheads - oldheads)
 
         self.ui.status(_("added %d changesets"
                          " with %d changes to %d files%s\n")
                          % (changesets, revisions, files, heads))
 
         if changesets > 0:
             self.hook('pretxnchangegroup', throw=True,
                       node=hex(self.changelog.node(cor+1)), source=srctype,
                       url=url)
 
         tr.close()
 
         if changesets > 0:
             self.hook("changegroup", node=hex(self.changelog.node(cor+1)),
                       source=srctype, url=url)
 
             for i in xrange(cor + 1, cnr + 1):
                 self.hook("incoming", node=hex(self.changelog.node(i)),
                           source=srctype, url=url)
 
         # never return 0 here:
         if newheads < oldheads:
             return newheads - oldheads - 1
         else:
             return newheads - oldheads + 1
 
 
     def stream_in(self, remote):
         fp = remote.stream_out()
         l = fp.readline()
         try:
             resp = int(l)
         except ValueError:
             raise util.UnexpectedOutput(
                 _('Unexpected response from remote server:'), l)
         if resp == 1:
             raise util.Abort(_('operation forbidden by server'))
         elif resp == 2:
             raise util.Abort(_('locking the remote repository failed'))
         elif resp != 0:
             raise util.Abort(_('the server sent an unknown error code'))
         self.ui.status(_('streaming all changes\n'))
         l = fp.readline()
         try:
             total_files, total_bytes = map(int, l.split(' ', 1))
         except ValueError, TypeError:
             raise util.UnexpectedOutput(
                 _('Unexpected response from remote server:'), l)
         self.ui.status(_('%d files to transfer, %s of data\n') %
                        (total_files, util.bytecount(total_bytes)))
         start = time.time()
         for i in xrange(total_files):
             # XXX doesn't support '\n' or '\r' in filenames
             l = fp.readline()
             try:
                 name, size = l.split('\0', 1)
                 size = int(size)
             except ValueError, TypeError:
                 raise util.UnexpectedOutput(
                     _('Unexpected response from remote server:'), l)
             self.ui.debug('adding %s (%s)\n' % (name, util.bytecount(size)))
             ofp = self.sopener(name, 'w')
             for chunk in util.filechunkiter(fp, limit=size):
                 ofp.write(chunk)
             ofp.close()
         elapsed = time.time() - start
         if elapsed <= 0:
             elapsed = 0.001
         self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') %
                        (util.bytecount(total_bytes), elapsed,
                         util.bytecount(total_bytes / elapsed)))
         self.invalidate()
         return len(self.heads()) + 1
 
     def clone(self, remote, heads=[], stream=False):
         '''clone remote repository.
 
         keyword arguments:
         heads: list of revs to clone (forces use of pull)
         stream: use streaming clone if possible'''
 
         # now, all clients that can request uncompressed clones can
         # read repo formats supported by all servers that can serve
         # them.
 
         # if revlog format changes, client will have to check version
         # and format flags on "stream" capability, and use
         # uncompressed only if compatible.
 
         if stream and not heads and remote.capable('stream'):
             return self.stream_in(remote)
         return self.pull(remote, heads)
 
 # used to avoid circular references so destructors work
 def aftertrans(files):
     renamefiles = [tuple(t) for t in files]
     def a():
         for src, dest in renamefiles:
             util.rename(src, dest)
     return a
 
 def instance(ui, path, create):
     return localrepository(ui, util.drop_scheme('file', path), create)
 
 def islocal(path):
     return True

tests/hghave

@@ -1,81 +1,81 b''
 #!/usr/bin/env python
 """Test the running system for features availability. Exit with zero
 if all features are there, non-zero otherwise.
 """
 import optparse
 import os
 import sys
 import tempfile
 
 def has_symlink():
     return hasattr(os, "symlink")
 
 def has_fifo():
     return hasattr(os, "mkfifo")
 
 def has_executablebit():
     fd, path = tempfile.mkstemp()
     os.close(fd)
     try:
         s = os.lstat(path).st_mode
         os.chmod(path, s | 0100)
         return (os.lstat(path).st_mode & 0100 != 0)
     finally:
         os.remove(path)
 
 def has_eol_in_paths():
     try:
         fd, path = tempfile.mkstemp(suffix='\n\r')
         os.close(fd)
         os.remove(path)
         return True
     except:
         return False
 
 checks = {
     "symlink": (has_symlink, "symbolic links"),
     "fifo": (has_fifo, "named pipes"),
     "execbit": (has_executablebit, "executable bit"),
     "eol-in-paths": (has_eol_in_paths, "end-of-lines in paths"),
 }
 
 def list_features():
     for name, feature in checks.iteritems():
         desc = feature[1]
         print name + ':', desc
 
 parser = optparse.OptionParser("%prog [options] [features]")
 parser.add_option("--list-features", action="store_true",
                   help="list available features")
 parser.add_option("-q", "--quiet", action="store_true",
                   help="check features silently")
 
 if __name__ == '__main__':
     options, args = parser.parse_args()
     if options.list_features:
         list_features()
         sys.exit(0)
-        
+
     quiet = options.quiet
 
     failures = 0
 
     def error(msg):
         global failures
         if not quiet:
             sys.stderr.write(msg + '\n')
         failures += 1
-    
+
     for feature in args:
         if feature not in checks:
             error('hghave: unknown feature: ' + feature)
             continue
-        
-        check, desc = checks[feature]       
+
+        check, desc = checks[feature]
         if not check():
             error('hghave: missing feature: ' + desc)
 
     if failures != 0:
         sys.exit(1)
 
-    
+

tests/run-tests.py

@@ -1,463 +1,463 b''
 #!/usr/bin/env python
 #
 # run-tests.py - Run a set of tests on Mercurial
 #
 # Copyright 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 import difflib
 import errno
 import optparse
 import os
 import popen2
 import re
 import shutil
 import signal
 import sys
 import tempfile
 import time
 
 # hghave reserved exit code to skip test
 SKIPPED_STATUS = 80
 
 required_tools = ["python", "diff", "grep", "unzip", "gunzip", "bunzip2", "sed"]
 
 parser = optparse.OptionParser("%prog [options] [tests]")
 parser.add_option("-v", "--verbose", action="store_true",
     help="output verbose messages")
 parser.add_option("-t", "--timeout", type="int",
     help="kill errant tests after TIMEOUT seconds")
 parser.add_option("-c", "--cover", action="store_true",
     help="print a test coverage report")
 parser.add_option("-s", "--cover_stdlib", action="store_true",
     help="print a test coverage report inc. standard libraries")
 parser.add_option("-C", "--annotate", action="store_true",
     help="output files annotated with coverage")
 parser.add_option("-r", "--retest", action="store_true",
     help="retest failed tests")
 parser.add_option("-f", "--first", action="store_true",
     help="exit on the first test failure")
 parser.add_option("-R", "--restart", action="store_true",
     help="restart at last error")
 parser.add_option("-i", "--interactive", action="store_true",
     help="prompt to accept changed output")
 
 parser.set_defaults(timeout=180)
 (options, args) = parser.parse_args()
 verbose = options.verbose
 coverage = options.cover or options.cover_stdlib or options.annotate
 python = sys.executable
 
 def vlog(*msg):
     if verbose:
         for m in msg:
             print m,
         print
 
 def splitnewlines(text):
     '''like str.splitlines, but only split on newlines.
     keep line endings.'''
     i = 0
     lines = []
     while True:
         n = text.find('\n', i)
         if n == -1:
             last = text[i:]
             if last:
                 lines.append(last)
             return lines
         lines.append(text[i:n+1])
         i = n + 1
 
 def extract_missing_features(lines):
     '''Extract missing/unknown features log lines as a list'''
     missing = []
     for line in lines:
         if not line.startswith('hghave: '):
             continue
         line = line.splitlines()[0]
         missing.append(line[8:])
 
     return missing
 
 def show_diff(expected, output):
     for line in difflib.unified_diff(expected, output,
             "Expected output", "Test output"):
         sys.stdout.write(line)
 
 def find_program(program):
     """Search PATH for a executable program"""
     for p in os.environ.get('PATH', os.defpath).split(os.pathsep):
         name = os.path.join(p, program)
         if os.access(name, os.X_OK):
             return name
     return None
 
 def check_required_tools():
     # Before we go any further, check for pre-requisite tools
     # stuff from coreutils (cat, rm, etc) are not tested
     for p in required_tools:
         if os.name == 'nt':
             p += '.exe'
         found = find_program(p)
         if found:
             vlog("# Found prerequisite", p, "at", found)
         else:
             print "WARNING: Did not find prerequisite tool: "+p
 
 def cleanup_exit():
     if verbose:
         print "# Cleaning up HGTMP", HGTMP
     shutil.rmtree(HGTMP, True)
 
 def use_correct_python():
     # some tests run python interpreter. they must use same
     # interpreter we use or bad things will happen.
     exedir, exename = os.path.split(sys.executable)
     if exename == 'python':
         path = find_program('python')
         if os.path.dirname(path) == exedir:
             return
     vlog('# Making python executable in test path use correct Python')
     my_python = os.path.join(BINDIR, 'python')
     try:
         os.symlink(sys.executable, my_python)
     except AttributeError:
         # windows fallback
         shutil.copyfile(sys.executable, my_python)
         shutil.copymode(sys.executable, my_python)
 
 def install_hg():
     global python
     vlog("# Performing temporary installation of HG")
     installerrs = os.path.join("tests", "install.err")
 
     os.chdir("..") # Get back to hg root
     cmd = ('%s setup.py clean --all'
            ' install --force --home="%s" --install-lib="%s" >%s 2>&1'
            % (sys.executable, INST, PYTHONDIR, installerrs))
     vlog("# Running", cmd)
     if os.system(cmd) == 0:
         if not verbose:
             os.remove(installerrs)
     else:
         f = open(installerrs)
         for line in f:
             print line,
         f.close()
         sys.exit(1)
     os.chdir(TESTDIR)
 
     os.environ["PATH"] = "%s%s%s" % (BINDIR, os.pathsep, os.environ["PATH"])
     os.environ["PYTHONPATH"] = PYTHONDIR
 
     use_correct_python()
 
     if coverage:
         vlog("# Installing coverage wrapper")
         os.environ['COVERAGE_FILE'] = COVERAGE_FILE
         if os.path.exists(COVERAGE_FILE):
             os.unlink(COVERAGE_FILE)
         # Create a wrapper script to invoke hg via coverage.py
         os.rename(os.path.join(BINDIR, "hg"), os.path.join(BINDIR, "_hg.py"))
         f = open(os.path.join(BINDIR, 'hg'), 'w')
         f.write('#!' + sys.executable + '\n')
         f.write('import sys, os; os.execv(sys.executable, [sys.executable, '
                 '"%s", "-x", "%s"] + sys.argv[1:])\n' %
                 (os.path.join(TESTDIR, 'coverage.py'),
                  os.path.join(BINDIR, '_hg.py')))
         f.close()
         os.chmod(os.path.join(BINDIR, 'hg'), 0700)
         python = '"%s" "%s" -x' % (sys.executable,
                                    os.path.join(TESTDIR,'coverage.py'))
 
 def output_coverage():
     vlog("# Producing coverage report")
     omit = [BINDIR, TESTDIR, PYTHONDIR]
     if not options.cover_stdlib:
         # Exclude as system paths (ignoring empty strings seen on win)
         omit += [x for x in sys.path if x != '']
     omit = ','.join(omit)
     os.chdir(PYTHONDIR)
     cmd = '"%s" "%s" -i -r "--omit=%s"' % (
         sys.executable, os.path.join(TESTDIR, 'coverage.py'), omit)
     vlog("# Running: "+cmd)
     os.system(cmd)
     if options.annotate:
         adir = os.path.join(TESTDIR, 'annotated')
         if not os.path.isdir(adir):
             os.mkdir(adir)
         cmd = '"%s" "%s" -i -a "--directory=%s" "--omit=%s"' % (
             sys.executable, os.path.join(TESTDIR, 'coverage.py'),
             adir, omit)
         vlog("# Running: "+cmd)
         os.system(cmd)
 
 class Timeout(Exception):
     pass
 
 def alarmed(signum, frame):
     raise Timeout
 
 def run(cmd):
     """Run command in a sub-process, capturing the output (stdout and stderr).
     Return the exist code, and output."""
     # TODO: Use subprocess.Popen if we're running on Python 2.4
     if os.name == 'nt':
         tochild, fromchild = os.popen4(cmd)
         tochild.close()
         output = fromchild.read()
         ret = fromchild.close()
         if ret == None:
             ret = 0
     else:
         proc = popen2.Popen4(cmd)
         try:
             output = ''
             proc.tochild.close()
             output = proc.fromchild.read()
             ret = proc.wait()
             if os.WIFEXITED(ret):
                 ret = os.WEXITSTATUS(ret)
         except Timeout:
             vlog('# Process %d timed out - killing it' % proc.pid)
             os.kill(proc.pid, signal.SIGTERM)
             ret = proc.wait()
             if ret == 0:
                 ret = signal.SIGTERM << 8
             output += ("\n### Abort: timeout after %d seconds.\n"
                        % options.timeout)
     return ret, splitnewlines(output)
 
 def run_one(test):
     '''tristate output:
     None -> skipped
     True -> passed
     False -> failed'''
 
     vlog("# Test", test)
     if not verbose:
         sys.stdout.write('.')
         sys.stdout.flush()
 
     # create a fresh hgrc
     hgrc = file(HGRCPATH, 'w+')
     hgrc.write('[ui]\n')
     hgrc.write('slash = True\n')
     hgrc.close()
 
     err = os.path.join(TESTDIR, test+".err")
     ref = os.path.join(TESTDIR, test+".out")
     testpath = os.path.join(TESTDIR, test)
 
     if os.path.exists(err):
         os.remove(err)       # Remove any previous output files
 
     # Make a tmp subdirectory to work in
     tmpd = os.path.join(HGTMP, test)
     os.mkdir(tmpd)
     os.chdir(tmpd)
 
     try:
         tf = open(testpath)
         firstline = tf.readline().rstrip()
         tf.close()
     except:
         firstline = ''
     lctest = test.lower()
 
     if lctest.endswith('.py') or firstline == '#!/usr/bin/env python':
         cmd = '%s "%s"' % (python, testpath)
     elif lctest.endswith('.bat'):
         # do not run batch scripts on non-windows
         if os.name != 'nt':
             print '\nSkipping %s: batch script' % test
             return None
         # To reliably get the error code from batch files on WinXP,
         # the "cmd /c call" prefix is needed. Grrr
         cmd = 'cmd /c call "%s"' % testpath
     else:
         # do not run shell scripts on windows
         if os.name == 'nt':
             print '\nSkipping %s: shell script' % test
             return None
         # do not try to run non-executable programs
         if not os.access(testpath, os.X_OK):
             print '\nSkipping %s: not executable' % test
             return None
         cmd = '"%s"' % testpath
 
     if options.timeout > 0:
         signal.alarm(options.timeout)
 
     vlog("# Running", cmd)
     ret, out = run(cmd)
     vlog("# Ret was:", ret)
 
     if options.timeout > 0:
         signal.alarm(0)
 
     skipped = (ret == SKIPPED_STATUS)
     diffret = 0
     # If reference output file exists, check test output against it
     if os.path.exists(ref):
         f = open(ref, "r")
         ref_out = splitnewlines(f.read())
         f.close()
     else:
         ref_out = []
     if not skipped and out != ref_out:
         diffret = 1
         print "\nERROR: %s output changed" % (test)
         show_diff(ref_out, out)
     if skipped:
         missing = extract_missing_features(out)
         if not missing:
             missing = ['irrelevant']
         print '\nSkipping %s: %s' % (test, missing[-1])
     elif ret:
         print "\nERROR: %s failed with error code %d" % (test, ret)
     elif diffret:
         ret = diffret
 
-    if ret != 0 and not skipped: 
+    if ret != 0 and not skipped:
         # Save errors to a file for diagnosis
         f = open(err, "wb")
         for line in out:
             f.write(line)
         f.close()
 
     # Kill off any leftover daemon processes
     try:
         fp = file(DAEMON_PIDS)
         for line in fp:
             try:
                 pid = int(line)
             except ValueError:
                 continue
             try:
                 os.kill(pid, 0)
                 vlog('# Killing daemon process %d' % pid)
                 os.kill(pid, signal.SIGTERM)
                 time.sleep(0.25)
                 os.kill(pid, 0)
                 vlog('# Daemon process %d is stuck - really killing it' % pid)
                 os.kill(pid, signal.SIGKILL)
             except OSError, err:
                 if err.errno != errno.ESRCH:
                     raise
         fp.close()
         os.unlink(DAEMON_PIDS)
     except IOError:
         pass
 
     os.chdir(TESTDIR)
     shutil.rmtree(tmpd, True)
     if skipped:
         return None
     return ret == 0
 
 
 os.umask(022)
 
 check_required_tools()
 
 # Reset some environment variables to well-known values so that
 # the tests produce repeatable output.
 os.environ['LANG'] = os.environ['LC_ALL'] = 'C'
 os.environ['TZ'] = 'GMT'
 
 TESTDIR = os.environ["TESTDIR"] = os.getcwd()
 HGTMP   = os.environ["HGTMP"]   = tempfile.mkdtemp("", "hgtests.")
 DAEMON_PIDS = os.environ["DAEMON_PIDS"] = os.path.join(HGTMP, 'daemon.pids')
 HGRCPATH = os.environ["HGRCPATH"] = os.path.join(HGTMP, '.hgrc')
 
 os.environ["HGEDITOR"] = sys.executable + ' -c "import sys; sys.exit(0)"'
 os.environ["HGMERGE"]  = ('python "%s" -L my -L other'
                           % os.path.join(TESTDIR, os.path.pardir, 'contrib',
                                          'simplemerge'))
 os.environ["HGUSER"]   = "test"
 os.environ["HGENCODING"] = "ascii"
 os.environ["HGENCODINGMODE"] = "strict"
 
 vlog("# Using TESTDIR", TESTDIR)
 vlog("# Using HGTMP", HGTMP)
 
 INST = os.path.join(HGTMP, "install")
 BINDIR = os.path.join(INST, "bin")
 PYTHONDIR = os.path.join(INST, "lib", "python")
 COVERAGE_FILE = os.path.join(TESTDIR, ".coverage")
 
 try:
     try:
         install_hg()
 
         if options.timeout > 0:
             try:
                 signal.signal(signal.SIGALRM, alarmed)
                 vlog('# Running tests with %d-second timeout' %
                      options.timeout)
             except AttributeError:
                 print 'WARNING: cannot run tests with timeouts'
                 options.timeout = 0
 
         tested = 0
         failed = 0
         skipped = 0
 
         if len(args) == 0:
             args = os.listdir(".")
             args.sort()
 
 
         tests = []
         for test in args:
             if (test.startswith("test-") and '~' not in test and
                 ('.' not in test or test.endswith('.py') or
                  test.endswith('.bat'))):
                 tests.append(test)
 
         if options.restart:
             orig = list(tests)
             while tests:
                 if os.path.exists(tests[0] + ".err"):
                     break
                 tests.pop(0)
             if not tests:
                 print "running all tests"
                 tests = orig
 
         for test in tests:
             if options.retest and not os.path.exists(test + ".err"):
                 skipped += 1
                 continue
             ret = run_one(test)
             if ret is None:
                 skipped += 1
             elif not ret:
                 if options.interactive:
                     print "Accept this change? [n] ",
                     answer = sys.stdin.readline().strip()
                     if answer.lower() in "y yes".split():
                         os.rename(test + ".err", test + ".out")
                         tested += 1
                         continue
                 failed += 1
                 if options.first:
                     break
             tested += 1
 
         print "\n# Ran %d tests, %d skipped, %d failed." % (tested, skipped,
                                                             failed)
         if coverage:
             output_coverage()
     except KeyboardInterrupt:
         failed = True
         print "\ninterrupted!"
 finally:
     cleanup_exit()
 
 if failed:
     sys.exit(1)