How to use TatSu - 10 common examples

def test_exp_result(self): def print_exp_res(): res = "\n" res += " cat < {}".format(exp_res_file) + "\n" res += json.dumps(dic, indent=2) + "\n" res += "EOF" + "\n" res += "\n" return res self.maxDiff = None parser = RPSLViaParser() ast = parser.parse(line, rule_name="start")  dic = asjson(ast) if exp_res: self.assertDictEqual(dic, exp_res, "\n\nTo fix it:\n{}".format(print_exp_res())) return print(print_exp_res())

def _test_syntax(self, line): parser = RPSLViaParser() ast = parser.parse(line, rule_name="start") # Build the reverse statement starting from the result of the parser # and check that it matches the input line. # Do this only when there are no actions in the original line, too # much effort to rebuild the action list. if "action" in line: return  dic = asjson(ast) from_to = "from" if dic["action"] == "import-via:" else "to" accept_announce = "accept" if dic["action"] == "import-via:" else "announce" s = "{action} {afi} {rules} {filter}".format( action=dic["action"], afi="afi {afi_list}".format( afi_list=" ".join([afi for afi in dic["afi"]]) ) if dic["afi"] else "", rules=" ".join([ "{via} {from_to} {peers}".format( from_to=from_to, via="{intermediate_as} {router}".format( intermediate_as=rule["via"]["intermediate_as"], router="{peer} {at} {local}".format( peer=rule["via"]["router"]["peer_router"]

def test_fn_in_fn(): """Test function declarations being impossible inside a function body.""" decl = emptyfn(emptyfn(""))  with raises(FailedParse): parse_source(decl)

def _default(self, ast, *args, **kwargs): if not args: return ast typespec = args[0].split(BASE_CLASS_TOKEN) typename = typespec[0] bases = typespec[-1:0:-1] base = self.base_type for base_ in bases: base = self._get_constructor(base_, base) constructor = self._get_constructor(typename, base) try:  if type(constructor) is type and issubclass(constructor, Node): return constructor(*args[1:], ast=ast, ctx=self.ctx, **kwargs) else: return constructor(ast, *args[1:], **kwargs) except Exception as e: raise SemanticError( 'Could not call constructor for %s: %s' % (typename, str(e)) )

if PY33: name = cls.__qualname__ else: name = cls.__name__ # Try to reference the class try: idents = name.split('.') _cls = getattr(module, idents[0]) for ident in idents[1:]: _cls = getattr(_cls, ident) assert _cls == cls except AttributeError:  raise CodegenError("Couldn't find base type, it has to be importable") return modulename, name

def _get_full_name(cls): if not inspect.isclass(cls): raise CodegenError("Base type has to be a class") module = inspect.getmodule(cls) if not module:  raise CodegenError("Base type has to be inside a module") modulename = module.__name__ if PY33: name = cls.__qualname__ else: name = cls.__name__ # Try to reference the class try: idents = name.split('.') _cls = getattr(module, idents[0]) for ident in idents[1:]: _cls = getattr(_cls, ident) assert _cls == cls except AttributeError:

def _get_full_name(cls): if not inspect.isclass(cls):  raise CodegenError("Base type has to be a class") module = inspect.getmodule(cls) if not module: raise CodegenError("Base type has to be inside a module") modulename = module.__name__ if PY33: name = cls.__qualname__ else: name = cls.__name__ # Try to reference the class try: idents = name.split('.') _cls = getattr(module, idents[0]) for ident in idents[1:]: _cls = getattr(_cls, ident)

parseinfo = self.node.directives.get('parseinfo', True) namechars = repr(self.node.directives.get('namechars') or '') rules = '\n'.join([ self.get_renderer(rule).render() for rule in self.node.rules ]) version = str(tuple(int(n) for n in str(timestamp()).split('.'))) keywords = [str(k) for k in self.keywords] keywords = '\n'.join(" %s," % repr(k) for k in keywords) if keywords: keywords = '\n%s\n' % keywords  fields.update(rules=indent(rules), start=self.node.rules[0].name, abstract_rules=abstract_rules, version=version, whitespace=whitespace, nameguard=nameguard, ignorecase=ignorecase, comments_re=comments_re, eol_comments_re=eol_comments_re, left_recursion=left_recursion, parseinfo=parseinfo, keywords=keywords, namechars=namechars, )

 @tatsumasu() def _IDENTIFIER_(self): # noqa self._pattern('[\\w$](?:[\\w\\d]|\\\\u[\\dA-Fa-f]{4})*')

 @tatsumasu() def _start_(self): self._expression_() self._check_eof()