This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12368

mercurial: use io.BytesIO instead of util.stringio
Needs RevisionPublic

Authored by indygreg on Mar 9 2022, 8:07 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Summary

util.stringio is an alias to io.BytesIO. Let's just use io.BytesIO
directly.

I'm doing this because I noticed pytype was confused about types due to
the indirection.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

indygreg created this revision.Mar 9 2022, 8:07 PM
Alphare requested changes to this revision.Mar 14 2022, 6:23 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
mercurial/patch.py
601

This is unrelated and will probably break the current version of the CI (now that I think of it, I was supposed to figure out how to properly fix this annoyance last week and got sidetracked. I'll try to get to it this week.)

This revision now requires changes to proceed.Mar 14 2022, 6:23 AM

Revision Contents
Changeset List

Diff 32622

mercurial/archival.py

# archival.py - revision archival for mercurial # archival.py - revision archival for mercurial
# #
# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> # Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
import gzip import gzip
import io
import os import os
import struct import struct
import tarfile import tarfile
import time import time
import zipfile import zipfile
import zlib import zlib
from .i18n import _ from .i18n import _
from .node import nullrev from .node import nullrev
from .pycompat import open from .pycompat import open
from . import ( from . import (
error, error,
formatter, formatter,
match as matchmod, match as matchmod,
pycompat, pycompat,
scmutil, scmutil,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from .utils import stringutil from .utils import stringutil
stringio = util.stringio
# from unzip source code: # from unzip source code:
_UNX_IFREG = 0x8000 _UNX_IFREG = 0x8000
_UNX_IFLNK = 0xA000 _UNX_IFLNK = 0xA000
def tidyprefix(dest, kind, prefix): def tidyprefix(dest, kind, prefix):
"""choose prefix to use for names in archive. make sure prefix is """choose prefix to use for names in archive. make sure prefix is
safe for consumers.""" safe for consumers."""
repo = ctx.repo() repo = ctx.repo()
opts = { opts = {
b'template': repo.ui.config( b'template': repo.ui.config(
b'experimental', b'archivemetatemplate', _defaultmetatemplate b'experimental', b'archivemetatemplate', _defaultmetatemplate
) )
} }
out = util.stringio() out = io.BytesIO()
fm = formatter.formatter(repo.ui, out, b'archive', opts) fm = formatter.formatter(repo.ui, out, b'archive', opts)
fm.startitem() fm.startitem()
fm.context(ctx=ctx) fm.context(ctx=ctx)
fm.data(root=_rootctx(repo).hex()) fm.data(root=_rootctx(repo).hex())
if ctx.rev() is None: if ctx.rev() is None:
dirty = b'' dirty = b''
if islink: if islink:
i.type = tarfile.SYMTYPE i.type = tarfile.SYMTYPE
i.mode = 0o777 i.mode = 0o777
i.linkname = pycompat.fsdecode(data) i.linkname = pycompat.fsdecode(data)
data = None data = None
i.size = 0 i.size = 0
else: else:
i.mode = mode i.mode = mode
data = stringio(data) data = io.BytesIO(data)
self.z.addfile(i, data) self.z.addfile(i, data)
def done(self): def done(self):
self.z.close() self.z.close()
if self.fileobj: if self.fileobj:
self.fileobj.close() self.fileobj.close()

mercurial/cmdutil.py

# cmdutil.py - help for command processing in mercurial # cmdutil.py - help for command processing in mercurial
# #
# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
import copy as copymod import copy as copymod
import errno import errno
import io
import os import os
import re import re
from .i18n import _ from .i18n import _
from .node import ( from .node import (
hex, hex,
nullrev, nullrev,
short, short,
from typing import ( from typing import (
Any, Any,
Dict, Dict,
) )
for t in (Any, Dict): for t in (Any, Dict):
assert t assert t
stringio = util.stringio
# templates of common command options # templates of common command options
dryrunopts = [ dryrunopts = [
(b'n', b'dry-run', None, _(b'do not perform actions, just print output')), (b'n', b'dry-run', None, _(b'do not perform actions, just print output')),
] ]
confirmopts = [ confirmopts = [
(b'', b'confirm', None, _(b'ask before applying actions')), (b'', b'confirm', None, _(b'ask before applying actions')),
fd, tmpname = pycompat.mkstemp( fd, tmpname = pycompat.mkstemp(
prefix=os.path.basename(f) + b'.', dir=backupdir prefix=os.path.basename(f) + b'.', dir=backupdir
) )
os.close(fd) os.close(fd)
ui.debug(b'backup %r as %r\n' % (f, tmpname)) ui.debug(b'backup %r as %r\n' % (f, tmpname))
util.copyfile(repo.wjoin(f), tmpname, copystat=True) util.copyfile(repo.wjoin(f), tmpname, copystat=True)
backups[f] = tmpname backups[f] = tmpname
fp = stringio() fp = io.BytesIO()
for c in chunks: for c in chunks:
fname = c.filename() fname = c.filename()
if fname in backups: if fname in backups:
c.write(fp) c.write(fp)
dopatch = fp.tell() dopatch = fp.tell()
fp.seek(0) fp.seek(0)
# 2.5 optionally review / modify patch in text editor # 2.5 optionally review / modify patch in text editor
# performing a partial revert of the added file, the only option is # performing a partial revert of the added file, the only option is
# "remove added file <name> (Yn)?", so we don't need to worry about the # "remove added file <name> (Yn)?", so we don't need to worry about the
# alsorestore value. Ideally we'd be able to partially revert # alsorestore value. Ideally we'd be able to partially revert
# copied/renamed files. # copied/renamed files.
newlyaddedandmodifiedfiles, unusedalsorestore = newandmodified(chunks) newlyaddedandmodifiedfiles, unusedalsorestore = newandmodified(chunks)
if tobackup is None: if tobackup is None:
tobackup = set() tobackup = set()
# Apply changes # Apply changes
fp = stringio() fp = io.BytesIO()
# chunks are serialized per file, but files aren't sorted # chunks are serialized per file, but files aren't sorted
for f in sorted({c.header.filename() for c in chunks if ishunk(c)}): for f in sorted({c.header.filename() for c in chunks if ishunk(c)}):
prntstatusmsg(b'revert', f) prntstatusmsg(b'revert', f)
files = set() files = set()
for c in chunks: for c in chunks:
if ishunk(c): if ishunk(c):
abs = c.header.filename() abs = c.header.filename()
# Create a backup file only if this hunk should be backed up # Create a backup file only if this hunk should be backed up

mercurial/crecord.py

# stuff related specifically to patch manipulation / parsing # stuff related specifically to patch manipulation / parsing
# #
# Copyright 2008 Mark Edgington <edgimar@gmail.com> # Copyright 2008 Mark Edgington <edgimar@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
# #
# This code is based on the Mark Edgington's crecord extension. # This code is based on the Mark Edgington's crecord extension.
# (Itself based on Bryan O'Sullivan's record extension.) # (Itself based on Bryan O'Sullivan's record extension.)
import io
import os import os
import re import re
import signal import signal
from .i18n import _ from .i18n import _
from .pycompat import ( from .pycompat import (
getattr, getattr,
open, open,
) )
from . import ( from . import (
diffhelper, diffhelper,
encoding, encoding,
error, error,
patch as patchmod, patch as patchmod,
pycompat, pycompat,
scmutil, scmutil,
util, util,
) )
from .utils import stringutil from .utils import stringutil
stringio = util.stringio
# patch comments based on the git one # patch comments based on the git one
diffhelptext = _( diffhelptext = _(
b"""# To remove '-' lines, make them ' ' lines (context). b"""# To remove '-' lines, make them ' ' lines (context).
# To remove '+' lines, delete them. # To remove '+' lines, delete them.
# Lines starting with # will be removed from the patch. # Lines starting with # will be removed from the patch.
""" """
) )
# list of all headers in patch # list of all headers in patch
self.patch = None self.patch = None
# flag is False if this header was ever unfolded from initial state # flag is False if this header was ever unfolded from initial state
self.neverunfolded = True self.neverunfolded = True
self.hunks = [uihunk(h, self) for h in self.hunks] self.hunks = [uihunk(h, self) for h in self.hunks]
def prettystr(self): def prettystr(self):
x = stringio() x = io.BytesIO()
self.pretty(x) self.pretty(x)
return x.getvalue() return x.getvalue()
def nextsibling(self): def nextsibling(self):
numheadersinpatch = len(self.patch) numheadersinpatch = len(self.patch)
indexofthisheader = self.patch.index(self) indexofthisheader = self.patch.index(self)
if indexofthisheader < numheadersinpatch - 1: if indexofthisheader < numheadersinpatch - 1:
elif changedlinestr.startswith(b"-"): elif changedlinestr.startswith(b"-"):
hunklinelist.append(b" " + changedlinestr[1:]) hunklinelist.append(b" " + changedlinestr[1:])
fp.write(b''.join(self.before + hunklinelist + self.after)) fp.write(b''.join(self.before + hunklinelist + self.after))
pretty = write pretty = write
def prettystr(self): def prettystr(self):
x = stringio() x = io.BytesIO()
self.pretty(x) self.pretty(x)
return x.getvalue() return x.getvalue()
def reversehunk(self): def reversehunk(self):
"""return a recordhunk which is the reverse of the hunk """return a recordhunk which is the reverse of the hunk
Assuming the displayed patch is diff(A, B) result. The returned hunk is Assuming the displayed patch is diff(A, B) result. The returned hunk is
intended to be applied to B, instead of A. intended to be applied to B, instead of A.
self.ui.write(b"\n") self.ui.write(b"\n")
return None return None
if chunk.header.binary(): if chunk.header.binary():
self.ui.write(_(b'cannot edit patch for binary file')) self.ui.write(_(b'cannot edit patch for binary file'))
self.ui.write(b"\n") self.ui.write(b"\n")
return None return None
# write the initial patch # write the initial patch
patch = stringio() patch = io.BytesIO()
patch.write(diffhelptext + hunkhelptext) patch.write(diffhelptext + hunkhelptext)
chunk.header.write(patch) chunk.header.write(patch)
chunk.write(patch) chunk.write(patch)
# start the editor and wait for it to complete # start the editor and wait for it to complete
try: try:
patch = self.ui.edit(patch.getvalue(), b"", action=b"diff") patch = self.ui.edit(patch.getvalue(), b"", action=b"diff")
except error.Abort as exc: except error.Abort as exc:

mercurial/patch.py

# patch.py - patch file parsing routines # patch.py - patch file parsing routines
# #
# Copyright 2006 Brendan Cully <brendan@kublai.com> # Copyright 2006 Brendan Cully <brendan@kublai.com>
# Copyright 2007 Chris Mason <chris.mason@oracle.com> # Copyright 2007 Chris Mason <chris.mason@oracle.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
import collections import collections
import contextlib import contextlib
import copy import copy
import errno import errno
import io
import os import os
import re import re
import shutil import shutil
import zlib import zlib
from .i18n import _ from .i18n import _
from .node import ( from .node import (
hex, hex,
) )
from .utils import ( from .utils import (
dateutil, dateutil,
hashutil, hashutil,
procutil, procutil,
stringutil, stringutil,
) )
stringio = util.stringio
gitre = re.compile(br'diff --git a/(.*) b/(.*)') gitre = re.compile(br'diff --git a/(.*) b/(.*)')
tabsplitter = re.compile(br'(\t+|[^\t]+)') tabsplitter = re.compile(br'(\t+|[^\t]+)')
wordsplitter = re.compile( wordsplitter = re.compile(
br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|[^ \ta-zA-Z0-9_\x80-\xff])' br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|[^ \ta-zA-Z0-9_\x80-\xff])'
) )
PatchError = error.PatchError PatchError = error.PatchError
PatchParseError = error.PatchParseError PatchParseError = error.PatchParseError
return True return True
if line.startswith((b' ', b'-', b'+')): if line.startswith((b' ', b'-', b'+')):
# diff line - don't check for header pattern in there # diff line - don't check for header pattern in there
return False return False
l = line.split(b': ', 1) l = line.split(b': ', 1)
return len(l) == 2 and b' ' not in l[0] return len(l) == 2 and b' ' not in l[0]
def chunk(lines): def chunk(lines):
return stringio(b''.join(lines)) return io.BytesIO(b''.join(lines))
def hgsplit(stream, cur): def hgsplit(stream, cur):
inheader = True inheader = True
for line in stream: for line in stream:
if not line.strip(): if not line.strip():
inheader = False inheader = False
if not inheader and line.startswith(b'# HG changeset patch'): if not inheader and line.startswith(b'# HG changeset patch'):
cur.append(line) cur.append(line)
if cur: if cur:
for c in split(chunk(cur[1:])): for c in split(chunk(cur[1:])):
yield c yield c
def mimesplit(stream, cur): def mimesplit(stream, cur):
def msgfp(m): def msgfp(m):
fp = stringio() fp = io.BytesIO()
# pytype: disable=wrong-arg-types # pytype: disable=wrong-arg-types
g = mail.Generator(fp, mangle_from_=False) g = mail.Generator(fp, mangle_from_=False)
# pytype: enable=wrong-arg-types # pytype: enable=wrong-arg-types
g.flatten(m) g.flatten(m)
fp.seek(0) fp.seek(0)
return fp return fp
for line in stream: for line in stream:
m = diffre.search(payload) m = diffre.search(payload)
if m: if m:
hgpatch = False hgpatch = False
hgpatchheader = False hgpatchheader = False
ignoretext = False ignoretext = False
ui.debug(b'found patch at byte %d\n' % m.start(0)) ui.debug(b'found patch at byte %d\n' % m.start(0))
diffs_seen += 1 diffs_seen += 1
cfp = stringio() cfp = io.BytesIO()
for line in payload[: m.start(0)].splitlines(): for line in payload[: m.start(0)].splitlines():
if line.startswith(b'# HG changeset patch') and not hgpatch: if line.startswith(b'# HG changeset patch') and not hgpatch:
ui.debug(b'patch generated by hg export\n') ui.debug(b'patch generated by hg export\n')
hgpatch = True hgpatch = True
hgpatchheader = True hgpatchheader = True
# drop earlier commit message content # drop earlier commit message content
cfp.seek(0) cfp.seek(0)
cfp.truncate() cfp.truncate()
class filestore: class filestore:
def __init__(self, maxsize=None): def __init__(self, maxsize=None):
self.opener = None self.opener = None
self.files = {} self.files = {}
self.created = 0 self.created = 0
self.maxsize = maxsize self.maxsize = maxsize
if self.maxsize is None: if self.maxsize is None:
self.maxsize = 4 * (2 ** 20) self.maxsize = 4 * (2**20)
AlphareUnsubmitted
Not Done

This is unrelated and will probably break the current version of the CI (now that I think of it, I was supposed to figure out how to properly fix this annoyance last week and got sidetracked. I'll try to get to it this week.)

Alphare: This is unrelated and will probably break the current version of the CI (now that I think of it…
self.size = 0 self.size = 0
self.data = {} self.data = {}
def setfile(self, fname, data, mode, copied=None): def setfile(self, fname, data, mode, copied=None):
if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize: if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize:
self.data[fname] = (data, mode, copied) self.data[fname] = (data, mode, copied)
self.size += len(data) self.size += len(data)
else: else:
environ={b'HGUSER': ui.username()}, environ={b'HGUSER': ui.username()},
blockedtag=b'filterpatch', blockedtag=b'filterpatch',
) )
if ret != 0: if ret != 0:
ui.warn(_(b"editor exited with exit code %d\n") % ret) ui.warn(_(b"editor exited with exit code %d\n") % ret)
continue continue
# Remove comment lines # Remove comment lines
patchfp = open(patchfn, 'rb') patchfp = open(patchfn, 'rb')
ncpatchfp = stringio() ncpatchfp = io.BytesIO()
for line in patchfp: for line in patchfp:
line = util.fromnativeeol(line) line = util.fromnativeeol(line)
if not line.startswith(b'#'): if not line.startswith(b'#'):
ncpatchfp.write(line) ncpatchfp.write(line)
patchfp.close() patchfp.close()
ncpatchfp.seek(0) ncpatchfp.seek(0)
newpatches = parsepatch(ncpatchfp) newpatches = parsepatch(ncpatchfp)
finally: finally:
>>> hunks = parsepatch([rawpatch]) >>> hunks = parsepatch([rawpatch])
>>> hunkscomingfromfilterpatch = [] >>> hunkscomingfromfilterpatch = []
>>> for h in hunks: >>> for h in hunks:
... hunkscomingfromfilterpatch.append(h) ... hunkscomingfromfilterpatch.append(h)
... hunkscomingfromfilterpatch.extend(h.hunks) ... hunkscomingfromfilterpatch.extend(h.hunks)
>>> reversedhunks = reversehunks(hunkscomingfromfilterpatch) >>> reversedhunks = reversehunks(hunkscomingfromfilterpatch)
>>> from . import util >>> from . import util
>>> fp = util.stringio() >>> fp = io.BytesIO()
>>> for c in reversedhunks: >>> for c in reversedhunks:
... c.write(fp) ... c.write(fp)
>>> fp.seek(0) or None >>> fp.seek(0) or None
>>> reversedpatch = fp.read() >>> reversedpatch = fp.read()
>>> print(pycompat.sysstr(reversedpatch)) >>> print(pycompat.sysstr(reversedpatch))
diff --git a/folder1/g b/folder1/g diff --git a/folder1/g b/folder1/g
--- a/folder1/g --- a/folder1/g
+++ b/folder1/g +++ b/folder1/g
... 4 ... 4
... 5 ... 5
... 6 ... 6
... +6.1 ... +6.1
... +6.2 ... +6.2
... 7 ... 7
... 8 ... 8
... +9''' ... +9'''
>>> out = util.stringio() >>> out = io.BytesIO()
>>> headers = parsepatch([rawpatch], maxcontext=1) >>> headers = parsepatch([rawpatch], maxcontext=1)
>>> for header in headers: >>> for header in headers:
... header.write(out) ... header.write(out)
... for hunk in header.hunks: ... for hunk in header.hunks:
... hunk.write(out) ... hunk.write(out)
>>> print(pycompat.sysstr(out.getvalue())) >>> print(pycompat.sysstr(out.getvalue()))
diff --git a/folder1/g b/folder1/g diff --git a/folder1/g b/folder1/g
--- a/folder1/g --- a/folder1/g
b'file': newfile, b'file': newfile,
b'range': addrange, b'range': addrange,
}, },
b'range': {b'context': addcontext, b'hunk': addhunk}, b'range': {b'context': addcontext, b'hunk': addhunk},
b'other': {b'other': addother}, b'other': {b'other': addother},
} }
p = parser() p = parser()
fp = stringio() fp = io.BytesIO()
fp.write(b''.join(originalchunks)) fp.write(b''.join(originalchunks))
fp.seek(0) fp.seek(0)
state = b'context' state = b'context'
for newstate, data in scanpatch(fp): for newstate, data in scanpatch(fp):
try: try:
p.transitions[state][newstate](p, data) p.transitions[state][newstate](p, data)
except KeyError: except KeyError:
we scan the git patch for copy and rename commands so we can we scan the git patch for copy and rename commands so we can
perform the copies ahead of time. perform the copies ahead of time.
""" """
pos = 0 pos = 0
try: try:
pos = lr.fp.tell() pos = lr.fp.tell()
fp = lr.fp fp = lr.fp
except IOError: except IOError:
fp = stringio(lr.fp.read()) fp = io.BytesIO(lr.fp.read())
gitlr = linereader(fp) gitlr = linereader(fp)
gitlr.push(firstline) gitlr.push(firstline)
gitpatches = readgitpatch(gitlr) gitpatches = readgitpatch(gitlr)
fp.seek(pos) fp.seek(pos)
return gitpatches return gitpatches
def iterhunks(fp): def iterhunks(fp):

mercurial/profiling.py

# profiling.py - profiling functions # profiling.py - profiling functions
# #
# Copyright 2016 Gregory Szorc <gregory.szorc@gmail.com> # Copyright 2016 Gregory Szorc <gregory.szorc@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
import contextlib import contextlib
import io
from .i18n import _ from .i18n import _
from .pycompat import ( from .pycompat import (
getattr, getattr,
open, open,
) )
from . import ( from . import (
encoding, encoding,
_(b"unrecognized profiler '%s' - ignored\n") % profiler _(b"unrecognized profiler '%s' - ignored\n") % profiler
) )
profiler = b'stat' profiler = b'stat'
self._output = self._ui.config(b'profiling', b'output') self._output = self._ui.config(b'profiling', b'output')
try: try:
if self._output == b'blackbox': if self._output == b'blackbox':
self._fp = util.stringio() self._fp = io.BytesIO()
elif self._output: elif self._output:
path = util.expandpath(self._output) path = util.expandpath(self._output)
self._fp = open(path, b'wb') self._fp = open(path, b'wb')
elif pycompat.iswindows: elif pycompat.iswindows:
# parse escape sequence by win32print() # parse escape sequence by win32print()
class uifp: class uifp:
def __init__(self, ui): def __init__(self, ui):
self._ui = ui self._ui = ui

mercurial/pure/mpatch.py

# mpatch.py - Python implementation of mpatch.c # mpatch.py - Python implementation of mpatch.c
# #
# Copyright 2009 Olivia Mackall <olivia@selenic.com> and others # Copyright 2009 Olivia Mackall <olivia@selenic.com> and others
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
import io import io
import struct import struct
stringio = io.BytesIO
class mpatchError(Exception): class mpatchError(Exception):
"""error raised when a delta cannot be decoded""" """error raised when a delta cannot be decoded"""
# This attempts to apply a series of patches in time proportional to # This attempts to apply a series of patches in time proportional to
# the total size of the patches, rather than patches * len(text). This # the total size of the patches, rather than patches * len(text). This
# means rather than shuffling strings around, we shuffle around # means rather than shuffling strings around, we shuffle around
# pointers to fragments with fragment lists. # pointers to fragments with fragment lists.
pl = sum(plens) pl = sum(plens)
bl = len(a) + pl bl = len(a) + pl
tl = bl + bl + pl # enough for the patches and two working texts tl = bl + bl + pl # enough for the patches and two working texts
b1, b2 = 0, bl b1, b2 = 0, bl
if not tl: if not tl:
return a return a
m = stringio() m = io.BytesIO()
# load our original text # load our original text
m.write(a) m.write(a)
frags = [(len(a), b1)] frags = [(len(a), b1)]
# copy all the patches into our segment so we can memmove from them # copy all the patches into our segment so we can memmove from them
pos = b2 + bl pos = b2 + bl
m.seek(pos) m.seek(pos)

mercurial/pure/parsers.py

error, error,
revlogutils, revlogutils,
util, util,
) )
from ..revlogutils import nodemap as nodemaputil from ..revlogutils import nodemap as nodemaputil
from ..revlogutils import constants as revlog_constants from ..revlogutils import constants as revlog_constants
stringio = io.BytesIO
_pack = struct.pack _pack = struct.pack
_unpack = struct.unpack _unpack = struct.unpack
_compress = zlib.compress _compress = zlib.compress
_decompress = zlib.decompress _decompress = zlib.decompress
# a special value used internally for `size` if the file come from the other parent # a special value used internally for `size` if the file come from the other parent
if b'\0' in f: if b'\0' in f:
f, c = f.split(b'\0') f, c = f.split(b'\0')
copymap[f] = c copymap[f] = c
dmap[f] = DirstateItem.from_v1_data(*e[:4]) dmap[f] = DirstateItem.from_v1_data(*e[:4])
return parents return parents
def pack_dirstate(dmap, copymap, pl): def pack_dirstate(dmap, copymap, pl):
cs = stringio() cs = io.BytesIO()
write = cs.write write = cs.write
write(b"".join(pl)) write(b"".join(pl))
for f, e in dmap.items(): for f, e in dmap.items():
if f in copymap: if f in copymap:
f = b"%s\0%s" % (f, copymap[f]) f = b"%s\0%s" % (f, copymap[f])
e = _pack( e = _pack(
b">cllll", b">cllll",
e.v1_state(), e.v1_state(),
e.v1_mode(), e.v1_mode(),
e.v1_size(), e.v1_size(),
e.v1_mtime(), e.v1_mtime(),
len(f), len(f),
) )
write(e) write(e)
write(f) write(f)
return cs.getvalue() return cs.getvalue()

mercurial/url.py

# url.py - HTTP handling for mercurial # url.py - HTTP handling for mercurial
# #
# Copyright 2005, 2006, 2007, 2008 Olivia Mackall <olivia@selenic.com> # Copyright 2005, 2006, 2007, 2008 Olivia Mackall <olivia@selenic.com>
# Copyright 2006, 2007 Alexis S. L. Carvalho <alexis@cecm.usp.br> # Copyright 2006, 2007 Alexis S. L. Carvalho <alexis@cecm.usp.br>
# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> # Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
import base64 import base64
import io
import socket import socket
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from . import ( from . import (
encoding, encoding,
error, error,
httpconnection as httpconnectionmod, httpconnection as httpconnectionmod,
keepalive, keepalive,
pycompat, pycompat,
sslutil, sslutil,
urllibcompat, urllibcompat,
util, util,
) )
from .utils import ( from .utils import (
stringutil, stringutil,
urlutil, urlutil,
) )
httplib = util.httplib httplib = util.httplib
stringio = util.stringio
urlerr = util.urlerr urlerr = util.urlerr
urlreq = util.urlreq urlreq = util.urlreq
def escape(s, quote=None): def escape(s, quote=None):
"""Replace special characters "&", "<" and ">" to HTML-safe sequences. """Replace special characters "&", "<" and ">" to HTML-safe sequences.
If the optional flag quote is true, the quotation mark character (") If the optional flag quote is true, the quotation mark character (")
is also translated. is also translated.
res.version = 9 res.version = 9
else: else:
raise httplib.UnknownProtocol(version) raise httplib.UnknownProtocol(version)
if res.version == 9: if res.version == 9:
res.length = None res.length = None
res.chunked = 0 res.chunked = 0
res.will_close = 1 res.will_close = 1
res.msg = httplib.HTTPMessage(stringio()) res.msg = httplib.HTTPMessage(io.BytesIO())
return False return False
res.msg = httplib.HTTPMessage(res.fp) res.msg = httplib.HTTPMessage(res.fp)
res.msg.fp = None res.msg.fp = None
# are we using the chunked-style of transfer encoding? # are we using the chunked-style of transfer encoding?
trenc = res.msg.getheader(b'transfer-encoding') trenc = res.msg.getheader(b'transfer-encoding')
if trenc and trenc.lower() == b"chunked": if trenc and trenc.lower() == b"chunked":

mercurial/wireprotoserver.py

# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> # Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>
# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
import contextlib import contextlib
import io
import struct import struct
import threading import threading
from .i18n import _ from .i18n import _
from . import ( from . import (
encoding, encoding,
error, error,
pycompat, pycompat,
util, util,
wireprototypes, wireprototypes,
wireprotov1server, wireprotov1server,
) )
from .interfaces import util as interfaceutil from .interfaces import util as interfaceutil
from .utils import ( from .utils import (
compression, compression,
stringutil, stringutil,
) )
stringio = util.stringio
urlerr = util.urlerr urlerr = util.urlerr
urlreq = util.urlreq urlreq = util.urlreq
HTTP_OK = 200 HTTP_OK = 200
HGTYPE = b'application/mercurial-0.1' HGTYPE = b'application/mercurial-0.1'
HGTYPE2 = b'application/mercurial-0.2' HGTYPE2 = b'application/mercurial-0.2'
HGERRTYPE = b'application/hg-error' HGERRTYPE = b'application/hg-error'
length -= int(self._req.headers.get(b'X-HgArgs-Post', 0)) length -= int(self._req.headers.get(b'X-HgArgs-Post', 0))
return util.filechunkiter(self._req.bodyfh, limit=length) return util.filechunkiter(self._req.bodyfh, limit=length)
@contextlib.contextmanager @contextlib.contextmanager
def mayberedirectstdio(self): def mayberedirectstdio(self):
oldout = self._ui.fout oldout = self._ui.fout
olderr = self._ui.ferr olderr = self._ui.ferr
out = util.stringio() out = io.BytesIO()
try: try:
self._ui.fout = out self._ui.fout = out
self._ui.ferr = out self._ui.ferr = out
yield out yield out
finally: finally:
self._ui.fout = oldout self._ui.fout = oldout
self._ui.ferr = olderr self._ui.ferr = olderr