hgsubversion: hgsubversion/hg_delta

comparison hgsubversion/hg_delta_editor.py @ 411:d71972428fce

editor: move current revision state into a separate class This makes it more obvious and needs fewer faux namespacing.

author	Dirkjan Ochtman <dirkjan@ochtman.nl>
date	Thu, 11 Jun 2009 10:12:16 +0200
parents	eb524b957345
children	ac0cc3c9ea63

comparison

equal deleted inserted replaced

-:eb524b957345
+:d71972428fce
 except: #pragma: no cover
 if not hasattr(self, '_exception_info'):
 self._exception_info = sys.exc_info()
 raise
 return fun
+class RevisionData(object):
+__slots__ = [
+'file', 'files', 'deleted', 'rev', 'execfiles', 'symlinks', 'batons',
+'copies', 'missing', 'emptybranches', 'base', 'closebranches',
+'externals',
+]
+def __init__(self):
+self.clear()
+def clear(self):
+self.file = None
+self.files = {}
+self.deleted = {}
+self.rev = None
+self.execfiles = {}
+self.symlinks = {}
+self.batons = {}
+# Map fully qualified destination file paths to module source path
+self.copies = {}
+self.missing = set()
+self.emptybranches = {}
+self.base = None
+self.closebranches = set()
+self.externals = {}
 class HgChangeReceiver(delta.Editor):
 def last_known_revision(self):
 self.meta_data_dir)
 # ensure nested paths are handled properly
 self.tag_locations.sort()
 self.tag_locations.reverse()
-self.clear_current_info()
+self.current = RevisionData()
 self.authors = maps.AuthorMap(self.ui, self.authors_file,
 defaulthost=author_host)
 if authors: self.authors.load(authors)
 self.lastdate = '1970-01-01 00:00:00 -0000'
 date += ' -0000'
 self.lastdate = date
 else:
 date = self.lastdate
 return date
-def clear_current_info(self):
-'''Clear the info relevant to a replayed revision so that the next
-revision can be replayed.
-'''
-# Map files to raw svn data (symlink prefix is preserved)
-self.current_files = {}
-self.deleted_files = {}
-self.current_rev = None
-self.current_files_exec = {}
-self.current_files_symlink = {}
-self.dir_batons = {}
-# Map fully qualified destination file paths to module source path
-self.copies = {}
-self.missing_plaintexts = set()
-self.commit_branches_empty = {}
-self.base_revision = None
-self.branches_to_delete = set()
-self.externals = {}
 def _save_metadata(self):
 '''Save the Subversion metadata. This should really be called after
 every revision is created.
 '''
 ln =  self._localname(test)
 if ln and ln.startswith('../'):
 return None, None, None
 return path, ln, test
-def set_current_rev(self, rev):
-"""Set the revision we're currently converting.
-"""
-self.current_rev = rev
 def set_file(self, path, data, isexec=False, islink=False):
 if islink:
 data = 'link ' + data
-self.current_files[path] = data
+self.current.files[path] = data
-self.current_files_exec[path] = isexec
+self.current.execfiles[path] = isexec
-self.current_files_symlink[path] = islink
+self.current.symlinks[path] = islink
-if path in self.deleted_files:
+if path in self.current.deleted:
-del self.deleted_files[path]
+del self.current.deleted[path]
-if path in self.missing_plaintexts:
+if path in self.current.missing:
-self.missing_plaintexts.remove(path)
+self.current.missing.remove(path)
 def delete_file(self, path):
-self.deleted_files[path] = True
+self.current.deleted[path] = True
-if path in self.current_files:
+if path in self.current.files:
-del self.current_files[path]
+del self.current.files[path]
-self.current_files_exec[path] = False
+self.current.execfiles[path] = False
-self.current_files_symlink[path] = False
+self.current.symlinks[path] = False
 self.ui.note('D %s\n' % path)
 def _normalize_path(self, path):
 '''Normalize a path to strip of leading slashes and our subdir if we
 have one.
 def update_branch_tag_map_for_rev(self, revision):
 paths = revision.paths
 added_branches = {}
 added_tags = {}
-self.branches_to_delete = set()
+self.current.closebranches = set()
 tags_to_delete = set()
 for p in sorted(paths):
 t_name = self._is_path_tag(p)
 if t_name != False:
 src_p, src_rev = paths[p].copyfrom_path, paths[p].copyfrom_rev
 #    action will be 'R'.
 fi, br = self._path_and_branch_for_path(p)
 if fi is not None:
 if fi == '':
 if paths[p].action == 'D':
-self.branches_to_delete.add(br) # case 4
+self.current.closebranches.add(br) # case 4
 elif paths[p].action == 'R':
 parent = self._determine_parent_branch(
 p, paths[p].copyfrom_path, paths[p].copyfrom_rev,
 revision.revnum)
 added_branches.update(parent)
 continue # case 1
 if paths[p].action == 'D':
 for known in self.branches:
 if self._svnpath(known).startswith(p):
-self.branches_to_delete.add(known) # case 5
+self.current.closebranches.add(known) # case 5
 parent = self._determine_parent_branch(
 p, paths[p].copyfrom_path, paths[p].copyfrom_rev, revision.revnum)
 if not parent and paths[p].copyfrom_path:
 bpath, branch = self._path_and_branch_for_path(p, False)
 if (bpath is not None
 parent = {branch: (None, 0, revision.revnum)}
 added_branches.update(parent)
 rmtags = dict((t, self.tags[t][0]) for t in tags_to_delete)
 return {
 'tags': (added_tags, rmtags),
-'branches': (added_branches, self.branches_to_delete),
+'branches': (added_branches, self.current.closebranches),
 }
 def save_tbdelta(self, tbdelta):
 for t in tbdelta['tags'][1]:
 del self.tags[t]
 (info[0] or 'trunk', info[1], t))
 self.tags.update(tbdelta['tags'][0])
 self.branches.update(tbdelta['branches'][0])
 def _updateexternals(self):
-if not self.externals:
+if not self.current.externals:
 return
 # Accumulate externals records for all branches
-revnum = self.current_rev.revnum
+revnum = self.current.rev.revnum
 branches = {}
-for path, entry in self.externals.iteritems():
+for path, entry in self.current.externals.iteritems():
 if not self._is_path_valid(path):
 self.ui.warn('WARNING: Invalid path %s in externals\n' % path)
 continue
 p, b, bp = self._split_branch_path(path)
 if bp not in branches:
 def commit_current_delta(self, tbdelta):
 if hasattr(self, '_exception_info'):  #pragma: no cover
 traceback.print_exception(*self._exception_info)
 raise ReplayException()
-if self.missing_plaintexts:
+if self.current.missing:
 raise MissingPlainTextError()
 self._updateexternals()
 # paranoidly generate the list of files to commit
-files_to_commit = set(self.current_files.keys())
+files_to_commit = set(self.current.files.keys())
-files_to_commit.update(self.current_files_symlink.keys())
+files_to_commit.update(self.current.symlinks.keys())
-files_to_commit.update(self.current_files_exec.keys())
+files_to_commit.update(self.current.execfiles.keys())
-files_to_commit.update(self.deleted_files.keys())
+files_to_commit.update(self.current.deleted.keys())
 # back to a list and sort so we get sane behavior
 files_to_commit = list(files_to_commit)
 files_to_commit.sort()
 branch_batches = {}
-rev = self.current_rev
+rev = self.current.rev
 date = self.fixdate(rev.date)
 # build up the branches that have files on them
 for f in files_to_commit:
 if not  self._is_path_valid(f):
 closebranches[branch] = ha
 # 1. handle normal commits
 closedrevs = closebranches.values()
 for branch, files in branch_batches.iteritems():
-if branch in self.commit_branches_empty and files:
+if branch in self.current.emptybranches and files:
-del self.commit_branches_empty[branch]
+del self.current.emptybranches[branch]
 files = dict(files)
 parents = (self.get_parent_revision(rev.revnum, branch),
 revlog.nullid)
-if parents[0] in closedrevs and branch in self.branches_to_delete:
+if parents[0] in closedrevs and branch in self.current.closebranches:
 continue
 extra = util.build_extra(rev.revnum, branch, self.uuid, self.subdir)
 if branch is not None:
 if (branch not in self.branches
 and branch not in self.repo.branchtags()):
 continue
 parent_ctx = self.repo.changectx(parents[0])
 if '.hgsvnexternals' not in parent_ctx and '.hgsvnexternals' in files:
 # Do not register empty externals files
-if (files['.hgsvnexternals'] in self.current_files
+if (files['.hgsvnexternals'] in self.current.files
-and not self.current_files[files['.hgsvnexternals']]):
+and not self.current.files[files['.hgsvnexternals']]):
 del files['.hgsvnexternals']
 def filectxfn(repo, memctx, path):
 current_file = files[path]
-if current_file in self.deleted_files:
+if current_file in self.current.deleted:
 raise IOError()
-copied = self.copies.get(current_file)
+copied = self.current.copies.get(current_file)
 flags = parent_ctx.flags(path)
-is_exec = self.current_files_exec.get(current_file, 'x' in flags)
+is_exec = self.current.execfiles.get(current_file, 'x' in flags)
-is_link = self.current_files_symlink.get(current_file, 'l' in flags)
+is_link = self.current.symlinks.get(current_file, 'l' in flags)
-if current_file in self.current_files:
+if current_file in self.current.files:
-data = self.current_files[current_file]
+data = self.current.files[current_file]
 if is_link and data.startswith('link '):
 data = data[len('link '):]
 elif is_link:
 self.ui.warn('file marked as link, but contains data: '
 '%s (%r)\n' % (current_file, flags))
 util.describe_commit(self.ui, new_hash, branch)
 if (rev.revnum, branch) not in self.revmap:
 self.revmap[rev.revnum, branch] = new_hash
 # 2. handle branches that need to be committed without any files
-for branch in self.commit_branches_empty:
+for branch in self.current.emptybranches:
 ha = self.get_parent_revision(rev.revnum, branch)
 if ha == node.nullid:
 continue
 parent_ctx = self.repo.changectx(ha)
 def del_all_files(*args):
 raise IOError
 # True here meant nuke all files, shouldn't happen with branch closing
-if self.commit_branches_empty[branch]: #pragma: no cover
+if self.current.emptybranches[branch]: #pragma: no cover
 raise hgutil.Abort('Empty commit to an open branch attempted. '
 'Please report this issue.')
 extra = util.build_extra(rev.revnum, branch, self.uuid, self.subdir)
 if not self.usebranchnames:
 extra.pop('branch', None)
 if parent is None:
 continue
 self.delbranch(branch, parent, rev)
 self._save_metadata()
-self.clear_current_info()
+self.current.clear()
 def delbranch(self, branch, node, rev):
 pctx = self.repo[node]
 files = pctx.manifest().keys()
 extra = {'close': 1}
 @ieditor
 def delete_entry(self, path, revision_bogus, parent_baton, pool=None):
 br_path, branch = self._path_and_branch_for_path(path)
 if br_path == '':
-self.branches_to_delete.add(branch)
+self.current.closebranches.add(branch)
 if br_path is not None:
-ha = self.get_parent_revision(self.current_rev.revnum, branch)
+ha = self.get_parent_revision(self.current.rev.revnum, branch)
 if ha == revlog.nullid:
 return
 ctx = self.repo.changectx(ha)
 if br_path not in ctx:
 br_path2 = ''
 if br_path != '':
 br_path2 = br_path + '/'
 # assuming it is a directory
-self.externals[path] = None
+self.current.externals[path] = None
-map(self.delete_file, [pat for pat in self.current_files.iterkeys()
+map(self.delete_file, [pat for pat in self.current.files.iterkeys()
 if pat.startswith(path+'/')])
 for f in ctx.walk(util.PrefixMatch(br_path2)):
 f_p = '%s/%s' % (path, f[len(br_path2):])
-if f_p not in self.current_files:
+if f_p not in self.current.files:
 self.delete_file(f_p)
 self.delete_file(path)
 @ieditor
 def open_file(self, path, parent_baton, base_revision, p=None):
-self.current_file = None
+self.current.file = None
 fpath, branch = self._path_and_branch_for_path(path)
 if not fpath:
 self.ui.debug('WARNING: Opening non-existant file %s\n' % path)
 return
-self.current_file = path
+self.current.file = path
 self.ui.note('M %s\n' % path)
 if base_revision != -1:
-self.base_revision = base_revision
+self.current.base = base_revision
 else:
-self.base_revision = None
+self.current.base = None
-if self.current_file in self.current_files:
+if self.current.file in self.current.files:
 return
 baserev = base_revision
 if baserev is None or baserev == -1:
-baserev = self.current_rev.revnum - 1
+baserev = self.current.rev.revnum - 1
 parent = self.get_parent_revision(baserev + 1, branch)
 ctx = self.repo[parent]
 if not self._is_path_valid(path):
 return
 if fpath not in ctx:
-self.missing_plaintexts.add(path)
+self.current.missing.add(path)
 fctx = ctx.filectx(fpath)
 base = fctx.data()
 if 'l' in fctx.flags():
 base = 'link ' + base
 self.set_file(path, base, 'x' in fctx.flags(), 'l' in fctx.flags())
 @ieditor
 def add_file(self, path, parent_baton=None, copyfrom_path=None,
 copyfrom_revision=None, file_pool=None):
-self.current_file = None
+self.current.file = None
-self.base_revision = None
+self.current.base = None
-if path in self.deleted_files:
+if path in self.current.deleted:
-del self.deleted_files[path]
+del self.current.deleted[path]
 fpath, branch = self._path_and_branch_for_path(path, existing=False)
 if not fpath:
 return
 if branch not in self.branches:
 # we know this branch will exist now, because it has at least one file. Rock.
-self.branches[branch] = None, 0, self.current_rev.revnum
+self.branches[branch] = None, 0, self.current.rev.revnum
-self.current_file = path
+self.current.file = path
 if not copyfrom_path:
 self.ui.note('A %s\n' % path)
 self.set_file(path, '', False, False)
 return
 self.ui.note('A+ %s\n' % path)
 (from_file,
 from_branch) = self._path_and_branch_for_path(copyfrom_path)
 if not from_file:
-self.missing_plaintexts.add(path)
+self.current.missing.add(path)
 return
 ha = self.get_parent_revision(copyfrom_revision + 1,
 from_branch)
 ctx = self.repo.changectx(ha)
 if from_file in ctx:
 fctx = ctx.filectx(from_file)
 flags = fctx.flags()
 self.set_file(path, fctx.data(), 'x' in flags, 'l' in flags)
 if from_branch == branch:
-parentid = self.get_parent_revision(self.current_rev.revnum,
+parentid = self.get_parent_revision(self.current.rev.revnum,
 branch)
 if parentid != revlog.nullid:
 parentctx = self.repo.changectx(parentid)
 if util.aresamefiles(parentctx, ctx, [from_file]):
-self.copies[path] = from_file
+self.current.copies[path] = from_file
 @ieditor
 def add_directory(self, path, parent_baton, copyfrom_path,
 copyfrom_revision, dir_pool=None):
-self.dir_batons[path] = path
+self.current.batons[path] = path
 br_path, branch = self._path_and_branch_for_path(path)
 if br_path is not None:
 if not copyfrom_path and not br_path:
-self.commit_branches_empty[branch] = True
+self.current.emptybranches[branch] = True
 else:
-self.commit_branches_empty[branch] = False
+self.current.emptybranches[branch] = False
 if br_path is None or not copyfrom_path:
 return path
 if copyfrom_path:
 tag = self._is_path_tag(copyfrom_path)
 if tag not in self.tags:
 tag = None
 if not self._is_path_valid(copyfrom_path) and not tag:
-self.missing_plaintexts.add('%s/' % path)
+self.current.missing.add('%s/' % path)
 return path
 if tag:
 source_branch, source_rev = self.tags[tag]
 cp_f = ''
 else:
 source_rev = copyfrom_revision
 cp_f, source_branch = self._path_and_branch_for_path(copyfrom_path)
 if cp_f == '' and br_path == '':
 assert br_path is not None
-self.branches[branch] = source_branch, source_rev, self.current_rev.revnum
+self.branches[branch] = source_branch, source_rev, self.current.rev.revnum
 new_hash = self.get_parent_revision(source_rev + 1,
 source_branch)
 if new_hash == node.nullid:
-self.missing_plaintexts.add('%s/' % path)
+self.current.missing.add('%s/' % path)
 return path
 cp_f_ctx = self.repo.changectx(new_hash)
 if cp_f != '/' and cp_f != '':
 cp_f = '%s/' % cp_f
 else:
 continue
 f2 = f[len(cp_f):]
 fctx = cp_f_ctx.filectx(f)
 fp_c = path + '/' + f2
 self.set_file(fp_c, fctx.data(), 'x' in fctx.flags(), 'l' in fctx.flags())
-if fp_c in self.deleted_files:
+if fp_c in self.current.deleted:
-del self.deleted_files[fp_c]
+del self.current.deleted[fp_c]
 if branch == source_branch:
 copies[fp_c] = f
 if copies:
 # Preserve the directory copy records if no file was changed between
 # the source and destination revisions, or discard it completely.
-parentid = self.get_parent_revision(self.current_rev.revnum, branch)
+parentid = self.get_parent_revision(self.current.rev.revnum, branch)
 if parentid != revlog.nullid:
 parentctx = self.repo.changectx(parentid)
 if util.aresamefiles(parentctx, cp_f_ctx, copies.values()):
-self.copies.update(copies)
+self.current.copies.update(copies)
 return path
 @ieditor
 def change_file_prop(self, file_baton, name, value, pool=None):
 if name == 'svn:executable':
-self.current_files_exec[self.current_file] = bool(value is not None)
+self.current.execfiles[self.current.file] = bool(value is not None)
 elif name == 'svn:special':
-self.current_files_symlink[self.current_file] = bool(value is not None)
+self.current.symlinks[self.current.file] = bool(value is not None)
 @ieditor
 def change_dir_prop(self, dir_baton, name, value, pool=None):
 if dir_baton is None:
 return
-path = self.dir_batons[dir_baton]
+path = self.current.batons[dir_baton]
 if name == 'svn:externals':
-self.externals[path] = value
+self.current.externals[path] = value
 @ieditor
 def open_directory(self, path, parent_baton, base_revision, dir_pool=None):
-self.dir_batons[path] = path
+self.current.batons[path] = path
 p_, branch = self._path_and_branch_for_path(path)
 if p_ == '':
-self.commit_branches_empty[branch] = False
+self.current.emptybranches[branch] = False
 return path
 @ieditor
 def close_directory(self, dir_baton, dir_pool=None):
 if dir_baton is not None:
-del self.dir_batons[dir_baton]
+del self.current.batons[dir_baton]
 @ieditor
 def apply_textdelta(self, file_baton, base_checksum, pool=None):
 # We know coming in here the file must be one of the following options:
 # 1) Deleted (invalid, fail an assertion)
 # 2) Missing a base text (bail quick since we have to fetch a full plaintext)
-# 3) Has a base text in self.current_files, apply deltas
+# 3) Has a base text in self.current.files, apply deltas
 base = ''
-if not self._is_path_valid(self.current_file):
+if not self._is_path_valid(self.current.file):
 return lambda x: None
-assert self.current_file not in self.deleted_files, (
+assert self.current.file not in self.current.deleted, (
-'Cannot apply_textdelta to a deleted file: %s' % self.current_file)
+'Cannot apply_textdelta to a deleted file: %s' % self.current.file)
-assert (self.current_file in self.current_files
+assert (self.current.file in self.current.files
-or self.current_file in self.missing_plaintexts), '%s not found' % self.current_file
+or self.current.file in self.current.missing), '%s not found' % self.current.file
-if self.current_file in self.missing_plaintexts:
+if self.current.file in self.current.missing:
 return lambda x: None
-base = self.current_files[self.current_file]
+base = self.current.files[self.current.file]
 source = cStringIO.StringIO(base)
 target = cStringIO.StringIO()
 self.stream = target
 handler, baton = delta.svn_txdelta_apply(source, target, None)
 if not callable(handler): #pragma: no cover
 raise hgutil.Abort('Error in Subversion bindings: '
 'cannot call handler!')
 def txdelt_window(window):
 try:
-if not self._is_path_valid(self.current_file):
+if not self._is_path_valid(self.current.file):
 return
 handler(window, baton)
 # window being None means commit this file
 if not window:
-self.current_files[self.current_file] = target.getvalue()
+self.current.files[self.current.file] = target.getvalue()
 except core.SubversionException, e: #pragma: no cover
 if e.apr_err == core.SVN_ERR_INCOMPLETE_DATA:
-self.missing_plaintexts.add(self.current_file)
+self.current.missing.add(self.current.file)
 else: #pragma: no cover
 raise hgutil.Abort(*e.args)
 except: #pragma: no cover
-print len(base), self.current_file
+print len(base), self.current.file
 self._exception_info = sys.exc_info()
 raise
 return txdelt_window

Mercurial > hgsubversion

comparison hgsubversion/hg_delta_editor.py @ 411:d71972428fce