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

equal deleted inserted replaced

-:552eabef663b
+:2e9f5453ab5a
 def __new__(cls):
 raise TypeError("'%s' is not instantiatable" % cls.__name__)
 @staticmethod
-def _parsedecl(spec):
+def _parse(spec):
-"""Parse an alias name and arguments"""
+"""Parse an alias name, arguments and definition"""
-raise NotImplementedError
-@staticmethod
-def _parsedefn(spec):
-"""Parse an alias definition"""
 raise NotImplementedError
 @staticmethod
 def _getlist(tree):
 """Extract a list of arguments from parsed tree"""
 @classmethod
 def _builddecl(cls, decl):
 """Parse an alias declaration into ``(name, tree, args, errorstr)``
 This function analyzes the parsed tree. The parsing rule is provided
-by ``_parsedecl()``.
+by ``_parse()``.
 - ``name``: of declared alias (may be ``decl`` itself at error)
 - ``tree``: parse result (or ``None`` at error)
 - ``args``: list of argument names (or None for symbol declaration)
 - ``errorstr``: detail about detected error (or None)
 ...         return []
 ...     if tree[0] == 'list':
 ...         return list(tree[1:])
 ...     return [tree]
 >>> class aliasrules(basealiasrules):
-...     _parsedecl = staticmethod(parse)
+...     _parse = staticmethod(parse)
 ...     _getlist = staticmethod(getlist)
 >>> builddecl = aliasrules._builddecl
 >>> builddecl('foo')
 ('foo', ('symbol', 'foo'), None, None)
 >>> builddecl('$foo')
 ('foo("bar', None, None, 'at 5: unterminated string')
 >>> builddecl('foo($1, $2, $1)')
 ('foo', None, None, 'argument names collide with each other')
 """
 try:
-tree = cls._parsedecl(decl)
+tree = cls._parse(decl)
 except error.ParseError as inst:
 return (decl, None, None, parseerrordetail(inst))
 if tree[0] == cls._symbolnode:
 # "name = ...." style
 @classmethod
 def _builddefn(cls, defn, args):
 """Parse an alias definition into a tree and marks substitutions
 This function marks alias argument references as ``_aliasarg``. The
-parsing rule is provided by ``_parsedefn()``.
+parsing rule is provided by ``_parse()``.
 ``args`` is a list of alias argument names, or None if the alias
 is declared as a symbol.
 >>> parsemap = {
 ...     '$1 or $bar': ('or', ('symbol', '$1'), ('symbol', '$bar')),
 ...     '$10 or baz': ('or', ('symbol', '$10'), ('symbol', 'baz')),
 ...     '"$1" or "foo"': ('or', ('string', '$1'), ('string', 'foo')),
 ... }
 >>> class aliasrules(basealiasrules):
-...     _parsedefn = staticmethod(parsemap.__getitem__)
+...     _parse = staticmethod(parsemap.__getitem__)
 ...     _getlist = staticmethod(lambda x: [])
 >>> builddefn = aliasrules._builddefn
 >>> def pprint(tree):
 ...     print prettyformat(tree, ('_aliasarg', 'string', 'symbol'))
 >>> args = ['$1', '$2', 'foo']
 >>> pprint(builddefn('"$1" or "foo"', args))
 (or
 ('string', '$1')
 ('string', 'foo'))
 """
-tree = cls._parsedefn(defn)
+tree = cls._parse(defn)
 if args:
 args = set(args)
 else:
 args = set()
 return cls._relabelargs(tree, args)

changeset 28875	2e9f5453ab5a
parent 28873	2ca3b7c563f3
child 28892	0c135f37c6f8