Commit 258638f8 authored by Gregory Szorc's avatar Gregory Szorc
Browse files

Bug 1393242 - Vendor python-hglib 2.4; r=mshal 

python-hglib is a Python client for Mercurial's command server. It
facilitates querying Mercurial efficiently (using a single process)
and without having to parse output in the common case.

Let's vendor it so we can make use of it for more advanced Mercurial
scenarios.

Content vendored from changeset 820d7c1e470a without modifications
(other than deleting unwanted files).

As part of vendoring, we add the package to the virtualenv and make
it available to mach.

MozReview-Commit-ID: F4KLbW1lAvk

--HG--
extra : rebase_source : 39321a880a13a0b0323a7217f538978b729e2afe
parent 48ba6bac

build/virtualenv_packages.txt

+1 −0
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ mozilla.pth:third_party/python/configobj 
mozilla.pth:third_party/python/cram

mozilla.pth:third_party/python/dlmanager

mozilla.pth:third_party/python/futures

mozilla.pth:third_party/python/hglib

mozilla.pth:third_party/python/jsmin

optional:setup.py:third_party/python/psutil:build_ext:--inplace

mozilla.pth:third_party/python/psutil

third_party/python/hglib/LICENSE

0 → 100644
+20 −0
Original line number Diff line number Diff line 
Copyright (c) 2011 Matt Mackall and other contributors



Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the

"Software"), to deal in the Software without restriction, including

without limitation the rights to use, copy, modify, merge, publish,

distribute, sublicense, and/or sell copies of the Software, and to

permit persons to whom the Software is furnished to do so, subject to

the following conditions:



The above copyright notice and this permission notice shall be

included in all copies or substantial portions of the Software.



THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 No newline at end of file

third_party/python/hglib/hglib/__init__.py

0 → 100644
+40 −0
Original line number Diff line number Diff line 
import subprocess

from hglib import client, util, error



HGPATH = 'hg'



def open(path=None, encoding=None, configs=None):

    '''starts a cmdserver for the given path (or for a repository found

    in the cwd). HGENCODING is set to the given encoding. configs is a

    list of key, value, similar to those passed to hg --config.

    '''

    return client.hgclient(path, encoding, configs)



def init(dest=None, ssh=None, remotecmd=None, insecure=False,

         encoding=None, configs=None):

    args = util.cmdbuilder('init', dest, e=ssh, remotecmd=remotecmd,

                           insecure=insecure)



    args.insert(0, HGPATH)

    proc = util.popen(args)

    out, err = proc.communicate()

    if proc.returncode:

        raise error.CommandError(args, proc.returncode, out, err)



    return client.hgclient(dest, encoding, configs, connect=False)



def clone(source=None, dest=None, noupdate=False, updaterev=None, rev=None,

          branch=None, pull=False, uncompressed=False, ssh=None, remotecmd=None,

          insecure=False, encoding=None, configs=None):

    args = util.cmdbuilder('clone', source, dest, noupdate=noupdate,

                           updaterev=updaterev, rev=rev, branch=branch,

                           pull=pull, uncompressed=uncompressed,

                           e=ssh, remotecmd=remotecmd, insecure=insecure)



    args.insert(0, HGPATH)

    proc = util.popen(args)

    out, err = proc.communicate()

    if proc.returncode:

        raise error.CommandError(args, proc.returncode, out, err)



    return client.hgclient(dest, encoding, configs, connect=False)

third_party/python/hglib/hglib/client.py

0 → 100644
+1717 −0

File added.

Preview size limit exceeded, changes collapsed.

third_party/python/hglib/hglib/context.py

0 → 100644
+238 −0
Original line number Diff line number Diff line 
import hglib.client  # Circular dependency.

from hglib import util, templates

from hglib.error import CommandError

from hglib.util import b, strtobytes, integertypes



_nullcset = [b('-1'), b('0000000000000000000000000000000000000000'), b(''),

             b(''), b(''), b(''), b('')]



class changectx(object):

    """A changecontext object makes access to data related to a particular

    changeset convenient."""

    def __init__(self, repo, changeid=b('')):

        """changeid is a revision number, node, or tag"""

        if changeid == b(''):

            changeid = b('.')

        self._repo = repo

        if isinstance(changeid, hglib.client.revision):

            cset = changeid

        elif changeid == -1:

            cset = _nullcset

        else:

            if isinstance(changeid, integertypes):

                changeid = b('rev(') + strtobytes(changeid) + b(')')



            notfound = False

            try:

                cset = self._repo.log(changeid)

                # hg bbf4f3dfd700 gave a null result for tip+1

                if (cset and cset[0][1] == _nullcset[1]

                    and cset[0][0] != _nullcset[0]):

                    notfound = True

            except CommandError:

                notfound = True



            if notfound or not len(cset):

                raise ValueError('changeid %r not found in repo' % changeid)

            if len(cset) > 1:

                raise ValueError('changeid must yield a single changeset')

            cset = cset[0]



        self._rev, self._node, self._tags = cset[:3]

        self._branch, self._author, self._description, self._date = cset[3:]



        self._rev = int(self._rev)



        self._tags = self._tags.split()

        try:

            self._tags.remove(b('tip'))

        except ValueError:

            pass



        self._ignored = None

        self._clean = None



    def __str__(self):

        return self._node[:12].decode('latin-1')



    def __int__(self):

        return self._rev



    def __repr__(self):

        return "<changectx %s>" % str(self)



    def __hash__(self):

        try:

            return hash(self._rev)

        except AttributeError:

            return id(self)



    def __eq__(self, other):

        try:

            return self._rev == other._rev

        except AttributeError:

            return False



    def __ne__(self, other):

        return not (self == other)



    def __nonzero__(self):

        return self._rev != -1



    def __bool__(self):

        return self.__nonzero__()



    def __contains__(self, key):

        return key in self._manifest



    def __iter__(self):

        for f in sorted(self._manifest):

            yield f



    @util.propertycache

    def _status(self):

        return self._parsestatus(self._repo.status(change=strtobytes(self)))[:4]



    def _parsestatus(self, stat):

        d = dict((c, [])

                 for c in (b('M'), b('A'), b('R'), b('!'), b('?'), b('I'),

                    b('C'), b(' ')))

        for k, path in stat:

            d[k].append(path)

        return (d[b('M')], d[b('A')], d[b('R')], d[b('!')], d[b('?')],

                d[b('I')], d[b('C')])



    def status(self, ignored=False, clean=False):

        """Explicit status query

        Unless this method is used to query the working copy status, the

        _status property will implicitly read the status using its default

        arguments."""

        stat = self._parsestatus(self._repo.status(change=strtobytes(self),

                                                   ignored=ignored,

                                                   clean=clean))

        self._unknown = self._ignored = self._clean = None

        if ignored:

            self._ignored = stat[5]

        if clean:

            self._clean = stat[6]

        self._status = stat[:4]

        return stat



    def rev(self):

        return self._rev



    def node(self):

        return self._node



    def tags(self):

        return self._tags



    def branch(self):

        return self._branch



    def author(self):

        return self._author



    def user(self):

        return self._author



    def date(self):

        return self._date



    def description(self):

        return self._description



    def files(self):

        return sorted(self._status[0] + self._status[1] + self._status[2])



    def modified(self):

        return self._status[0]



    def added(self):

        return self._status[1]



    def removed(self):

        return self._status[2]



    def ignored(self):

        if self._ignored is None:

            self.status(ignored=True)

        return self._ignored



    def clean(self):

        if self._clean is None:

            self.status(clean=True)

        return self._clean



    @util.propertycache

    def _manifest(self):

        d = {}

        for node, p, e, s, path in self._repo.manifest(rev=strtobytes(self)):

            d[path] = node

        return d



    def manifest(self):

        return self._manifest



    def hex(self):

        return hex(self._node)



    @util.propertycache

    def _parents(self):

        """return contexts for each parent changeset"""

        par = self._repo.parents(rev=strtobytes(self))

        if not par:

            return [changectx(self._repo, -1)]

        return [changectx(self._repo, int(cset.rev)) for cset in par]



    def parents(self):

        return self._parents



    def p1(self):

        return self._parents[0]



    def p2(self):

        if len(self._parents) == 2:

            return self._parents[1]

        return changectx(self._repo, -1)



    @util.propertycache

    def _bookmarks(self):

        books = [bm for bm in self._repo.bookmarks()[0] if bm[1] == self._rev]



        bms = []

        for name, r, n in books:

            bms.append(name)

        return bms



    def bookmarks(self):

        return self._bookmarks



    def hidden(self):

        """return True if the changeset is hidden, else False"""

        return bool(self._repo.log(revrange=self._node + b(' and hidden()'),

                                   hidden=True))



    def phase(self):

        """return the phase of the changeset (public, draft or secret)"""

        return self._repo.phase(strtobytes(self._rev))[0][1]



    def children(self):

        """return contexts for each child changeset"""

        for c in self._repo.log(b('children(') + self._node + b(')')):

            yield changectx(self._repo, c)



    def ancestors(self):

        for a in self._repo.log(b('ancestors(') + self._node + b(')')):

            yield changectx(self._repo, a)



    def descendants(self):

        for d in self._repo.log(b('descendants(') + self._node + b(')')):

            yield changectx(self._repo, d)



    def ancestor(self, c2):

        """

        return the ancestor context of self and c2

        """

        return changectx(self._repo,

                         b('ancestor(') + self + b(', ') + c2 + b(')'))