Directives: Import, Inheritance, Declaration and Assignment — Cheetah3 - The Python-Powered Template Engine

# Directives: Import, Inheritance, Declaration and Assignment

## #import and #from

The template:

    #import math

This construct does not produce any output.

The generated module, at the bottom of the import section:

    import math

## #extends

The template:

    #extends SomeClass

The generated import (skipped if {SomeClass} has already been imported):

    from SomeClass import SomeClass

The generated class:

    class x(SomeClass):

## #implements

The template:

    #implements doOutput

In the generated class, the main method is {.doOutput} instead of {.respond}, and the attribute naming this method is:

    _mainCheetahMethod_for_x2= 'doOutput'

## #set and #set global

The template:

    #set $namesList = ['Moe','Larry','Curly']
    $namesList
    #set global $toes = ['eeny', 'meeny', 'miney', 'moe']
    $toes

The output:

    ['Moe', 'Larry', 'Curly']
    ['eeny', 'meeny', 'miney', 'moe']

The generated code:

    1  namesList = ['Moe','Larry','Curly']
    2  write(filter(namesList)) # generated from '$namesList' at line 2, col 1.
    3  write('\n')
    4  globalSetVars["toes"] = ['eeny', 'meeny', 'miney', 'moe']
    5  write(filter(VFS(SL,"toes",1))) # generated from '$toes' at line 4, col 1.
    6  write('\n')

{globalSetVars} is a local variable referencing {._globalSetVars}. Writes go into it directly, but reads take advantage of the fact that {._globalSetVars} is on the searchList. (In fact, it’s the very first namespace.)

## #del

The template:

    #set $a = 1
    #del $a
    #set $a = 2
    #set $arr = [0, 1, 2]
    #del $a, $arr[1]

In the generated class:

    1  a = 1
    2  del a
    3  a = 2
    4  arr = [0, 1, 2]
    5  del a, arr[1]

## #attr

The template:

    #attr $namesList = ['Moe', 'Larry', 'Curly']

In the generated class:

    ## GENERATED ATTRIBUTES

    namesList = ['Moe', 'Larry', 'Curly']

## #def

The template:

    #def printArg($arg)
    The argument is $arg.
    #end def
    My method returned $printArg(5).

The output:

    My method returned The argument is 5.
    .

Hmm, not exactly what we expected. The method returns a trailing newline because we didn’t end the last line with {#slurp}. So the second period (outside the method) appears on a separate line.

The {#def} generates a method {.printArg} whose structure is similar to the main method:

    def printArg(self,
            arg,
            trans=None,
            dummyTrans=False,
            VFS=valueFromSearchList,
            VFN=valueForName,
            getmtime=getmtime,
            currentTime=time.time):

        """
        Generated from #def printArg($arg) at line 1, col 1.
        """

        if not trans:
            trans = DummyTransaction()
            dummyTrans = True
        write = trans.response().write
        SL = self._searchList
        filter = self._currentFilter
        globalSetVars = self._globalSetVars

        ########################################
        ## START - generated method body

        write('The argument is ')
        write(filter(arg)) # generated from '$arg' at line 2, col 17.
        write('.\n')

        ########################################
        ## END - generated method body

        if dummyTrans:
            return trans.response().getvalue()
        else:
            return ""

When {.printArg} is called from a placeholder, only the arguments the user supplied are passed. The other arguments retain their default values.

## #block

The template:

    #block content
    This page is under construction.
    #end block

The output:

    This page is under construction.

This construct generates a method {.content} in the same structure as {.printArg} above, containing the write code:

    write('This page is under construction.\n')

In the main method, the write code is:

    self.content(trans=trans) # generated from ('content', '#block content')
        # at line 1, col 1.

So a block placeholder implicitly passes the current transaction to the method.