Řešení zavináčů – nechť je z Latte základ Nette šablon

Nikde jsem nenašel, jestli se hnulo s řešením
zavináčů, takže tohle je
můj návrh řešení.

Základní předpoklad: pokud někdo používá Nette šablony, používá LatteFilter.

Bohužel z pozice filtru (resp. makroprocesoru) toho Latte moc nezmůže.
Jednou možností by bylo z Latte udělat 2-pass
makroprocesor – tzn. že v prvním běhu by si zapamatoval potřebné informace o šabloně
(kde je jaký snippet, jakými podmínkami je obalen) a podle toho by si v druhém běhu
před dané podmínky zavináče „domyslel“.

Ale lepší by podle mě bylo, aby Latte povýšil z pozice filtru na základní stavební
kámen Nette šablon – už ně makroprocesor, nýbrž plnohodnotný jazyk.

Místo toho, aby přechroupával textovou verzi šablony, vytvořil by si její in-memory
reprezentaci, tu zpracoval a z ní až vygeneroval PHP kód. Compile-time šablon by se
asi prodloužil, run-time by byl stejně rychlý v případě zavedení optimalizací by mohl
být ještě rychlejší.

Vytvořil jsem prototyp Latte parseru v phpegu, napsat
plnohodnotný parser, ať v phpegu, nebo ručně, by nemělo být složité. V prototypu
parseru je s HTML tagy pracováno jako s HTML tagy, takže
<li {if $first}class="first"{/fi}> skončí chybou. V plnohodnotném parseru by šlo
i toto řešit. Nicméně bych se přikláněl k něčemu na způsob mého dřívějšího
smart_attrs patche.

Aby z Latte byl opravdu jazyk, krom syntaxe by měl mít také jasně definovanou
sémantiku. U většiny příkazů (podmínky, cykly, odkazy…) je to asi jasné. Zaměřil
bych se na dědičnost.

Příkaz {extends …} musí být v šabloně na prvním místě, na jakémkoli jiném místě
znamená sémantickou chybu. Nechť vše vně bloků
(ať deklarovaných pomocí {block …}, nebo atributu n:block="…") je záporný
prostor a uvnitř bloků kladný prostor (terminologie vypůjčená z
Evoque). Extenduje-li šablona A
šablonu B,
záporný prostor A je nahrazen záporným prostorem B. Resp.
místo TOMu (Template Object Modelu) Ačka použijeme TOM Bčka,
a v něm nahradíme bloky shodnými bloky z Ačka.

Podobně by se měly všechny {include …} uzly nahradit uzly odpovídajícími
vkládanému obsahu.

Například TOM šalony:

{* A.latte *}
some negative space
{block foo}bar{/block}
{block baz}bar{/block}
negative space at the end of file

by byl:

[
    @TextNode {
        text = "some negative space\n"
    },
    @BlockNode {
        name = "foo",
        children = [
            @TextNode {
                text = "bar"
            }
        ]
    },
    @BlockNode {
        name = "baz",
        children = [
            @TextNode {
                text = "bar"
            }
        ]
    }
    @TextNode {
        text = "negative space at the end of file\n"
    },
]

a šablony:

{* B.latte *}
{extends A.latte}

{block foo}wow{/block}

by byl:

[
    @TextNode {
        text = "some negative space\n"
    },
    @BlockNode {
        name = "foo",
        children = [
            @TextNode {
                text = "wow"
            }
        ]
    },
    @BlockNode {
        name = "baz",
        children = [
            @TextNode {
                text = "bar"
            }
        ]
    }
    @TextNode {
        text = "negative space at the end of file\n"
    },
]

Až tedy proběhne fáze starající se v šablonách o dědičnost, dostaneme in-memory
reprezentaci šablony (TOM), která bude obsahovat jak správný záporný prostor, tak
správný kladný prostor a nebude obsahovat žádné includy. S tímhle TOMem se už dají
provádět další transformace a kontroly.

Při generování se může používat technika jako doteď
(if (SnippetHelper::$outputAllowed) {):

class LatteNode
{
    abstract public function isAnySnippetInside();

    abstract public function generatePhp();
}

class SnippetNode
{
    public function isAnySnippetInside()
    {
        return TRUE;
    }

    public function generatePhp() { … }
}

class IfNode
{
    /** @var string */
    private $condition;

    /** @var array of LatteNode */
    private $ifClause;

    /** @var array if LatteNode */
    private $elseClause;

    public function isAnySnippetInside()
    {
        foreach (array_merge($this->ifClause, $this->elseClause) as $node) {
            if ($node->isAnySnippetInside()) {
                return TRUE;
            }
        }

        return FALSE;
    }

    public function generatePhp()
    {
        $php = "";

        if ($this->isAnySnippetInside()) {
            $php .= "}\n";
        }

        $php .= "if ({$this->condition}):\n"

        if ($this->isAnySnippetInside()) {
            $php .= "if (SnippetHelper::\$outputAllowed) {\n";
        }

        foreach ($this->ifClause as $node) {
            $php .= $node->generatePhp();
        }

        if (!empty($this->elseClause)) {
            if ($this->isAnySnippetInside()) {
                $php .= "}\n";
            }

            $php .= "else:\n";

            if ($this->isAnySnippetInside()) {
                $php .= "if (SnippetHelper::\$outputAllowed) {\n";
            }

            foreach ($this->elseClause as $node) {
                $php .= $node->generatePhp();
            }
        }

        if ($this->isAnySnippetInside()) {
            $php .= "}\n";
        }

        $php .= "endif;\n";

        if ($this->isAnySnippetInside()) {
            $php .= "if (SnippetHelper::\$outputAllowed) {\n";
        }
    }
}