This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9240

errors: name arguments to ParseError constructor
ClosedPublic

Authored by martinvonz on Oct 22 2020, 2:17 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG0fc8b066928a: errors: name arguments to ParseError constructor
Summary

As with similar previous patches, this is to improve readability.

Diff Detail

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

Event Timeline

martinvonz created this revision.Oct 22 2020, 2:17 PM
martinvonz added a commit: rHG0fc8b066928a: errors: name arguments to ParseError constructor.Oct 28 2020, 9:52 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG0fc8b066928a: errors: name arguments to ParseError constructor (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/eol.py (2 lines)
Mmercurial/dispatch.py (8 lines)
Mmercurial/error.py (11 lines)
Mmercurial/parser.py (6 lines)
Mmercurial/revsetlang.py (4 lines)
Mmercurial/templater.py (6 lines)

Diff 23289

hgext/eol.py

except (IOError, LookupError): except (IOError, LookupError):
pass pass
except errormod.ParseError as inst: except errormod.ParseError as inst:
ui.warn( ui.warn(
_( _(
b"warning: ignoring .hgeol file due to parse error " b"warning: ignoring .hgeol file due to parse error "
b"at %s: %s\n" b"at %s: %s\n"
) )
% (inst.args[1], inst.args[0]) % (inst.location, inst.message)
) )
return None return None
def ensureenabled(ui): def ensureenabled(ui):
"""make sure the extension is enabled when used as hook """make sure the extension is enabled when used as hook
When eol is used through hooks, the extension is never formally loaded and When eol is used through hooks, the extension is never formally loaded and

mercurial/dispatch.py

write(_(b"(did you mean one of %s?)\n") % ss) write(_(b"(did you mean one of %s?)\n") % ss)
def _formatparse(write, inst): def _formatparse(write, inst):
similar = [] similar = []
if isinstance(inst, error.UnknownIdentifier): if isinstance(inst, error.UnknownIdentifier):
# make sure to check fileset first, as revset can invoke fileset # make sure to check fileset first, as revset can invoke fileset
similar = _getsimilar(inst.symbols, inst.function) similar = _getsimilar(inst.symbols, inst.function)
if len(inst.args) > 1: if inst.location is not None:
write( write(
_(b"hg: parse error at %s: %s\n") _(b"hg: parse error at %s: %s\n")
% (pycompat.bytestr(inst.args[1]), inst.args[0]) % (pycompat.bytestr(inst.location), inst.message)
) )
if inst.args[0].startswith(b' '): if inst.message.startswith(b' '):
write(_(b"unexpected leading whitespace\n")) write(_(b"unexpected leading whitespace\n"))
else: else:
write(_(b"hg: parse error: %s\n") % inst.args[0]) write(_(b"hg: parse error: %s\n") % inst.message)
_reportsimilar(write, similar) _reportsimilar(write, similar)
if inst.hint: if inst.hint:
write(_(b"(%s)\n") % inst.hint) write(_(b"(%s)\n") % inst.hint)
def _formatargs(args): def _formatargs(args):
return b' '.join(procutil.shellquote(a) for a in args) return b' '.join(procutil.shellquote(a) for a in args)

mercurial/error.py

"""Exception raised when a remote repo reports failure""" """Exception raised when a remote repo reports failure"""
__bytes__ = _tobytes __bytes__ = _tobytes
class ParseError(Hint, Exception): class ParseError(Hint, Exception):
"""Raised when parsing config files and {rev,file}sets (msg[, pos])""" """Raised when parsing config files and {rev,file}sets (msg[, pos])"""
def __init__(self, message, location=None, hint=None):
self.message = message
self.location = location
self.hint = hint
# Pass the message and possibly location into the Exception constructor
# to help code that looks for exc.args.
if location is not None:
Exception.__init__(self, message, location)
else:
Exception.__init__(self, message)
__bytes__ = _tobytes __bytes__ = _tobytes
class PatchError(Exception): class PatchError(Exception):
__bytes__ = _tobytes __bytes__ = _tobytes
class UnknownIdentifier(ParseError): class UnknownIdentifier(ParseError):

mercurial/parser.py

matches = [tree] matches = [tree]
if _matchtree(pattern, tree, placeholder, incompletenodes, matches): if _matchtree(pattern, tree, placeholder, incompletenodes, matches):
return matches return matches
def parseerrordetail(inst): def parseerrordetail(inst):
"""Compose error message from specified ParseError object """Compose error message from specified ParseError object
""" """
if len(inst.args) > 1: if inst.location is not None:
return _(b'at %d: %s') % (inst.args[1], inst.args[0]) return _(b'at %d: %s') % (inst.location, inst.message)
else: else:
return inst.args[0] return inst.message
class alias(object): class alias(object):
"""Parsed result of alias""" """Parsed result of alias"""
def __init__(self, name, args, err, replacement): def __init__(self, name, args, err, replacement):
self.name = name self.name = name
self.args = args self.args = args

mercurial/revsetlang.py

else: else:
return tuple(foldconcat(t) for t in tree) return tuple(foldconcat(t) for t in tree)
def parse(spec, lookup=None): def parse(spec, lookup=None):
try: try:
return _parsewith(spec, lookup=lookup) return _parsewith(spec, lookup=lookup)
except error.ParseError as inst: except error.ParseError as inst:
if len(inst.args) > 1: # has location if inst.location is not None:
loc = inst.args[1] loc = inst.location
# Remove newlines -- spaces are equivalent whitespace. # Remove newlines -- spaces are equivalent whitespace.
spec = spec.replace(b'\n', b' ') spec = spec.replace(b'\n', b' ')
# We want the caret to point to the place in the template that # We want the caret to point to the place in the template that
# failed to parse, but in a hint we get a open paren at the # failed to parse, but in a hint we get a open paren at the
# start. Therefore, we print "loc + 1" spaces (instead of "loc") # start. Therefore, we print "loc + 1" spaces (instead of "loc")
# to line up the caret with the location of the error. # to line up the caret with the location of the error.
inst.hint = spec + b'\n' + b' ' * (loc + 1) + b'^ ' + _(b'here') inst.hint = spec + b'\n' + b' ' * (loc + 1) + b'^ ' + _(b'here')
raise raise

mercurial/templater.py

raise error.ParseError(_(b"unterminated string"), start) raise error.ParseError(_(b"unterminated string"), start)
except error.ParseError as inst: except error.ParseError as inst:
_addparseerrorhint(inst, tmpl) _addparseerrorhint(inst, tmpl)
raise raise
yield (b'end', None, pos) yield (b'end', None, pos)
def _addparseerrorhint(inst, tmpl): def _addparseerrorhint(inst, tmpl):
if len(inst.args) <= 1: if inst.location is None:
return # no location return
loc = inst.args[1] loc = inst.location
# Offset the caret location by the number of newlines before the # Offset the caret location by the number of newlines before the
# location of the error, since we will replace one-char newlines # location of the error, since we will replace one-char newlines
# with the two-char literal r'\n'. # with the two-char literal r'\n'.
offset = tmpl[:loc].count(b'\n') offset = tmpl[:loc].count(b'\n')
tmpl = tmpl.replace(b'\n', br'\n') tmpl = tmpl.replace(b'\n', br'\n')
# We want the caret to point to the place in the template that # We want the caret to point to the place in the template that
# failed to parse, but in a hint we get a open paren at the # failed to parse, but in a hint we get a open paren at the
# start. Therefore, we print "loc + 1" spaces (instead of "loc") # start. Therefore, we print "loc + 1" spaces (instead of "loc")