( )⚙ 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
460

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 (12 lines)

Diff 5478

mercurial/match.py

# match.py - filename matching # match.py - filename matching
# #
# Copyright 2008, 2009 Matt Mackall <mpm@selenic.com> and others # Copyright 2008, 2009 Matt Mackall <mpm@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.
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import copy import copy
import os import os
import re import re
from .i18n import _ from .i18n import _
from . import ( from . import (
encoding,
error, error,
pathutil, pathutil,
util, util,
) )
allpatternkinds = ('re', 'glob', 'path', 'relglob', 'relpath', 'relre', allpatternkinds = ('re', 'glob', 'path', 'relglob', 'relpath', 'relre',
'listfile', 'listfile0', 'set', 'include', 'subinclude', 'listfile', 'listfile0', 'set', 'include', 'subinclude',
'rootfilesin') 'rootfilesin')
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._fileset or dir in self._fileset or
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
@encoding.strmethod
def __repr__(self): def __repr__(self):
return ('<patternmatcher patterns=%r>' % self._pats) return ('<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)
if self._prefix and dir in self._roots: if self._prefix and dir in self._roots:
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)))
@encoding.strmethod
def __repr__(self): def __repr__(self):
return ('<includematcher includes=%r>' % self._pats) return ('<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).
''' '''
return set(util.dirs(self._fileset)) | {'.'} return set(util.dirs(self._fileset)) | {'.'}
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
@encoding.strmethod
def __repr__(self): def __repr__(self):
return ('<exactmatcher files=%r>' % self._files) return ('<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.
''' '''
def visitdir(self, dir): def visitdir(self, dir):
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()
@encoding.strmethod
def __repr__(self): def __repr__(self):
return ('<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2)) return ('<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.
return bool(visit1 and self._m2.visitdir(dir)) return bool(visit1 and self._m2.visitdir(dir))
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()
@encoding.strmethod
def __repr__(self): def __repr__(self):
return ('<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2)) return ('<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:
return self._matcher.visitdir(dir) return self._matcher.visitdir(dir)
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
@encoding.strmethod
def __repr__(self): def __repr__(self):
return ('<subdirmatcher path=%r, matcher=%r>' % return ('<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
r = False r = False
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
@encoding.strmethod
def __repr__(self): def __repr__(self):
return ('<unionmatcher matchers=%r>' % self._matchers) return ('<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):