mercurial-scm/hg: comparison mercurial/utils/stringutil.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 ``level`` specifies the initial indent level. Used if ``indent > 0``.
 """
 if isinstance(o, bytes):
 if bprefix:
-yield "b'%s'" % escapestr(o)
+yield b"b'%s'" % escapestr(o)
 else:
-yield "'%s'" % escapestr(o)
+yield b"'%s'" % escapestr(o)
 elif isinstance(o, bytearray):
 # codecs.escape_encode() can't handle bytearray, so escapestr fails
 # without coercion.
-yield "bytearray['%s']" % escapestr(bytes(o))
+yield b"bytearray['%s']" % escapestr(bytes(o))
 elif isinstance(o, list):
 if not o:
-yield '[]'
+yield b'[]'
 return
-yield '['
+yield b'['
 if indent:
 level += 1
-yield '\n'
+yield b'\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
 for i, a in enumerate(o):
 for chunk in pprintgen(
 a, bprefix=bprefix, indent=indent, level=level
 ):
 yield chunk
 if i + 1 < len(o):
 if indent:
-yield ',\n'
+yield b',\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
 else:
-yield ', '
+yield b', '
 if indent:
 level -= 1
-yield '\n'
+yield b'\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
-yield ']'
+yield b']'
 elif isinstance(o, dict):
 if not o:
-yield '{}'
+yield b'{}'
 return
-yield '{'
+yield b'{'
 if indent:
 level += 1
-yield '\n'
+yield b'\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
 for i, (k, v) in enumerate(sorted(o.items())):
 for chunk in pprintgen(
 k, bprefix=bprefix, indent=indent, level=level
 ):
 yield chunk
-yield ': '
+yield b': '
 for chunk in pprintgen(
 v, bprefix=bprefix, indent=indent, level=level
 ):
 yield chunk
 if i + 1 < len(o):
 if indent:
-yield ',\n'
+yield b',\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
 else:
-yield ', '
+yield b', '
 if indent:
 level -= 1
-yield '\n'
+yield b'\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
-yield '}'
+yield b'}'
 elif isinstance(o, set):
 if not o:
-yield 'set([])'
+yield b'set([])'
 return
-yield 'set(['
+yield b'set(['
 if indent:
 level += 1
-yield '\n'
+yield b'\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
 for i, k in enumerate(sorted(o)):
 for chunk in pprintgen(
 k, bprefix=bprefix, indent=indent, level=level
 ):
 yield chunk
 if i + 1 < len(o):
 if indent:
-yield ',\n'
+yield b',\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
 else:
-yield ', '
+yield b', '
 if indent:
 level -= 1
-yield '\n'
+yield b'\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
-yield '])'
+yield b'])'
 elif isinstance(o, tuple):
 if not o:
-yield '()'
+yield b'()'
 return
-yield '('
+yield b'('
 if indent:
 level += 1
-yield '\n'
+yield b'\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
 for i, a in enumerate(o):
 for chunk in pprintgen(
 a, bprefix=bprefix, indent=indent, level=level
 ):
 yield chunk
 if i + 1 < len(o):
 if indent:
-yield ',\n'
+yield b',\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
 else:
-yield ', '
+yield b', '
 if indent:
 level -= 1
-yield '\n'
+yield b'\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
-yield ')'
+yield b')'
 elif isinstance(o, types.GeneratorType):
 # Special case of empty generator.
 try:
 nextitem = next(o)
 except StopIteration:
-yield 'gen[]'
+yield b'gen[]'
 return
-yield 'gen['
+yield b'gen['
 if indent:
 level += 1
-yield '\n'
+yield b'\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
 last = False
 while not last:
 current = nextitem
 ):
 yield chunk
 if not last:
 if indent:
-yield ',\n'
+yield b',\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
 else:
-yield ', '
+yield b', '
 if indent:
 level -= 1
-yield '\n'
+yield b'\n'
-yield ' ' * (level * indent)
+yield b' ' * (level * indent)
-yield ']'
+yield b']'
 else:
 yield pycompat.byterepr(o)
 def prettyrepr(o):
 while p0 < len(rs):
 # '... field=<type ... field=<type ...'
 #      ~~~~~~~~~~~~~~~~
 #      p0    p1        q0    q1
 q0 = -1
-q1 = rs.find('<', p1 + 1)
+q1 = rs.find(b'<', p1 + 1)
 if q1 < 0:
 q1 = len(rs)
-elif q1 > p1 + 1 and rs.startswith('=', q1 - 1):
+elif q1 > p1 + 1 and rs.startswith(b'=', q1 - 1):
 # backtrack for ' field=<'
-q0 = rs.rfind(' ', p1 + 1, q1 - 1)
+q0 = rs.rfind(b' ', p1 + 1, q1 - 1)
 if q0 < 0:
 q0 = q1
 else:
 q0 += 1  # skip ' '
-l = rs.count('<', 0, p0) - rs.count('>', 0, p0)
+l = rs.count(b'<', 0, p0) - rs.count(b'>', 0, p0)
 assert l >= 0
 lines.append((l, rs[p0:q0].rstrip()))
 p0, p1 = q0, q1
-return '\n'.join('  ' * l + s for l, s in lines)
+return b'\n'.join(b'  ' * l + s for l, s in lines)
 def buildrepr(r):
 """Format an optional printable representation from unexpanded bits
 callable  lambda: '<branch %r>' % sorted(b)
 object    other
 ========  =================================
 """
 if r is None:
-return ''
+return b''
 elif isinstance(r, tuple):
 return r[0] % pycompat.rapply(pycompat.maybebytestr, r[1:])
 elif isinstance(r, bytes):
 return r
 elif callable(r):
 return pprint(r)
 def binary(s):
 """return true if a string is binary data"""
-return bool(s and '\0' in s)
+return bool(s and b'\0' in s)
 def stringmatcher(pattern, casesensitive=True):
 """
 accepts a string, possibly starting with 're:' or 'literal:' prefix.
 case insensitive literal matches
 >>> itest(b'ABCDEFG', b'abc', b'def', b'abcdefg')
 ('literal', 'ABCDEFG', [False, False, True])
 """
-if pattern.startswith('re:'):
+if pattern.startswith(b're:'):
 pattern = pattern[3:]
 try:
 flags = 0
 if not casesensitive:
 flags = remod.I
 regex = remod.compile(pattern, flags)
 except remod.error as e:
-raise error.ParseError(_('invalid regular expression: %s') % e)
+raise error.ParseError(_(b'invalid regular expression: %s') % e)
-return 're', pattern, regex.search
+return b're', pattern, regex.search
-elif pattern.startswith('literal:'):
+elif pattern.startswith(b'literal:'):
 pattern = pattern[8:]
 match = pattern.__eq__
 if not casesensitive:
 ipat = encoding.lower(pattern)
 match = lambda s: ipat == encoding.lower(s)
-return 'literal', pattern, match
+return b'literal', pattern, match
 def shortuser(user):
 """Return a short representation of a user name or email address."""
-f = user.find('@')
+f = user.find(b'@')
 if f >= 0:
 user = user[:f]
-f = user.find('<')
+f = user.find(b'<')
 if f >= 0:
 user = user[f + 1 :]
-f = user.find(' ')
+f = user.find(b' ')
 if f >= 0:
 user = user[:f]
-f = user.find('.')
+f = user.find(b'.')
 if f >= 0:
 user = user[:f]
 return user
 def emailuser(user):
 """Return the user portion of an email address."""
-f = user.find('@')
+f = user.find(b'@')
 if f >= 0:
 user = user[:f]
-f = user.find('<')
+f = user.find(b'<')
 if f >= 0:
 user = user[f + 1 :]
 return user
 def email(author):
 '''get email of author.'''
-r = author.find('>')
+r = author.find(b'>')
 if r == -1:
 r = None
-return author[author.find('<') + 1 : r]
+return author[author.find(b'<') + 1 : r]
 def person(author):
 """Returns the name before an email address,
 interpreting it as per RFC 5322
 >>> person(b'Foo "buz" Bar <foo@bar>')
 'Foo "buz" Bar'
 >>> person(b'"Foo Bar <foo@bar>')
 'Foo Bar'
 """
-if '@' not in author:
+if b'@' not in author:
 return author
-f = author.find('<')
+f = author.find(b'<')
 if f != -1:
-return author[:f].strip(' "').replace('\\"', '"')
+return author[:f].strip(b' "').replace(b'\\"', b'"')
-f = author.find('@')
+f = author.find(b'@')
-return author[:f].replace('.', ' ')
+return author[:f].replace(b'.', b' ')
 @attr.s(hash=True)
 class mailmapping(object):
 '''Represents a username/email key or value in
 for line in mailmapcontent.splitlines():
 # Don't bother checking the line if it is a comment or
 # is an improperly formed author field
-if line.lstrip().startswith('#'):
+if line.lstrip().startswith(b'#'):
 continue
 # names, emails hold the parsed emails and names for each line
 # name_builder holds the words in a persons name
 names, emails = [], []
 namebuilder = []
 for element in line.split():
-if element.startswith('#'):
+if element.startswith(b'#'):
 # If we reach a comment in the mailmap file, move on
 break
-elif element.startswith('<') and element.endswith('>'):
+elif element.startswith(b'<') and element.endswith(b'>'):
 # We have found an email.
 # Parse it, and finalize any names from earlier
 emails.append(element[1:-1])  # Slice off the "<>"
 if namebuilder:
-names.append(' '.join(namebuilder))
+names.append(b' '.join(namebuilder))
 namebuilder = []
 # Break if we have found a second email, any other
 # data does not fit the spec for .mailmap
 if len(emails) > 1:
 # We call this commit2 as not to erase original commit fields
 commit2 = mailmapping(email=commit.email)
 proper = mailmap.get(commit2, mailmapping(None, None))
 # Return the author field with proper values filled in
-return '%s <%s>' % (
+return b'%s <%s>' % (
 proper.name if proper.name else commit.name,
 proper.email if proper.email else commit.email,
 )
 return _correctauthorformat.match(author) is not None
 def ellipsis(text, maxlength=400):
 """Trim string to at most maxlength (default: 400) columns in display."""
-return encoding.trim(text, maxlength, ellipsis='...')
+return encoding.trim(text, maxlength, ellipsis=b'...')
 def escapestr(s):
 if isinstance(s, memoryview):
 s = bytes(s)
 colwidth = encoding.ucolwidth
 for i in pycompat.xrange(len(ucstr)):
 l += colwidth(ucstr[i])
 if space_left < l:
 return (ucstr[:i], ucstr[i:])
-return ucstr, ''
+return ucstr, b''
 # overriding of base class
 def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
 space_left = max(width - cur_len, 1)
 def _wrap_chunks(self, chunks):
 colwidth = encoding.ucolwidth
 lines = []
 if self.width <= 0:
-raise ValueError("invalid width %r (must be > 0)" % self.width)
+raise ValueError(b"invalid width %r (must be > 0)" % self.width)
 # Arrange in reverse order so items can be efficiently popped
 # from a stack of chucks.
 chunks.reverse()
 global _MBTextWrapper
 _MBTextWrapper = tw
 return tw(**kwargs)
-def wrap(line, width, initindent='', hangindent=''):
+def wrap(line, width, initindent=b'', hangindent=b''):
 maxindent = max(len(hangindent), len(initindent))
 if width <= maxindent:
 # adjust for weird terminal size
 width = max(78, maxindent + 1)
 line = line.decode(
 )
 return wrapper.fill(line).encode(pycompat.sysstr(encoding.encoding))
 _booleans = {
-'1': True,
+b'1': True,
-'yes': True,
+b'yes': True,
-'true': True,
+b'true': True,
-'on': True,
+b'on': True,
-'always': True,
+b'always': True,
-'0': False,
+b'0': False,
-'no': False,
+b'no': False,
-'false': False,
+b'false': False,
-'off': False,
+b'off': False,
-'never': False,
+b'never': False,
 }
 def parsebool(s):
 """Parse s into a boolean.

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43506	9f70512ae2cf