# 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':

        return commitphase

    maxphase = phases.public

    maxsub = None

    for s in sorted(substate):

        sub = ctx.sub(s)

        subphase = sub.phase(substate[s][1])

        if maxphase < subphase:

            maxphase = subphase

            maxsub = s

    if commitphase < maxphase:

        if check == 'abort':

            raise util.Abort(_("can't commit in %s phase"

                               " conflicting %s from subrepository %s") %

                             (phases.phasenames[commitphase],

                              phases.phasenames[maxphase], maxsub))

        ui.warn(_("warning: changes are committed in"

                  " %s phase from subrepository %s\n") %

                (phases.phasenames[maxphase], maxsub))

        return maxphase

    return commitphase

# subrepo classes need to implement the following abstract class:

class abstractsubrepo(object):

    def __init__(self, ui):

        self.ui = ui

    def storeclean(self, path):

        """

        returns true if the repository has not changed since it was last

        cloned from or pushed to a given repository.

        """

        return False

    def dirty(self, ignoreupdate=False):

        """returns true if the dirstate of the subrepo is dirty or does not

        match current stored state. If ignoreupdate is true, only check

        whether the subrepo has uncommitted changes in its dirstate.

        """

        raise NotImplementedError

    def basestate(self):

        """current working directory base state, disregarding .hgsubstate

        state and working directory modifications"""

        raise NotImplementedError

    def checknested(self, path):

        """check if path is a subrepository within this repository"""

        return False

    def commit(self, text, user, date):

        """commit the current changes to the subrepo with the given

        log message. Use given user and date if possible. Return the

        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

        (should verify the dirstate is not dirty first)

        """

        raise NotImplementedError

    def get(self, state, overwrite=False):

        """run whatever commands are needed to put the subrepo into

        this state

        """

        raise NotImplementedError

    def merge(self, state):

        """merge currently-saved state with the new state."""

        raise NotImplementedError

    def push(self, opts):

        """perform whatever action is analogous to 'hg push'

        This may be a no-op on some systems.

        """

        raise NotImplementedError

    def add(self, ui, match, prefix, explicitonly, **opts):

        return []

    def addremove(self, matcher, prefix, opts, dry_run, similarity):

        self.ui.warn("%s: %s" % (prefix, _("addremove is not supported")))

        return 1

    def cat(self, match, prefix, **opts):

        return 1

    def status(self, rev2, **opts):

        return scmutil.status([], [], [], [], [], [], [])

    def diff(self, ui, diffopts, node2, match, prefix, **opts):

        pass

    def outgoing(self, ui, dest, opts):

        return 1

    def incoming(self, ui, source, opts):

        return 1

    def files(self):

        """return filename iterator"""

        raise NotImplementedError

    def filedata(self, name):

        """return file data"""

        raise NotImplementedError

    def fileflags(self, name):

        """return file flags"""

        return ''

    def archive(self, archiver, prefix, match=None):

        if match is not None:

            files = [f for f in self.files() if match(f)]

        else:

            files = self.files()

        total = len(files)

        relpath = subrelpath(self)