...

Source file src/github.com/noirbizarre/gonja/parser/tests.go

Documentation: github.com/noirbizarre/gonja/parser

     1  package parser
     2  
     3  import (
     4  	log "github.com/sirupsen/logrus"
     5  
     6  	"github.com/noirbizarre/gonja/nodes"
     7  )
     8  
     9  func (p *Parser) ParseTest(expr nodes.Expression) (nodes.Expression, error) {
    10  	log.WithFields(log.Fields{
    11  		"current": p.Current(),
    12  	}).Trace("parseTest")
    13  
    14  	expr, err := p.ParseFilterExpression(expr)
    15  	if err != nil {
    16  		return nil, err
    17  	}
    18  
    19  	if p.MatchName("is") != nil {
    20  		not := p.MatchName("not")
    21  		ident := p.Next()
    22  
    23  		test := &nodes.TestCall{
    24  			Token:  ident,
    25  			Name:   ident.Val,
    26  			Args:   []nodes.Expression{},
    27  			Kwargs: map[string]nodes.Expression{},
    28  		}
    29  
    30  		arg, err := p.ParseExpression()
    31  		if err == nil && arg != nil {
    32  			test.Args = append(test.Args, arg)
    33  		}
    34  
    35  		
    36  
    37  		// // Check for test-argument (2 tokens needed: ':' ARG)
    38  		// if p.Match(tokens.Lparen) != nil {
    39  		// 	if p.Peek(tokens.VariableEnd) != nil {
    40  		// 		return nil, p.Error("Filter parameter required after '('.", nil)
    41  		// 	}
    42  
    43  		// 	for p.Match(tokens.Comma) != nil || p.Match(tokens.Rparen) == nil {
    44  		// 		// TODO: Handle multiple args and kwargs
    45  		// 		v, err := p.ParseExpression()
    46  		// 		if err != nil {
    47  		// 			return nil, err
    48  		// 		}
    49  
    50  		// 		if p.Match(tokens.Assign) != nil {
    51  		// 			key := v.Position().Val
    52  		// 			value, errValue := p.ParseExpression()
    53  		// 			if errValue != nil {
    54  		// 				return nil, errValue
    55  		// 			}
    56  		// 			test.Kwargs[key] = value
    57  		// 		} else {
    58  		// 			test.Args = append(test.Args, v)
    59  		// 		}
    60  		// 	}
    61  		// } else {
    62  		// 	arg, err := p.ParseExpression()
    63  		// 	if err == nil && arg != nil {
    64  		// 		test.Args = append(test.Args, arg)
    65  		// 	}
    66  		// }
    67  
    68  		expr = &nodes.TestExpression{
    69  			Expression: expr,
    70  			Test:       test,
    71  		}
    72  
    73  		if not != nil {
    74  			expr = &nodes.Negation{expr, not}
    75  		}
    76  	}
    77  
    78  	log.WithFields(log.Fields{
    79  		"expr": expr,
    80  	}).Trace("parseTest return")
    81  	return expr, nil
    82  }
    83  

View as plain text