mercurial-scm/hg: comparison mercurial/context.py

equal deleted inserted replaced

-:0d714a48ab53
+:077f1e637cd8
 # Copyright 2006, 2007 Matt Mackall <mpm@selenic.com>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
-from node import nullid, nullrev, short
+from node import nullid, nullrev, short, hex
 from i18n import _
 import ancestor, bdiff, revlog, util, os, errno
 class changectx(object):
 """A changecontext object makes access to data related to a particular
 changeset convenient."""
-def __init__(self, repo, changeid=None):
+def __init__(self, repo, changeid=''):
 """changeid is a revision number, node, or tag"""
+if changeid == '':
+changeid = '.'
 self._repo = repo
-if not changeid and changeid != 0:
-p1, p2 = self._repo.dirstate.parents()
-self._rev = self._repo.changelog.rev(p1)
-if self._rev == -1:
-changeid = 'tip'
-else:
-self._node = p1
-return
 self._node = self._repo.lookup(changeid)
 self._rev = self._repo.changelog.rev(self._node)
 def __str__(self):
 return short(self.node())
+def __int__(self):
+return self.rev()
 def __repr__(self):
 return "<changectx %s>" % str(self)
+def __hash__(self):
+try:
+return hash(self._rev)
+except AttributeError:
+return id(self)
 def __eq__(self, other):
 try:
 return self._rev == other._rev
 except AttributeError:
 return self._manifest
 elif name == '_manifestdelta':
 md = self._repo.manifest.readdelta(self._changeset[0])
 self._manifestdelta = md
 return self._manifestdelta
+elif name == '_parents':
+p = self._repo.changelog.parents(self._node)
+if p[1] == nullid:
+p = p[:-1]
+self._parents = [changectx(self._repo, x) for x in p]
+return self._parents
 else:
 raise AttributeError, name
 def __contains__(self, key):
 return key in self._manifest
 def __getitem__(self, key):
 return self.filectx(key)
 def __iter__(self):
-a = self._manifest.keys()
+for f in util.sort(self._manifest):
-a.sort()
-for f in a:
 yield f
 def changeset(self): return self._changeset
 def manifest(self): return self._manifest
 def rev(self): return self._rev
 def node(self): return self._node
+def hex(self): return hex(self._node)
 def user(self): return self._changeset[1]
 def date(self): return self._changeset[2]
 def files(self): return self._changeset[3]
 def description(self): return self._changeset[4]
 def branch(self): return self._changeset[5].get("branch")
 def extra(self): return self._changeset[5]
 def tags(self): return self._repo.nodetags(self._node)
 def parents(self):
 """return contexts for each parent changeset"""
-p = self._repo.changelog.parents(self._node)
+return self._parents
-return [changectx(self._repo, x) for x in p]
 def children(self):
 """return contexts for each child changeset"""
 c = self._repo.changelog.children(self._node)
 return [changectx(self._repo, x) for x in c]
+def ancestors(self):
+for a in self._repo.changelog.ancestors(self._rev):
+yield changectx(self._repo, a)
+def descendants(self):
+for d in self._repo.changelog.descendants(self._rev):
+yield changectx(self._repo, d)
 def _fileinfo(self, path):
 if '_manifest' in self.__dict__:
 try:
 return self._manifest[path], self._manifest.flags(path)
 return node, flag
 def filenode(self, path):
 return self._fileinfo(path)[0]
-def fileflags(self, path):
+def flags(self, path):
 try:
 return self._fileinfo(path)[1]
 except revlog.LookupError:
 return ''
 if fileid is None:
 fileid = self.filenode(path)
 return filectx(self._repo, path, fileid=fileid,
 changectx=self, filelog=filelog)
-def filectxs(self):
-"""generate a file context for each file in this changeset's
-manifest"""
-mf = self.manifest()
-m = mf.keys()
-m.sort()
-for f in m:
-yield self.filectx(f, fileid=mf[f])
 def ancestor(self, c2):
 """
 return the ancestor context of self and c2
 """
 n = self._repo.changelog.ancestor(self._node, c2._node)
 return changectx(self._repo, n)
+def walk(self, match):
+fdict = dict.fromkeys(match.files())
+# for dirstate.walk, files=['.'] means "walk the whole tree".
+# follow that here, too
+fdict.pop('.', None)
+for fn in self:
+for ffn in fdict:
+# match if the file is the exact name or a directory
+if ffn == fn or fn.startswith("%s/" % ffn):
+del fdict[ffn]
+break
+if match(fn):
+yield fn
+for fn in util.sort(fdict):
+if match.bad(fn, 'No such file in rev ' + str(self)) and match(fn):
+yield fn
 class filectx(object):
 """A filecontext object makes access to data related to a particular
 filerevision convenient."""
 def __init__(self, repo, path, changeid=None, fileid=None,
 return "%s@%s" % (self.path(), short(self.node()))
 def __repr__(self):
 return "<filectx %s>" % str(self)
+def __hash__(self):
+try:
+return hash((self._path, self._fileid))
+except AttributeError:
+return id(self)
 def __eq__(self, other):
 try:
 return (self._path == other._path
 and self._fileid == other._fileid)
 except AttributeError:
 return filectx(self._repo, self._path, fileid=fileid,
 filelog=self._filelog)
 def filerev(self): return self._filerev
 def filenode(self): return self._filenode
-def fileflags(self): return self._changectx.fileflags(self._path)
+def flags(self): return self._changectx.flags(self._path)
-def isexec(self): return 'x' in self.fileflags()
-def islink(self): return 'l' in self.fileflags()
 def filelog(self): return self._filelog
 def rev(self):
 if '_changectx' in self.__dict__:
 return self._changectx.rev()
 needed[p] += 1
 # sort by revision (per file) which is a topological order
 visit = []
 for f in files:
-fn = [(n.rev(), n) for n in needed.keys() if n._path == f]
+fn = [(n.rev(), n) for n in needed if n._path == f]
 visit.extend(fn)
-visit.sort()
 hist = {}
+for r, f in util.sort(visit):
-for r, f in visit:
 curr = decorate(f.data(), f)
 for p in parents(f):
 if p != nullid:
 curr = pair(hist[p], curr)
 # trim the history of unneeded revs
 return None
 class workingctx(changectx):
 """A workingctx object makes access to data related to
-the current working directory convenient."""
+the current working directory convenient.
-def __init__(self, repo):
+parents - a pair of parent nodeids, or None to use the dirstate.
+date - any valid date string or (unixtime, offset), or None.
+user - username string, or None.
+extra - a dictionary of extra values, or None.
+changes - a list of file lists as returned by localrepo.status()
+or None to use the repository status.
+"""
+def __init__(self, repo, parents=None, text="", user=None, date=None,
+extra=None, changes=None):
 self._repo = repo
 self._rev = None
 self._node = None
+self._text = text
+if date:
+self._date = util.parsedate(date)
+if user:
+self._user = user
+if parents:
+self._parents = [changectx(self._repo, p) for p in parents]
+if changes:
+self._status = list(changes)
+self._extra = {}
+if extra:
+self._extra = extra.copy()
+if 'branch' not in self._extra:
+branch = self._repo.dirstate.branch()
+try:
+branch = branch.decode('UTF-8').encode('UTF-8')
+except UnicodeDecodeError:
+raise util.Abort(_('branch name not in UTF-8!'))
+self._extra['branch'] = branch
+if self._extra['branch'] == '':
+self._extra['branch'] = 'default'
 def __str__(self):
 return str(self._parents[0]) + "+"
 def __nonzero__(self):
 return True
+def __contains__(self, key):
+return self._dirstate[key] not in "?r"
 def __getattr__(self, name):
-if name == '_parents':
-self._parents = self._repo.parents()
-return self._parents
 if name == '_status':
-self._status = self._repo.status()
+self._status = self._repo.status(unknown=True)
 return self._status
+elif name == '_user':
+self._user = self._repo.ui.username()
+return self._user
+elif name == '_date':
+self._date = util.makedate()
+return self._date
 if name == '_manifest':
 self._buildmanifest()
 return self._manifest
+elif name == '_parents':
+p = self._repo.dirstate.parents()
+if p[1] == nullid:
+p = p[:-1]
+self._parents = [changectx(self._repo, x) for x in p]
+return self._parents
 else:
 raise AttributeError, name
 def _buildmanifest(self):
 """generate a manifest corresponding to the working directory"""
 man = self._parents[0].manifest().copy()
 copied = self._repo.dirstate.copies()
-is_exec = util.execfunc(self._repo.root,
+cf = lambda x: man.flags(copied.get(x, x))
-lambda p: man.execf(copied.get(p,p)))
+ff = self._repo.dirstate.flagfunc(cf)
-is_link = util.linkfunc(self._repo.root,
-lambda p: man.linkf(copied.get(p,p)))
 modified, added, removed, deleted, unknown = self._status[:5]
 for i, l in (("a", added), ("m", modified), ("u", unknown)):
 for f in l:
 man[f] = man.get(copied.get(f, f), nullid) + i
 try:
-man.set(f, is_exec(f), is_link(f))
+man.set(f, ff(f))
 except OSError:
 pass
 for f in deleted + removed:
 if f in man:
 self._manifest = man
 def manifest(self): return self._manifest
-def user(self): return self._repo.ui.username()
+def user(self): return self._user or self._repo.ui.username()
-def date(self): return util.makedate()
+def date(self): return self._date
-def description(self): return ""
+def description(self): return self._text
 def files(self):
-f = self.modified() + self.added() + self.removed()
+return util.sort(self._status[0] + self._status[1] + self._status[2])
-f.sort()
-return f
 def modified(self): return self._status[0]
 def added(self): return self._status[1]
 def removed(self): return self._status[2]
 def deleted(self): return self._status[3]
 def unknown(self): return self._status[4]
 def clean(self): return self._status[5]
-def branch(self): return self._repo.dirstate.branch()
+def branch(self): return self._extra['branch']
+def extra(self): return self._extra
 def tags(self):
 t = []
 [t.extend(p.tags()) for p in self.parents()]
 return t
-def parents(self):
-"""return contexts for each parent changeset"""
-return self._parents
 def children(self):
 return []
-def fileflags(self, path):
+def flags(self, path):
 if '_manifest' in self.__dict__:
 try:
 return self._manifest.flags(path)
 except KeyError:
 return ''
 pnode = self._parents[0].changeset()[0]
 orig = self._repo.dirstate.copies().get(path, path)
 node, flag = self._repo.manifest.find(pnode, orig)
-is_link = util.linkfunc(self._repo.root,
-lambda p: flag and 'l' in flag)
-is_exec = util.execfunc(self._repo.root,
-lambda p: flag and 'x' in flag)
 try:
-return (is_link(path) and 'l' or '') + (is_exec(path) and 'x' or '')
+ff = self._repo.dirstate.flagfunc(lambda x: flag or '')
+return ff(path)
 except OSError:
 pass
 if not node or path in self.deleted() or path in self.removed():
 return ''
 filelog=filelog)
 def ancestor(self, c2):
 """return the ancestor context of self and c2"""
 return self._parents[0].ancestor(c2) # punt on two parents for now
+def walk(self, match):
+return util.sort(self._repo.dirstate.walk(match, True, False).keys())
 class workingfilectx(filectx):
 """A workingfilectx object makes access to data related to a particular
 file in the working directory convenient."""
 def __init__(self, repo, path, filelog=None, workingctx=None):
 except OSError, err:
 if err.errno != errno.ENOENT: raise
 return (t, tz)
 def cmp(self, text): return self._repo.wread(self._path) == text
+class memctx(object):
+"""A memctx is a subset of changectx supposed to be built on memory
+and passed to commit functions.
+NOTE: this interface and the related memfilectx are experimental and
+may change without notice.
+parents - a pair of parent nodeids.
+filectxfn - a callable taking (repo, memctx, path) arguments and
+returning a memctx object.
+date - any valid date string or (unixtime, offset), or None.
+user - username string, or None.
+extra - a dictionary of extra values, or None.
+"""
+def __init__(self, repo, parents, text, files, filectxfn, user=None,
+date=None, extra=None):
+self._repo = repo
+self._rev = None
+self._node = None
+self._text = text
+self._date = date and util.parsedate(date) or util.makedate()
+self._user = user
+parents = [(p or nullid) for p in parents]
+p1, p2 = parents
+self._parents = [changectx(self._repo, p) for p in (p1, p2)]
+files = util.sort(list(files))
+self._status = [files, [], [], [], []]
+self._filectxfn = filectxfn
+self._extra = extra and extra.copy() or {}
+if 'branch' not in self._extra:
+self._extra['branch'] = 'default'
+elif self._extra.get('branch') == '':
+self._extra['branch'] = 'default'
+def __str__(self):
+return str(self._parents[0]) + "+"
+def __int__(self):
+return self._rev
+def __nonzero__(self):
+return True
+def user(self): return self._user or self._repo.ui.username()
+def date(self): return self._date
+def description(self): return self._text
+def files(self): return self.modified()
+def modified(self): return self._status[0]
+def added(self): return self._status[1]
+def removed(self): return self._status[2]
+def deleted(self): return self._status[3]
+def unknown(self): return self._status[4]
+def clean(self): return self._status[5]
+def branch(self): return self._extra['branch']
+def extra(self): return self._extra
+def flags(self, f): return self[f].flags()
+def parents(self):
+"""return contexts for each parent changeset"""
+return self._parents
+def filectx(self, path, filelog=None):
+"""get a file context from the working directory"""
+return self._filectxfn(self._repo, self, path)
+class memfilectx(object):
+"""A memfilectx is a subset of filectx supposed to be built by client
+code and passed to commit functions.
+"""
+def __init__(self, path, data, islink, isexec, copied):
+"""copied is the source file path, or None."""
+self._path = path
+self._data = data
+self._flags = (islink and 'l' or '') + (isexec and 'x' or '')
+self._copied = None
+if copied:
+self._copied = (copied, nullid)
+def __nonzero__(self): return True
+def __str__(self): return "%s@%s" % (self.path(), self._changectx)
+def path(self): return self._path
+def data(self): return self._data
+def flags(self): return self._flags
+def isexec(self): return 'x' in self._flags
+def islink(self): return 'l' in self._flags
+def renamed(self): return self._copied

changeset 6876	077f1e637cd8
parent 6846	54b7c79575fa
child 7008	8fee8ff13d37