# subrepo.py - sub-repository handling for Mercurial

#

# Copyright 2009-2010 Matt Mackall <mpm@selenic.com>

#

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

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

import copy

import errno, os, re, shutil, posixpath, sys

import xml.dom.minidom

import stat, subprocess, tarfile

from i18n import _

import config, util, node, error, cmdutil, scmutil, match as matchmod

import phases

import pathutil

import exchange

hg = None

propertycache = util.propertycache

nullstate = ('', '', 'empty')

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

def _getstorehashcachename(remotepath):

    '''get a unique filename for the store hash cache of a remote repository'''

    return util.sha1(_expandedabspath(remotepath)).hexdigest()[0:12]

class SubrepoAbort(error.Abort):

    """Exception class used to avoid handling a subrepo error more than once"""

    def __init__(self, *args, **kw):

        error.Abort.__init__(self, *args, **kw)

        self.subrepo = kw.get('subrepo')

        self.cause = kw.get('cause')

def annotatesubrepoerror(func):

    def decoratedmethod(self, *args, **kargs):

        try:

            res = func(self, *args, **kargs)

        except SubrepoAbort, ex:

            # This exception has already been handled

            raise ex

        except error.Abort, ex:

            subrepo = subrelpath(self)

            errormsg = str(ex) + ' ' + _('(in subrepo %s)') % subrepo

            # avoid handling this exception by raising a SubrepoAbort exception

            raise SubrepoAbort(errormsg, hint=ex.hint, subrepo=subrepo,

                               cause=sys.exc_info())

        return res

    return decoratedmethod

def state(ctx, ui):

    """return a state dict, mapping subrepo paths configured in .hgsub

    to tuple: (source from .hgsub, revision from .hgsubstate, kind

    (key in types dict))

    """

    p = config.config()

    def read(f, sections=None, remap=None):

        if f in ctx:

            try:

                data = ctx[f].data()

            except IOError, err:

                if err.errno != errno.ENOENT:

                    raise

                # handle missing subrepo spec files as removed

                ui.warn(_("warning: subrepo spec file %s not found\n") % f)

                return

            p.parse(f, data, sections, remap, read)

        else:

            raise util.Abort(_("subrepo spec file %s not found") % f)

    if '.hgsub' in ctx:

        read('.hgsub')

    for path, src in ui.configitems('subpaths'):

        p.set('subpaths', path, src, ui.configsource('subpaths', path))

    rev = {}

    if '.hgsubstate' in ctx:

        try:

            for i, l in enumerate(ctx['.hgsubstate'].data().splitlines()):

                l = l.lstrip()

                if not l:

                    continue

                try:

                    revision, path = l.split(" ", 1)

                except ValueError:

                    raise util.Abort(_("invalid subrepository revision "

                                       "specifier in .hgsubstate line %d")

                                     % (i + 1))

                rev[path] = revision

        except IOError, err:

            if err.errno != errno.ENOENT:

                raise

    def remap(src):

        for pattern, repl in p.items('subpaths'):

            # Turn r'C:\foo\bar' into r'C:\\foo\\bar' since re.sub

            # does a string decode.

            repl = repl.encode('string-escape')

            # However, we still want to allow back references to go

            # through unharmed, so we turn r'\\1' into r'\1'. Again,

            # extra escapes are needed because re.sub string decodes.

            repl = re.sub(r'\\\\([0-9]+)', r'\\\1', repl)

            try:

                src = re.sub(pattern, repl, src, 1)

            except re.error, e:

                raise util.Abort(_("bad subrepository pattern in %s: %s")

                                 % (p.source('subpaths', pattern), e))

        return src

    state = {}

    for path, src in p[''].items():

        kind = 'hg'

        if src.startswith('['):

            if ']' not in src:

                raise util.Abort(_('missing ] in subrepo source'))

            kind, src = src.split(']', 1)

            kind = kind[1:]

            src = src.lstrip() # strip any extra whitespace after ']'

        if not util.url(src).isabs():

            parent = _abssource(ctx._repo, abort=False)

            if parent:

                parent = util.url(parent)

                parent.path = posixpath.join(parent.path or '', src)

                parent.path = posixpath.normpath(parent.path)

                joined = str(parent)

                # Remap the full joined path and use it if it changes,

                # else remap the original source.

                remapped = remap(joined)

                if remapped == joined:

                    src = remap(src)

                else:

                    src = remapped

        src = remap(src)

        state[util.pconvert(path)] = (src.strip(), rev.get(path, ''), kind)

    return state

def writestate(repo, state):

    """rewrite .hgsubstate in (outer) repo with these subrepo states"""

    lines = ['%s %s\n' % (state[s][1], s) for s in sorted(state)]

    repo.wwrite('.hgsubstate', ''.join(lines), '')

def submerge(repo, wctx, mctx, actx, overwrite):

    """delegated from merge.applyupdates: merging of .hgsubstate file

    in working context, merging context and ancestor context"""

    if mctx == actx: # backwards?

        actx = wctx.p1()

    s1 = wctx.substate

    s2 = mctx.substate

    sa = actx.substate

    sm = {}

    repo.ui.debug("subrepo merge %s %s %s\n" % (wctx, mctx, actx))

    def debug(s, msg, r=""):

        if r:

            r = "%s:%s:%s" % r

        repo.ui.debug("  subrepo %s: %s %s\n" % (s, msg, r))

    for s, l in sorted(s1.iteritems()):

        a = sa.get(s, nullstate)

        ld = l # local state with possible dirty flag for compares

        if wctx.sub(s).dirty():

            ld = (l[0], l[1] + "+")

        if wctx == actx: # overwrite

            a = ld

        if s in s2:

            r = s2[s]

            if ld == r or r == a: # no change or local is newer

                sm[s] = l

                continue

            elif ld == a: # other side changed

                debug(s, "other changed, get", r)

                wctx.sub(s).get(r, overwrite)

                sm[s] = r

            elif ld[0] != r[0]: # sources differ

                if repo.ui.promptchoice(

                    _(' subrepository sources for %s differ\n'

                      'use (l)ocal source (%s) or (r)emote source (%s)?'

                      '$$ &Local $$ &Remote') % (s, l[0], r[0]), 0):

                    debug(s, "prompt changed, get", r)

                    wctx.sub(s).get(r, overwrite)

                    sm[s] = r

            elif ld[1] == a[1]: # local side is unchanged

                debug(s, "other side changed, get", r)

                wctx.sub(s).get(r, overwrite)

                sm[s] = r

            else:

                debug(s, "both sides changed")

                srepo = wctx.sub(s)

                option = repo.ui.promptchoice(

                    _(' subrepository %s diverged (local revision: %s, '

                      'remote revision: %s)\n'

                      '(M)erge, keep (l)ocal or keep (r)emote?'

                      '$$ &Merge $$ &Local $$ &Remote')

                    % (s, srepo.shortid(l[1]), srepo.shortid(r[1])), 0)

                if option == 0:

                    wctx.sub(s).merge(r)

                    sm[s] = l

                    debug(s, "merge with", r)

                elif option == 1:

                    sm[s] = l

                    debug(s, "keep local subrepo revision", l)

                else:

                    wctx.sub(s).get(r, overwrite)

                    sm[s] = r

                    debug(s, "get remote subrepo revision", r)

        elif ld == a: # remote removed, local unchanged

            debug(s, "remote removed, remove")

            wctx.sub(s).remove()

        elif a == nullstate: # not present in remote or ancestor

            debug(s, "local added, keep")

            sm[s] = l

            continue

        else:

            if repo.ui.promptchoice(

                _(' local changed subrepository %s which remote removed\n'

                  'use (c)hanged version or (d)elete?'

                  '$$ &Changed $$ &Delete') % s, 0):

                debug(s, "prompt remove")

                wctx.sub(s).remove()

    for s, r in sorted(s2.items()):

        if s in s1:

            continue

        elif s not in sa:

            debug(s, "remote added, get", r)

            mctx.sub(s).get(r)

            sm[s] = r

        elif r != sa[s]:

            if repo.ui.promptchoice(

                _(' remote changed subrepository %s which local removed\n'

                  'use (c)hanged version or (d)elete?'

                  '$$ &Changed $$ &Delete') % s, 0) == 0:

                debug(s, "prompt recreate", r)

                mctx.sub(s).get(r)

                sm[s] = r

    # record merged .hgsubstate

    writestate(repo, sm)

    return sm

def _updateprompt(ui, sub, dirty, local, remote):

    if dirty:

        msg = (_(' subrepository sources for %s differ\n'

                 'use (l)ocal source (%s) or (r)emote source (%s)?'

                 '$$ &Local $$ &Remote')

               % (subrelpath(sub), local, remote))

    else:

        msg = (_(' subrepository sources for %s differ (in checked out '

                 'version)\n'

                 'use (l)ocal source (%s) or (r)emote source (%s)?'

                 '$$ &Local $$ &Remote')

               % (subrelpath(sub), local, remote))

    return ui.promptchoice(msg, 0)

def reporelpath(repo):

    """return path to this (sub)repo as seen from outermost repo"""

    parent = repo

    while util.safehasattr(parent, '_subparent'):

        parent = parent._subparent

    return repo.root[len(pathutil.normasprefix(parent.root)):]

def subrelpath(sub):

    """return path to this subrepo as seen from outermost repo"""

    if util.safehasattr(sub, '_relpath'):

        return sub._relpath

    if not util.safehasattr(sub, '_repo'):

        return sub._path

    return reporelpath(sub._repo)

def _abssource(repo, push=False, abort=True):

    """return pull/push path of repo - either based on parent repo .hgsub info

    or on the top repo config. Abort or return None if no source found."""

    if util.safehasattr(repo, '_subparent'):

        source = util.url(repo._subsource)

        if source.isabs():

            return str(source)

        source.path = posixpath.normpath(source.path)

        parent = _abssource(repo._subparent, push, abort=False)

        if parent:

            parent = util.url(util.pconvert(parent))

            parent.path = posixpath.join(parent.path or '', source.path)

            parent.path = posixpath.normpath(parent.path)

            return str(parent)

    else: # recursion reached top repo

        if util.safehasattr(repo, '_subtoppath'):

            return repo._subtoppath

        if push and repo.ui.config('paths', 'default-push'):

            return repo.ui.config('paths', 'default-push')

        if repo.ui.config('paths', 'default'):

            return repo.ui.config('paths', 'default')

        if repo.shared():

            # chop off the .hg component to get the default path form

            return os.path.dirname(repo.sharedpath)

    if abort:

        raise util.Abort(_("default path for subrepository not found"))

def _sanitize(ui, path, ignore):

    for dirname, dirs, names in os.walk(path):

        for i, d in enumerate(dirs):

            if d.lower() == ignore:

                del dirs[i]

                break

        if os.path.basename(dirname).lower() != '.hg':

            continue

        for f in names:

            if f.lower() == 'hgrc':

                ui.warn(_("warning: removing potentially hostile 'hgrc' "

                          "in '%s'\n") % dirname)

                os.unlink(os.path.join(dirname, f))

def subrepo(ctx, path):

    """return instance of the right subrepo class for subrepo in path"""

    # subrepo inherently violates our import layering rules

    # because it wants to make repo objects from deep inside the stack

    # so we manually delay the circular imports to not break

    # scripts that don't use our demand-loading

    global hg

    import hg as h

    hg = h

    pathutil.pathauditor(ctx._repo.root)(path)

    state = ctx.substate[path]

    if state[2] not in types:

        raise util.Abort(_('unknown subrepo type %s') % state[2])

    return types[state[2]](ctx, path, state[:2])

def newcommitphase(ui, ctx):

    commitphase = phases.newcommitphase(ui)

    substate = getattr(ctx, "substate", None)

    if not substate:

        return commitphase

    check = ui.config('phases', 'checksubrepos', 'follow')

    if check not in ('ignore', 'follow', 'abort'):

        raise util.Abort(_('invalid phases.checksubrepos configuration: %s')

                         % (check))

    if check == 'ignore':