mercurial: comparison hgext/convert/subversion.py

equal deleted inserted replaced

-:1a6d702e059d
+:b9ec04eb2aa3
 try:
 tagid = self.latest(source, sourcerev)
 if tagid and tagname not in tags:
 tags[tagname] = tagid
 except SvnPathNotFound:
-# It happens when we are following directories we assumed
+# It happens when we are following directories
-# were copied with their parents but were really created
+# we assumed were copied with their parents
-# in the tag directory.
+# but were really created in the tag
+# directory.
 pass
 pendings = remainings
 tagspath = srctagspath
 except SubversionException:
 except SubversionException:
 dirent = None
 if not dirent:
 raise SvnPathNotFound(_('%s not found up to revision %d') % (path, stop))
-# stat() gives us the previous revision on this line of development, but
+# stat() gives us the previous revision on this line of
-# it might be in *another module*. Fetch the log and detect renames down
+# development, but it might be in *another module*. Fetch the
-# to the latest revision.
+# log and detect renames down to the latest revision.
 stream = self._getlog([path], stop, dirent.created_rev)
 try:
 for entry in stream:
 paths, revnum, author, date, message = entry
 if revnum <= dirent.created_rev:
 self.prevmodule = module
 return prevmodule
 def expandpaths(self, rev, paths, parents):
 entries = []
-copyfrom = {} # Map of entrypath, revision for finding source of deleted revisions.
+# Map of entrypath, revision for finding source of deleted
+# revisions.
+copyfrom = {}
 copies = {}
 new_module, revnum = self.revsplit(rev)[1:]
 if new_module != self.module:
 self.module = new_module
 kind = self._checkpath(entrypath, revnum)
 if kind == svn.core.svn_node_file:
 entries.append(self.recode(entry))
 if not ent.copyfrom_path or not parents:
 continue
-# Copy sources not in parent revisions cannot be represented,
+# Copy sources not in parent revisions cannot be
-# ignore their origin for now
+# represented, ignore their origin for now
 pmodule, prevnum = self.revsplit(parents[0])[1:]
 if ent.copyfrom_rev < prevnum:
 continue
 copyfrom_path = self.getrelpath(ent.copyfrom_path, pmodule)
 if not copyfrom_path:
 (entrypath, copyfrom_path, ent.copyfrom_rev))
 copies[self.recode(entry)] = self.recode(copyfrom_path)
 elif kind == 0: # gone, but had better be a deleted *file*
 self.ui.debug(_("gone from %s\n") % ent.copyfrom_rev)
-# if a branch is created but entries are removed in the same
+# if a branch is created but entries are removed in
-# changeset, get the right fromrev
+# the same changeset, get the right fromrev
-# parents cannot be empty here, you cannot remove things from
+# parents cannot be empty here, you cannot remove
-# a root revision.
+# things from a root revision.
 uuid, old_module, fromrev = self.revsplit(parents[0])
 basepath = old_module + "/" + self.getrelpath(path)
 entrypath = basepath
 self.ui.debug(_("base, entry %s %s\n") % (basepath, entrypath))
 frompath, froment = lookup_parts(entrypath) or (None, revnum - 1)
-# need to remove fragment from lookup_parts and replace with copyfrom_path
+# need to remove fragment from lookup_parts and
+# replace with copyfrom_path
 if frompath is not None:
 self.ui.debug(_("munge-o-matic\n"))
 self.ui.debug(entrypath + '\n')
 self.ui.debug(entrypath[len(frompath):] + '\n')
 entrypath = froment.copyfrom_path + entrypath[len(frompath):]
 fromrev = froment.copyfrom_rev
 self.ui.debug(_("info: %s %s %s %s\n") % (frompath, froment, ent, entrypath))
-# We can avoid the reparent calls if the module has not changed
+# We can avoid the reparent calls if the module has
-# but it probably does not worth the pain.
+# not changed but it probably does not worth the pain.
 prevmodule = self.reparent('')
 fromkind = svn.ra.check_path(self.ra, entrypath.strip('/'), fromrev)
 self.reparent(prevmodule)
 if fromkind == svn.core.svn_node_file:   # a deleted file
 entries.append(self.recode(entry))
 elif fromkind == svn.core.svn_node_dir:
 # print "Deleted/moved non-file:", revnum, path, ent
 # children = self._find_children(path, revnum - 1)
-# print "find children %s@%d from %d action %s" % (path, revnum, ent.copyfrom_rev, ent.action)
+# print ("find children %s@%d from %d action %s" %
+#        (path, revnum, ent.copyfrom_rev, ent.action))
 # Sometimes this is tricky. For example: in
 # The Subversion Repository revision 6940 a dir
 # was copied and one of its files was deleted
 # from the new location in the same commit. This
 # code can't deal with that yet.
 if ent.action == 'M':
 continue
 # Also this could create duplicate entries. Not sure
 # whether this will matter. Maybe should make entries a set.
-# print "Changed directory", revnum, path, ent.action, ent.copyfrom_path, ent.copyfrom_rev
+# print "Changed directory", revnum, path, ent.action, \
+#     ent.copyfrom_path, ent.copyfrom_rev
 # This will fail if a directory was copied
 # from another branch and then some of its files
 # were deleted in the same transaction.
 children = sorted(self._find_children(path, revnum))
 for child in children:
 # Need to filter out directories here...
 kind = self._checkpath(entrypath, revnum)
 if kind != svn.core.svn_node_dir:
 entries.append(self.recode(entrypath))
-# Copies here (must copy all from source)
+# Copies here (must copy all from source) Probably not
-# Probably not a real problem for us if
+# a real problem for us if source does not exist
-# source does not exist
 if not ent.copyfrom_path or not parents:
 continue
-# Copy sources not in parent revisions cannot be represented,
+# Copy sources not in parent revisions cannot be
-# ignore their origin for now
+# represented, ignore their origin for now
 pmodule, prevnum = self.revsplit(parents[0])[1:]
 if ent.copyfrom_rev < prevnum:
 continue
 copyfrompath = ent.copyfrom_path.decode(self.encoding)
 copyfrompath = self.getrelpath(copyfrompath, pmodule)

changeset 8660	b9ec04eb2aa3
parent 8339	f55869abb5c3
child 8693	68e0a55eee6e