convert: handle percent-encoded bytes in file URLs like Subversion
75b59d221aa3 added most of the code that gets removed by this patch. It helped
making progress on Python 3, but the reasoning was wrong in many ways. I tried
to retract it while it was queued, but it was too late.
Back then, I was asssuming that what happened on Python 2 (preserving bytes) is
correct and my Python 3 change is a hack. However it turned out that Subversion
interprets percent-encoded bytes as UTF-8. Accepting the same format as
Subversion is a good idea.
Consistency with urlreq.pathname2url() (as described in the removed comment)
doesn’t matter because that function is only used for passing paths to urllib.
This is not a backwards-incompatible change because before
5c0d5b48e58c,
non-ASCII filenames didn’t work at all on Python 2.
When the locale encoding is ISO-8859-15, `svn` accepts `file:///tmp/a%E2%82%AC`
for `/tmp/a€`. Before this patch, this was the case for this extension on
Python 3, but not on Python 2. This patch makes it work like with `svn` on both
Python 2 and Python 3.
# gnuarch.py - GNU Arch support for the convert extension
#
# Copyright 2008, 2009 Aleix Conchillo Flaque <aleix@member.fsf.org>
# and others
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from __future__ import absolute_import
import os
import shutil
import stat
import tempfile
from mercurial.i18n import _
from mercurial import (
encoding,
error,
mail,
pycompat,
util,
)
from mercurial.utils import (
dateutil,
procutil,
)
from . import common
class gnuarch_source(common.converter_source, common.commandline):
class gnuarch_rev(object):
def __init__(self, rev):
self.rev = rev
self.summary = b''
self.date = None
self.author = b''
self.continuationof = None
self.add_files = []
self.mod_files = []
self.del_files = []
self.ren_files = {}
self.ren_dirs = {}
def __init__(self, ui, repotype, path, revs=None):
super(gnuarch_source, self).__init__(ui, repotype, path, revs=revs)
if not os.path.exists(os.path.join(path, b'{arch}')):
raise common.NoRepo(
_(b"%s does not look like a GNU Arch repository") % path
)
# Could use checktool, but we want to check for baz or tla.
self.execmd = None
if procutil.findexe(b'baz'):
self.execmd = b'baz'
else:
if procutil.findexe(b'tla'):
self.execmd = b'tla'
else:
raise error.Abort(_(b'cannot find a GNU Arch tool'))
common.commandline.__init__(self, ui, self.execmd)
self.path = os.path.realpath(path)
self.tmppath = None
self.treeversion = None
self.lastrev = None
self.changes = {}
self.parents = {}
self.tags = {}
self.encoding = encoding.encoding
self.archives = []
def before(self):
# Get registered archives
self.archives = [
i.rstrip(b'\n') for i in self.runlines0(b'archives', b'-n')
]
if self.execmd == b'tla':
output = self.run0(b'tree-version', self.path)
else:
output = self.run0(b'tree-version', b'-d', self.path)
self.treeversion = output.strip()
# Get name of temporary directory
version = self.treeversion.split(b'/')
self.tmppath = os.path.join(
pycompat.fsencode(tempfile.gettempdir()), b'hg-%s' % version[1]
)
# Generate parents dictionary
self.parents[None] = []
treeversion = self.treeversion
child = None
while treeversion:
self.ui.status(_(b'analyzing tree version %s...\n') % treeversion)
archive = treeversion.split(b'/')[0]
if archive not in self.archives:
self.ui.status(
_(
b'tree analysis stopped because it points to '
b'an unregistered archive %s...\n'
)
% archive
)
break
# Get the complete list of revisions for that tree version
output, status = self.runlines(
b'revisions', b'-r', b'-f', treeversion
)
self.checkexit(
status, b'failed retrieving revisions for %s' % treeversion
)
# No new iteration unless a revision has a continuation-of header
treeversion = None
for l in output:
rev = l.strip()
self.changes[rev] = self.gnuarch_rev(rev)
self.parents[rev] = []
# Read author, date and summary
catlog, status = self.run(b'cat-log', b'-d', self.path, rev)
if status:
catlog = self.run0(b'cat-archive-log', rev)
self._parsecatlog(catlog, rev)
# Populate the parents map
self.parents[child].append(rev)
# Keep track of the current revision as the child of the next
# revision scanned
child = rev
# Check if we have to follow the usual incremental history
# or if we have to 'jump' to a different treeversion given
# by the continuation-of header.
if self.changes[rev].continuationof:
treeversion = b'--'.join(
self.changes[rev].continuationof.split(b'--')[:-1]
)
break
# If we reached a base-0 revision w/o any continuation-of
# header, it means the tree history ends here.
if rev[-6:] == b'base-0':
break
def after(self):
self.ui.debug(b'cleaning up %s\n' % self.tmppath)
shutil.rmtree(self.tmppath, ignore_errors=True)
def getheads(self):
return self.parents[None]
def getfile(self, name, rev):
if rev != self.lastrev:
raise error.Abort(_(b'internal calling inconsistency'))
if not os.path.lexists(os.path.join(self.tmppath, name)):
return None, None
return self._getfile(name, rev)
def getchanges(self, rev, full):
if full:
raise error.Abort(_(b"convert from arch does not support --full"))
self._update(rev)
changes = []
copies = {}
for f in self.changes[rev].add_files:
changes.append((f, rev))
for f in self.changes[rev].mod_files:
changes.append((f, rev))
for f in self.changes[rev].del_files:
changes.append((f, rev))
for src in self.changes[rev].ren_files:
to = self.changes[rev].ren_files[src]
changes.append((src, rev))
changes.append((to, rev))
copies[to] = src
for src in self.changes[rev].ren_dirs:
to = self.changes[rev].ren_dirs[src]
chgs, cps = self._rendirchanges(src, to)
changes += [(f, rev) for f in chgs]
copies.update(cps)
self.lastrev = rev
return sorted(set(changes)), copies, set()
def getcommit(self, rev):
changes = self.changes[rev]
return common.commit(
author=changes.author,
date=changes.date,
desc=changes.summary,
parents=self.parents[rev],
rev=rev,
)
def gettags(self):
return self.tags
def _execute(self, cmd, *args, **kwargs):
cmdline = [self.execmd, cmd]
cmdline += args
cmdline = [procutil.shellquote(arg) for arg in cmdline]
bdevnull = pycompat.bytestr(os.devnull)
cmdline += [b'>', bdevnull, b'2>', bdevnull]
cmdline = procutil.quotecommand(b' '.join(cmdline))
self.ui.debug(cmdline, b'\n')
return os.system(pycompat.rapply(procutil.tonativestr, cmdline))
def _update(self, rev):
self.ui.debug(b'applying revision %s...\n' % rev)
changeset, status = self.runlines(b'replay', b'-d', self.tmppath, rev)
if status:
# Something went wrong while merging (baz or tla
# issue?), get latest revision and try from there
shutil.rmtree(self.tmppath, ignore_errors=True)
self._obtainrevision(rev)
else:
old_rev = self.parents[rev][0]
self.ui.debug(
b'computing changeset between %s and %s...\n' % (old_rev, rev)
)
self._parsechangeset(changeset, rev)
def _getfile(self, name, rev):
mode = os.lstat(os.path.join(self.tmppath, name)).st_mode
if stat.S_ISLNK(mode):
data = util.readlink(os.path.join(self.tmppath, name))
if mode:
mode = b'l'
else:
mode = b''
else:
data = util.readfile(os.path.join(self.tmppath, name))
mode = (mode & 0o111) and b'x' or b''
return data, mode
def _exclude(self, name):
exclude = [b'{arch}', b'.arch-ids', b'.arch-inventory']
for exc in exclude:
if name.find(exc) != -1:
return True
return False
def _readcontents(self, path):
files = []
contents = os.listdir(path)
while len(contents) > 0:
c = contents.pop()
p = os.path.join(path, c)
# os.walk could be used, but here we avoid internal GNU
# Arch files and directories, thus saving a lot time.
if not self._exclude(p):
if os.path.isdir(p):
contents += [os.path.join(c, f) for f in os.listdir(p)]
else:
files.append(c)
return files
def _rendirchanges(self, src, dest):
changes = []
copies = {}
files = self._readcontents(os.path.join(self.tmppath, dest))
for f in files:
s = os.path.join(src, f)
d = os.path.join(dest, f)
changes.append(s)
changes.append(d)
copies[d] = s
return changes, copies
def _obtainrevision(self, rev):
self.ui.debug(b'obtaining revision %s...\n' % rev)
output = self._execute(b'get', rev, self.tmppath)
self.checkexit(output)
self.ui.debug(b'analyzing revision %s...\n' % rev)
files = self._readcontents(self.tmppath)
self.changes[rev].add_files += files
def _stripbasepath(self, path):
if path.startswith(b'./'):
return path[2:]
return path
def _parsecatlog(self, data, rev):
try:
catlog = mail.parsebytes(data)
# Commit date
self.changes[rev].date = dateutil.datestr(
dateutil.strdate(catlog['Standard-date'], b'%Y-%m-%d %H:%M:%S')
)
# Commit author
self.changes[rev].author = self.recode(catlog['Creator'])
# Commit description
self.changes[rev].summary = b'\n\n'.join(
(
self.recode(catlog['Summary']),
self.recode(catlog.get_payload()),
)
)
self.changes[rev].summary = self.recode(self.changes[rev].summary)
# Commit revision origin when dealing with a branch or tag
if 'Continuation-of' in catlog:
self.changes[rev].continuationof = self.recode(
catlog['Continuation-of']
)
except Exception:
raise error.Abort(_(b'could not parse cat-log of %s') % rev)
def _parsechangeset(self, data, rev):
for l in data:
l = l.strip()
# Added file (ignore added directory)
if l.startswith(b'A') and not l.startswith(b'A/'):
file = self._stripbasepath(l[1:].strip())
if not self._exclude(file):
self.changes[rev].add_files.append(file)
# Deleted file (ignore deleted directory)
elif l.startswith(b'D') and not l.startswith(b'D/'):
file = self._stripbasepath(l[1:].strip())
if not self._exclude(file):
self.changes[rev].del_files.append(file)
# Modified binary file
elif l.startswith(b'Mb'):
file = self._stripbasepath(l[2:].strip())
if not self._exclude(file):
self.changes[rev].mod_files.append(file)
# Modified link
elif l.startswith(b'M->'):
file = self._stripbasepath(l[3:].strip())
if not self._exclude(file):
self.changes[rev].mod_files.append(file)
# Modified file
elif l.startswith(b'M'):
file = self._stripbasepath(l[1:].strip())
if not self._exclude(file):
self.changes[rev].mod_files.append(file)
# Renamed file (or link)
elif l.startswith(b'=>'):
files = l[2:].strip().split(b' ')
if len(files) == 1:
files = l[2:].strip().split(b'\t')
src = self._stripbasepath(files[0])
dst = self._stripbasepath(files[1])
if not self._exclude(src) and not self._exclude(dst):
self.changes[rev].ren_files[src] = dst
# Conversion from file to link or from link to file (modified)
elif l.startswith(b'ch'):
file = self._stripbasepath(l[2:].strip())
if not self._exclude(file):
self.changes[rev].mod_files.append(file)
# Renamed directory
elif l.startswith(b'/>'):
dirs = l[2:].strip().split(b' ')
if len(dirs) == 1:
dirs = l[2:].strip().split(b'\t')
src = self._stripbasepath(dirs[0])
dst = self._stripbasepath(dirs[1])
if not self._exclude(src) and not self._exclude(dst):
self.changes[rev].ren_dirs[src] = dst