mercurial: comparison mercurial/tags.py

equal deleted inserted replaced

-:346af7687c6f
+:89a2afe31e82
 fp.write(updateold % (old, tag))
 fp.write(updatenew % (new, tag))
 def findglobaltags(ui, repo):
-'''Find global tags in a repo: return a tagsmap
+"""Find global tags in a repo: return a tagsmap
 tagsmap: tag name to (node, hist) 2-tuples.
 The tags cache is read and updated as a side-effect of calling.
-'''
+"""
 (heads, tagfnode, valid, cachetags, shouldwrite) = _readtagcache(ui, repo)
 if cachetags is not None:
 assert not shouldwrite
 # XXX is this really 100% correct?  are there oddball special
 # cases where a global tag should outrank a local tag but won't,
 _updatetags(filetags, alltags, b'local', tagtypes)
 def _readtaghist(ui, repo, lines, fn, recode=None, calcnodelines=False):
-'''Read tag definitions from a file (or any source of lines).
+"""Read tag definitions from a file (or any source of lines).
 This function returns two sortdicts with similar information:
 - the first dict, bintaghist, contains the tag information as expected by
 the _readtags function, i.e. a mapping from tag name to (node, hist):
 [hexnode, line number] pairs, ordered from the oldest to the newest node.
 When calcnodelines is False the hextaglines dict is not calculated (an
 empty dict is returned). This is done to improve this function's
 performance in cases where the line numbers are not needed.
-'''
+"""
 bintaghist = util.sortdict()
 hextaglines = util.sortdict()
 count = 0
 bintaghist[name].append(nodebin)
 return bintaghist, hextaglines
 def _readtags(ui, repo, lines, fn, recode=None, calcnodelines=False):
-'''Read tag definitions from a file (or any source of lines).
+"""Read tag definitions from a file (or any source of lines).
 Returns a mapping from tag name to (node, hist).
 "node" is the node id from the last line read for that name. "hist"
 is the list of node ids previously associated with it (in file order).
 All node ids are binary, not hex.
-'''
+"""
 filetags, nodelines = _readtaghist(
 ui, repo, lines, fn, recode=recode, calcnodelines=calcnodelines
 )
 # util.sortdict().__setitem__ is much slower at replacing then inserting
 # new entries. The difference can matter if there are thousands of tags.
 filename = b'%s-%s' % (filename, repo.filtername)
 return filename
 def _readtagcache(ui, repo):
-'''Read the tag cache.
+"""Read the tag cache.
 Returns a tuple (heads, fnodes, validinfo, cachetags, shouldwrite).
 If the cache is completely up-to-date, "cachetags" is a dict of the
 form returned by _readtags() and "heads", "fnodes", and "validinfo" are
 when writing the tags cache. "fnodes" is a mapping from head to .hgtags
 filenode. "shouldwrite" is True.
 If the cache is not up to date, the caller is responsible for reading tag
 info from each returned head. (See findglobaltags().)
-'''
+"""
 try:
 cachefile = repo.cachevfs(_filename(repo), b'r')
 # force reading the file for static-http
 cachelines = iter(cachefile)
 except IOError:
 except (OSError, IOError):
 pass
 def tag(repo, names, node, message, local, user, date, editor=False):
-'''tag a revision with one or more symbolic names.
+"""tag a revision with one or more symbolic names.
 names is a list of strings or, when adding a single tag, names may be a
 string.
 if local is True, the tags are stored in a per-repository file.
 message: commit message to use if committing
 user: name of user to use if committing
-date: date tuple to use if committing'''
+date: date tuple to use if committing"""
 if not local:
 m = matchmod.exact([b'.hgtags'])
 st = repo.status(match=m, unknown=True, ignored=True)
 if any(

changeset 45942	89a2afe31e82
parent 45787	225e513c444e
child 46495	5aac1a1a5beb