( )⚙ D2109 py3: make sure we return str from __repr__

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2109

py3: make sure we return str from __repr__
ClosedPublic

Authored by pulkit on Feb 11 2018, 7:38 AM.

Details

Reviewers
durin42
yuja
Group Reviewers
hg-reviewers
Commits
rHGc4fa47f880d3: py3: make sure we return str from __repr__

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

pulkit created this revision.Feb 11 2018, 7:38 AM
durin42 accepted this revision.Feb 11 2018, 9:04 AM
This revision is now accepted and ready to land.Feb 11 2018, 9:04 AM
yuja requested changes to this revision.Feb 11 2018, 9:05 AM
yuja added a subscriber: yuja.
yuja added inline comments.
mercurial/match.py
456

Maybe you know, '%r' % [bytes, ...] is incompatible across python versions,
so it's probably better to build a repr string in bytes, and convert it
to unicode.

See f0827211eb1f and fc44c2657dc5 for example.

This revision now requires changes to proceed.Feb 11 2018, 9:05 AM
pulkit updated this revision to Diff 5478.Feb 12 2018, 3:47 AM
pulkit edited the summary of this revision. (Show Details)Feb 12 2018, 3:55 AM
yuja accepted this revision.Feb 12 2018, 5:43 AM
This revision is now accepted and ready to land.Feb 12 2018, 5:43 AM
Closed by commit rHGc4fa47f880d3: py3: make sure we return str from __repr__ (authored by pulkit). · Explain WhyFeb 12 2018, 6:07 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/match.py (18 lines)

Diff 5372

mercurial/match.py

def matchfn(self, f): def matchfn(self, f):
return True return True
def visitdir(self, dir): def visitdir(self, dir):
return 'all' return 'all'
def __repr__(self): def __repr__(self):
return '<alwaysmatcher>' return r'<alwaysmatcher>'
class nevermatcher(basematcher): class nevermatcher(basematcher):
'''Matches nothing.''' '''Matches nothing.'''
def __init__(self, root, cwd, badfn=None): def __init__(self, root, cwd, badfn=None):
super(nevermatcher, self).__init__(root, cwd, badfn) super(nevermatcher, self).__init__(root, cwd, badfn)
# It's a little weird to say that the nevermatcher is an exact matcher # It's a little weird to say that the nevermatcher is an exact matcher
# or a prefix matcher, but it seems to make sense to let callers take # or a prefix matcher, but it seems to make sense to let callers take
# fast paths based on either. There will be no exact matches, nor any # fast paths based on either. There will be no exact matches, nor any
# prefixes (files() returns []), so fast paths iterating over them should # prefixes (files() returns []), so fast paths iterating over them should
# be efficient (and correct). # be efficient (and correct).
def isexact(self): def isexact(self):
return True return True
def prefix(self): def prefix(self):
return True return True
def visitdir(self, dir): def visitdir(self, dir):
return False return False
def __repr__(self): def __repr__(self):
return '<nevermatcher>' return r'<nevermatcher>'
class patternmatcher(basematcher): class patternmatcher(basematcher):
def __init__(self, root, cwd, kindpats, ctx=None, listsubrepos=False, def __init__(self, root, cwd, kindpats, ctx=None, listsubrepos=False,
badfn=None): badfn=None):
super(patternmatcher, self).__init__(root, cwd, badfn) super(patternmatcher, self).__init__(root, cwd, badfn)
self._files = _explicitfiles(kindpats) self._files = _explicitfiles(kindpats)
dir in self._dirs or dir in self._dirs or
any(parentdir in self._fileset any(parentdir in self._fileset
for parentdir in util.finddirs(dir))) for parentdir in util.finddirs(dir)))
def prefix(self): def prefix(self):
return self._prefix return self._prefix
def __repr__(self): def __repr__(self):
return ('<patternmatcher patterns=%r>' % self._pats) return (r'<patternmatcher patterns=%r>' % self._pats)
class includematcher(basematcher): class includematcher(basematcher):
def __init__(self, root, cwd, kindpats, ctx=None, listsubrepos=False, def __init__(self, root, cwd, kindpats, ctx=None, listsubrepos=False,
badfn=None): badfn=None):
super(includematcher, self).__init__(root, cwd, badfn) super(includematcher, self).__init__(root, cwd, badfn)
self._pats, self.matchfn = _buildmatch(ctx, kindpats, '(?:/|$)', self._pats, self.matchfn = _buildmatch(ctx, kindpats, '(?:/|$)',
return 'all' return 'all'
return ('.' in self._roots or return ('.' in self._roots or
dir in self._roots or dir in self._roots or
dir in self._dirs or dir in self._dirs or
any(parentdir in self._roots any(parentdir in self._roots
for parentdir in util.finddirs(dir))) for parentdir in util.finddirs(dir)))
def __repr__(self): def __repr__(self):
return ('<includematcher includes=%r>' % self._pats) return (r'<includematcher includes=%r>' % self._pats)
class exactmatcher(basematcher): class exactmatcher(basematcher):
'''Matches the input files exactly. They are interpreted as paths, not '''Matches the input files exactly. They are interpreted as paths, not
patterns (so no kind-prefixes). patterns (so no kind-prefixes).
''' '''
def __init__(self, root, cwd, files, badfn=None): def __init__(self, root, cwd, files, badfn=None):
super(exactmatcher, self).__init__(root, cwd, badfn) super(exactmatcher, self).__init__(root, cwd, badfn)
def visitdir(self, dir): def visitdir(self, dir):
return dir in self._dirs return dir in self._dirs
def isexact(self): def isexact(self):
return True return True
def __repr__(self): def __repr__(self):
return ('<exactmatcher files=%r>' % self._files) return (r'<exactmatcher files=%r>' % self._files)
yujaUnsubmitted
Not Done

Maybe you know, '%r' % [bytes, ...] is incompatible across python versions,
so it's probably better to build a repr string in bytes, and convert it
to unicode.

See f0827211eb1f and fc44c2657dc5 for example.

yuja: Maybe you know, `'%r' % [bytes, ...]` is incompatible across python versions, so it's probably…
class differencematcher(basematcher): class differencematcher(basematcher):
'''Composes two matchers by matching if the first matches and the second '''Composes two matchers by matching if the first matches and the second
does not. does not.
The second matcher's non-matching-attributes (root, cwd, bad, explicitdir, The second matcher's non-matching-attributes (root, cwd, bad, explicitdir,
traversedir) are ignored. traversedir) are ignored.
''' '''
if self._m2.visitdir(dir) == 'all': if self._m2.visitdir(dir) == 'all':
return False return False
return bool(self._m1.visitdir(dir)) return bool(self._m1.visitdir(dir))
def isexact(self): def isexact(self):
return self._m1.isexact() return self._m1.isexact()
def __repr__(self): def __repr__(self):
return ('<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2)) return (r'<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2))
def intersectmatchers(m1, m2): def intersectmatchers(m1, m2):
'''Composes two matchers by matching if both of them match. '''Composes two matchers by matching if both of them match.
The second matcher's non-matching-attributes (root, cwd, bad, explicitdir, The second matcher's non-matching-attributes (root, cwd, bad, explicitdir,
traversedir) are ignored. traversedir) are ignored.
''' '''
if m1 is None or m2 is None: if m1 is None or m2 is None:
def always(self): def always(self):
return self._m1.always() and self._m2.always() return self._m1.always() and self._m2.always()
def isexact(self): def isexact(self):
return self._m1.isexact() or self._m2.isexact() return self._m1.isexact() or self._m2.isexact()
def __repr__(self): def __repr__(self):
return ('<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2)) return (r'<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2))
class subdirmatcher(basematcher): class subdirmatcher(basematcher):
"""Adapt a matcher to work on a subdirectory only. """Adapt a matcher to work on a subdirectory only.
The paths are remapped to remove/insert the path as needed: The paths are remapped to remove/insert the path as needed:
>>> from . import pycompat >>> from . import pycompat
>>> m1 = match(b'root', b'', [b'a.txt', b'sub/b.txt']) >>> m1 = match(b'root', b'', [b'a.txt', b'sub/b.txt'])
def always(self): def always(self):
return self._always return self._always
def prefix(self): def prefix(self):
return self._matcher.prefix() and not self._always return self._matcher.prefix() and not self._always
def __repr__(self): def __repr__(self):
return ('<subdirmatcher path=%r, matcher=%r>' % return (r'<subdirmatcher path=%r, matcher=%r>' %
(self._path, self._matcher)) (self._path, self._matcher))
class unionmatcher(basematcher): class unionmatcher(basematcher):
"""A matcher that is the union of several matchers. """A matcher that is the union of several matchers.
The non-matching-attributes (root, cwd, bad, explicitdir, traversedir) are The non-matching-attributes (root, cwd, bad, explicitdir, traversedir) are
taken from the first matcher. taken from the first matcher.
""" """
for m in self._matchers: for m in self._matchers:
v = m.visitdir(dir) v = m.visitdir(dir)
if v == 'all': if v == 'all':
return v return v
r |= v r |= v
return r return r
def __repr__(self): def __repr__(self):
return ('<unionmatcher matchers=%r>' % self._matchers) return (r'<unionmatcher matchers=%r>' % self._matchers)
def patkind(pattern, default=None): def patkind(pattern, default=None):
'''If pattern is 'kind:pat' with a known kind, return kind.''' '''If pattern is 'kind:pat' with a known kind, return kind.'''
return _patsplit(pattern, default)[0] return _patsplit(pattern, default)[0]
def _patsplit(pattern, default): def _patsplit(pattern, default):
"""Split a string into the optional pattern kind prefix and the actual """Split a string into the optional pattern kind prefix and the actual
pattern.""" pattern."""