def listComprehension(self, state, node, expr, *xs): exprView = viewEval( expr ) xViews = mapViewEval( xs, None, python25ViewState( Parser.listComprehensionItem ) ) return nodeEditor( node, flow( [ label( '[', punctuationStyle ), flow( [ exprView ] + xViews, spacing=15.0 ), label( ']', punctuationStyle ) ] ), UnparsedText( '[ ' + exprView.text + ' ' + UnparsedText( ' ' ).join( [ x.text for x in xViews ] ) + ' ]', PRECEDENCE_LISTCOMPREHENSION ), state )
def classStmt(self, state, node, name, inheritance, suite): classLabel = keywordLabel( classKeyword ) classUnparsed = UnparsedText( classKeyword ) classUnparsed.associateWith( classLabel ) nameLabel = label( name ) nameUnparsed = UnparsedText( name ) nameUnparsed.associateWith( nameLabel ) if inheritance != '<nil>': inheritanceView = viewEval( inheritance, None, python25ViewState( Parser.tupleOrExpression ) ) inhWidget = ahbox( [ label( '(', punctuationStyle ), inheritanceView, label( ')', punctuationStyle ) ] ) inhUnparsed = UnparsedText( '(' ) + inheritanceView.text + ')' classLine = flow( [ classLabel, nameLabel, inhWidget, label( ':', punctuationStyle ) ], spacing=10.0 ) classLineUnparsed = classUnparsed + ' ' + nameUnparsed + inhUnparsed + ':' else: inhWidgets = [] classLine = flow( [ classLabel, nameLabel, label( ':', punctuationStyle ) ], spacing=10.0 ) classLineUnparsed = classUnparsed + ' ' + nameUnparsed + ':' return compoundStatementEditor( node, classLine, UnparsedText( classLineUnparsed, PRECEDENCE_STMT ), suite, state )
def generatorExpression(self, state, node, expr, *xs): exprView = viewEval( expr ) xViews = mapViewEval( xs, None, python25ViewState( Parser.generatorExpressionItem ) ) return nodeEditor( node, flow( [ label( '(', punctuationStyle ), flow( [ exprView ] + xViews, spacing=15.0 ), label( ')', punctuationStyle ) ] ), UnparsedText( '( ' + exprView.text + ' ' + UnparsedText( ' ' ).join( [ x.text for x in xViews ] ) + ' ]', PRECEDENCE_GENERATOREXPRESSION ), state )
def genFor(self, state, node, target, source): targetView = viewEval( target, None, python25ViewState( Parser.targetList ) ) sourceView = viewEval( source, None, python25ViewState( Parser.orTest ) ) return nodeEditor( node, flow( [ keywordLabel( forKeyword ), targetView, keywordLabel( inKeyword ), sourceView ] ), UnparsedText( forKeyword + ' ' + targetView.text + ' ' + inKeyword + sourceView.text, PRECEDENCE_GENERATOREXPRESSION ), state )
def listFor(self, state, node, target, source): targetView = viewEval( target, None, python25ViewState( Parser.targetList ) ) sourceView = viewEval( source, None, python25ViewState( Parser.oldTupleOrExpression ) ) return nodeEditor( node, flow( [ keywordLabel( forKeyword ), targetView, keywordLabel( inKeyword ), sourceView ] ), UnparsedText( forKeyword + ' ' + targetView.text + ' ' + inKeyword + sourceView.text, PRECEDENCE_LISTCOMPREHENSION ), state )
def augAssignStmt(self, state, node, op, target, value): targetView = viewEval( target, None, python25ViewState( Parser.targetItem ) ) valueView = viewEval( value, None, python25ViewState( Parser.tupleOrExpressionOrYieldExpression ) ) return nodeEditor( node, flow( [ targetView, label( op, punctuationStyle ), valueView ] ), UnparsedText( targetView.text + op + valueView.text, PRECEDENCE_STMT ), state )
def attributeRef(self, state, node, target, name): targetView = viewEval( target ) nameUnparsed = UnparsedText( name ) nameLabel = label( name ) nameUnparsed.associateWith( nameLabel ) return nodeEditor( node, flow( [ viewEval( target ), label( '.' ), nameLabel ] ), UnparsedText( _unparsePrecedenceGT( targetView.text, PRECEDENCE_ATTR ) + '.' + nameUnparsed, PRECEDENCE_ATTR ), state )
def assignmentStmt(self, state, node, targets, value): targetViews = mapViewEval( targets, None, python25ViewState( Parser.targetList ) ) valueView = viewEval( value, None, python25ViewState( Parser.tupleOrExpressionOrYieldExpression ) ) targetWidgets = [] for t in targetViews: targetWidgets.append( ahbox( [ t, label( '=', punctuationStyle ) ] ) ) return nodeEditor( node, flow( targetWidgets + [ valueView ] ), UnparsedText( UnparsedText( ' = ' ).join( [ t.text for t in targetViews ] ) + ' = ' + valueView.text, PRECEDENCE_STMT ), state )
def whileStmt(self, state, node, condition, suite): whileLabel = keywordLabel( whileKeyword ) whileUnparsed = UnparsedText( whileKeyword ) whileUnparsed.associateWith( whileLabel ) conditionView = viewEval( condition ) return compoundStatementEditor( node, flow( [ whileLabel, ahbox( [ conditionView, label( ':', punctuationStyle ) ] ) ] ), UnparsedText( whileUnparsed + ' ' + conditionView.text + ':', PRECEDENCE_STMT ), suite, state )
def forStmt(self, state, node, target, source, suite): forLabel = keywordLabel( forKeyword ) forUnparsed = UnparsedText( forKeyword ) forUnparsed.associateWith( forLabel ) targetView = viewEval( target, None, python25ViewState( Parser.targetList ) ) sourceView = viewEval( source, None, python25ViewState( Parser.tupleOrExpression ) ) return compoundStatementEditor( node, flow( [ forLabel, targetView, keywordLabel( inKeyword ), ahbox( [ sourceView, label( ':', punctuationStyle ) ] ) ] ), UnparsedText( forUnparsed + ' ' + targetView.text + ' ' + inKeyword + sourceView.text + ':', PRECEDENCE_LISTCOMPREHENSION ), suite, state )
def importStmt(self, state, node, *xs): xViews = mapViewEval( xs, None, python25ViewState( Parser.moduleImport ) ) xWidgets = [] if len( xs ) > 0: for xv in xViews[:-1]: xWidgets.append( ahbox( [ xv, label( ',', punctuationStyle ) ] ) ) xWidgets.append( xViews[-1] ) return nodeEditor( node, flow( [ keywordLabel( importKeyword ) ] + xWidgets, spacing=10.0 ), UnparsedText( importKeyword + ' ' + UnparsedText( ', ' ).join( [ xv.text for xv in xViews ] ), PRECEDENCE_STMT ), state )
def call(self, state, node, target, *args): targetView = viewEval( target ) argViews = mapViewEval( args, None, python25ViewState( Parser.callArg ) ) argWidgets = [] if len( args ) > 0: for a in argViews[:-1]: argWidgets.append( ahbox( [ a, label( ',', punctuationStyle ) ] ) ) argWidgets.append( argViews[-1] ) return nodeEditor( node, flow( [ viewEval( target ), label( '(', punctuationStyle ) ] + argWidgets + [ label( ')', punctuationStyle ) ] ), UnparsedText( _unparsePrecedenceGT( targetView.text, PRECEDENCE_CALL ) + '( ' + UnparsedText( ', ' ).join( [ a.text for a in argViews ] ) + ' )', PRECEDENCE_CALL ), state )
def globalStmt(self, state, node, *xs): globalLabel = keywordLabel( globalKeyword ) globalUnparsed = UnparsedText( globalKeyword ) globalUnparsed.associateWith( globalLabel ) xViews = mapViewEval( xs, None, python25ViewState( Parser.globalVar ) ) xWidgets = [] if len( xs ) > 0: for xv in xViews[:-1]: xWidgets.append( ahbox( [ xv, label( ',', punctuationStyle ) ] ) ) xWidgets.append( xViews[-1] ) return nodeEditor( node, flow( [ globalLabel ] + xWidgets, spacing=10.0 ), UnparsedText( globalUnparsed + ' ' + UnparsedText( ', ' ).join( [ xv.text for xv in xViews ] ), PRECEDENCE_STMT ), state )
def raiseStmt(self, state, node, *xs): xs = [ x for x in xs if x != '<nil>' ] xViews = mapViewEval( xs ) xWidgets = [] if len( xs ) > 0: for x in xViews[:-1]: xWidgets.append( ahbox( [ x, label( ',', punctuationStyle ) ] ) ) xWidgets.append( xViews[-1] ) xText = UnparsedText( ', ' ).join( [ x.text for x in xViews ] ) if len( xs ) > 0: xText = ' ' + xText return nodeEditor( node, flow( [ keywordLabel( raiseKeyword ) ] + xWidgets, spacing=10.0 ), UnparsedText( UnparsedText( raiseKeyword ) + xText, PRECEDENCE_STMT ), state )
def assertStmt(self, state, node, condition, fail): assertLabel = keywordLabel( assertKeyword ) assertUnparsed = UnparsedText( assertKeyword ) assertUnparsed.associateWith( assertLabel ) conditionView = viewEval( condition ) widgets = [ assertLabel ] if fail != '<nil>': failView = viewEval( fail ) widgets.append( ahbox( [ conditionView, label( ',', punctuationStyle ) ] ) ) widgets.append( viewEval( fail ) ) else: failView = None widgets.append( conditionView ) return nodeEditor( node, flow( widgets, spacing=10.0 ), UnparsedText( assertUnparsed + ' ' + conditionView.text + ( ', ' + failView.text ) if failView is not None else '', PRECEDENCE_STMT ), state )
def withStmt(self, state, node, expr, target, suite): withLabel = keywordLabel( withKeyword ) withUnparsed = UnparsedText( withKeyword ) withUnparsed.associateWith( withLabel ) exprView = viewEval( expr ) widgets = [ exprView ] txt = withUnparsed + ' ' + exprView.text if target != '<nil>': targetView = viewEval( target ) widgets.append( keywordLabel( asKeyword ) ) widgets.append( targetView ) txt += ' as ' + targetView.text widgets.append( label( ':', punctuationStyle ) ) return compoundStatementEditor( node, flow( [ withLabel ] + widgets, spacing=10.0 ), UnparsedText( txt + ':', PRECEDENCE_STMT ), suite, state )
def lambdaExpr(self, state, node, params, expr): # The Python 2.5 grammar has two versions of the lambda expression grammar; one what reckognises the full lambda expression, and one that # reckognises a lambda expression that cannot wrap conditional expression. # Ensure that we use the correct parser for @expr exprParser = Parser.expression if state is not None: parser, mode = state if parser is Parser.oldExpression or parser is Parser.oldLambdaExpr or parser is Parser.oldTupleOrExpression: exprParser = Parser.oldExpression exprView = viewEval( expr, None, python25ViewState( exprParser ) ) paramViews = mapViewEval( params, None, python25ViewState( Parser.param ) ) paramWidgets = [] if len( params ) > 0: for p in paramViews[:-1]: paramWidgets.append( ahbox( [ p, label( ',', punctuationStyle ) ] ) ) paramWidgets.append( paramViews[-1] ) return nodeEditor( node, flow( [ keywordLabel( lambdaKeyword ) ] + paramWidgets + [ label( ':', punctuationStyle ), exprView ], spacing=5.0 ), UnparsedText( lambdaKeyword + ' ' + UnparsedText( ', ' ).join( [ p.text for p in paramViews ] ) + ': ' + exprView.text, PRECEDENCE_LAMBDAEXPR ), state )
def defStmt(self, state, node, name, params, suite): defLabel = keywordLabel( defKeyword ) defUnparsed = UnparsedText( defKeyword ) defUnparsed.associateWith( defLabel ) nameLabel = label( name ) nameUnparsed = UnparsedText( name ) nameUnparsed.associateWith( nameLabel ) paramViews = mapViewEval( params, None, python25ViewState( Parser.param ) ) paramWidgets = [ label( '(', punctuationStyle ) ] if len( params ) > 0: for p in paramViews[:-1]: paramWidgets.append( ahbox( [ p, label( ',', punctuationStyle ) ] ) ) paramWidgets.append( paramViews[-1] ) paramWidgets.append( label( ')', punctuationStyle ) ) return compoundStatementEditor( node, flow( [ defLabel, nameLabel ] + paramWidgets + [ label( ':', punctuationStyle ) ], spacing=10.0 ), UnparsedText( defUnparsed + ' ' + nameUnparsed + '(' + UnparsedText( ', ' ).join( [ p.text for p in paramViews ] ) + '):', PRECEDENCE_STMT ), suite, state )
def execStmt(self, state, node, src, loc, glob): execLabel = keywordLabel( execKeyword ) execUnparsed = UnparsedText( execKeyword ) execUnparsed.associateWith( execLabel ) srcView = viewEval( src, None, python25ViewState( Parser.orOp ) ) widgets = [ srcView ] txt = execUnparsed + ' ' + srcView.text if loc != '<nil>': locView = viewEval( loc ) widgets.append( keywordLabel( inKeyword ) ) if glob != '<nil>': widgets.append( ahbox( [ locView, label( ',', punctuationStyle ) ] ) ) else: widgets.append( locView ) txt += ' ' + inKeyword + ' ' + locView.text if glob != '<nil>': globView = viewEval( glob ) widgets.append( globView ) txt += ', ' + globView.text return nodeEditor( node, flow( [ execLabel ] + widgets, spacing=10.0 ), UnparsedText( txt , PRECEDENCE_STMT ), state )
def exceptStmt(self, state, node, exc, target, suite): exceptLabel = keywordLabel( exceptKeyword ) exceptUnparsed = UnparsedText( exceptKeyword ) exceptUnparsed.associateWith( exceptLabel ) widgets = [] txt = exceptUnparsed if exc != '<nil>': excView = viewEval( exc ) if target != '<nil>': widgets.append( ahbox( [ excView, label( ',', punctuationStyle ) ] ) ) else: widgets.append( excView ) txt += ' ' + excView.text if target != '<nil>': targetView = viewEval( target ) widgets.append( targetView ) txt += ', ' + targetView.text widgets.append( label( ':', punctuationStyle ) ) return compoundStatementEditor( node, flow( [ exceptLabel ] + widgets, spacing=10.0 ), UnparsedText( txt + ':', PRECEDENCE_STMT ), suite, state )
def genIf(self, state, node, condition): conditionView = viewEval( condition, None, python25ViewState( Parser.oldExpression ) ) return nodeEditor( node, flow( [ keywordLabel( ifKeyword ), conditionView ] ), UnparsedText( ifKeyword + ' ' + conditionView.text, PRECEDENCE_GENERATOREXPRESSION ), state )
def yieldStmt(self, state, node, value): valueView = viewEval( value ) return nodeEditor( node, flow( [ keywordLabel( yieldKeyword ), valueView ] ), UnparsedText( yieldKeyword + ' ' + valueView.text, PRECEDENCE_STMT ), state )
def returnStmt(self, state, node, value): valueView = viewEval( value, None, python25ViewState( Parser.tupleOrExpression ) ) return nodeEditor( node, flow( [ keywordLabel( returnKeyword ), valueView ] ), UnparsedText( returnKeyword + ' ' + valueView.text, PRECEDENCE_STMT ), state )
def delStmt(self, state, node, target): targetView = viewEval( target, None, python25ViewState( Parser.targetList ) ) return nodeEditor( node, flow( [ keywordLabel( delKeyword ), targetView ] ), UnparsedText( delKeyword + ' ' + targetView.text, PRECEDENCE_STMT ), state )
def yieldAtom(self, state, node, value): valueView = viewEval( value ) return nodeEditor( node, flow( [ label( '(', punctuationStyle ), keywordLabel( yieldKeyword ), valueView, label( ')', punctuationStyle ) ] ), UnparsedText( '(' + yieldKeyword + ' ' + valueView.text + ')', PRECEDENCE_YIELDEXPR ), state )
def fromImportAllStmt(self, state, node, moduleName): moduleNameView = viewEval( moduleName, None, python25ViewState( Parser.moduleContentImport ) ) return nodeEditor( node, flow( [ keywordLabel( fromKeyword ), moduleNameView, keywordLabel( importKeyword ), label( '*', punctuationStyle ) ], spacing=10.0 ), UnparsedText( fromKeyword + ' ' + moduleNameView.text + ' ' + importKeyword + ' *', PRECEDENCE_STMT ), state )