subrepo: print pushing url

mercurial/subrepo.py

@@ -1,379 +1,380
 # subrepo.py - sub-repository handling for Mercurial
 #
 # Copyright 2009-2010 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import errno, os, re, xml.dom.minidom, shutil, urlparse, posixpath
 from i18n import _
 import config, util, node, error
 hg = None
 
 nullstate = ('', '', 'empty')
 
 def state(ctx):
     p = config.config()
     def read(f, sections=None, remap=None):
         if f in ctx:
             p.parse(f, ctx[f].data(), sections, remap, read)
         else:
             raise util.Abort(_("subrepo spec file %s not found") % f)
 
     if '.hgsub' in ctx:
         read('.hgsub')
 
     rev = {}
     if '.hgsubstate' in ctx:
         try:
             for l in ctx['.hgsubstate'].data().splitlines():
                 revision, path = l.split(" ", 1)
                 rev[path] = revision
         except IOError, err:
             if err.errno != errno.ENOENT:
                 raise
 
     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:]
         state[path] = (src.strip(), rev.get(path, ''), kind)
 
     return state
 
 def writestate(repo, state):
     repo.wwrite('.hgsubstate',
                 ''.join(['%s %s\n' % (state[s][1], s)
                          for s in sorted(state)]), '')
 
 def submerge(repo, wctx, mctx, actx):
     # working context, merging context, 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 s1.items():
         if wctx != actx and wctx.sub(s).dirty():
             l = (l[0], l[1] + "+")
         a = sa.get(s, nullstate)
         if s in s2:
             r = s2[s]
             if l == r or r == a: # no change or local is newer
                 sm[s] = l
                 continue
             elif l == a: # other side changed
                 debug(s, "other changed, get", r)
                 wctx.sub(s).get(r)
                 sm[s] = r
             elif l[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)?')
                       % (s, l[0], r[0]),
                       (_('&Local'), _('&Remote')), 0):
                     debug(s, "prompt changed, get", r)
                     wctx.sub(s).get(r)
                     sm[s] = r
             elif l[1] == a[1]: # local side is unchanged
                 debug(s, "other side changed, get", r)
                 wctx.sub(s).get(r)
                 sm[s] = r
             else:
                 debug(s, "both sides changed, merge with", r)
                 wctx.sub(s).merge(r)
                 sm[s] = l
         elif l == a: # remote removed, local unchanged
             debug(s, "remote removed, remove")
             wctx.sub(s).remove()
         else:
             if repo.ui.promptchoice(
                 _(' local changed subrepository %s which remote removed\n'
                   'use (c)hanged version or (d)elete?') % s,
                 (_('&Changed'), _('&Delete')), 0):
                 debug(s, "prompt remove")
                 wctx.sub(s).remove()
 
     for s, r in 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?') % s,
                 (_('&Changed'), _('&Delete')), 0) == 0:
                 debug(s, "prompt recreate", r)
                 wctx.sub(s).get(r)
                 sm[s] = r
 
     # record merged .hgsubstate
     writestate(repo, sm)
 
 def _abssource(repo, push=False):
     if hasattr(repo, '_subparent'):
         source = repo._subsource
         if source.startswith('/') or '://' in source:
             return source
         parent = _abssource(repo._subparent, push)
         if '://' in parent:
             if parent[-1] == '/':
                 parent = parent[:-1]
             r = urlparse.urlparse(parent + '/' + source)
             r = urlparse.urlunparse((r[0], r[1],
                                      posixpath.normpath(r.path),
                                      r[3], r[4], r[5]))
             return r
         return posixpath.normpath(os.path.join(parent, repo._subsource))
     if push and repo.ui.config('paths', 'default-push'):
         return repo.ui.config('paths', 'default-push', repo.root)
     return repo.ui.config('paths', 'default', repo.root)
 
 def subrepo(ctx, 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
 
     util.path_auditor(ctx._repo.root)(path)
     state = ctx.substate.get(path, nullstate)
     if state[2] not in types:
         raise util.Abort(_('unknown subrepo type %s') % state[2])
     return types[state[2]](ctx, path, state[:2])
 
 # subrepo classes need to implement the following methods:
 # __init__(self, ctx, path, state)
 # dirty(self): returns true if the dirstate of the subrepo
 #   does not match current stored state
 # 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.
 # remove(self): remove the subrepo (should verify the dirstate
 #   is not dirty first)
 # get(self, state): run whatever commands are needed to put the
 #   subrepo into this state
 # merge(self, state): merge currently-saved state with the new state.
 # push(self, force): perform whatever action is analagous to 'hg push'
 #   This may be a no-op on some systems.
 
 class hgsubrepo(object):
     def __init__(self, ctx, path, state):
         self._path = path
         self._state = state
         r = ctx._repo
         root = r.wjoin(path)
         create = False
         if not os.path.exists(os.path.join(root, '.hg')):
             create = True
             util.makedirs(root)
         self._repo = hg.repository(r.ui, root, create=create)
         self._repo._subparent = r
         self._repo._subsource = state[0]
 
         if create:
             fp = self._repo.opener("hgrc", "w", text=True)
             fp.write('[paths]\n')
 
             def addpathconfig(key, value):
                 fp.write('%s = %s\n' % (key, value))
                 self._repo.ui.setconfig('paths', key, value)
 
             defpath = _abssource(self._repo)
             defpushpath = _abssource(self._repo, True)
             addpathconfig('default', defpath)
             if defpath != defpushpath:
                 addpathconfig('default-push', defpushpath)
             fp.close()
 
     def dirty(self):
         r = self._state[1]
         if r == '':
             return True
         w = self._repo[None]
         if w.p1() != self._repo[r]: # version checked out change
             return True
         return w.dirty() # working directory changed
 
     def commit(self, text, user, date):
         self._repo.ui.debug("committing subrepo %s\n" % self._path)
         n = self._repo.commit(text, user, date)
         if not n:
             return self._repo['.'].hex() # different version checked out
         return node.hex(n)
 
     def remove(self):
         # we can't fully delete the repository as it may contain
         # local-only history
         self._repo.ui.note(_('removing subrepo %s\n') % self._path)
         hg.clean(self._repo, node.nullid, False)
 
     def _get(self, state):
         source, revision, kind = state
         try:
             self._repo.lookup(revision)
         except error.RepoError:
             self._repo._subsource = source
             srcurl = _abssource(self._repo)
             self._repo.ui.status(_('pulling subrepo %s from %s\n')
                                  % (self._path, srcurl))
             other = hg.repository(self._repo.ui, srcurl)
             self._repo.pull(other)
 
     def get(self, state):
         self._get(state)
         source, revision, kind = state
         self._repo.ui.debug("getting subrepo %s\n" % self._path)
         hg.clean(self._repo, revision, False)
 
     def merge(self, state):
         self._get(state)
         cur = self._repo['.']
         dst = self._repo[state[1]]
         anc = dst.ancestor(cur)
         if anc == cur:
             self._repo.ui.debug("updating subrepo %s\n" % self._path)
             hg.update(self._repo, state[1])
         elif anc == dst:
             self._repo.ui.debug("skipping subrepo %s\n" % self._path)
         else:
             self._repo.ui.debug("merging subrepo %s\n" % self._path)
             hg.merge(self._repo, state[1], remind=False)
 
     def push(self, force):
         # push subrepos depth-first for coherent ordering
         c = self._repo['']
         subs = c.substate # only repos that are committed
         for s in sorted(subs):
             if not c.sub(s).push(force):
                 return False
 
-        self._repo.ui.status(_('pushing subrepo %s\n') % self._path)
         dsturl = _abssource(self._repo, True)
+        self._repo.ui.status(_('pushing subrepo %s to %s\n') %
+            (self._path, dsturl))
         other = hg.repository(self._repo.ui, dsturl)
         return self._repo.push(other, force)
 
 class svnsubrepo(object):
     def __init__(self, ctx, path, state):
         self._path = path
         self._state = state
         self._ctx = ctx
         self._ui = ctx._repo.ui
 
     def _svncommand(self, commands):
         path = os.path.join(self._ctx._repo.origroot, self._path)
         cmd = ['svn'] + commands + [path]
         cmd = [util.shellquote(arg) for arg in cmd]
         cmd = util.quotecommand(' '.join(cmd))
         env = dict(os.environ)
         # Avoid localized output, preserve current locale for everything else.
         env['LC_MESSAGES'] = 'C'
         write, read, err = util.popen3(cmd, env=env, newlines=True)
         retdata = read.read()
         err = err.read().strip()
         if err:
             raise util.Abort(err)
         return retdata
 
     def _wcrev(self):
         output = self._svncommand(['info', '--xml'])
         doc = xml.dom.minidom.parseString(output)
         entries = doc.getElementsByTagName('entry')
         if not entries:
             return 0
         return int(entries[0].getAttribute('revision') or 0)
 
     def _wcchanged(self):
         """Return (changes, extchanges) where changes is True
         if the working directory was changed, and extchanges is
         True if any of these changes concern an external entry.
         """
         output = self._svncommand(['status', '--xml'])
         externals, changes = [], []
         doc = xml.dom.minidom.parseString(output)
         for e in doc.getElementsByTagName('entry'):
             s = e.getElementsByTagName('wc-status')
             if not s:
                 continue
             item = s[0].getAttribute('item')
             props = s[0].getAttribute('props')
             path = e.getAttribute('path')
             if item == 'external':
                 externals.append(path)
             if (item not in ('', 'normal', 'unversioned', 'external')
                 or props not in ('', 'none')):
                 changes.append(path)
         for path in changes:
             for ext in externals:
                 if path == ext or path.startswith(ext + os.sep):
                     return True, True
         return bool(changes), False
 
     def dirty(self):
         if self._wcrev() == self._state[1] and not self._wcchanged()[0]:
             return False
         return True
 
     def commit(self, text, user, date):
         # user and date are out of our hands since svn is centralized
         changed, extchanged = self._wcchanged()
         if not changed:
             return self._wcrev()
         if extchanged:
             # Do not try to commit externals
             raise util.Abort(_('cannot commit svn externals'))
         commitinfo = self._svncommand(['commit', '-m', text])
         self._ui.status(commitinfo)
         newrev = re.search('Committed revision ([\d]+).', commitinfo)
         if not newrev:
             raise util.Abort(commitinfo.splitlines()[-1])
         newrev = newrev.groups()[0]
         self._ui.status(self._svncommand(['update', '-r', newrev]))
         return newrev
 
     def remove(self):
         if self.dirty():
             self._ui.warn(_('not removing repo %s because '
                             'it has changes.\n' % self._path))
             return
         self._ui.note(_('removing subrepo %s\n') % self._path)
         shutil.rmtree(self._ctx.repo.join(self._path))
 
     def get(self, state):
         status = self._svncommand(['checkout', state[0], '--revision', state[1]])
         if not re.search('Checked out revision [\d]+.', status):
             raise util.Abort(status.splitlines()[-1])
         self._ui.status(status)
 
     def merge(self, state):
         old = int(self._state[1])
         new = int(state[1])
         if new > old:
             self.get(state)
 
     def push(self, force):
         # nothing for svn
         pass
 
 types = {
     'hg': hgsubrepo,
     'svn': svnsubrepo,
     }

tests/test-subrepo.out

@@ -1,295 +1,295
 % first revision, no sub
 adding a
 % add first sub
 adding a
 parent: 0:f7b1eb17ad24 tip
  0
 branch: default
 commit: 1 added, 1 subrepos
 update: (current)
 committing subrepository s
 % add sub sub
 parent: 1:7cf8cfea66e4 tip
  1
 branch: default
 commit: 1 subrepos
 update: (current)
 committing subrepository s
 committing subrepository ss
 parent: 2:df30734270ae tip
  2
 branch: default
 commit: (clean)
 update: (current)
 % bump sub rev
 committing subrepository s
 % leave sub dirty
 committing subrepository s
 changeset:   3:1c833a7a9e3a
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     4
 
 % check caching
 0 files updated, 0 files merged, 2 files removed, 0 files unresolved
 % restore
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 path s
  source   s
  revision 1c833a7a9e3a4445c711aaf0f012379cd0d4034e
 % new branch for merge tests
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 adding t/t
 % 5
 committing subrepository t
 created new head
 % 6
 committing subrepository t
 path s
  source   s
  revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 path t
  source   t
  revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
 % 7
 committing subrepository t
 % 8
 % merge tests
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 path s
  source   s
  revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
 path t
  source   t
  revision 60ca1237c19474e7a3978b0dc1ca4e6f36d51382
 created new head
   searching for copies back to rev 2
 resolving manifests
  overwrite None partial False
  ancestor 1f14a2e2d3ec local f0d2028bf86d+ remote 1831e14459c4
  .hgsubstate: versions differ -> m
 update: .hgsubstate 1/1 files (100.00%)
 subrepo merge f0d2028bf86d+ 1831e14459c4 1f14a2e2d3ec
   subrepo t: other changed, get t:6747d179aa9a688023c4b0cad32e4c92bb7f34ad:hg
 getting subrepo t
 resolving manifests
  overwrite True partial False
  ancestor 60ca1237c194+ local 60ca1237c194+ remote 6747d179aa9a
  t: remote is newer -> g
 update: t 1/1 files (100.00%)
 getting t
 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 path s
  source   s
  revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
 path t
  source   t
  revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
 committing subrepository t
   searching for copies back to rev 2
 resolving manifests
  overwrite None partial False
  ancestor 1831e14459c4 local e45c8b14af55+ remote f94576341bcf
  .hgsubstate: versions differ -> m
 update: .hgsubstate 1/1 files (100.00%)
 subrepo merge e45c8b14af55+ f94576341bcf 1831e14459c4
   subrepo t: both sides changed, merge with t:7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4:hg
 merging subrepo t
   searching for copies back to rev 2
 resolving manifests
  overwrite None partial False
  ancestor 6747d179aa9a local 20a0db6fbf6c+ remote 7af322bc1198
  t: versions differ -> m
 preserving t for resolve of t
 update: t 1/1 files (100.00%)
 picked tool 'internal:merge' for t (binary False symlink False)
 merging t
 my t@20a0db6fbf6c+ other t@7af322bc1198 ancestor t@6747d179aa9a
 warning: conflicts during merge.
 merging t failed!
 0 files updated, 0 files merged, 0 files removed, 1 files unresolved
 use 'hg resolve' to retry unresolved file merges or 'hg update -C' to abandon
 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 % should conflict
 <<<<<<< local
 conflict
 =======
 t3
 >>>>>>> other
 % clone
 updating to branch default
 pulling subrepo s from .../sub/t/s
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 4 changesets with 5 changes to 3 files
 pulling subrepo ss from .../sub/t/s/ss
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 pulling subrepo t from .../sub/t/t
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 4 changesets with 4 changes to 1 files (+1 heads)
 3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 path s
  source   s
  revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
 path t
  source   t
  revision 20a0db6fbf6c3d2836e6519a642ae929bfc67c0e
 % push
 committing subrepository t
 pushing ...sub/t
-pushing ...subrepo ss
+pushing ...sub/t/s/ss
 searching for changes
 no changes found
-pushing ...subrepo s
+pushing ...sub/t/s
 searching for changes
 no changes found
-pushing ...subrepo t
+pushing ...sub/t/t
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 % push -f
 committing subrepository s
 abort: push creates new remote heads on branch 'default'!
 pushing ...sub/t
-pushing ...subrepo ss
+pushing ...sub/t/s/ss
 searching for changes
 no changes found
-pushing ...subrepo s
+pushing ...sub/t/s
 searching for changes
 (did you forget to merge? use push -f to force)
 pushing ...sub/t
-pushing ...subrepo ss
+pushing ...sub/t/s/ss
 searching for changes
 no changes found
-pushing ...subrepo s
+pushing ...sub/t/s
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files (+1 heads)
-pushing ...subrepo t
+pushing ...sub/t/t
 searching for changes
 no changes found
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 % update
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 committing subrepository t
 % pull
 pulling ...sub/t
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 (run 'hg update' to get a working copy)
 pulling subrepo t from .../sub/t/t
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 blah
 % bogus subrepo path aborts
 abort: missing ] in subrepo source
 % issue 1986
 adding a
 marked working directory as branch br
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 adding b
 created new head
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 adding c
 created new head
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding .hgsub
 committing subrepository s
 marked working directory as branch br
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 adding b
 committing subrepository s
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 adding c
 created new head
 2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 adding d
 committing subrepository s
 created new head
 2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 adding e
 committing subrepository s
 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 % test subrepo delete from .hgsubstate
 adding testdelete/nested/foo
 adding testdelete/nested2/foo
 adding testdelete/.hgsub
 committing subrepository nested2
 committing subrepository nested
 nested
 % test repository cloning
 adding nested_absolute/foo
 adding nested_relative/foo2
 adding main/.hgsub
 committing subrepository nested_relative
 committing subrepository nested_absolute
 updating to branch default
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 [paths]
 default = $HGTMP/test-subrepo/sub/mercurial/nested_absolute
 [paths]
 default = $HGTMP/test-subrepo/sub/mercurial/nested_relative
 % issue 1977
 adding a
 adding .hgsub
 committing subrepository s
 updating to branch default
 pulling subrepo s from .../sub/repo/s
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
 committing subrepository s
 abort: push creates new remote heads on branch 'default'!
 0 files updated, 0 files merged, 0 files removed, 0 files unresolved