# subrepoutil.py - sub-repository operations and substate handling
#
# 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.
from __future__ import absolute_import
import errno
import os
import posixpath
import re
from .i18n import _
from .pycompat import getattr
from . import (
config,
error,
filemerge,
pathutil,
phases,
pycompat,
util,
)
from .utils import stringutil
nullstate = (b'', b'', b'empty')
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()
repo = ctx.repo()
def read(f, sections=None, remap=None):
if f in ctx:
try:
data = ctx[f].data()
except IOError as err:
if err.errno != errno.ENOENT:
raise
# handle missing subrepo spec files as removed
ui.warn(
_(b"warning: subrepo spec file \'%s\' not found\n")
% repo.pathto(f)
)
return
p.parse(f, data, sections, remap, read)
else:
raise error.Abort(
_(b"subrepo spec file \'%s\' not found") % repo.pathto(f)
)
if b'.hgsub' in ctx:
read(b'.hgsub')
for path, src in ui.configitems(b'subpaths'):
p.set(b'subpaths', path, src, ui.configsource(b'subpaths', path))
rev = {}
if b'.hgsubstate' in ctx:
try:
for i, l in enumerate(ctx[b'.hgsubstate'].data().splitlines()):
l = l.lstrip()
if not l:
continue
try:
revision, path = l.split(b" ", 1)
except ValueError:
raise error.Abort(
_(
b"invalid subrepository revision "
b"specifier in \'%s\' line %d"
)
% (repo.pathto(b'.hgsubstate'), (i + 1))
)
rev[path] = revision
except IOError as err:
if err.errno != errno.ENOENT:
raise
def remap(src):
for pattern, repl in p.items(b'subpaths'):
# Turn r'C:\foo\bar' into r'C:\\foo\\bar' since re.sub
# does a string decode.
repl = stringutil.escapestr(repl)
# 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(br'\\\\([0-9]+)', br'\\\1', repl)
try:
src = re.sub(pattern, repl, src, 1)
except re.error as e:
raise error.Abort(
_(b"bad subrepository pattern in %s: %s")
% (
p.source(b'subpaths', pattern),
stringutil.forcebytestr(e),
)
)
return src
state = {}
for path, src in p[b''].items():
kind = b'hg'
if src.startswith(b'['):
if b']' not in src:
raise error.Abort(_(b'missing ] in subrepository source'))
kind, src = src.split(b']', 1)
kind = kind[1:]
src = src.lstrip() # strip any extra whitespace after ']'
if not util.url(src).isabs():
parent = _abssource(repo, abort=False)
if parent:
parent = util.url(parent)
parent.path = posixpath.join(parent.path or b'', src)
parent.path = posixpath.normpath(parent.path)
joined = bytes(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, b''), kind)
return state
def writestate(repo, state):
"""rewrite .hgsubstate in (outer) repo with these subrepo states"""
lines = [
b'%s %s\n' % (state[s][1], s)
for s in sorted(state)
if state[s][1] != nullstate[1]
]
repo.wwrite(b'.hgsubstate', b''.join(lines), b'')
def submerge(repo, wctx, mctx, actx, overwrite, labels=None):
"""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(b"subrepo merge %s %s %s\n" % (wctx, mctx, actx))
def debug(s, msg, r=b""):
if r:
r = b"%s:%s:%s" % r
repo.ui.debug(b" subrepo %s: %s %s\n" % (s, msg, r))
promptssrc = filemerge.partextras(labels)
for s, l in sorted(pycompat.iteritems(s1)):
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] + b"+")
if wctx == actx: # overwrite
a = ld
prompts = promptssrc.copy()
prompts[b's'] = s
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, b"other changed, get", r)
wctx.sub(s).get(r, overwrite)
sm[s] = r
elif ld[0] != r[0]: # sources differ
prompts[b'lo'] = l[0]
prompts[b'ro'] = r[0]
if repo.ui.promptchoice(
_(
b' subrepository sources for %(s)s differ\n'
b'you can use (l)ocal%(l)s source (%(lo)s)'
b' or (r)emote%(o)s source (%(ro)s).\n'
b'what do you want to do?'
b'$$ &Local $$ &Remote'
)
% prompts,
0,
):
debug(s, b"prompt changed, get", r)
wctx.sub(s).get(r, overwrite)
sm[s] = r
elif ld[1] == a[1]: # local side is unchanged
debug(s, b"other side changed, get", r)
wctx.sub(s).get(r, overwrite)
sm[s] = r
else:
debug(s, b"both sides changed")
srepo = wctx.sub(s)
prompts[b'sl'] = srepo.shortid(l[1])
prompts[b'sr'] = srepo.shortid(r[1])
option = repo.ui.promptchoice(
_(
b' subrepository %(s)s diverged (local revision: %(sl)s, '
b'remote revision: %(sr)s)\n'
b'you can (m)erge, keep (l)ocal%(l)s or keep '
b'(r)emote%(o)s.\n'
b'what do you want to do?'
b'$$ &Merge $$ &Local $$ &Remote'
)
% prompts,
0,
)
if option == 0:
wctx.sub(s).merge(r)
sm[s] = l
debug(s, b"merge with", r)
elif option == 1:
sm[s] = l
debug(s, b"keep local subrepo revision", l)
else:
wctx.sub(s).get(r, overwrite)
sm[s] = r
debug(s, b"get remote subrepo revision", r)
elif ld == a: # remote removed, local unchanged
debug(s, b"remote removed, remove")
wctx.sub(s).remove()
elif a == nullstate: # not present in remote or ancestor
debug(s, b"local added, keep")
sm[s] = l
continue
else:
if repo.ui.promptchoice(
_(
b' local%(l)s changed subrepository %(s)s'
b' which remote%(o)s removed\n'
b'use (c)hanged version or (d)elete?'
b'$$ &Changed $$ &Delete'
)
% prompts,
0,
):
debug(s, b"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, b"remote added, get", r)
mctx.sub(s).get(r)
sm[s] = r
elif r != sa[s]:
prompts = promptssrc.copy()
prompts[b's'] = s
if (
repo.ui.promptchoice(
_(
b' remote%(o)s changed subrepository %(s)s'
b' which local%(l)s removed\n'
b'use (c)hanged version or (d)elete?'
b'$$ &Changed $$ &Delete'
)
% prompts,
0,
)
== 0
):
debug(s, b"prompt recreate", r)
mctx.sub(s).get(r)
sm[s] = r
# record merged .hgsubstate
writestate(repo, sm)
return sm
def precommit(ui, wctx, status, match, force=False):
"""Calculate .hgsubstate changes that should be applied before committing
Returns (subs, commitsubs, newstate) where
- subs: changed subrepos (including dirty ones)
- commitsubs: dirty subrepos which the caller needs to commit recursively
- newstate: new state dict which the caller must write to .hgsubstate
This also updates the given status argument.
"""
subs = []
commitsubs = set()
newstate = wctx.substate.copy()
# only manage subrepos and .hgsubstate if .hgsub is present
if b'.hgsub' in wctx:
# we'll decide whether to track this ourselves, thanks
for c in status.modified, status.added, status.removed:
if b'.hgsubstate' in c:
c.remove(b'.hgsubstate')
# compare current state to last committed state
# build new substate based on last committed state
oldstate = wctx.p1().substate
for s in sorted(newstate.keys()):
if not match(s):
# ignore working copy, use old state if present
if s in oldstate:
newstate[s] = oldstate[s]
continue
if not force:
raise error.Abort(
_(b"commit with new subrepo %s excluded") % s
)
dirtyreason = wctx.sub(s).dirtyreason(True)
if dirtyreason:
if not ui.configbool(b'ui', b'commitsubrepos'):
raise error.Abort(
dirtyreason,
hint=_(b"use --subrepos for recursive commit"),
)
subs.append(s)
commitsubs.add(s)
else:
bs = wctx.sub(s).basestate()
newstate[s] = (newstate[s][0], bs, newstate[s][2])
if oldstate.get(s, (None, None, None))[1] != bs:
subs.append(s)
# check for removed subrepos
for p in wctx.parents():
r = [s for s in p.substate if s not in newstate]
subs += [s for s in r if match(s)]
if subs:
if not match(b'.hgsub') and b'.hgsub' in (
wctx.modified() + wctx.added()
):
raise error.Abort(_(b"can't commit subrepos without .hgsub"))
status.modified.insert(0, b'.hgsubstate')
elif b'.hgsub' in status.removed:
# clean up .hgsubstate when .hgsub is removed
if b'.hgsubstate' in wctx and b'.hgsubstate' not in (
status.modified + status.added + status.removed
):
status.removed.insert(0, b'.hgsubstate')
return subs, commitsubs, newstate
def reporelpath(repo):
"""return path to this (sub)repo as seen from outermost repo"""
parent = repo
while util.safehasattr(parent, b'_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"""
return sub._relpath
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, b'_subparent'):
source = util.url(repo._subsource)
if source.isabs():
return bytes(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 b'', source.path)
parent.path = posixpath.normpath(parent.path)
return bytes(parent)
else: # recursion reached top repo
path = None
if util.safehasattr(repo, b'_subtoppath'):
path = repo._subtoppath
elif push and repo.ui.config(b'paths', b'default-push'):
path = repo.ui.config(b'paths', b'default-push')
elif repo.ui.config(b'paths', b'default'):
path = repo.ui.config(b'paths', b'default')
elif repo.shared():
# chop off the .hg component to get the default path form. This has
# already run through vfsmod.vfs(..., realpath=True), so it doesn't
# have problems with 'C:'
return os.path.dirname(repo.sharedpath)
if path:
# issue5770: 'C:\' and 'C:' are not equivalent paths. The former is
# as expected: an absolute path to the root of the C: drive. The
# latter is a relative path, and works like so:
#
# C:\>cd C:\some\path
# C:\>D:
# D:\>python -c "import os; print os.path.abspath('C:')"
# C:\some\path
#
# D:\>python -c "import os; print os.path.abspath('C:relative')"
# C:\some\path\relative
if util.hasdriveletter(path):
if len(path) == 2 or path[2:3] not in br'\/':
path = os.path.abspath(path)
return path
if abort:
raise error.Abort(_(b"default path for subrepository not found"))
def newcommitphase(ui, ctx):
commitphase = phases.newcommitphase(ui)
substate = getattr(ctx, "substate", None)
if not substate:
return commitphase
check = ui.config(b'phases', b'checksubrepos')
if check not in (b'ignore', b'follow', b'abort'):
raise error.Abort(
_(b'invalid phases.checksubrepos configuration: %s') % check
)
if check == b'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 == b'abort':
raise error.Abort(
_(
b"can't commit in %s phase"
b" conflicting %s from subrepository %s"
)
% (
phases.phasenames[commitphase],
phases.phasenames[maxphase],
maxsub,
)
)
ui.warn(
_(
b"warning: changes are committed in"
b" %s phase from subrepository %s\n"
)
% (phases.phasenames[maxphase], maxsub)
)
return maxphase
return commitphase