mercurial-scm/hg: mercurial/util.py comparison

comparison mercurial/util.py @ 34131:0fa781320203

doctest: bulk-replace string literals with b'' for Python 3 Our code transformer can't rewrite string literals in docstrings, and I don't want to make the transformer more complex.

author	Yuya Nishihara <yuya@tcha.org>
date	Sun, 03 Sep 2017 14:32:11 +0900
parents	6c5cdb02f2f9
children	d4d4d11bac77

comparison

equal deleted inserted replaced

-:ada8a19672ab
+:0fa781320203
 class digester(object):
 """helper to compute digests.
 This helper can be used to compute one or more digests given their name.
->>> d = digester(['md5', 'sha1'])
+>>> d = digester([b'md5', b'sha1'])
->>> d.update('foo')
+>>> d.update(b'foo')
 >>> [k for k in sorted(d)]
 ['md5', 'sha1']
->>> d['md5']
+>>> d[b'md5']
 'acbd18db4cc2f85cedef654fccc4a4d8'
->>> d['sha1']
+>>> d[b'sha1']
 '0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33'
->>> digester.preferred(['md5', 'sha1'])
+>>> digester.preferred([b'md5', b'sha1'])
 'sha1'
 """
 def __init__(self, digests, s=''):
 self._hashes = {}
 If it isn't defined, the current Mercurial version string will be parsed.
 ``n`` can be 2, 3, or 4. Here is how some version strings map to
 returned values:
->>> v = '3.6.1+190-df9b73d2d444'
+>>> v = b'3.6.1+190-df9b73d2d444'
 >>> versiontuple(v, 2)
 (3, 6)
 >>> versiontuple(v, 3)
 (3, 6, 1)
 >>> versiontuple(v, 4)
 (3, 6, 1, '190-df9b73d2d444')
->>> versiontuple('3.6.1+190-df9b73d2d444+20151118')
+>>> versiontuple(b'3.6.1+190-df9b73d2d444+20151118')
 (3, 6, 1, '190-df9b73d2d444+20151118')
->>> v = '3.6'
+>>> v = b'3.6'
 >>> versiontuple(v, 2)
 (3, 6)
 >>> versiontuple(v, 3)
 (3, 6, None)
 >>> versiontuple(v, 4)
 (3, 6, None, None)
->>> v = '3.9-rc'
+>>> v = b'3.9-rc'
 >>> versiontuple(v, 2)
 (3, 9)
 >>> versiontuple(v, 3)
 (3, 9, None)
 >>> versiontuple(v, 4)
 (3, 9, None, 'rc')
->>> v = '3.9-rc+2-02a8fea4289b'
+>>> v = b'3.9-rc+2-02a8fea4289b'
 >>> versiontuple(v, 2)
 (3, 9)
 >>> versiontuple(v, 3)
 (3, 9, None)
 >>> versiontuple(v, 4)
 return f
 class sortdict(collections.OrderedDict):
 '''a simple sorted dictionary
->>> d1 = sortdict([('a', 0), ('b', 1)])
+>>> d1 = sortdict([(b'a', 0), (b'b', 1)])
 >>> d2 = d1.copy()
 >>> d2
 sortdict([('a', 0), ('b', 1)])
->>> d2.update([('a', 2)])
+>>> d2.update([(b'a', 2)])
 >>> d2.keys() # should still be in last-set order
 ['b', 'a']
 '''
 def __setitem__(self, key, value):
 _winreservedchars = ':*?"<>|'
 def checkwinfilename(path):
 r'''Check that the base-relative path is a valid filename on Windows.
 Returns None if the path is ok, or a UI string describing the problem.
->>> checkwinfilename("just/a/normal/path")
+>>> checkwinfilename(b"just/a/normal/path")
->>> checkwinfilename("foo/bar/con.xml")
+>>> checkwinfilename(b"foo/bar/con.xml")
 "filename contains 'con', which is reserved on Windows"
->>> checkwinfilename("foo/con.xml/bar")
+>>> checkwinfilename(b"foo/con.xml/bar")
 "filename contains 'con', which is reserved on Windows"
->>> checkwinfilename("foo/bar/xml.con")
+>>> checkwinfilename(b"foo/bar/xml.con")
->>> checkwinfilename("foo/bar/AUX/bla.txt")
+>>> checkwinfilename(b"foo/bar/AUX/bla.txt")
 "filename contains 'AUX', which is reserved on Windows"
->>> checkwinfilename("foo/bar/bla:.txt")
+>>> checkwinfilename(b"foo/bar/bla:.txt")
 "filename contains ':', which is reserved on Windows"
->>> checkwinfilename("foo/bar/b\07la.txt")
+>>> checkwinfilename(b"foo/bar/b\07la.txt")
 "filename contains '\\x07', which is invalid on Windows"
->>> checkwinfilename("foo/bar/bla ")
+>>> checkwinfilename(b"foo/bar/bla ")
 "filename ends with ' ', which is not allowed on Windows"
->>> checkwinfilename("../bar")
+>>> checkwinfilename(b"../bar")
->>> checkwinfilename("foo\\")
+>>> checkwinfilename(b"foo\\")
 "filename ends with '\\', which is invalid on Windows"
->>> checkwinfilename("foo\\/bar")
+>>> checkwinfilename(b"foo\\/bar")
 "directory name ends with '\\', which is invalid on Windows"
 '''
 if path.endswith('\\'):
 return _("filename ends with '\\', which is invalid on Windows")
 if '\\/' in path:
 """parse a localized date/time and return a (unixtime, offset) tuple.
 The date may be a "unixtime offset" string or in one of the specified
 formats. If the date already is a (unixtime, offset) tuple, it is returned.
->>> parsedate(' today ') == parsedate(\
+>>> parsedate(b' today ') == parsedate(\
 datetime.date.today().strftime('%b %d'))
 True
->>> parsedate( 'yesterday ') == parsedate((datetime.date.today() -\
+>>> parsedate(b'yesterday ') == parsedate((datetime.date.today() -\
 datetime.timedelta(days=1)\
 ).strftime('%b %d'))
 True
 >>> now, tz = makedate()
->>> strnow, strtz = parsedate('now')
+>>> strnow, strtz = parsedate(b'now')
 >>> (strnow - now) < 1
 True
 >>> tz == strtz
 True
 """
 '<{date}' on or before a given date
 '>{date}' on or after a given date
->>> p1 = parsedate("10:29:59")
+>>> p1 = parsedate(b"10:29:59")
->>> p2 = parsedate("10:30:00")
+>>> p2 = parsedate(b"10:30:00")
->>> p3 = parsedate("10:30:59")
+>>> p3 = parsedate(b"10:30:59")
->>> p4 = parsedate("10:31:00")
+>>> p4 = parsedate(b"10:31:00")
->>> p5 = parsedate("Sep 15 10:30:00 1999")
+>>> p5 = parsedate(b"Sep 15 10:30:00 1999")
->>> f = matchdate("10:30")
+>>> f = matchdate(b"10:30")
 >>> f(p1[0])
 False
 >>> f(p2[0])
 True
 >>> f(p3[0])
 >>> def itest(pattern, *tests):
 ...     kind, pattern, matcher = stringmatcher(pattern, casesensitive=False)
 ...     return (kind, pattern, [bool(matcher(t)) for t in tests])
 exact matching (no prefix):
->>> test('abcdefg', 'abc', 'def', 'abcdefg')
+>>> test(b'abcdefg', b'abc', b'def', b'abcdefg')
 ('literal', 'abcdefg', [False, False, True])
 regex matching ('re:' prefix)
->>> test('re:a.+b', 'nomatch', 'fooadef', 'fooadefbar')
+>>> test(b're:a.+b', b'nomatch', b'fooadef', b'fooadefbar')
 ('re', 'a.+b', [False, False, True])
 force exact matches ('literal:' prefix)
->>> test('literal:re:foobar', 'foobar', 're:foobar')
+>>> test(b'literal:re:foobar', b'foobar', b're:foobar')
 ('literal', 're:foobar', [False, True])
 unknown prefixes are ignored and treated as literals
->>> test('foo:bar', 'foo', 'bar', 'foo:bar')
+>>> test(b'foo:bar', b'foo', b'bar', b'foo:bar')
 ('literal', 'foo:bar', [False, False, True])
 case insensitive regex matches
->>> itest('re:A.+b', 'nomatch', 'fooadef', 'fooadefBar')
+>>> itest(b're:A.+b', b'nomatch', b'fooadef', b'fooadefBar')
 ('re', 'A.+b', [False, False, True])
 case insensitive literal matches
->>> itest('ABCDEFG', 'abc', 'def', 'abcdefg')
+>>> itest(b'ABCDEFG', b'abc', b'def', b'abcdefg')
 ('literal', 'ABCDEFG', [False, False, True])
 """
 if pattern.startswith('re:'):
 pattern = pattern[3:]
 try:
 Note that for backward compatibility reasons, bundle URLs do not
 take host names. That means 'bundle://../' has a path of '../'.
 Examples:
->>> url('http://www.ietf.org/rfc/rfc2396.txt')
+>>> url(b'http://www.ietf.org/rfc/rfc2396.txt')
 <url scheme: 'http', host: 'www.ietf.org', path: 'rfc/rfc2396.txt'>
->>> url('ssh://[::1]:2200//home/joe/repo')
+>>> url(b'ssh://[::1]:2200//home/joe/repo')
 <url scheme: 'ssh', host: '[::1]', port: '2200', path: '/home/joe/repo'>
->>> url('file:///home/joe/repo')
+>>> url(b'file:///home/joe/repo')
 <url scheme: 'file', path: '/home/joe/repo'>
->>> url('file:///c:/temp/foo/')
+>>> url(b'file:///c:/temp/foo/')
 <url scheme: 'file', path: 'c:/temp/foo/'>
->>> url('bundle:foo')
+>>> url(b'bundle:foo')
 <url scheme: 'bundle', path: 'foo'>
->>> url('bundle://../foo')
+>>> url(b'bundle://../foo')
 <url scheme: 'bundle', path: '../foo'>
->>> url(r'c:\foo\bar')
+>>> url(br'c:\foo\bar')
 <url path: 'c:\\foo\\bar'>
->>> url(r'\\blah\blah\blah')
+>>> url(br'\\blah\blah\blah')
 <url path: '\\\\blah\\blah\\blah'>
->>> url(r'\\blah\blah\blah#baz')
+>>> url(br'\\blah\blah\blah#baz')
 <url path: '\\\\blah\\blah\\blah', fragment: 'baz'>
->>> url(r'file:///C:\users\me')
+>>> url(br'file:///C:\users\me')
 <url scheme: 'file', path: 'C:\\users\\me'>
 Authentication credentials:
->>> url('ssh://joe:xyz@x/repo')
+>>> url(b'ssh://joe:xyz@x/repo')
 <url scheme: 'ssh', user: 'joe', passwd: 'xyz', host: 'x', path: 'repo'>
->>> url('ssh://joe@x/repo')
+>>> url(b'ssh://joe@x/repo')
 <url scheme: 'ssh', user: 'joe', host: 'x', path: 'repo'>
 Query strings and fragments:
->>> url('http://host/a?b#c')
+>>> url(b'http://host/a?b#c')
 <url scheme: 'http', host: 'host', path: 'a', query: 'b', fragment: 'c'>
->>> url('http://host/a?b#c', parsequery=False, parsefragment=False)
+>>> url(b'http://host/a?b#c', parsequery=False, parsefragment=False)
 <url scheme: 'http', host: 'host', path: 'a?b#c'>
 Empty path:
->>> url('')
+>>> url(b'')
 <url path: ''>
->>> url('#a')
+>>> url(b'#a')
 <url path: '', fragment: 'a'>
->>> url('http://host/')
+>>> url(b'http://host/')
 <url scheme: 'http', host: 'host', path: ''>
->>> url('http://host/#a')
+>>> url(b'http://host/#a')
 <url scheme: 'http', host: 'host', path: '', fragment: 'a'>
 Only scheme:
->>> url('http:')
+>>> url(b'http:')
 <url scheme: 'http'>
 """
 _safechars = "!~*'()+"
 _safepchars = "/!~*'()+:\\"
 def __bytes__(self):
 r"""Join the URL's components back into a URL string.
 Examples:
->>> str(url('http://user:pw@host:80/c:/bob?fo:oo#ba:ar'))
+>>> str(url(b'http://user:pw@host:80/c:/bob?fo:oo#ba:ar'))
 'http://user:pw@host:80/c:/bob?fo:oo#ba:ar'
->>> str(url('http://user:pw@host:80/?foo=bar&baz=42'))
+>>> str(url(b'http://user:pw@host:80/?foo=bar&baz=42'))
 'http://user:pw@host:80/?foo=bar&baz=42'
->>> str(url('http://user:pw@host:80/?foo=bar%3dbaz'))
+>>> str(url(b'http://user:pw@host:80/?foo=bar%3dbaz'))
 'http://user:pw@host:80/?foo=bar%3dbaz'
->>> str(url('ssh://user:pw@[::1]:2200//home/joe#'))
+>>> str(url(b'ssh://user:pw@[::1]:2200//home/joe#'))
 'ssh://user:pw@[::1]:2200//home/joe#'
->>> str(url('http://localhost:80//'))
+>>> str(url(b'http://localhost:80//'))
 'http://localhost:80//'
->>> str(url('http://localhost:80/'))
+>>> str(url(b'http://localhost:80/'))
 'http://localhost:80/'
->>> str(url('http://localhost:80'))
+>>> str(url(b'http://localhost:80'))
 'http://localhost:80/'
->>> str(url('bundle:foo'))
+>>> str(url(b'bundle:foo'))
 'bundle:foo'
->>> str(url('bundle://../foo'))
+>>> str(url(b'bundle://../foo'))
 'bundle:../foo'
->>> str(url('path'))
+>>> str(url(b'path'))
 'path'
->>> str(url('file:///tmp/foo/bar'))
+>>> str(url(b'file:///tmp/foo/bar'))
 'file:///tmp/foo/bar'
->>> str(url('file:///c:/tmp/foo/bar'))
+>>> str(url(b'file:///c:/tmp/foo/bar'))
 'file:///c:/tmp/foo/bar'
->>> print url(r'bundle:foo\bar')
+>>> print url(br'bundle:foo\bar')
 bundle:foo\bar
->>> print url(r'file:///D:\data\hg')
+>>> print url(br'file:///D:\data\hg')
 file:///D:\data\hg
 """
 if self._localpath:
 s = self.path
 if self.scheme == 'bundle':
 ('kb', 2**10), ('mb', 2**20), ('gb', 2**30), ('b', 1))
 def sizetoint(s):
 '''Convert a space specifier to a byte count.
->>> sizetoint('30')
+>>> sizetoint(b'30')
 30
->>> sizetoint('2.2kb')
+>>> sizetoint(b'2.2kb')
 2252
->>> sizetoint('6M')
+>>> sizetoint(b'6M')
 6291456
 '''
 t = s.strip().lower()
 try:
 for k, u in _sizeunits:

Mercurial > public > mercurial-scm > hg

comparison mercurial/util.py @ 34131:0fa781320203