mercurial-scm/hg-stable: mercurial/subrepo.py comparison

comparison mercurial/subrepo.py @ 24803:e89f909edffa stable 3.4-rc

merge default into stable for 3.4 freeze

author	Matt Mackall <mpm@selenic.com>
date	Thu, 16 Apr 2015 20:57:51 -0500
parents	56e15db9109f
children	a99931201d1b

comparison

equal deleted inserted replaced

-:612ed41ae359
+:e89f909edffa
 #
 # 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 errno, os, re, 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
 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)
+ui.warn(_("warning: subrepo spec file \'%s\' not found\n") %
+util.pathto(ctx.repo().root, ctx.repo().getcwd(), f))
 return
 p.parse(f, data, sections, remap, read)
 else:
-raise util.Abort(_("subrepo spec file %s not found") % f)
+repo = ctx.repo()
+raise util.Abort(_("subrepo spec file \'%s\' not found") %
+util.pathto(repo.root, repo.getcwd(), f))
 if '.hgsub' in ctx:
 read('.hgsub')
 for path, src in ui.configitems('subpaths'):
 if not l:
 continue
 try:
 revision, path = l.split(" ", 1)
 except ValueError:
+repo = ctx.repo()
 raise util.Abort(_("invalid subrepository revision "
-"specifier in .hgsubstate line %d")
+"specifier in \'%s\' line %d")
-% (i + 1))
+% (util.pathto(repo.root, repo.getcwd(),
+'.hgsubstate'), (i + 1)))
 rev[path] = revision
 except IOError, err:
 if err.errno != errno.ENOENT:
 raise
 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)
+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)
 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
-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'):
 # 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):
+def _sanitize(ui, vfs, ignore):
-for dirname, dirs, names in os.walk(path):
+for dirname, dirs, names in vfs.walk():
 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)
+"in '%s'\n") % vfs.join(dirname))
-os.unlink(os.path.join(dirname, f))
+vfs.unlink(vfs.reljoin(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
 # scripts that don't use our demand-loading
 global hg
 import hg as h
 hg = h
-pathutil.pathauditor(ctx._repo.root)(path)
+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])
 # subrepo classes need to implement the following abstract class:
 class abstractsubrepo(object):
-def __init__(self, ui):
+def __init__(self, ctx, path):
-self.ui = ui
+"""Initialize abstractsubrepo part
+``ctx`` is the context referring this subrepository in the
+parent repository.
+``path`` is the path to this subrepositiry as seen from
+innermost repository.
+"""
+self.ui = ctx.repo().ui
+self._ctx = ctx
+self._path = path
 def storeclean(self, path):
 """
 returns true if the repository has not changed since it was last
 cloned from or pushed to a given repository.
 match current stored state. If ignoreupdate is true, only check
 whether the subrepo has uncommitted changes in its dirstate.
 """
 raise NotImplementedError
+def dirtyreason(self, ignoreupdate=False):
+"""return reason string if it is ``dirty()``
+Returned string should have enough information for the message
+of exception.
+This returns None, otherwise.
+"""
+if self.dirty(ignoreupdate=ignoreupdate):
+return _("uncommitted changes in subrepository '%s'"
+) % subrelpath(self)
+def bailifchanged(self, ignoreupdate=False):
+"""raise Abort if subrepository is ``dirty()``
+"""
+dirtyreason = self.dirtyreason(ignoreupdate=ignoreupdate)
+if dirtyreason:
+raise util.Abort(dirtyreason)
 def basestate(self):
 """current working directory base state, disregarding .hgsubstate
 state and working directory modifications"""
 raise NotImplementedError
 raise NotImplementedError
 def fileflags(self, name):
 """return file flags"""
 return ''
+def printfiles(self, ui, m, fm, fmt):
+"""handle the files command for this subrepo"""
+return 1
 def archive(self, archiver, prefix, match=None):
 if match is not None:
 files = [f for f in self.files() if match(f)]
 else:
 unit=_('files'), total=total)
 for i, name in enumerate(files):
 flags = self.fileflags(name)
 mode = 'x' in flags and 0755 or 0644
 symlink = 'l' in flags
-archiver.addfile(os.path.join(prefix, self._path, name),
+archiver.addfile(self.wvfs.reljoin(prefix, self._path, name),
 mode, symlink, self.filedata(name))
 self.ui.progress(_('archiving (%s)') % relpath, i + 1,
 unit=_('files'), total=total)
 self.ui.progress(_('archiving (%s)') % relpath, None)
 return total
 return []
 def shortid(self, revid):
 return revid
+@propertycache
+def wvfs(self):
+"""return vfs to access the working directory of this subrepository
+"""
+return scmutil.vfs(self._ctx.repo().wvfs.join(self._path))
+@propertycache
+def _relpath(self):
+"""return path to this subrepository as seen from outermost repository
+"""
+return self.wvfs.reljoin(reporelpath(self._ctx.repo()), self._path)
 class hgsubrepo(abstractsubrepo):
 def __init__(self, ctx, path, state):
-super(hgsubrepo, self).__init__(ctx._repo.ui)
+super(hgsubrepo, self).__init__(ctx, path)
-self._path = path
 self._state = state
-r = ctx._repo
+r = ctx.repo()
 root = r.wjoin(path)
 create = not r.wvfs.exists('%s/.hg' % path)
 self._repo = hg.repository(r.baseui, root, create=create)
 self.ui = self._repo.ui
 for s, k in [('ui', 'commitsubrepos')]:
 fp.close()
 @annotatesubrepoerror
 def add(self, ui, match, prefix, explicitonly, **opts):
 return cmdutil.add(ui, self._repo, match,
-os.path.join(prefix, self._path), explicitonly,
+self.wvfs.reljoin(prefix, self._path),
-**opts)
+explicitonly, **opts)
+@annotatesubrepoerror
 def addremove(self, m, prefix, opts, dry_run, similarity):
 # In the same way as sub directories are processed, once in a subrepo,
 # always entry any of its subrepos.  Don't corrupt the options that will
 # be used to process sibling subrepos however.
 opts = copy.copy(opts)
 opts['subrepos'] = True
 return scmutil.addremove(self._repo, m,
-os.path.join(prefix, self._path), opts,
+self.wvfs.reljoin(prefix, self._path), opts,
 dry_run, similarity)
 @annotatesubrepoerror
 def cat(self, match, prefix, **opts):
 rev = self._state[1]
 ctx = self._repo[rev]
 for subpath in ctx.substate:
 s = subrepo(ctx, subpath)
 submatch = matchmod.narrowmatcher(subpath, match)
 total += s.archive(
-archiver, os.path.join(prefix, self._path), submatch)
+archiver, self.wvfs.reljoin(prefix, self._path), submatch)
 return total
 @annotatesubrepoerror
 def dirty(self, ignoreupdate=False):
 r = self._state[1]
 other = hg.peer(self._repo, {}, srcurl)
 if len(self._repo) == 0:
 self.ui.status(_('cloning subrepo %s from %s\n')
 % (subrelpath(self), srcurl))
 parentrepo = self._repo._subparent
-shutil.rmtree(self._repo.path)
+# use self._repo.vfs instead of self.wvfs to remove .hg only
+self._repo.vfs.rmtree()
 other, cloned = hg.clone(self._repo._subparent.baseui, {},
 other, self._repo.root,
 update=False)
 self._repo = cloned.local()
 self._initrepo(parentrepo, source, create=True)
 @annotatesubrepoerror
 def files(self):
 rev = self._state[1]
 ctx = self._repo[rev]
-return ctx.manifest()
+return ctx.manifest().keys()
 def filedata(self, name):
 rev = self._state[1]
 return self._repo[rev][name].data()
 def fileflags(self, name):
 rev = self._state[1]
 ctx = self._repo[rev]
 return ctx.flags(name)
+@annotatesubrepoerror
+def printfiles(self, ui, m, fm, fmt):
+# If the parent context is a workingctx, use the workingctx here for
+# consistency.
+if self._ctx.rev() is None:
+ctx = self._repo[None]
+else:
+rev = self._state[1]
+ctx = self._repo[rev]
+return cmdutil.files(ui, ctx, m, fm, fmt, True)
 def walk(self, match):
 ctx = self._repo[None]
 return ctx.walk(match)
 @annotatesubrepoerror
 def forget(self, match, prefix):
 return cmdutil.forget(self.ui, self._repo, match,
-os.path.join(prefix, self._path), True)
+self.wvfs.reljoin(prefix, self._path), True)
 @annotatesubrepoerror
 def removefiles(self, matcher, prefix, after, force, subrepos):
 return cmdutil.remove(self.ui, self._repo, matcher,
-os.path.join(prefix, self._path), after, force,
+self.wvfs.reljoin(prefix, self._path),
-subrepos)
+after, force, subrepos)
 @annotatesubrepoerror
 def revert(self, substate, *pats, **opts):
 # reverting a subrepo is a 2 step process:
 # 1. if the no_backup is not set, revert all modified
 # We could do it if there was a set:subrepos() predicate
 opts = opts.copy()
 opts['date'] = None
 opts['rev'] = substate[1]
-pats = []
-if not opts.get('all'):
-pats = ['set:modified()']
 self.filerevert(*pats, **opts)
 # Update the repo to the revision specified in the given substate
-self.get(substate, overwrite=True)
+if not opts.get('dry_run'):
+self.get(substate, overwrite=True)
 def filerevert(self, *pats, **opts):
 ctx = self._repo[opts['rev']]
 parents = self._repo.dirstate.parents()
 if opts.get('all'):
 cmdutil.revert(self.ui, self._repo, ctx, parents, *pats, **opts)
 def shortid(self, revid):
 return revid[:12]
+@propertycache
+def wvfs(self):
+"""return own wvfs for efficiency and consitency
+"""
+return self._repo.wvfs
+@propertycache
+def _relpath(self):
+"""return path to this subrepository as seen from outermost repository
+"""
+# Keep consistent dir separators by avoiding vfs.join(self._path)
+return reporelpath(self._repo)
 class svnsubrepo(abstractsubrepo):
 def __init__(self, ctx, path, state):
-super(svnsubrepo, self).__init__(ctx._repo.ui)
+super(svnsubrepo, self).__init__(ctx, path)
-self._path = path
 self._state = state
-self._ctx = ctx
 self._exe = util.findexe('svn')
 if not self._exe:
 raise util.Abort(_("'svn' executable not found for subrepo '%s'")
 % self._path)
 # --non-interactive.
 if commands[0] in ('update', 'checkout', 'commit'):
 cmd.append('--non-interactive')
 cmd.extend(commands)
 if filename is not None:
-path = os.path.join(self._ctx._repo.origroot, self._path, filename)
+path = self.wvfs.reljoin(self._ctx.repo().origroot,
+self._path, filename)
 cmd.append(path)
 env = dict(os.environ)
 # Avoid localized output, preserve current locale for everything else.
 lc_all = env.get('LC_ALL')
 if lc_all:
 self.ui.warn(_('not removing repo %s because '
 'it has changes.\n') % self._path)
 return
 self.ui.note(_('removing subrepo %s\n') % self._path)
-def onerror(function, path, excinfo):
+self.wvfs.rmtree(forcibly=True)
-if function is not os.remove:
-raise
-# read-only files cannot be unlinked under Windows
-s = os.stat(path)
-if (s.st_mode & stat.S_IWRITE) != 0:
-raise
-os.chmod(path, stat.S_IMODE(s.st_mode) | stat.S_IWRITE)
-os.remove(path)
-path = self._ctx._repo.wjoin(self._path)
-shutil.rmtree(path, onerror=onerror)
 try:
-os.removedirs(os.path.dirname(path))
+self._ctx.repo().wvfs.removedirs(os.path.dirname(self._path))
 except OSError:
 pass
 @annotatesubrepoerror
 def get(self, state, overwrite=False):
 args.append('--force')
 # The revision must be specified at the end of the URL to properly
 # update to a directory which has since been deleted and recreated.
 args.append('%s@%s' % (state[0], state[1]))
 status, err = self._svncommand(args, failok=True)
-_sanitize(self.ui, self._ctx._repo.wjoin(self._path), '.svn')
+_sanitize(self.ui, self.wvfs, '.svn')
 if not re.search('Checked out revision [0-9]+.', status):
 if ('is already a working copy for a different URL' in err
 and (self._wcchanged()[:2] == (False, False))):
 # obstructed but clean working copy, so just blow it away.
 self.remove()
 return self._svncommand(['cat'], name)[0]
 class gitsubrepo(abstractsubrepo):
 def __init__(self, ctx, path, state):
-super(gitsubrepo, self).__init__(ctx._repo.ui)
+super(gitsubrepo, self).__init__(ctx, path)
 self._state = state
-self._ctx = ctx
+self._abspath = ctx.repo().wjoin(path)
-self._path = path
+self._subparent = ctx.repo()
-self._relpath = os.path.join(reporelpath(ctx._repo), path)
-self._abspath = ctx._repo.wjoin(path)
-self._subparent = ctx._repo
 self._ensuregit()
 def _ensuregit(self):
 try:
 self._gitexecutable = 'git'
 (command, p.returncode, self._relpath))
 return retdata, p.returncode
 def _gitmissing(self):
-return not os.path.exists(os.path.join(self._abspath, '.git'))
+return not self.wvfs.exists('.git')
 def _gitstate(self):
 return self._gitcommand(['rev-parse', 'HEAD'])
 def _gitcurrentbranch(self):
 # the -f option will otherwise throw away files added for
 # commit, not just unmark them.
 self._gitcommand(['reset', 'HEAD'])
 cmd.append('-f')
 self._gitcommand(cmd + args)
-_sanitize(self.ui, self._abspath, '.git')
+_sanitize(self.ui, self.wvfs, '.git')
 def rawcheckout():
 # no branch to checkout, check it out with no branch
 self.ui.warn(_('checking out detached HEAD in subrepo %s\n') %
 self._relpath)
 # Since we are only looking at branching at update, we need to
 # detect this situation and perform this action lazily.
 if tracking[remote] != self._gitcurrentbranch():
 checkout([tracking[remote]])
 self._gitcommand(['merge', '--ff', remote])
-_sanitize(self.ui, self._abspath, '.git')
+_sanitize(self.ui, self.wvfs, '.git')
 else:
 # a real merge would be required, just checkout the revision
 rawcheckout()
 @annotatesubrepoerror
 def mergefunc():
 if base == revision:
 self.get(state) # fast forward merge
 elif base != self._state[1]:
 self._gitcommand(['merge', '--no-commit', revision])
-_sanitize(self.ui, self._abspath, '.git')
+_sanitize(self.ui, self.wvfs, '.git')
 if self.dirty():
 if self._gitstate() != revision:
 dirty = self._gitstate() == self._state[1] or code != 0
 if _updateprompt(self.ui, self, dirty,
 'cannot push revision %s\n') %
 (self._relpath, self._state[1]))
 return False
 @annotatesubrepoerror
+def add(self, ui, match, prefix, explicitonly, **opts):
+if self._gitmissing():
+return []
+(modified, added, removed,
+deleted, unknown, ignored, clean) = self.status(None, unknown=True,
+clean=True)
+tracked = set()
+# dirstates 'amn' warn, 'r' is added again
+for l in (modified, added, deleted, clean):
+tracked.update(l)
+# Unknown files not of interest will be rejected by the matcher
+files = unknown
+files.extend(match.files())
+rejected = []
+files = [f for f in sorted(set(files)) if match(f)]
+for f in files:
+exact = match.exact(f)
+command = ["add"]
+if exact:
+command.append("-f") #should be added, even if ignored
+if ui.verbose or not exact:
+ui.status(_('adding %s\n') % match.rel(f))
+if f in tracked:  # hg prints 'adding' even if already tracked
+if exact:
+rejected.append(f)
+continue
+if not opts.get('dry_run'):
+self._gitcommand(command + [f])
+for f in rejected:
+ui.warn(_("%s already tracked!\n") % match.abs(f))
+return rejected
+@annotatesubrepoerror
 def remove(self):
 if self._gitmissing():
 return
 if self.dirty():
 self.ui.warn(_('not removing repo %s because '
 return
 # we can't fully delete the repository as it may contain
 # local-only history
 self.ui.note(_('removing subrepo %s\n') % self._relpath)
 self._gitcommand(['config', 'core.bare', 'true'])
-for f in os.listdir(self._abspath):
+for f, kind in self.wvfs.readdir():
 if f == '.git':
 continue
-path = os.path.join(self._abspath, f)
+if kind == stat.S_IFDIR:
-if os.path.isdir(path) and not os.path.islink(path):
+self.wvfs.rmtree(f)
-shutil.rmtree(path)
 else:
-os.remove(path)
+self.wvfs.unlink(f)
 def archive(self, archiver, prefix, match=None):
 total = 0
 source, revision = self._state
 if not revision:
 continue
 if info.issym():
 data = info.linkname
 else:
 data = tar.extractfile(info).read()
-archiver.addfile(os.path.join(prefix, self._path, info.name),
+archiver.addfile(self.wvfs.reljoin(prefix, self._path, info.name),
 info.mode, info.issym(), data)
 total += 1
 self.ui.progress(_('archiving (%s)') % relpath, i + 1,
 unit=_('files'))
 self.ui.progress(_('archiving (%s)') % relpath, None)
 return total
 @annotatesubrepoerror
+def cat(self, match, prefix, **opts):
+rev = self._state[1]
+if match.anypats():
+return 1 #No support for include/exclude yet
+if not match.files():
+return 1
+for f in match.files():
+output = self._gitcommand(["show", "%s:%s" % (rev, f)])
+fp = cmdutil.makefileobj(self._subparent, opts.get('output'),
+self._ctx.node(),
+pathname=self.wvfs.reljoin(prefix, f))
+fp.write(output)
+fp.close()
+return 0
+@annotatesubrepoerror
 def status(self, rev2, **opts):
 rev1 = self._state[1]
 if self._gitmissing() or not rev1:
 # if the repo is missing, return no results
-return [], [], [], [], [], [], []
+return scmutil.status([], [], [], [], [], [], [])
 modified, added, removed = [], [], []
 self._gitupdatestat()
 if rev2:
 command = ['diff-tree', rev1, rev2]
 else:
 elif status == 'D':
 removed.append(f)
 deleted, unknown, ignored, clean = [], [], [], []
-if not rev2:
+command = ['status', '--porcelain', '-z']
-command = ['ls-files', '--others', '--exclude-standard']
+if opts.get('unknown'):
-out = self._gitcommand(command)
+command += ['--untracked-files=all']
-for line in out.split('\n'):
+if opts.get('ignored'):
-if len(line) == 0:
+command += ['--ignored']
-continue
+out = self._gitcommand(command)
-unknown.append(line)
+changedfiles = set()
+changedfiles.update(modified)
+changedfiles.update(added)
+changedfiles.update(removed)
+for line in out.split('\0'):
+if not line:
+continue
+st = line[0:2]
+#moves and copies show 2 files on one line
+if line.find('\0') >= 0:
+filename1, filename2 = line[3:].split('\0')
+else:
+filename1 = line[3:]
+filename2 = None
+changedfiles.add(filename1)
+if filename2:
+changedfiles.add(filename2)
+if st == '??':
+unknown.append(filename1)
+elif st == '!!':
+ignored.append(filename1)
+if opts.get('clean'):
+out = self._gitcommand(['ls-files'])
+for f in out.split('\n'):
+if not f in changedfiles:
+clean.append(f)
 return scmutil.status(modified, added, removed, deleted,
 unknown, ignored, clean)
 @annotatesubrepoerror
 cmd.append('--stat')
 else:
 # for Git, this also implies '-p'
 cmd.append('-U%d' % diffopts.context)
-gitprefix = os.path.join(prefix, self._path)
+gitprefix = self.wvfs.reljoin(prefix, self._path)
 if diffopts.noprefix:
 cmd.extend(['--src-prefix=%s/' % gitprefix,
 '--dst-prefix=%s/' % gitprefix])
 else:
 cmd.append(node1)
 if node2:
 cmd.append(node2)
-if match.anypats():
-return #No support for include/exclude yet
 output = ""
 if match.always():
 output += self._gitcommand(cmd) + '\n'
-elif match.files():
+else:
-for f in match.files():
+st = self.status(node2)[:3]
-output += self._gitcommand(cmd + [f]) + '\n'
+files = [f for sublist in st for f in sublist]
-elif match(gitprefix): #Subrepo is matched
+for f in files:
-output += self._gitcommand(cmd) + '\n'
+if match(f):
+output += self._gitcommand(cmd + ['--', f]) + '\n'
 if output.strip():
 ui.write(output)
 @annotatesubrepoerror
 names = status.modified
 for name in names:
 bakname = "%s.orig" % name
 self.ui.note(_('saving current version of %s as %s\n') %
 (name, bakname))
-util.rename(os.path.join(self._abspath, name),
+self.wvfs.rename(name, bakname)
-os.path.join(self._abspath, bakname))
+if not opts.get('dry_run'):
 self.get(substate, overwrite=True)
 return []
 def shortid(self, revid):
 return revid[:7]

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/subrepo.py @ 24803:e89f909edffa stable 3.4-rc