Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1717 insertions, 0 deletions

diff --git a/third_party/python/python-hglib/hglib/client.py b/third_party/python/python-hglib/hglib/client.py
new file mode 100644
index 0000000000..4eababdf40
--- /dev/null
+++ b/third_party/python/python-hglib/hglib/client.py
@@ -0,0 +1,1717 @@
+import struct, re, datetime
+import hglib
+from hglib import error, util, templates, merge, context
+
+from hglib.util import b, cmdbuilder, BytesIO, strtobytes
+
+class revision(tuple):
+    def __new__(cls, rev, node, tags, branch, author, desc, date):
+        return tuple.__new__(cls, (rev, node, tags, branch, author, desc, date))
+
+    @property
+    def rev(self):
+        return self[0]
+
+    @property
+    def node(self):
+        return self[1]
+
+    @property
+    def tags(self):
+        return self[2]
+
+    @property
+    def branch(self):
+        return self[3]
+
+    @property
+    def author(self):
+        return self[4]
+
+    @property
+    def desc(self):
+        return self[5]
+
+    @property
+    def date(self):
+        return self[6]
+
+class hgclient(object):
+    inputfmt = '>I'
+    outputfmt = '>cI'
+    outputfmtsize = struct.calcsize(outputfmt)
+    retfmt = '>i'
+
+    def __init__(self, path, encoding, configs, connect=True):
+        self._args = [hglib.HGPATH, 'serve', '--cmdserver', 'pipe',
+                '--config', 'ui.interactive=True']
+        if path:
+            self._args += ['-R', path]
+        if configs:
+            for config in configs:
+                self._args += ['--config', config]
+        self._env = {'HGPLAIN': '1'}
+        if encoding:
+            self._env['HGENCODING'] = encoding
+
+        self.server = None
+        self._version = None
+        # include the hidden changesets if True
+        self.hidden = None
+
+        self._cbout = None
+        self._cberr = None
+        self._cbprompt = None
+
+        if connect:
+            self.open()
+
+        self._protocoltracefn = None
+
+    def setcbout(self, cbout):
+        """
+        cbout is a function that will be called with the stdout data of
+        the command as it runs. Call with None to stop getting call backs.
+        """
+        self._cbout = cbout
+
+    def setcberr(self, cberr):
+        """
+        cberr is a function that will be called with the stderr data of
+        the command as it runs.Call with None to stop getting call backs.
+        """
+        self._cberr = cberr
+
+    def setcbprompt(self, cbprompt):
+        """
+        cbprompt is used to reply to prompts by the server
+        It receives the max number of bytes to return and the
+        contents of stdout received so far.
+
+        Call with None to stop getting call backs.
+
+        cbprompt is never called from merge() or import_()
+        which already handle the prompt.
+        """
+        self._cbprompt = cbprompt
+
+    def setprotocoltrace(self, tracefn=None):
+        """
+        if tracefn is None no trace calls will be made.
+        Otherwise tracefn is call as tracefn( direction, channel, data )
+        direction is 'r' for read from server and 'w' for write to server
+        channel is always None when direction is 'w'
+        and the channel-identified when the direction is 'r'
+        """
+        self._protocoltracefn = tracefn
+
+    def __enter__(self):
+        if self.server is None:
+            self.open()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def _readhello(self):
+        """ read the hello message the server sends when started """
+        ch, msg = self._readchannel()
+        assert ch == b('o')
+
+        msg = msg.split(b('\n'))
+
+        self.capabilities = msg[0][len(b('capabilities: ')):]
+        if not self.capabilities:
+            raise error.ResponseError(
+                "bad hello message: expected 'capabilities: '"
+                ", got %r" % msg[0])
+
+        self.capabilities = set(self.capabilities.split())
+
+        # at the very least the server should be able to run commands
+        assert b('runcommand') in self.capabilities
+
+        self._encoding = msg[1][len(b('encoding: ')):]
+        if not self._encoding:
+            raise error.ResponseError("bad hello message: expected 'encoding: '"
+                                      ", got %r" % msg[1])
+
+    def _readchannel(self):
+        data = self.server.stdout.read(hgclient.outputfmtsize)
+        if not data:
+            raise error.ServerError()
+        channel, length = struct.unpack(hgclient.outputfmt, data)
+        if channel in b('IL'):
+            return channel, length
+        else:
+            return channel, self.server.stdout.read(length)
+
+    @staticmethod
+    def _parserevs(splitted):
+        '''splitted is a list of fields according to our rev.style, where
+        each 6 fields compose one revision.
+        '''
+        revs = []
+        for rev in util.grouper(7, splitted):
+            # truncate the timezone and convert to a local datetime
+            posixtime = float(rev[6].split(b('.'), 1)[0])
+            dt = datetime.datetime.fromtimestamp(posixtime)
+            revs.append(revision(rev[0], rev[1], rev[2], rev[3],
+                                 rev[4], rev[5], dt))
+        return revs
+
+    def runcommand(self, args, inchannels, outchannels):
+        def writeblock(data):
+            if self._protocoltracefn is not None:
+                self._protocoltracefn('w', None, data)
+            self.server.stdin.write(struct.pack(self.inputfmt, len(data)))
+            self.server.stdin.write(data)
+            self.server.stdin.flush()
+
+        if not self.server:
+            raise ValueError("server not connected")
+
+        self.server.stdin.write(b('runcommand\n'))
+        writeblock(b('\0').join(args))
+
+        while True:
+            channel, data = self._readchannel()
+            if self._protocoltracefn is not None:
+                self._protocoltracefn('r', channel, data)
+
+            # input channels
+            if channel in inchannels:
+                writeblock(inchannels[channel](data))
+            # output channels
+            elif channel in outchannels:
+                outchannels[channel](data)
+            # result channel, command finished
+            elif channel == b('r'):
+                return struct.unpack(hgclient.retfmt, data)[0]
+            # a channel that we don't know and can't ignore
+            elif channel.isupper():
+                raise error.ResponseError(
+                    "unexpected data on required channel '%s'" % channel)
+            # optional channel
+            else:
+                pass
+
+    def rawcommand(self, args, eh=None, prompt=None, input=None):
+        """
+        args is the cmdline (usually built using util.cmdbuilder)
+
+        eh is an error handler that is passed the return code, stdout and stderr
+        If no eh is given, we raise a CommandError if ret != 0
+
+        prompt is used to reply to prompts by the server
+        It receives the max number of bytes to return and the contents of stdout
+        received so far
+
+        input is used to reply to bulk data requests by the server
+        It receives the max number of bytes to return
+        """
+        out, err = BytesIO(), BytesIO()
+        outchannels = {}
+        if self._cbout is None:
+            outchannels[b('o')] = out.write
+        else:
+            def out_handler(data):
+                out.write(data)
+                self._cbout(data)
+            outchannels[b('o')] = out_handler
+        if self._cberr is None:
+            outchannels[b('e')] = err.write
+        else:
+            def err_handler(data):
+                err.write(data)
+                self._cberr(data)
+            outchannels[b('e')] = err_handler
+
+        inchannels = {}
+        if prompt is None:
+            prompt = self._cbprompt
+        if prompt is not None:
+            def func(size):
+                reply = prompt(size, out.getvalue())
+                return reply
+            inchannels[b('L')] = func
+        if input is not None:
+            inchannels[b('I')] = input
+
+        ret = self.runcommand(args, inchannels, outchannels)
+        out, err = out.getvalue(), err.getvalue()
+
+        if ret:
+            if eh is None:
+                raise error.CommandError(args, ret, out, err)
+            else:
+                return eh(ret, out, err)
+        return out
+
+    def open(self):
+        if self.server is not None:
+            raise ValueError('server already open')
+
+        self.server = util.popen(self._args, self._env)
+        try:
+            self._readhello()
+        except error.ServerError:
+            ret, serr = self._close()
+            raise error.ServerError('server exited with status %d: %s'
+                                    % (ret, serr.strip()))
+        return self
+
+    def close(self):
+        """Closes the command server instance and waits for it to exit,
+        returns the exit code.
+
+        Attempting to call any function afterwards that needs to
+        communicate with the server will raise a ValueError.
+        """
+        return self._close()[0]
+
+    def _close(self):
+        _sout, serr = self.server.communicate()
+        ret = self.server.returncode
+        self.server = None
+        return ret, serr
+
+    def add(self, files=[], dryrun=False, subrepos=False, include=None,
+            exclude=None):
+        """
+        Add the specified files on the next commit.
+        If no files are given, add all files to the repository.
+
+        dryrun - do no perform actions
+        subrepos - recurse into subrepositories
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+
+        Return whether all given files were added.
+        """
+        if not isinstance(files, list):
+            files = [files]
+
+        args = cmdbuilder(b('add'), n=dryrun, S=subrepos, I=include, X=exclude,
+                          *files)
+
+        eh = util.reterrorhandler(args)
+        self.rawcommand(args, eh=eh)
+
+        return bool(eh)
+
+    def addremove(self, files=[], similarity=None, dryrun=False, include=None,
+                  exclude=None):
+        """Add all new files and remove all missing files from the repository.
+
+        New files are ignored if they match any of the patterns in
+        ".hgignore". As with add, these changes take effect at the
+        next commit.
+
+        similarity - used to detect renamed files. With a parameter
+        greater than 0, this compares every removed file with every
+        added file and records those similar enough as renames. This
+        option takes a percentage between 0 (disabled) and 100 (files
+        must be identical) as its parameter. Detecting renamed files
+        this way can be expensive. After using this option, "hg status
+        -C" can be used to check which files were identified as moved
+        or renamed.
+
+        dryrun - do no perform actions
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+
+        Return True if all files are successfully added.
+
+        """
+        if not isinstance(files, list):
+            files = [files]
+
+        args = cmdbuilder(b('addremove'), s=similarity, n=dryrun, I=include,
+                          X=exclude, *files)
+
+        eh = util.reterrorhandler(args)
+        self.rawcommand(args, eh=eh)
+
+        return bool(eh)
+
+    def annotate(self, files, rev=None, nofollow=False, text=False, user=False,
+                 file=False, date=False, number=False, changeset=False,
+                 line=False, verbose=False, include=None, exclude=None):
+        """
+        Show changeset information by line for each file in files.
+
+        rev - annotate the specified revision
+        nofollow - don't follow copies and renames
+        text - treat all files as text
+        user - list the author (long with -v)
+        file - list the filename
+        date - list the date
+        number - list the revision number (default)
+        changeset - list the changeset
+        line - show line number at the first appearance
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+
+        Yields a (info, contents) tuple for each line in a file. Info is a space
+        separated string according to the given options.
+        """
+        if not isinstance(files, list):
+            files = [files]
+
+        args = cmdbuilder(b('annotate'), r=rev, no_follow=nofollow, a=text,
+                          u=user, f=file, d=date, n=number, c=changeset,
+                          l=line, v=verbose, I=include, X=exclude,
+                          hidden=self.hidden, *files)
+
+        out = self.rawcommand(args)
+
+        for line in out.splitlines():
+            yield tuple(line.split(b(': '), 1))
+
+    def archive(self, dest, rev=None, nodecode=False, prefix=None, type=None,
+                subrepos=False, include=None, exclude=None):
+        """Create an unversioned archive of a repository revision.
+
+        The exact name of the destination archive or directory is given using a
+        format string; see export for details.
+
+        Each member added to an archive file has a directory prefix
+        prepended. Use prefix to specify a format string for the
+        prefix. The default is the basename of the archive, with
+        suffixes removed.
+
+        dest - destination path
+        rev - revision to distribute. The revision used is the parent of the
+        working directory if one isn't given.
+
+        nodecode - do not pass files through decoders
+        prefix - directory prefix for files in archive
+        type - type of distribution to create. The archive type is automatically
+        detected based on file extension if one isn't given.
+
+        Valid types are:
+
+        "files"  a directory full of files (default)
+        "tar"    tar archive, uncompressed
+        "tbz2"   tar archive, compressed using bzip2
+        "tgz"    tar archive, compressed using gzip
+        "uzip"   zip archive, uncompressed
+        "zip"    zip archive, compressed using deflate
+
+        subrepos - recurse into subrepositories
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+
+        """
+        args = cmdbuilder(b('archive'), dest, r=rev,
+                          no_decode=nodecode, p=prefix,
+                          t=type, S=subrepos, I=include, X=exclude,
+                          hidden=self.hidden)
+
+        self.rawcommand(args)
+
+    def backout(self, rev, merge=False, parent=None, tool=None, message=None,
+                logfile=None, date=None, user=None):
+        """Prepare a new changeset with the effect of rev undone in the current
+        working directory.
+
+        If rev is the parent of the working directory, then this new
+        changeset is committed automatically. Otherwise, hg needs to
+        merge the changes and the merged result is left uncommitted.
+
+        rev - revision to backout
+        merge - merge with old dirstate parent after backout
+        parent - parent to choose when backing out merge
+        tool - specify merge tool
+        message - use text as commit message
+        logfile - read commit message from file
+        date - record the specified date as commit date
+        user - record the specified user as committer
+
+        """
+        if message and logfile:
+            raise ValueError("cannot specify both a message and a logfile")
+
+        args = cmdbuilder(b('backout'), r=rev, merge=merge, parent=parent,
+                          t=tool, m=message, l=logfile, d=date, u=user,
+                          hidden=self.hidden)
+
+        self.rawcommand(args)
+
+    def bookmark(self, name, rev=None, force=False, delete=False,
+                 inactive=False, rename=None):
+        """
+        Set a bookmark on the working directory's parent revision or rev,
+        with the given name.
+
+        name - bookmark name
+        rev - revision to bookmark
+        force - bookmark even if another bookmark with the same name exists
+        delete - delete the given bookmark
+        inactive - do not mark the new bookmark active
+        rename - rename the bookmark given by rename to name
+        """
+        args = cmdbuilder(b('bookmark'), name, r=rev, f=force, d=delete,
+                          i=inactive, m=rename)
+
+        self.rawcommand(args)
+
+    def bookmarks(self):
+        """
+        Return the bookmarks as a list of (name, rev, node) and the index of the
+        current one.
+
+        If there isn't a current one, -1 is returned as the index.
+        """
+        args = cmdbuilder(b('bookmarks'), hidden=self.hidden)
+        out = self.rawcommand(args)
+
+        bms = []
+        current = -1
+        if out.rstrip() != b('no bookmarks set'):
+            for line in out.splitlines():
+                iscurrent, line = line[0:3], line[3:]
+                if b('*') in iscurrent:
+                    current = len(bms)
+                name, line = line.split(b(' '), 1)
+                rev, node = line.split(b(':'))
+                bms.append((name, int(rev), node))
+        return bms, current
+
+    def branch(self, name=None, clean=False, force=False):
+        """When name isn't given, return the current branch name. Otherwise
+        set the working directory branch name (the branch will not
+        exist in the repository until the next commit). Standard
+        practice recommends that primary development take place on the
+        'default' branch.
+
+        When clean is True, reset and return the working directory
+        branch to that of the parent of the working directory,
+        negating a previous branch change.
+
+        name - new branch name
+        clean - reset branch name to parent branch name
+        force - set branch name even if it shadows an existing branch
+
+        """
+        if name and clean:
+            raise ValueError('cannot use both name and clean')
+
+        args = cmdbuilder(b('branch'), name, f=force, C=clean)
+        out = self.rawcommand(args).rstrip()
+
+        if name:
+            return name
+        elif not clean:
+            return out
+        else:
+            # len('reset working directory to branch ') == 34
+            return out[34:]
+
+    def branches(self, active=False, closed=False):
+        """
+        Returns the repository's named branches as a list of (name, rev, node).
+
+        active - show only branches that have unmerged heads
+        closed - show normal and closed branches
+        """
+        args = cmdbuilder(b('branches'), a=active, c=closed, hidden=self.hidden)
+        out = self.rawcommand(args)
+
+        branches = []
+        for line in out.rstrip().splitlines():
+            namerev, node = line.rsplit(b(':'), 1)
+            name, rev = namerev.rsplit(b(' '), 1)
+            name = name.rstrip()
+            node = node.split()[0] # get rid of ' (inactive)'
+            branches.append((name, int(rev), node))
+        return branches
+
+    def bundle(self, file, destrepo=None, rev=[], branch=[], base=[], all=False,
+               force=False, type=None, ssh=None, remotecmd=None,
+               insecure=False):
+        """Generate a compressed changegroup file collecting changesets not
+        known to be in another repository.
+
+        If destrepo isn't given, then hg assumes the destination will have all
+        the nodes you specify with base. To create a bundle containing all
+        changesets, use all (or set base to 'null').
+
+        file - destination file name
+        destrepo - repository to look for changes
+        rev - a changeset intended to be added to the destination
+        branch - a specific branch you would like to bundle
+        base - a base changeset assumed to be available at the destination
+        all - bundle all changesets in the repository
+        type - bundle compression type to use, available compression
+         methods are: none, bzip2, and gzip (default: bzip2)
+
+        force - run even when the destrepo is unrelated
+        ssh - specify ssh command to use
+        remotecmd - specify hg command to run on the remote side
+        insecure - do not verify server certificate (ignoring
+         web.cacerts config)
+
+        Return True if a bundle was created, False if no changes were found.
+
+        """
+        args = cmdbuilder(b('bundle'), file, destrepo, f=force, r=rev, b=branch,
+                          base=base, a=all, t=type, e=ssh, remotecmd=remotecmd,
+                          insecure=insecure, hidden=self.hidden)
+
+        eh = util.reterrorhandler(args)
+        self.rawcommand(args, eh=eh)
+
+        return bool(eh)
+
+    def cat(self, files, rev=None, output=None):
+        """Return a string containing the specified files as they were at the
+        given revision. If no revision is given, the parent of the working
+        directory is used, or tip if no revision is checked out.
+
+        If output is given, writes the contents to the specified file.
+        The name of the file is given using a format string. The
+        formatting rules are the same as for the export command, with
+        the following additions:
+
+        "%s"  basename of file being printed
+        "%d"  dirname of file being printed, or '.' if in repository root
+        "%p"  root-relative path name of file being printed
+
+        """
+        args = cmdbuilder(b('cat'), r=rev, o=output, hidden=self.hidden, *files)
+        out = self.rawcommand(args)
+
+        if not output:
+            return out
+
+    def clone(self, source=b('.'), dest=None, branch=None, updaterev=None,
+              revrange=None):
+        """
+        Create a copy of an existing repository specified by source in a new
+        directory dest.
+
+        If dest isn't specified, it defaults to the basename of source.
+
+        branch - clone only the specified branch
+        updaterev - revision, tag or branch to check out
+        revrange - include the specified changeset
+        """
+        args = cmdbuilder(b('clone'), source, dest, b=branch,
+                          u=updaterev, r=revrange)
+        self.rawcommand(args)
+
+    def init(self, dest, ssh=None, remotecmd=None, insecure=False):
+        args = util.cmdbuilder('init', dest, e=ssh, remotecmd=remotecmd,
+                               insecure=insecure)
+        self.rawcommand(args)
+
+    def commit(self, message=None, logfile=None, addremove=False,
+               closebranch=False, date=None, user=None, include=None,
+               exclude=None, amend=False):
+        """
+        Commit changes reported by status into the repository.
+
+        message - the commit message
+        logfile - read commit message from file
+        addremove - mark new/missing files as added/removed before committing
+        closebranch - mark a branch as closed, hiding it from the branch list
+        date - record the specified date as commit date
+        user - record the specified user as committer
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+        amend - amend the parent of the working dir
+        """
+        if amend and message is None and logfile is None:
+            # retrieve current commit message
+            message = self.log(b('.'))[0][5]
+        if message is None and logfile is None and not amend:
+            raise ValueError("must provide at least a message or a logfile")
+        elif message and logfile:
+            raise ValueError("cannot specify both a message and a logfile")
+
+        # --debug will print the committed cset
+        args = cmdbuilder(b('commit'), debug=True, m=message, A=addremove,
+                          close_branch=closebranch, d=date, u=user, l=logfile,
+                          I=include, X=exclude, amend=amend)
+        out = self.rawcommand(args)
+        m = re.search(b(r'^committed changeset (\d+):([0-9a-f]+)'), out,
+                      re.MULTILINE)
+        if not m:
+            raise ValueError('revision and node not found in hg output: %r'
+                             % out)
+        rev, node = m.groups()
+        return int(rev), node
+
+    def config(self, names=[], untrusted=False, showsource=False):
+        """Return a list of (section, key, value) config settings from all
+        hgrc files
+
+        When showsource is specified, return (source, section, key, value) where
+        source is of the form filename:[line]
+
+        """
+        def splitline(s):
+            k, value = s.rstrip().split(b('='), 1)
+            section, key = k.split(b('.'), 1)
+            return section, key, value
+
+        if not isinstance(names, list):
+            names = [names]
+
+        args = cmdbuilder(b('showconfig'), u=untrusted, debug=showsource,
+                          *names)
+        out = self.rawcommand(args)
+
+        conf = []
+        if showsource:
+            out = util.skiplines(out, b('read config from: '))
+            for line in out.splitlines():
+                m = re.match(b(r"(.+?:(?:\d+:)?) (.*)"), line)
+                t = splitline(m.group(2))
+                conf.append((m.group(1)[:-1], t[0], t[1], t[2]))
+        else:
+            for line in out.splitlines():
+                conf.append(splitline(line))
+
+        return conf
+
+    @property
+    def encoding(self):
+        """
+        Return the server's encoding (as reported in the hello message).
+        """
+        if not b('getencoding') in self.capabilities:
+            raise CapabilityError('getencoding')
+
+        if not self._encoding:
+            self.server.stdin.write(b('getencoding\n'))
+            self._encoding = self._readfromchannel('r')
+
+        return self._encoding
+
+    def copy(self, source, dest, after=False, force=False, dryrun=False,
+             include=None, exclude=None):
+        """Mark dest as having copies of source files. If dest is a
+        directory, copies are put in that directory. If dest is a
+        file, then source must be a string.
+
+        Returns True on success, False if errors are encountered.
+
+        source - a file or a list of files
+        dest - a destination file or directory
+        after - record a copy that has already occurred
+        force - forcibly copy over an existing managed file
+        dryrun - do not perform actions, just print output
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+
+        """
+        if not isinstance(source, list):
+            source = [source]
+
+        source.append(dest)
+        args = cmdbuilder(b('copy'), A=after, f=force, n=dryrun,
+                          I=include, X=exclude, *source)
+
+        eh = util.reterrorhandler(args)
+        self.rawcommand(args, eh=eh)
+
+        return bool(eh)
+
+    def diff(self, files=[], revs=[], change=None, text=False,
+             git=False, nodates=False, showfunction=False,
+             reverse=False, ignoreallspace=False,
+             ignorespacechange=False, ignoreblanklines=False,
+             unified=None, stat=False, subrepos=False, include=None,
+             exclude=None):
+        """
+        Return differences between revisions for the specified files.
+
+        revs - a revision or a list of two revisions to diff
+        change - change made by revision
+        text - treat all files as text
+        git - use git extended diff format
+        nodates - omit dates from diff headers
+        showfunction - show which function each change is in
+        reverse - produce a diff that undoes the changes
+        ignoreallspace - ignore white space when comparing lines
+        ignorespacechange - ignore changes in the amount of white space
+        ignoreblanklines - ignore changes whose lines are all blank
+        unified - number of lines of context to show
+        stat - output diffstat-style summary of changes
+        subrepos - recurse into subrepositories
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+        """
+        if change and revs:
+            raise ValueError('cannot specify both change and rev')
+
+        args = cmdbuilder(b('diff'), r=list(map(strtobytes, revs)), c=change,
+                          a=text, g=git, nodates=nodates,
+                          p=showfunction, reverse=reverse,
+                          w=ignoreallspace, b=ignorespacechange,
+                          B=ignoreblanklines, U=unified, stat=stat,
+                          S=subrepos, I=include, X=exclude, hidden=self.hidden,
+                          *files)
+
+        return self.rawcommand(args)
+
+    def export(self, revs, output=None, switchparent=False,
+               text=False, git=False, nodates=False):
+        """Return the header and diffs for one or more changesets. When
+        output is given, dumps to file. The name of the file is given
+        using a format string. The formatting rules are as follows:
+
+        "%%"  literal "%" character
+        "%H"  changeset hash (40 hexadecimal digits)
+        "%N"  number of patches being generated
+        "%R"  changeset revision number
+        "%b"  basename of the exporting repository
+        "%h"  short-form changeset hash (12 hexadecimal digits)
+        "%n"  zero-padded sequence number, starting at 1
+        "%r"  zero-padded changeset revision number
+
+        output - print output to file with formatted name
+        switchparent - diff against the second parent
+        rev - a revision or list of revisions to export
+        text - treat all files as text
+        git - use git extended diff format
+        nodates - omit dates from diff headers
+
+        """
+        if not isinstance(revs, list):
+            revs = [revs]
+        args = cmdbuilder(b('export'), o=output, switch_parent=switchparent,
+                          a=text, g=git, nodates=nodates, hidden=self.hidden,
+                          *revs)
+
+        out = self.rawcommand(args)
+
+        if output is None:
+            return out
+
+    def forget(self, files, include=None, exclude=None):
+        """Mark the specified files so they will no longer be tracked after
+        the next commit.
+
+        This only removes files from the current branch, not from the entire
+        project history, and it does not delete them from the working directory.
+
+        Returns True on success.
+
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+
+        """
+        if not isinstance(files, list):
+            files = [files]
+
+        args = cmdbuilder(b('forget'), I=include, X=exclude, *files)
+
+        eh = util.reterrorhandler(args)
+        self.rawcommand(args, eh=eh)
+
+        return bool(eh)
+
+    def grep(self, pattern, files=[], all=False, text=False, follow=False,
+             ignorecase=False, fileswithmatches=False, line=False, user=False,
+             date=False, include=None, exclude=None):
+        """Search for a pattern in specified files and revisions.
+
+        This behaves differently than Unix grep. It only accepts Python/Perl
+        regexps. It searches repository history, not the working directory.
+        It always prints the revision number in which a match appears.
+
+        Yields (filename, revision, [line, [match status, [user,
+        [date, [match]]]]]) per match depending on the given options.
+
+        all - print all revisions that match
+        text - treat all files as text
+        follow - follow changeset history, or file history across
+         copies and renames
+        ignorecase - ignore case when matching
+        fileswithmatches - return only filenames and revisions that match
+        line - return line numbers in the result tuple
+        user - return the author in the result tuple
+        date - return the date in the result tuple
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+
+        """
+        if not isinstance(files, list):
+            files = [files]
+
+        args = cmdbuilder(b('grep'), all=all, a=text, f=follow, i=ignorecase,
+                          l=fileswithmatches, n=line, u=user, d=date,
+                          I=include, X=exclude, hidden=self.hidden,
+                          *[pattern] + files)
+        args.append(b('-0'))
+
+        def eh(ret, out, err):
+            if ret != 1:
+                raise error.CommandError(args, ret, out, err)
+            return b('')
+
+        out = self.rawcommand(args, eh=eh).split(b('\0'))
+
+        fieldcount = 3
+        if user:
+            fieldcount += 1
+        if date:
+            fieldcount += 1
+        if line:
+            fieldcount += 1
+        if all:
+            fieldcount += 1
+        if fileswithmatches:
+            fieldcount -= 1
+
+        return util.grouper(fieldcount, out)
+
+    def heads(self, rev=[], startrev=[], topological=False, closed=False):
+        """Return a list of current repository heads or branch heads.
+
+        rev - return only branch heads on the branches associated with
+        the specified changesets.
+
+        startrev - return only heads which are descendants of the given revs.
+        topological - named branch mechanics will be ignored and only changesets
+        without children will be shown.
+
+        closed - normal and closed branch heads.
+
+        """
+        if not isinstance(rev, list):
+            rev = [rev]
+
+        args = cmdbuilder(b('heads'), r=startrev, t=topological, c=closed,
+                          template=templates.changeset, hidden=self.hidden,
+                          *rev)
+
+        def eh(ret, out, err):
+            if ret != 1:
+                raise error.CommandError(args, ret, out, err)
+            return b('')
+
+        out = self.rawcommand(args, eh=eh).split(b('\0'))[:-1]
+        return self._parserevs(out)
+
+    def identify(self, rev=None, source=None, num=False, id=False, branch=False,
+                 tags=False, bookmarks=False):
+        """Return a summary string identifying the repository state at rev
+        using one or two parent hash identifiers, followed by a "+" if
+        the working directory has uncommitted changes, the branch name
+        (if not default), a list of tags, and a list of bookmarks.
+
+        When rev is not given, return a summary string of the current
+        state of the repository.
+
+        Specifying source as a repository root or Mercurial bundle will cause
+        lookup to operate on that repository/bundle.
+
+        num - show local revision number
+        id - show global revision id
+        branch - show branch
+        tags - show tags
+        bookmarks - show bookmarks
+
+        """
+        args = cmdbuilder(b('identify'), source, r=rev, n=num, i=id,
+                          b=branch, t=tags, B=bookmarks,
+                          hidden=self.hidden)
+
+        return self.rawcommand(args)
+
+    def import_(self, patches, strip=None, force=False, nocommit=False,
+                bypass=False, exact=False, importbranch=False, message=None,
+                date=None, user=None, similarity=None):
+        """Import the specified patches which can be a list of file names or a
+        file-like object and commit them individually (unless nocommit is
+        specified).
+
+        strip - directory strip option for patch. This has the same
+        meaning as the corresponding patch option (default: 1)
+
+        force - skip check for outstanding uncommitted changes
+        nocommit - don't commit, just update the working directory
+        bypass - apply patch without touching the working directory
+        exact - apply patch to the nodes from which it was generated
+        importbranch - use any branch information in patch (implied by exact)
+        message - the commit message
+        date - record the specified date as commit date
+        user - record the specified user as committer
+        similarity - guess renamed files by similarity (0<=s<=100)
+
+        """
+        if hasattr(patches, 'read') and hasattr(patches, 'readline'):
+            patch = patches
+
+            def readline(size, output):
+                return patch.readline(size)
+
+            stdin = True
+            patches = ()
+            prompt = readline
+            input = patch.read
+        else:
+            stdin = False
+            prompt = None
+            input = None
+
+        args = cmdbuilder(b('import'), strip=strip, force=force,
+                          no_commit=nocommit, bypass=bypass, exact=exact,
+                          import_branch=importbranch, message=message,
+                          date=date, user=user, similarity=similarity, _=stdin,
+                          *patches)
+
+        self.rawcommand(args, prompt=prompt, input=input)
+
+    def incoming(self, revrange=None, path=None, force=False, newest=False,
+                 bundle=None, bookmarks=False, branch=None, limit=None,
+                 nomerges=False, subrepos=False):
+        """Return new changesets found in the specified path or the default pull
+        location.
+
+        When bookmarks=True, return a list of (name, node) of incoming
+        bookmarks.
+
+        revrange - a remote changeset or list of changesets intended to be added
+        force - run even if remote repository is unrelated
+        newest - show newest record first
+        bundle - avoid downloading the changesets twice and store the
+         bundles into the specified file.
+
+        bookmarks - compare bookmarks (this changes the return value)
+        branch - a specific branch you would like to pull
+        limit - limit number of changes returned
+        nomerges - do not show merges
+        ssh - specify ssh command to use
+        remotecmd - specify hg command to run on the remote side
+        insecure- do not verify server certificate (ignoring web.cacerts config)
+        subrepos - recurse into subrepositories
+
+        """
+        args = cmdbuilder(b('incoming'), path,
+                          template=templates.changeset, r=revrange,
+                          f=force, n=newest, bundle=bundle,
+                          B=bookmarks, b=branch, l=limit, M=nomerges,
+                          S=subrepos)
+
+        def eh(ret, out, err):
+            if ret != 1:
+                raise error.CommandError(args, ret, out, err)
+
+        out = self.rawcommand(args, eh=eh)
+        if not out:
+            return []
+
+        out = util.eatlines(out, 2)
+        if bookmarks:
+            bms = []
+            for line in out.splitlines():
+                bms.append(tuple(line.split()))
+            return bms
+        else:
+            out = out.split(b('\0'))[:-1]
+            return self._parserevs(out)
+
+    def log(self, revrange=None, files=[], follow=False,
+            followfirst=False, date=None, copies=False, keyword=None,
+            removed=False, onlymerges=False, user=None, branch=None,
+            prune=None, hidden=None, limit=None, nomerges=False,
+            include=None, exclude=None):
+        """Return the revision history of the specified files or the entire
+        project.
+
+        File history is shown without following rename or copy history of files.
+        Use follow with a filename to follow history across renames and copies.
+        follow without a filename will only show ancestors or descendants of the
+        starting revision. followfirst only follows the first parent of merge
+        revisions.
+
+        If revrange isn't specified, the default is "tip:0" unless
+        follow is set, in which case the working directory parent is
+        used as the starting revision.
+
+        The returned changeset is a named tuple with the following
+        string fields:
+
+            - rev
+            - node
+            - tags (space delimited)
+            - branch
+            - author
+            - desc
+
+        follow - follow changeset history, or file history across
+         copies and renames
+        followfirst - only follow the first parent of merge changesets
+        date - show revisions matching date spec
+        copies - show copied files
+        keyword - do case-insensitive search for a given text
+        removed - include revisions where files were removed
+        onlymerges - show only merges
+        user - revisions committed by user
+        branch - show changesets within the given named branch
+        prune - do not display revision or any of its ancestors
+        hidden - show hidden changesets
+        limit - limit number of changes displayed
+        nomerges - do not show merges
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+
+        """
+        if hidden is None:
+            hidden = self.hidden
+        args = cmdbuilder(b('log'), template=templates.changeset,
+                          r=revrange, f=follow, follow_first=followfirst,
+                          d=date, C=copies, k=keyword, removed=removed,
+                          m=onlymerges, u=user, b=branch, P=prune,
+                          l=limit, M=nomerges, I=include, X=exclude,
+                          hidden=hidden, *files)
+
+        out = self.rawcommand(args)
+        out = out.split(b('\0'))[:-1]
+
+        return self._parserevs(out)
+
+    def manifest(self, rev=None, all=False):
+        """Yields (nodeid, permission, executable, symlink, file path) tuples
+        for version controlled files for the given revision. If no
+        revision is given, the first parent of the working directory
+        is used, or the null revision if no revision is checked out.
+
+        When all is True, all files from all revisions are yielded
+        (just the name). This includes deleted and renamed files.
+
+        """
+        args = cmdbuilder(b('manifest'), r=rev, all=all, debug=True,
+                          hidden=self.hidden)
+
+        out = self.rawcommand(args)
+
+        if all:
+            for line in out.splitlines():
+                yield line
+        else:
+            for line in out.splitlines():
+                node = line[0:40]
+                perm = line[41:44]
+                symlink = line[45:46] == b('@')
+                executable = line[45:46] == b('*')
+                yield node, perm, executable, symlink, line[47:]
+
+    def merge(self, rev=None, force=False, tool=None, cb=merge.handlers.abort):
+        """Merge working directory with rev. If no revision is specified, the
+        working directory's parent is a head revision, and the current
+        branch contains exactly one other head, the other head is
+        merged with by default.
+
+        The current working directory is updated with all changes made in the
+        requested revision since the last common predecessor revision.
+
+        Files that changed between either parent are marked as changed for the
+        next commit and a commit must be performed before any further updates to
+        the repository are allowed. The next commit will have two parents.
+
+        force - force a merge with outstanding changes
+        tool - can be used to specify the merge tool used for file merges. It
+        overrides the HGMERGE environment variable and your configuration files.
+
+        cb - controls the behaviour when Mercurial prompts what to do
+        with regard to a specific file, e.g. when one parent modified
+        a file and the other removed it. It can be one of
+        merge.handlers, or a function that gets a single argument
+        which are the contents of stdout. It should return one of the
+        expected choices (a single character).
+
+        """
+        # we can't really use --preview since merge doesn't support --template
+        args = cmdbuilder(b('merge'), r=rev, f=force, t=tool)
+
+        prompt = None
+        if cb is merge.handlers.abort:
+            prompt = cb
+        elif cb is merge.handlers.noninteractive:
+            args.append(b('-y'))
+        else:
+            prompt = lambda size, output: cb(output) + b('\n')
+
+        self.rawcommand(args, prompt=prompt)
+
+    def move(self, source, dest, after=False, force=False, dryrun=False,
+             include=None, exclude=None):
+        """Mark dest as copies of source; mark source for deletion. If dest
+        is a directory, copies are put in that directory. If dest is a
+        file, then source must be a string.
+
+        Returns True on success, False if errors are encountered.
+
+        source - a file or a list of files
+        dest - a destination file or directory
+        after - record a rename that has already occurred
+        force - forcibly copy over an existing managed file
+        dryrun - do not perform actions, just print output
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+
+        """
+        if not isinstance(source, list):
+            source = [source]
+
+        source.append(dest)
+        args = cmdbuilder(b('move'), A=after, f=force, n=dryrun,
+                          I=include, X=exclude, *source)
+
+        eh = util.reterrorhandler(args)
+        self.rawcommand(args, eh=eh)
+
+        return bool(eh)
+
+    def outgoing(self, revrange=None, path=None, force=False, newest=False,
+                 bookmarks=False, branch=None, limit=None, nomerges=False,
+                 subrepos=False):
+        """Return changesets not found in the specified path or the default push
+        location.
+
+        When bookmarks=True, return a list of (name, node) of
+        bookmarks that will be pushed.
+
+        revrange - a (list of) changeset intended to be included in
+        the destination force - run even when the destination is
+        unrelated newest - show newest record first branch - a
+        specific branch you would like to push limit - limit number of
+        changes displayed nomerges - do not show merges ssh - specify
+        ssh command to use remotecmd - specify hg command to run on
+        the remote side insecure - do not verify server certificate
+        (ignoring web.cacerts config) subrepos - recurse into
+        subrepositories
+
+        """
+        args = cmdbuilder(b('outgoing'),
+                          path,
+                          template=templates.changeset, r=revrange,
+                          f=force, n=newest, B=bookmarks,
+                          b=branch, S=subrepos)
+
+        def eh(ret, out, err):
+            if ret != 1:
+                raise error.CommandError(args, ret, out, err)
+
+        out = self.rawcommand(args, eh=eh)
+        if not out:
+            return []
+
+        out = util.eatlines(out, 2)
+        if bookmarks:
+            bms = []
+            for line in out.splitlines():
+                bms.append(tuple(line.split()))
+            return bms
+        else:
+            out = out.split(b('\0'))[:-1]
+            return self._parserevs(out)
+
+    def parents(self, rev=None, file=None):
+        """Return the working directory's parent revisions. If rev is given,
+        the parent of that revision will be printed. If file is given,
+        the revision in which the file was last changed (before the
+        working directory revision or the revision specified by rev)
+        is returned.
+
+        """
+        args = cmdbuilder(b('parents'), file, template=templates.changeset,
+                          r=rev, hidden=self.hidden)
+
+        out = self.rawcommand(args)
+        if not out:
+            return
+
+        out = out.split(b('\0'))[:-1]
+
+        return self._parserevs(out)
+
+    def paths(self, name=None):
+        """
+        Return the definition of given symbolic path name. If no name is given,
+        return a dictionary of pathname : url of all available names.
+
+        Path names are defined in the [paths] section of your configuration file
+        and in "/etc/mercurial/hgrc". If run inside a repository, ".hg/hgrc" is
+        used, too.
+        """
+        if not name:
+            out = self.rawcommand([b('paths')])
+            if not out:
+                return {}
+
+            return dict([s.split(b(' = '))
+                         for s in out.rstrip().split(b('\n'))])
+        else:
+            args = cmdbuilder(b('paths'), name)
+            out = self.rawcommand(args)
+            return out.rstrip()
+
+    def pull(self, source=None, rev=None, update=False, force=False,
+             bookmark=None, branch=None, ssh=None, remotecmd=None,
+             insecure=False, tool=None):
+        """Pull changes from a remote repository.
+
+        This finds all changes from the repository specified by source
+        and adds them to this repository. If source is omitted, the
+        'default' path will be used. By default, this does not update
+        the copy of the project in the working directory.
+
+        Returns True on success, False if update was given and there were
+        unresolved files.
+
+        update - update to new branch head if changesets were pulled
+        force - run even when remote repository is unrelated
+        rev - a (list of) remote changeset intended to be added
+        bookmark - (list of) bookmark to pull
+        branch - a (list of) specific branch you would like to pull
+        ssh - specify ssh command to use
+        remotecmd - specify hg command to run on the remote side
+        insecure - do not verify server certificate (ignoring
+         web.cacerts config)
+        tool - specify merge tool for rebase
+
+        """
+        args = cmdbuilder(b('pull'), source, r=rev, u=update, f=force,
+                          B=bookmark, b=branch, e=ssh,
+                          remotecmd=remotecmd, insecure=insecure,
+                          t=tool)
+
+        eh = util.reterrorhandler(args)
+        self.rawcommand(args, eh=eh)
+
+        return bool(eh)
+
+    def push(self, dest=None, rev=None, force=False, bookmark=None, branch=None,
+             newbranch=False, ssh=None, remotecmd=None, insecure=False):
+        """Push changesets from this repository to the specified destination.
+
+        This operation is symmetrical to pull: it is identical to a pull in the
+        destination repository from the current one.
+
+        Returns True if push was successful, False if nothing to push.
+
+        rev - the (list of) specified revision and all its ancestors
+        will be pushed to the remote repository.
+
+        force - override the default behavior and push all changesets on all
+        branches.
+
+        bookmark - (list of) bookmark to push
+        branch - a (list of) specific branch you would like to push
+        newbranch - allows push to create a new named branch that is
+         not present at the destination. This allows you to only create
+         a new branch without forcing other changes.
+
+        ssh - specify ssh command to use
+        remotecmd - specify hg command to run on the remote side
+        insecure - do not verify server certificate (ignoring
+         web.cacerts config)
+
+        """
+        args = cmdbuilder(b('push'), dest, r=rev, f=force, B=bookmark, b=branch,
+                          new_branch=newbranch, e=ssh, remotecmd=remotecmd,
+                          insecure=insecure)
+
+        eh = util.reterrorhandler(args)
+        self.rawcommand(args, eh=eh)
+
+        return bool(eh)
+
+    def remove(self, files, after=False, force=False, include=None,
+               exclude=None):
+        """Schedule the indicated files for removal from the repository. This
+        only removes files from the current branch, not from the
+        entire project history.
+
+        Returns True on success, False if any warnings encountered.
+
+        after - used to remove only files that have already been deleted
+        force - remove (and delete) file even if added or modified
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+
+        """
+        if not isinstance(files, list):
+            files = [files]
+
+        args = cmdbuilder(b('remove'), A=after, f=force, I=include, X=exclude,
+                          *files)
+
+        eh = util.reterrorhandler(args)
+        self.rawcommand(args, eh=eh)
+
+        return bool(eh)
+
+    def resolve(self, file=[], all=False, listfiles=False, mark=False,
+                unmark=False, tool=None, include=None, exclude=None):
+        """
+        Redo merges or set/view the merge status of given files.
+
+        Returns True on success, False if any files fail a resolve attempt.
+
+        When listfiles is True, returns a list of (code, file path) of resolved
+        and unresolved files. Code will be 'R' or 'U' accordingly.
+
+        all - select all unresolved files
+        mark - mark files as resolved
+        unmark - mark files as unresolved
+        tool - specify merge tool
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+        """
+        if not isinstance(file, list):
+            file = [file]
+
+        args = cmdbuilder(b('resolve'), a=all, l=listfiles, m=mark, u=unmark,
+                          t=tool, I=include, X=exclude, *file)
+
+        out = self.rawcommand(args)
+
+        if listfiles:
+            l = []
+            for line in out.splitlines():
+                l.append(tuple(line.split(b(' '), 1)))
+            return l
+
+    def revert(self, files, rev=None, all=False, date=None, nobackup=False,
+               dryrun=False, include=None, exclude=None):
+        """With no revision specified, revert the specified files or
+        directories to the contents they had in the parent of the
+        working directory. This restores the contents of files to an
+        unmodified state and unschedules adds, removes, copies, and
+        renames. If the working directory has two parents, you must
+        explicitly specify a revision.
+
+        Specifying rev or date will revert the given files or
+        directories to their states as of a specific revision. Because
+        revert does not change the working directory parents, this
+        will cause these files to appear modified. This can be helpful
+        to "back out" some or all of an earlier change.
+
+        Modified files are saved with a .orig suffix before reverting.
+        To disable these backups, use nobackup.
+
+        Returns True on success.
+
+        all - revert all changes when no arguments given
+        date - tipmost revision matching date
+        rev - revert to the specified revision
+        nobackup - do not save backup copies of files
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+        dryrun - do not perform actions, just print output
+
+        """
+        if not isinstance(files, list):
+            files = [files]
+
+        args = cmdbuilder(b('revert'), r=rev, a=all, d=date,
+                          no_backup=nobackup, n=dryrun, I=include, X=exclude,
+                          hidden=self.hidden, *files)
+
+        eh = util.reterrorhandler(args)
+        self.rawcommand(args, eh=eh)
+
+        return bool(eh)
+
+    def root(self):
+        """
+        Return the root directory of the current repository.
+        """
+        return self.rawcommand([b('root')]).rstrip()
+
+    def status(self, rev=None, change=None, all=False, modified=False,
+               added=False, removed=False, deleted=False, clean=False,
+               unknown=False, ignored=False, copies=False,
+               subrepos=False, include=None, exclude=None):
+        """
+        Return status of files in the repository as a list of (code, file path)
+        where code can be:
+
+                M = modified
+                A = added
+                R = removed
+                C = clean
+                ! = missing (deleted by non-hg command, but still tracked)
+                ? = untracked
+                I = ignored
+                  = origin of the previous file listed as A (added)
+
+        rev - show difference from (list of) revision
+        change - list the changed files of a revision
+        all - show status of all files
+        modified - show only modified files
+        added - show only added files
+        removed - show only removed files
+        deleted - show only deleted (but tracked) files
+        clean - show only files without changes
+        unknown - show only unknown (not tracked) files
+        ignored - show only ignored files
+        copies - show source of copied files
+        subrepos - recurse into subrepositories
+        include - include names matching the given patterns
+        exclude - exclude names matching the given patterns
+        """
+        if rev and change:
+            raise ValueError('cannot specify both rev and change')
+
+        args = cmdbuilder(b('status'), rev=rev, change=change, A=all,
+                          m=modified, a=added, r=removed, d=deleted, c=clean,
+                          u=unknown, i=ignored, C=copies, S=subrepos, I=include,
+                          X=exclude, hidden=self.hidden)
+
+        args.append(b('-0'))
+
+        out = self.rawcommand(args)
+        l = []
+
+        for entry in out.split(b('\0')):
+            if entry:
+                if entry[0:1] == b(' '):
+                    l.append((b(' '), entry[2:]))
+                else:
+                    l.append(tuple(entry.split(b(' '), 1)))
+
+        return l
+
+    def tag(self, names, rev=None, message=None, force=False, local=False,
+            remove=False, date=None, user=None):
+        """Add one or more tags specified by names for the current or given
+        revision.
+
+        Changing an existing tag is normally disallowed; use force to override.
+
+        Tag commits are usually made at the head of a branch. If the
+        parent of the working directory is not a branch head, a
+        CommandError will be raised. force can be specified to force
+        the tag commit to be based on a non-head changeset.
+
+        local - make the tag local
+        rev - revision to tag
+        remove - remove a tag
+        message - set commit message
+        date - record the specified date as commit date
+        user - record the specified user as committer
+
+        """
+        if not isinstance(names, list):
+            names = [names]
+
+        args = cmdbuilder(b('tag'), r=rev, m=message, f=force, l=local,
+                          remove=remove, d=date, u=user, hidden=self.hidden,
+                          *names)
+
+        self.rawcommand(args)
+
+    def tags(self):
+        """
+        Return a list of repository tags as: (name, rev, node, islocal)
+        """
+        args = cmdbuilder(b('tags'), v=True)
+
+        out = self.rawcommand(args)
+
+        t = []
+        for line in out.splitlines():
+            taglocal = line.endswith(b(' local'))
+            if taglocal:
+                line = line[:-6]
+            name, rev = line.rsplit(b(' '), 1)
+            rev, node = rev.split(b(':'))
+            t.append((name.rstrip(), int(rev), node, taglocal))
+        return t
+
+    def phase(self, revs=(), secret=False, draft=False, public=False,
+              force=False):
+        '''Set or show the current phase name.
+
+        revs - target revision(s)
+        public - set changeset phase to public
+        draft - set changeset phase to draft
+        secret - set changeset phase to secret
+        force - allow to move boundary backward
+
+        output format: [(id, phase) ...] for each changeset
+
+        The arguments match the mercurial API.
+        '''
+        if not isinstance(revs, (list, tuple)):
+            revs = [revs]
+        args = util.cmdbuilder(b('phase'), secret=secret, draft=draft,
+                               public=public, force=force,
+                               hidden=self.hidden, *revs)
+        out = self.rawcommand(args)
+        if draft or public or secret:
+            return
+        else:
+            output = [i.split(b(': '))for i in out.strip().split(b('\n'))]
+            return [(int(num), phase) for (num, phase) in output]
+
+    def summary(self, remote=False):
+        """
+        Return a dictionary with a brief summary of the working directory state,
+        including parents, branch, commit status, and available updates.
+
+            'parent' : a list of (rev, node, tags, message)
+            'branch' : the current branch
+            'commit' : True if the working directory is clean, False otherwise
+            'update' : number of available updates,
+            ['remote' : (in, in bookmarks, out, out bookmarks),]
+            ['mq': (applied, unapplied) mq patches,]
+
+            unparsed entries will be of them form key : value
+        """
+        args = cmdbuilder(b('summary'), remote=remote, hidden=self.hidden)
+
+        out = self.rawcommand(args).splitlines()
+
+        d = {}
+        while out:
+            line = out.pop(0)
+            name, value = line.split(b(': '), 1)
+
+            if name == b('parent'):
+                parent, tags = value.split(b(' '), 1)
+                rev, node = parent.split(b(':'))
+
+                if tags:
+                    tags = tags.replace(b(' (empty repository)'), b(''))
+                else:
+                    tags = None
+
+                value = d.get(name, [])
+
+                if rev == b('-1'):
+                    value.append((int(rev), node, tags, None))
+                else:
+                    message = out.pop(0)[1:]
+                    value.append((int(rev), node, tags, message))
+            elif name == b('branch'):
+                pass
+            elif name == b('commit'):
+                value = value == b('(clean)')
+            elif name == b('update'):
+                if value == b('(current)'):
+                    value = 0
+                else:
+                    value = int(value.split(b(' '), 1)[0])
+            elif remote and name == b('remote'):
+                if value == b('(synced)'):
+                    value = 0, 0, 0, 0
+                else:
+                    inc = incb = out_ = outb = 0
+
+                    for v in value.split(b(', ')):
+                        count, v = v.split(b(' '), 1)
+                        if v == b('outgoing'):
+                            out_ = int(count)
+                        elif v.endswith(b('incoming')):
+                            inc = int(count)
+                        elif v == b('incoming bookmarks'):
+                            incb = int(count)
+                        elif v == b('outgoing bookmarks'):
+                            outb = int(count)
+
+                    value = inc, incb, out_, outb
+            elif name == b('mq'):
+                applied = unapplied = 0
+                for v in value.split(b(', ')):
+                    count, v = v.split(b(' '), 1)
+                    if v == b('applied'):
+                        applied = int(count)
+                    elif v == b('unapplied'):
+                        unapplied = int(count)
+                value = applied, unapplied
+
+            d[name] = value
+
+        return d
+
+    def tip(self):
+        """
+        Return the tip revision (usually just called the tip) which is the
+        changeset most recently added to the repository (and therefore the most
+        recently changed head).
+        """
+        args = cmdbuilder(b('tip'), template=templates.changeset,
+                          hidden=self.hidden)
+        out = self.rawcommand(args)
+        out = out.split(b('\0'))
+
+        return self._parserevs(out)[0]
+
+    def update(self, rev=None, clean=False, check=False, date=None):
+        """
+        Update the repository's working directory to changeset specified by rev.
+        If rev isn't specified, update to the tip of the current named branch.
+
+        Return the number of files (updated, merged, removed, unresolved)
+
+        clean - discard uncommitted changes (no backup)
+        check - update across branches if no uncommitted changes
+        date - tipmost revision matching date
+        """
+        if clean and check:
+            raise ValueError('clean and check cannot both be True')
+
+        args = cmdbuilder(b('update'), r=rev, C=clean, c=check, d=date,
+                          hidden=self.hidden)
+
+        def eh(ret, out, err):
+            if ret == 1:
+                return out
+
+            raise error.CommandError(args, ret, out, err)
+
+
+        out = self.rawcommand(args, eh=eh)
+
+        m = re.search(b(r'^(\d+).+, (\d+).+, (\d+).+, (\d+)'), out,
+                      re.MULTILINE)
+        return tuple(map(int, list(m.groups())))
+
+    @property
+    def version(self):
+        """Return hg version that runs the command server as a 4 fielded
+        tuple: major, minor, micro and local build info. e.g. (1, 9,
+        1, '+4-3095db9f5c2c')
+        """
+        if self._version is None:
+            v = self.rawcommand(cmdbuilder(b('version'), q=True))
+            v = list(re.match(b(r'.*?(\d+)\.(\d+)\.?(\d+)?(\+[0-9a-f-]+)?'),
+                              v).groups())
+
+            for i in range(3):
+                try:
+                    v[i] = int(v[i])
+                except TypeError:
+                    v[i] = 0
+
+            self._version = tuple(v)
+
+        return self._version
+
+    def __getitem__(self, changeid):
+        try:
+            return context.changectx(self, changeid)
+        except ValueError as e:
+            raise KeyError(*e.args)
+
+    def __contains__(self, changeid):
+        """
+        check if changeid, which can be either a local revision number or a
+        changeset id, matches a changeset in the client.
+        """
+        try:
+            context.changectx(self, changeid)
+            return True
+        except ValueError:
+            return False