Esempio n. 1
0
def exportMethod(method, lexems, style):
    # access level
    accessLevel = TaxonClass.getAccessLevelFor(method)
    if accessLevel:
        lexems += [Lex.keyword(accessLevel), Lex.space]
    isConstructor = method.type == 'constructor'
    # static
    if method.isStatic():
        lexems += [Lex.keyword('static'), Lex.space]
        isConstructor = False

    if isConstructor:
        lexems.append(Lex.keyword('constructor'))
    else:
        lexems.append(Lex.funcName(method.getName()))

    lexems.append(Lex.paramsBegin)
    for param in method.getParamsList():
        param.exportLexems(lexems, style)
        lexems.append(Lex.paramDiv)
    if lexems[-1] == Lex.paramDiv:
        lexems[-1] = Lex.paramDivLast
    lexems.append(Lex.paramsEnd)
    if not isConstructor:
        lexems.append(Lex.colon)
        typeExpr = method.getResultTypeExpr()
        if typeExpr:
            typeExpr.exportLexems(lexems, style)
        else:
            lexems.append(Lex.typeName('void'))
    method.getBody().exportLexems(lexems, style)
Esempio n. 2
0
    def exportLexems(self, lexems, style):
        # TODO: сформировать JSDoc
        # export, if public module member
        if self.owner.isModule() and 'public' in self.attrs:
            lexems += [Lex.keyword('export'), Lex.space]
        # const funcName = (
        lexems += [
            Lex.keyword('const'), Lex.space,
            Lex.funcName(self.getName()),
            Lex.binop('='), Lex.paramsBegin
        ]

        for param in self.getParamsList():
            param.exportLexems(lexems, style)
            lexems.append(Lex.paramDiv)
        if lexems[-1] == Lex.paramDiv:
            lexems[-1] = Lex.paramDivLast
        # ): {void | resultType} =>
        lexems += [Lex.paramsEnd, Lex.colon]
        typeExpr = self.getResultTypeExpr()
        if typeExpr:
            typeExpr.exportLexems(lexems, style)
        else:
            lexems.append(Lex.typeName('void'))
        lexems.append(Lex.binop('=>'))

        self.getBody().exportLexems(lexems, style)
        lexems.append(Lex.instrDiv)
Esempio n. 3
0
 def testParams(self):
     style['printWidth'] = 1000
     # function applyStyle(lexems: Lexem[], pos: number, isVertical: boolean, style: Styles): {value: string, pos: number} {}
     lexems = [
         ('function', 'keyword'),
         Lex.space,
         ('applyStyle', 'funcName'),
         Lex.paramsBegin,
         ('lexems', 'varName'),
         Lex.colon,
         ('Lexem', 'typeName'),
         Lex.arrayBegin,
         Lex.arrayEnd,
         Lex.paramDiv,
         ('pos', 'varName'),
         Lex.colon,
         Lex.typeName('number'),
         Lex.paramDiv,
         Lex.varName('isVertical'),
         Lex.colon,
         Lex.typeName('boolean'),
         Lex.paramDiv,
         Lex.varName('style'),
         Lex.colon,
         Lex.typeName('Styles'),
         Lex.paramsEnd,
         Lex.colon,
         Lex.objBegin,
         Lex.fieldName('value'),
         Lex.colon,
         Lex.typeName('string'),
         Lex.itemDiv,
         Lex.fieldName('pos'),
         Lex.colon,
         Lex.typeName('number'),
         Lex.objEnd,
         Lex.bodyBegin,
         Lex.bodyEnd,
     ]
     outRows = []
     formatLexems(outRows, lexems, 0, 0, style)
     # for row in outRows:
     # 	print('<<<%s>>>' % row.replace(' ', '_'))
     self.assertEqual(outRows, [
         "function applyStyle(lexems: Lexem[], pos: number, isVertical: boolean, style: Styles): {value: string, pos: number} {",
         "}"
     ])
Esempio n. 4
0
 def exportLexems(self, lexems, rules):
     self.exportComment(lexems, rules)
     if 'public' in self.attrs:
         lexems += [Lex.keyword('export'), Lex.space]
     lexems += [
         Lex.keyword('type'), Lex.space,
         Lex.typeName(self.getName()),
         Lex.binop('=')
     ]
     self.getTypeExpr().exportLexems(lexems, rules)
     lexems.append(Lex.instrDiv)
Esempio n. 5
0
 def exportLexems(self, lexems, style):
     txType = self.getTypeTaxon()
     lexems.append(Lex.typeName(txType.getName()))