# hg.py - repository classes for mercurial

#

# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from i18n import _

from lock import release

from node import hex, nullid

import cmdutil, discovery

import merge as mergemod

import verify as verifymod

import errno, os, shutil

def _local(path):

    path = util.expandpath(util.urllocalpath(path))

    return (os.path.isfile(path) and bundlerepo or localrepo)

def addbranchrevs(lrepo, other, branches, revs):

    peer = other.peer() # a courtesy to callers using a localrepo for other

    hashbranch, branches = branches

    if not hashbranch and not branches:

        return revs or None, revs and revs[0] or None

    revs = revs and list(revs) or []

    if not peer.capable('branchmap'):

        if branches:

            raise util.Abort(_("remote branch lookup not supported"))

        revs.append(hashbranch)

        return revs, revs[0]

    branchmap = peer.branchmap()

    def primary(branch):

        if branch == '.':

            if not lrepo:

                raise util.Abort(_("dirstate branch not accessible"))

            branch = lrepo.dirstate.branch()

        if branch in branchmap:

            revs.extend(node.hex(r) for r in reversed(branchmap[branch]))

            return True

        else:

            return False

    for branch in branches:

        if not primary(branch):

            raise error.RepoLookupError(_("unknown branch '%s'") % branch)

    if hashbranch:

        if not primary(hashbranch):

            revs.append(hashbranch)

    return revs, revs[0]

def parseurl(path, branches=None):

    '''parse url#branch, returning (url, (branch, branches))'''

    u = util.url(path)

    branch = None

    if u.fragment:

        branch = u.fragment

        u.fragment = None

    return str(u), (branch, branches or [])

schemes = {

    'bundle': bundlerepo,

    'file': _local,

    'http': httppeer,

    'https': httppeer,

    'ssh': sshpeer,

    'static-http': statichttprepo,

}

def _peerlookup(path):

    u = util.url(path)

    scheme = u.scheme or 'file'

    thing = schemes.get(scheme) or schemes['file']

    try:

        return thing(path)

    except TypeError:

        return thing

def islocal(repo):

    '''return true if repo or path is local'''

    if isinstance(repo, str):

        try:

            return _peerlookup(repo).islocal(repo)

        except AttributeError:

            return False

    return repo.local()

def openpath(ui, path):

    '''open path with open if local, url.open if remote'''

    if islocal(path):

        return util.posixfile(util.urllocalpath(path), 'rb')

    else:

        return url.open(ui, path)

def _peerorrepo(ui, path, create=False):

    """return a repository object for the specified path"""

    obj = _peerlookup(path).instance(ui, path, create)

    ui = getattr(obj, "ui", ui)

    for name, module in extensions.extensions():

        hook = getattr(module, 'reposetup', None)

        if hook:

            hook(ui, obj)

    return obj

def repository(ui, path='', create=False):

    """return a repository object for the specified path"""

    peer = _peerorrepo(ui, path, create)

    repo = peer.local()

    if not repo:

        raise util.Abort(_("repository '%s' is not local") %

                         (path or peer.url()))

    return repo.filtered('visible')

def peer(uiorrepo, opts, path, create=False):

    '''return a repository peer for the specified path'''

    rui = remoteui(uiorrepo, opts)

    return _peerorrepo(rui, path, create).peer()

def defaultdest(source):

    '''return default destination of clone if none is given'''

    return os.path.basename(os.path.normpath(util.url(source).path or ''))

def share(ui, source, dest=None, update=True):

    '''create a shared repository'''

    if not islocal(source):

        raise util.Abort(_('can only share local repositories'))

    if not dest:

        dest = defaultdest(source)

    else:

        dest = ui.expandpath(dest)

    if isinstance(source, str):

        origsource = ui.expandpath(source)

        source, branches = parseurl(origsource)

        srcrepo = repository(ui, source)

        rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None)

    else:

        srcrepo = source.local()

        origsource = source = srcrepo.url()

        checkout = None

    sharedpath = srcrepo.sharedpath # if our source is already sharing

    root = os.path.realpath(dest)

    roothg = os.path.join(root, '.hg')

    if os.path.exists(roothg):

        raise util.Abort(_('destination already exists'))

    if not os.path.isdir(root):

        os.mkdir(root)

    util.makedir(roothg, notindexed=True)

    requirements = ''

    try:

        requirements = srcrepo.opener.read('requires')

    except IOError, inst:

        if inst.errno != errno.ENOENT:

            raise

    requirements += 'shared\n'

    util.writefile(os.path.join(roothg, 'requires'), requirements)

    util.writefile(os.path.join(roothg, 'sharedpath'), sharedpath)

    r = repository(ui, root)

    default = srcrepo.ui.config('paths', 'default')

    if default:

        fp = r.opener("hgrc", "w", text=True)

        fp.write("[paths]\n")

        fp.write("default = %s\n" % default)

        fp.close()

    if update:

        r.ui.status(_("updating working directory\n"))

        if update is not True:

            checkout = update

        for test in (checkout, 'default', 'tip'):

            if test is None:

                continue

            try:

                uprev = r.lookup(test)

                break

            except error.RepoLookupError:

                continue

        _update(r, uprev)

def copystore(ui, srcrepo, destpath):

    '''copy files from store of srcrepo in destpath

    returns destlock

    '''

    destlock = None

    try:

        hardlink = None

        num = 0

        srcpublishing = srcrepo.ui.configbool('phases', 'publish', True)

        for f in srcrepo.store.copylist():

            if srcpublishing and f.endswith('phaseroots'):

                continue

            src = os.path.join(srcrepo.sharedpath, f)

            dst = os.path.join(destpath, f)

            dstbase = os.path.dirname(dst)

            if dstbase and not os.path.exists(dstbase):

                os.mkdir(dstbase)

            if os.path.exists(src):

                if dst.endswith('data'):

                    # lock to avoid premature writing to the target

                    destlock = lock.lock(os.path.join(dstbase, "lock"))

                hardlink, n = util.copyfiles(src, dst, hardlink)

                num += n

        if hardlink:

            ui.debug("linked %d files\n" % num)

        else:

            ui.debug("copied %d files\n" % num)

        return destlock

    except: # re-raises

        release(destlock)

        raise

def clone(ui, peeropts, source, dest=None, pull=False, rev=None,

          update=True, stream=False, branch=None):

    """Make a copy of an existing repository.

    Create a copy of an existing repository in a new directory.  The

    source and destination are URLs, as passed to the repository

    function.  Returns a pair of repository peers, the source and

    newly created destination.

    The location of the source is added to the new repository's

    .hg/hgrc file, as the default to be used for future pulls and

    pushes.

    If an exception is raised, the partly cloned/updated destination

    repository will be deleted.

    Arguments:

    source: repository object or URL

    dest: URL of destination repository to create (defaults to base

    name of source repository)

    pull: always pull from source repository, even in local case

    stream: stream raw data uncompressed from repository (fast over

    LAN, slow over WAN)

    rev: revision to clone up to (implies pull=True)

    update: update working directory after clone completes, if

    destination is local repository (True means update to default rev,

    anything else is treated as a revision)

    branch: branches to clone

    """

    if isinstance(source, str):

        origsource = ui.expandpath(source)

        source, branch = parseurl(origsource, branch)

        srcpeer = peer(ui, peeropts, source)

    else:

        srcpeer = source.peer() # in case we were called with a localrepo

        branch = (None, branch or [])

        origsource = source = srcpeer.url()

    rev, checkout = addbranchrevs(srcpeer, srcpeer, branch, rev)

    if dest is None:

        dest = defaultdest(source)

        ui.status(_("destination directory: %s\n") % dest)

    else:

        dest = ui.expandpath(dest)

    dest = util.urllocalpath(dest)

    source = util.urllocalpath(source)

    if not dest:

        raise util.Abort(_("empty destination path is not valid"))

    if os.path.exists(dest):

        if not os.path.isdir(dest):

            raise util.Abort(_("destination '%s' already exists") % dest)

        elif os.listdir(dest):

            raise util.Abort(_("destination '%s' is not empty") % dest)

    srclock = destlock = cleandir = None

    srcrepo = srcpeer.local()

    try:

        abspath = origsource

        if islocal(origsource):

            abspath = os.path.abspath(util.urllocalpath(origsource))

        if islocal(dest):

            cleandir = dest

        copy = False

        if (srcrepo and srcrepo.cancopy() and islocal(dest)

            and not phases.hassecret(srcrepo)):

            copy = not pull and not rev

        if copy:

            try:

                # we use a lock here because if we race with commit, we

                # can end up with extra data in the cloned revlogs that's

                # not pointed to by changesets, thus causing verify to

                # fail

                srclock = srcrepo.lock(wait=False)

            except error.LockError:

                copy = False

        if copy:

            srcrepo.hook('preoutgoing', throw=True, source='clone')

            hgdir = os.path.realpath(os.path.join(dest, ".hg"))

            if not os.path.exists(dest):

                os.mkdir(dest)

            else:

                # only clean up directories we create ourselves

                cleandir = hgdir

            try:

                destpath = hgdir

                util.makedir(destpath, notindexed=True)

            except OSError, inst:

                if inst.errno == errno.EEXIST:

                    cleandir = None

                    raise util.Abort(_("destination '%s' already exists")

                                     % dest)

                raise

            destlock = copystore(ui, srcrepo, destpath)

            # Recomputing branch cache might be slow on big repos,

            # so just copy it

            dstcachedir = os.path.join(destpath, 'cache')

            srcbranchcache = srcrepo.sjoin('cache/branchheads')

            dstbranchcache = os.path.join(dstcachedir, 'branchheads')

            if os.path.exists(srcbranchcache):

                if not os.path.exists(dstcachedir):

                    os.mkdir(dstcachedir)

                util.copyfile(srcbranchcache, dstbranchcache)

            # we need to re-init the repo after manually copying the data

            # into it

            destpeer = peer(srcrepo, peeropts, dest)

            srcrepo.hook('outgoing', source='clone',

                          node=node.hex(node.nullid))

        else:

            try:

                destpeer = peer(srcrepo or ui, peeropts, dest, create=True)

                                # only pass ui when no srcrepo

            except OSError, inst:

                if inst.errno == errno.EEXIST:

                    cleandir = None

                    raise util.Abort(_("destination '%s' already exists")

                                     % dest)

                raise

            revs = None

            if rev:

                if not srcpeer.capable('lookup'):