mercurial-crew-with-dirclash: comparison mercurial/dirstate.py

equal deleted inserted replaced

-:3a645af7fb76
+:a8be3c875988
 _format = ">cllll"
 class dirstate(object):
 def __init__(self, opener, ui, root):
-self.opener = opener
+self._opener = opener
-self.root = root
+self._root = root
 self._dirty = 0
-self.ui = ui
+self._ui = ui
 def __getattr__(self, name):
-if name == 'map':
+if name == '_map':
 self.read()
-return self.map
+return self._map
-elif name == 'copymap':
+elif name == '_copymap':
 self.read()
-return self.copymap
+return self._copymap
 elif name == '_branch':
 try:
-self._branch = self.opener("branch").read().strip()\
+self._branch = self._opener("branch").read().strip()\
 or "default"
 except IOError:
 self._branch = "default"
 return self._branch
-elif name == 'pl':
+elif name == '_pl':
-self.pl = [nullid, nullid]
+self._pl = [nullid, nullid]
 try:
-st = self.opener("dirstate").read(40)
+st = self._opener("dirstate").read(40)
 if len(st) == 40:
-self.pl = st[:20], st[20:40]
+self._pl = st[:20], st[20:40]
 except IOError, err:
 if err.errno != errno.ENOENT: raise
-return self.pl
+return self._pl
 elif name == 'dirs':
 self.dirs = {}
-for f in self.map:
+for f in self._map:
 self.updatedirs(f, 1)
 return self.dirs
 elif name == '_ignore':
-files = [self.wjoin('.hgignore')] + self.ui.hgignorefiles()
+files = [self.wjoin('.hgignore')] + self._ui.hgignorefiles()
-self._ignore = ignore.ignore(self.root, files, self.ui.warn)
+self._ignore = ignore.ignore(self._root, files, self._ui.warn)
 return self._ignore
 elif name == '_slash':
-self._slash = self.ui.configbool('ui', 'slash') and os.sep != '/'
+self._slash = self._ui.configbool('ui', 'slash') and os.sep != '/'
 return self._slash
 else:
 raise AttributeError, name
 def wjoin(self, f):
-return os.path.join(self.root, f)
+return os.path.join(self._root, f)
 def getcwd(self):
 cwd = os.getcwd()
-if cwd == self.root: return ''
+if cwd == self._root: return ''
-# self.root ends with a path separator if self.root is '/' or 'C:\'
+# self._root ends with a path separator if self._root is '/' or 'C:\'
-rootsep = self.root
+rootsep = self._root
 if not rootsep.endswith(os.sep):
 rootsep += os.sep
 if cwd.startswith(rootsep):
 return cwd[len(rootsep):]
 else:
 return cwd
 def pathto(self, f, cwd=None):
 if cwd is None:
 cwd = self.getcwd()
-path = util.pathto(self.root, cwd, f)
+path = util.pathto(self._root, cwd, f)
 if self._slash:
 return path.replace(os.sep, '/')
 return path
 def __del__(self):
 self.write()
 def __getitem__(self, key):
-return self.map[key]
+return self._map[key]
 def __contains__(self, key):
-return key in self.map
+return key in self._map
+def __iter__(self):
+a = self._map.keys()
+a.sort()
+for x in a:
+yield x
 def parents(self):
-return self.pl
+return self._pl
 def branch(self):
 return self._branch
 def markdirty(self):
 self._dirty = 1
 def setparents(self, p1, p2=nullid):
 self.markdirty()
-self.pl = p1, p2
+self._pl = p1, p2
 def setbranch(self, branch):
 self._branch = branch
-self.opener("branch", "w").write(branch + '\n')
+self._opener("branch", "w").write(branch + '\n')
 def state(self, key):
-return self.map.get(key, ("?",))[0]
+return self._map.get(key, ("?",))[0]
 def read(self):
-self.map = {}
+self._map = {}
-self.copymap = {}
+self._copymap = {}
-self.pl = [nullid, nullid]
+self._pl = [nullid, nullid]
 try:
-st = self.opener("dirstate").read()
+st = self._opener("dirstate").read()
 except IOError, err:
 if err.errno != errno.ENOENT: raise
 return
 if not st:
 return
-self.pl = [st[:20], st[20: 40]]
+self._pl = [st[:20], st[20: 40]]
 # deref fields so they will be local in loop
-dmap = self.map
+dmap = self._map
-copymap = self.copymap
+copymap = self._copymap
 unpack = struct.unpack
 pos = 40
 e_size = struct.calcsize(_format)
 copymap[f] = c
 dmap[f] = e[:4]
 pos = newpos
 def invalidate(self):
-for a in "map copymap _branch pl dirs _ignore".split():
+for a in "_map _copymap _branch pl dirs _ignore".split():
 if hasattr(self, a):
 self.__delattr__(a)
 def copy(self, source, dest):
 self.markdirty()
-self.copymap[dest] = source
+self._copymap[dest] = source
 def copied(self, file):
-return self.copymap.get(file, None)
+return self._copymap.get(file, None)
 def copies(self):
-return self.copymap
+return self._copymap
 def updatedirs(self, path, delta):
 for c in strutil.findall(path, '/'):
 pc = path[:c]
 self.dirs.setdefault(pc, 0)
 raise util.Abort(_('directory named %r already in dirstate') %
 f)
 for d in prefixes(f):
 if d in seendirs:
 break
-if d in self.map:
+if d in self._map:
 raise util.Abort(_('file named %r already in dirstate') %
 d)
 seendirs[d] = True
 # disallowed
 if '\r' in f or '\n' in f:
 self.markdirty()
 if state == "a":
 self.checkinterfering(files)
 for f in files:
 if state == "r":
-self.map[f] = ('r', 0, 0, 0)
+self._map[f] = ('r', 0, 0, 0)
 self.updatedirs(f, -1)
 else:
 if state == "a":
 self.updatedirs(f, 1)
 s = os.lstat(self.wjoin(f))
 st_size = kw.get('st_size', s.st_size)
 st_mtime = kw.get('st_mtime', s.st_mtime)
-self.map[f] = (state, s.st_mode, st_size, st_mtime)
+self._map[f] = (state, s.st_mode, st_size, st_mtime)
-if self.copymap.has_key(f):
+if self._copymap.has_key(f):
-del self.copymap[f]
+del self._copymap[f]
 def forget(self, files):
 if not files: return
 self.markdirty()
 for f in files:
 try:
-del self.map[f]
+del self._map[f]
 self.updatedirs(f, -1)
 except KeyError:
-self.ui.warn(_("not in dirstate: %s!\n") % f)
+self._ui.warn(_("not in dirstate: %s!\n") % f)
 pass
 def rebuild(self, parent, files):
 self.invalidate()
 for f in files:
 if files.execf(f):
-self.map[f] = ('n', 0777, -1, 0)
+self._map[f] = ('n', 0777, -1, 0)
 else:
-self.map[f] = ('n', 0666, -1, 0)
+self._map[f] = ('n', 0666, -1, 0)
-self.pl = (parent, nullid)
+self._pl = (parent, nullid)
 self.markdirty()
 def write(self):
 if not self._dirty:
 return
 cs = cStringIO.StringIO()
-cs.write("".join(self.pl))
+cs.write("".join(self._pl))
-for f, e in self.map.iteritems():
+for f, e in self._map.iteritems():
 c = self.copied(f)
 if c:
 f = f + "\0" + c
 e = struct.pack(_format, e[0], e[1], e[2], e[3], len(f))
 cs.write(e)
 cs.write(f)
-st = self.opener("dirstate", "w", atomictemp=True)
+st = self._opener("dirstate", "w", atomictemp=True)
 st.write(cs.getvalue())
 st.rename()
 self._dirty = 0
 def filterfiles(self, files):
 ret = {}
 unknown = []
 for x in files:
 if x == '.':
-return self.map.copy()
+return self._map.copy()
-if x not in self.map:
+if x not in self._map:
 unknown.append(x)
 else:
-ret[x] = self.map[x]
+ret[x] = self._map[x]
 if not unknown:
 return ret
-b = self.map.keys()
+b = self._map.keys()
 b.sort()
 blen = len(b)
 for x in unknown:
 bs = bisect.bisect(b, "%s%s" % (x, '/'))
 while bs < blen:
 s = b[bs]
 if len(s) > len(x) and s.startswith(x):
-ret[s] = self.map[s]
+ret[s] = self._map[s]
 else:
 break
 bs += 1
 return ret
 if stat.S_ISCHR(st.st_mode): kind = _('character device')
 elif stat.S_ISBLK(st.st_mode): kind = _('block device')
 elif stat.S_ISFIFO(st.st_mode): kind = _('fifo')
 elif stat.S_ISSOCK(st.st_mode): kind = _('socket')
 elif stat.S_ISDIR(st.st_mode): kind = _('directory')
-self.ui.warn(_('%s: unsupported file type (type is %s)\n')
+self._ui.warn(_('%s: unsupported file type (type is %s)\n')
 % (self.pathto(f), kind))
 return False
 def walk(self, files=None, match=util.always, badmatch=None):
 # filter out the stat
 '''
 # walk all files by default
 if not files:
 files = ['.']
-dc = self.map.copy()
+dc = self._map.copy()
 else:
 files = util.unique(files)
 dc = self.filterfiles(files)
 def imatch(file_):
 ignore = self._ignore
 if ignored:
 imatch = match
 ignore = util.never
-# self.root may end with a path separator when self.root == '/'
+# self._root may end with a path separator when self._root == '/'
-common_prefix_len = len(self.root)
+common_prefix_len = len(self._root)
-if not self.root.endswith(os.sep):
+if not self._root.endswith(os.sep):
 common_prefix_len += 1
 # recursion free walker, faster than os.walk.
 def findfiles(s):
 work = [s]
 if directories:
 if nf == fn or (fn.startswith(nf) and fn[len(nf)] == '/'):
 found = True
 break
 if not found:
 if inst.errno != errno.ENOENT or not badmatch:
-self.ui.warn('%s: %s\n' % (self.pathto(ff),
+self._ui.warn('%s: %s\n' % (self.pathto(ff),
 inst.strerror))
 elif badmatch and badmatch(ff) and imatch(nf):
 yield 'b', ff, None
 continue
 if stat.S_ISDIR(st.st_mode):

changeset 4615	a8be3c875988
parent 4614	3a645af7fb76
child 4616	9b00b73a5286