mercurial/subrepo.py

45956:346af7687c6f

_abssource = subrepoutil._abssource
propertycache = util.propertycache


def _expandedabspath(path):
    '''
    get a path or url and if it is a path expand it and return an absolute path
    '''
    expandedpath = util.urllocalpath(util.expandpath(path))
    u = util.url(expandedpath)
    if not u.scheme:
        path = util.normpath(os.path.abspath(u.path))
    return path

            return _(b'uncommitted changes in subrepository "%s"') % subrelpath(
                self
            )

    def bailifchanged(self, ignoreupdate=False, hint=None):
        """raise Abort if subrepository is ``dirty()``
        """
        dirtyreason = self.dirtyreason(ignoreupdate=ignoreupdate, missing=True)
        if dirtyreason:
            raise error.Abort(dirtyreason, hint=hint)

    def basestate(self):

        new state of the subrepo.
        """
        raise NotImplementedError

    def phase(self, state):
        """returns phase of specified state in the subrepository.
        """
        return phases.public

    def remove(self):
        """remove the subrepo

            progress.increment()
        progress.complete()
        return total

    def walk(self, match):
        '''
        walk recursively through the directory tree, finding all files
        matched by the match function
        '''

    def forget(self, match, prefix, uipathfn, dryrun, interactive):
        return ([], [])

    def removefiles(

    def shortid(self, revid):
        return revid

    def unshare(self):
        '''
        convert this repository from shared to normal storage.
        '''

    def verify(self, onpush=False):
        """verify the revision of this repository that is held in `_state` is
        present and not hidden.  Return 0 on success or warning, 1 on any
        error.  In the case of ``onpush``, warnings or errors will raise an

        """
        return 0

    @propertycache
    def wvfs(self):
        """return vfs to access the working directory of this subrepository
        """
        return vfsmod.vfs(self._ctx.repo().wvfs.join(self._path))

    @propertycache
    def _relpath(self):
        """return path to this subrepository as seen from outermost repository
        """
        return self.wvfs.reljoin(reporelpath(self._ctx.repo()), self._path)


class hgsubrepo(abstractsubrepo):
    def __init__(self, ctx, path, state, allowcreate):

            # the cached and current pull states have a different size
            clean = next(itercache, None) is None
        return clean

    def _calcstorehash(self, remotepath):
        '''calculate a unique "store hash"

        This method is used to to detect when there are changes that may
        require a push to a given remote path.'''
        # sort the files that will be hashed in increasing (likely) file size
        filelist = (b'bookmarks', b'store/phaseroots', b'store/00changelog.i')
        yield b'# %s\n' % _expandedabspath(remotepath)
        vfs = self._repo.vfs
        for relname in filelist:

        '''read the store hash cache for a given remote repository'''
        cachefile = _getstorehashcachename(remotepath)
        return self._cachestorehashvfs.tryreadlines(cachefile, b'r')

    def _cachestorehash(self, remotepath):
        '''cache the current store hash

        Each remote repo requires its own store hash cache, because a subrepo
        store may be "clean" versus a given remote repo, but not versus another
        '''
        cachefile = _getstorehashcachename(remotepath)
        with self._repo.lock():
            storehash = list(self._calcstorehash(remotepath))
            vfs = self._cachestorehashvfs
            vfs.writelines(cachefile, storehash, mode=b'wb', notindexed=True)

    def _getctx(self):
        '''fetch the context for this subrepo revision, possibly a workingctx
        '''
        if self._ctx.rev() is None:
            return self._repo[None]  # workingctx if parent is workingctx
        else:
            rev = self._state[1]
            return self._repo[rev]

                self._repo.ui.warn(b'%s\n' % msg)
            return 0

    @propertycache
    def wvfs(self):
        """return own wvfs for efficiency and consistency
        """
        return self._repo.wvfs

    @propertycache
    def _relpath(self):
        """return path to this subrepository as seen from outermost repository
        """
        # Keep consistent dir separators by avoiding vfs.join(self._path)
        return reporelpath(self._repo)


class svnsubrepo(abstractsubrepo):

            path = e.getAttribute('path').encode('utf8')
            if item == 'external':
                externals.append(path)
            elif item == 'missing':
                missing.append(path)
            if item not in (
                '',
                'normal',
                'unversioned',
                'external',
            ) or props not in ('', 'none', 'normal'):
                changes.append(path)
        for path in changes:
            for ext in externals:
                if path == ext or path.startswith(ext + pycompat.ossep):
                    return True, True, bool(missing)

        return -1

    @staticmethod
    def _checkversion(out):
        '''ensure git version is new enough

        >>> _checkversion = gitsubrepo._checkversion
        >>> _checkversion(b'git version 1.6.0')
        'ok'
        >>> _checkversion(b'git version 1.8.5')

        'ok'
        >>> _checkversion(b'git version 12345')
        'unknown'
        >>> _checkversion(b'no')
        'unknown'
        '''
        version = gitsubrepo._gitversion(out)
        # git 1.4.0 can't work at all, but 1.5.X can in at least some cases,
        # despite the docstring comment.  For now, error on 1.4.0, warn on
        # 1.5.0 but attempt to continue.
        if version == -1:

        diff-index only looks at changes to file stat;
        this command looks at file contents and updates the stat."""
        self._gitcommand([b'update-index', b'-q', b'--refresh'])

    def _gitbranchmap(self):
        '''returns 2 things:
        a map from git branch to revision
        a map from revision to branches'''
        branch2rev = {}
        rev2branch = {}

        out = self._gitcommand(
            [b'for-each-ref', b'--format', b'%(objectname) %(refname)']

45957:89a2afe31e82

_abssource = subrepoutil._abssource
propertycache = util.propertycache


def _expandedabspath(path):
    """
    get a path or url and if it is a path expand it and return an absolute path
    """
    expandedpath = util.urllocalpath(util.expandpath(path))
    u = util.url(expandedpath)
    if not u.scheme:
        path = util.normpath(os.path.abspath(u.path))
    return path

            return _(b'uncommitted changes in subrepository "%s"') % subrelpath(
                self
            )

    def bailifchanged(self, ignoreupdate=False, hint=None):
        """raise Abort if subrepository is ``dirty()``"""
        dirtyreason = self.dirtyreason(ignoreupdate=ignoreupdate, missing=True)
        if dirtyreason:
            raise error.Abort(dirtyreason, hint=hint)

    def basestate(self):

        new state of the subrepo.
        """
        raise NotImplementedError

    def phase(self, state):
        """returns phase of specified state in the subrepository."""
        return phases.public

    def remove(self):
        """remove the subrepo

            progress.increment()
        progress.complete()
        return total

    def walk(self, match):
        """
        walk recursively through the directory tree, finding all files
        matched by the match function
        """

    def forget(self, match, prefix, uipathfn, dryrun, interactive):
        return ([], [])

    def removefiles(

    def shortid(self, revid):
        return revid

    def unshare(self):
        """
        convert this repository from shared to normal storage.
        """

    def verify(self, onpush=False):
        """verify the revision of this repository that is held in `_state` is
        present and not hidden.  Return 0 on success or warning, 1 on any
        error.  In the case of ``onpush``, warnings or errors will raise an

        """
        return 0

    @propertycache
    def wvfs(self):
        """return vfs to access the working directory of this subrepository"""
        return vfsmod.vfs(self._ctx.repo().wvfs.join(self._path))

    @propertycache
    def _relpath(self):
        """return path to this subrepository as seen from outermost repository"""
        return self.wvfs.reljoin(reporelpath(self._ctx.repo()), self._path)


class hgsubrepo(abstractsubrepo):
    def __init__(self, ctx, path, state, allowcreate):

            # the cached and current pull states have a different size
            clean = next(itercache, None) is None
        return clean

    def _calcstorehash(self, remotepath):
        """calculate a unique "store hash"

        This method is used to to detect when there are changes that may
        require a push to a given remote path."""
        # sort the files that will be hashed in increasing (likely) file size
        filelist = (b'bookmarks', b'store/phaseroots', b'store/00changelog.i')
        yield b'# %s\n' % _expandedabspath(remotepath)
        vfs = self._repo.vfs
        for relname in filelist:

        '''read the store hash cache for a given remote repository'''
        cachefile = _getstorehashcachename(remotepath)
        return self._cachestorehashvfs.tryreadlines(cachefile, b'r')

    def _cachestorehash(self, remotepath):
        """cache the current store hash

        Each remote repo requires its own store hash cache, because a subrepo
        store may be "clean" versus a given remote repo, but not versus another
        """
        cachefile = _getstorehashcachename(remotepath)
        with self._repo.lock():
            storehash = list(self._calcstorehash(remotepath))
            vfs = self._cachestorehashvfs
            vfs.writelines(cachefile, storehash, mode=b'wb', notindexed=True)

    def _getctx(self):
        """fetch the context for this subrepo revision, possibly a workingctx"""
        if self._ctx.rev() is None:
            return self._repo[None]  # workingctx if parent is workingctx
        else:
            rev = self._state[1]
            return self._repo[rev]

                self._repo.ui.warn(b'%s\n' % msg)
            return 0

    @propertycache
    def wvfs(self):
        """return own wvfs for efficiency and consistency"""
        return self._repo.wvfs

    @propertycache
    def _relpath(self):
        """return path to this subrepository as seen from outermost repository"""
        # Keep consistent dir separators by avoiding vfs.join(self._path)
        return reporelpath(self._repo)


class svnsubrepo(abstractsubrepo):

            path = e.getAttribute('path').encode('utf8')
            if item == 'external':
                externals.append(path)
            elif item == 'missing':
                missing.append(path)
            if (
                item
                not in (
                    '',
                    'normal',
                    'unversioned',
                    'external',
                )
                or props not in ('', 'none', 'normal')
            ):
                changes.append(path)
        for path in changes:
            for ext in externals:
                if path == ext or path.startswith(ext + pycompat.ossep):
                    return True, True, bool(missing)

        return -1

    @staticmethod
    def _checkversion(out):
        """ensure git version is new enough

        >>> _checkversion = gitsubrepo._checkversion
        >>> _checkversion(b'git version 1.6.0')
        'ok'
        >>> _checkversion(b'git version 1.8.5')

        'ok'
        >>> _checkversion(b'git version 12345')
        'unknown'
        >>> _checkversion(b'no')
        'unknown'
        """
        version = gitsubrepo._gitversion(out)
        # git 1.4.0 can't work at all, but 1.5.X can in at least some cases,
        # despite the docstring comment.  For now, error on 1.4.0, warn on
        # 1.5.0 but attempt to continue.
        if version == -1:

        diff-index only looks at changes to file stat;
        this command looks at file contents and updates the stat."""
        self._gitcommand([b'update-index', b'-q', b'--refresh'])

    def _gitbranchmap(self):
        """returns 2 things:
        a map from git branch to revision
        a map from revision to branches"""
        branch2rev = {}
        rev2branch = {}

        out = self._gitcommand(
            [b'for-each-ref', b'--format', b'%(objectname) %(refname)']