mirror/fenom
1
0
Fork 0
mirror of https://github.com/fenom-template/fenom.git synced 2023-08-10 21:13:07 +03:00
Code Issues Projects Releases Wiki Activity

Update dosc and add tags {set} and {add}

Browse Source
This commit is contained in:
bzick
2014-08-05 17:49:42 +04:00
parent 0b96a02dd9
commit 6329765572
16 changed files with 250 additions and 378 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
docs/ru/readme.md
View File

@@ -17,14 +17,14 @@ Documentation
[Использование](./syntax.md#tags) тегов. [Использование](./syntax.md#tags) тегов.
* [var](./tags/var.md) — определение переменной * [set](./tags/set.md), `add` и `var` — определение значения переменной
* [if](./tags/if.md), `elseif` и `else` — условный оператор * [if](./tags/if.md), `elseif` и `else` — условный оператор
* [foreach](./tags/foreach.md), `foreaelse`, `break` and `continue` — перебор элементов массива или объекта * [foreach](./tags/foreach.md), `foreaelse`, `break` and `continue` — перебор элементов массива или объекта
* [for](./tags/for.md), `forelse`, `break` and `continue` — цикл * [for](./tags/for.md), `forelse`, `break` and `continue` — цикл
* [switch](./tags/switch.md), `case`, `default` — груповой условный оператор * [switch](./tags/switch.md), `case` — груповой условный оператор
* [cycle](./tags/cycle.md) — циклицеский перебор массива значений * [cycle](./tags/cycle.md) — циклицеский перебор массива значений
* [include](./tags/include.md), `insert` — вставляет и испольняет указанный шаблон * [include](./tags/include.md), `insert` — вставляет и испольняет указанный шаблон
* [extends](./tags/extends.md), `use`, `block` и `parent` — наследование шаблонов * [extends](./tags/extends.md), `use`, `block` и `parent` — [наследование](./inheritance.md) шаблонов
* [filter](./tags/filter.md) — примение модификаторов к фрагменту шаблона * [filter](./tags/filter.md) — примение модификаторов к фрагменту шаблона
* [ignore](./tags/ignore.md) — игнорирование тегов Fenom * [ignore](./tags/ignore.md) — игнорирование тегов Fenom
* [macro](./tags/macro.md) и `import` — пользовательские функции шаблонов * [macro](./tags/macro.md) и `import` — пользовательские функции шаблонов

64
docs/ru/start.md
View File

@@ -1,11 +1,12 @@
Basic usage Быстрый старт
=========== =============
## Install Fenom ## Установка Fenom
### Composer ### Composer
Add package Fenom in your require-list in `composer.json`: Fenom зарегестирован на [packagist.org](https://packagist.org/) как пакет [fenom/fenom](https://packagist.org/packages/fenom/fenom).
Что бы установить Fenom через composer пропишите в `composer.json` списке пакетов:
```json ```json
{ {
"require": { "require": {
@@ -13,56 +14,71 @@ Add package Fenom in your require-list in `composer.json`:
} }
} }
``` ```
and update project's dependencies: `composer update`. и обновите зависимости: `composer update`.
### Custom loader ### Custom loader
Clone Fenom to any directory: `git clone https://github.com/bzick/fenom.git`. Recommended use latest tag. Склонируйте Fenom в любую директорию Вашего проекта: `git clone https://github.com/bzick/fenom.git`. Рекомендуется использовать последнюю версию.
Fenom use [psr-0](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md#autoloading-standard) autoloading standard. Therefore you can Для загрузки классов Fenom использует [psr-0](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md#autoloading-standard) стандарт.
* use `psr-0` format in your project loader for loading Fenom's classes Таким образом вы можете:
* or register Fenom's autoloader: `Fenom::registerAutoload();` for loading itself. * использовать Ваш загрузчик, который понимает `psr-0` формат для загрузки классов Fenom из директории `src/` с пространством имен `Fenom`.
* или использовать строенный загрузчик Fenom: `Fenom::registerAutoload();` для загрузки самого себя.
Also you can use this autoloader for loading any library with `psr-0` file naming: Так же вы можете использовать встроенный в Fenom загрузчик для загрузки других классов в `psr-0` формате наименования класса и файла:
```php ```php
Fenom::registerAutoload(PROJECT_DIR."/src"); Fenom::registerAutoload(PROJECT_DIR."/classes");
``` ```
## Setup Fenom ## Настройка Fenom
Create an object via factory method Есть два варианта инициировать объект шаблонизатора: через `new` оператор и фабрику.
Пример создания Fenom через фабрику:
```php ```php
$fenom = Fenom::factory('/path/to/templates', '/path/to/compiled/template', $options); $fenom = Fenom::factory('/path/to/templates', '/path/to/compiled/template', $options);
``` ```
Пример создания Fenom через оператор `new`:
Create an object via `new` operator
```php ```php
$fenom = new Fenom(new Provider('/path/to/templates')); $fenom = new Fenom(new Provider('/path/to/templates'));
$fenom->setCompileDir('/path/to/template/cache'); $fenom->setCompileDir('/path/to/template/cache');
$fenom->setOptions($options); $fenom->setOptions($options);
``` ```
* `/path/to/templates` — directory, where stores your templates. * `/path/to/templates` — директория в которой хранятся шаблоны.
* `/path/to/template/cache` — directory, where stores compiled templates in PHP files. * `/path/to/template/cache` — директория в которую Fenom будет сохранять PHP-кеш шаблонов
* `$options` - bit-mask or array of [Fenom settings](./configuration.md#template-settings). * `$options` - битовая маска или массив [параметров](./configuration.md).
### Use Fenom ### Использование
Что бы отобразить шаблон на экран используйте метод `display`:
Output template
```php ```php
// $fenom->display(string $template, array $variables) : void
$fenom->display("template/name.tpl", $vars); $fenom->display("template/name.tpl", $vars);
``` ```
Get the result of rendering the template Метод найдет шаблон `template/name.tpl` отрисует его в `stdout`, подставляя переменные из массива `$vars`.
Метод `fetch` возвращает вывод шаблона вместо его отображения на экран.
```php ```php
// $fenom->fetch(string $template, array $variables) : string
$result = $fenom->fetch("template/name.tpl", $vars); $result = $fenom->fetch("template/name.tpl", $vars);
``` ```
Create the pipeline of rendering into callback Для отрисовки большого количества данных можно использовать поток
```php ```php
// $fenom->pipe(string $template, array $variables, callable $callback, int $chunk_size) : void
$fenom->pipe( $fenom->pipe(
"template/sitemap.tpl", "template/sitemap.tpl",
$vars, $vars,
$callback = [new SplFileObject("/tmp/sitemap.xml", "w"), "fwrite"], // pipe to file /tmp/sitemap.xml $callback = [new SplFileObject("compress.zlib:///tmp/sitemap.xml.gz", "w"), "fwrite"], // поток с архивацией в файл /tmp/sitemap.xml.gz
$chunk_size = 1e6 // chunk size for callback 1e6 // размер куска данных в байтах
); );
``` ```
Поток позволяет обрабатывать большой результат по кускам, размер куска указывается в байтах аргументом `$chunk_size`.
Каждый кусок передается в `$callback` для обработки или вывода.

228
docs/ru/syntax.md
View File

@@ -12,6 +12,8 @@
## Переменные ## Переменные
Переменные могут быть выведены на экран или могут быть использованы для функций, атрибутов, модификаторов внутри сложных выражений и т.д. Переменные могут быть выведены на экран или могут быть использованы для функций, атрибутов, модификаторов внутри сложных выражений и т.д.
Переменные в Fenom представлены знаком доллара с последующим именем переменной. Имя переменной чувствительно к регистру.
Правильное имя переменной должно начинаться с буквы или символа подчеркивания и состоять из букв, цифр и символов подчеркивания в любом количестве.
### Использование переменных ### Использование переменных
@@ -123,13 +125,6 @@
{"Hi, $username!"} выведет "Hi, Username!" {"Hi, $username!"} выведет "Hi, Username!"
``` ```
Аналогично могут быть обработаны элемент массива или свойство объекта
```smarty
{"Hi, $user.name!"}
{"Hi, $user->name!"}
```
Для чего-либо более сложного, используйте сложный синтаксис. Для чего-либо более сложного, используйте сложный синтаксис.
##### Сложный синтаксис ##### Сложный синтаксис
@@ -166,10 +161,10 @@ but if use single quote any template expressions will be on display as it is
это означает, что если вы попытаетесь использовать другие управляющие последовательности, такие как `\r` или `\n`, они будут выведены как есть вместо какого-либо особого поведения. это означает, что если вы попытаетесь использовать другие управляющие последовательности, такие как `\r` или `\n`, они будут выведены как есть вместо какого-либо особого поведения.
```smarty ```smarty
{'Hi, $foo'} outputs 'Hi, $foo' {'Hi, $foo'} выводит 'Hi, $foo'
{'Hi, {$foo}'} outputs 'Hi, {$foo}' {'Hi, {$foo}'} выводит 'Hi, {$foo}'
{'Hi, {$user.name}'} outputs 'Hi, {$user.name}' {'Hi, {$user.name}'} выводит 'Hi, {$user.name}'
{'Hi, {$user.name|up}'} outputs "Hi, {$user.name|up}" {'Hi, {$user.name|up}'} выводит "Hi, {$user.name|up}"
``` ```
### Целые числа ### Целые числа
@@ -205,149 +200,36 @@ but if use single quote any template expressions will be on display as it is
{var $c = 7E-10} {var $c = 7E-10}
``` ```
### Булев
Это простейший тип. Булевое выражает истинность значения. Он может быть либо TRUE либо FALSE.
Для указания булевого значения, используйте ключевое слово TRUE или FALSE. Оба регистро-независимы.
{set $a = true}
### NULL
Специальное значение NULL представляет собой переменную без значения. NULL - это единственно возможное значение типа null.
Обычно возникают путаницы между NULL и FALSE, так как по роли они похожи, но разлицаются по принципу:
NULL - это отсутствие присутствия, а FALSE - присутвие отсутствия.
### Операции ### Операции
Как и любой другой язык программирования/шаблонизации Fenom поддерживает множество различных операторов: Как и любой другой язык программирования/шаблонизации Fenom поддерживает множество различных операторов:
* [Арифметические операторы](./operators.md#arithmetic-operators) — `+`, `-`, `*`, `/`, `%` * Арифметические операторы — `+`, `-`, `*`, `/`, `%`
* [Логические операторы](./operators.md#logical-operators) — `||`, `&&`, `!$var`, `and`, `or`, `xor` * Логические операторы — `||`, `&&`, `!$var`, `and`, `or`, `xor`
* [Операторы сравнения](./operators.md#comparison-operators) — `>`, `>=`, `<`, `<=`, `==`, `!=`, `!==`, `<>` * Операторы сравнения — `>`, `>=`, `<`, `<=`, `==`, `!=`, `!==`, `<>`
* [Битовые операторы](./operators.md#bitwise-operators) — `|`, `&`, `^`, `~$var`, `>>`, `<<` * Битовые операторы — `|`, `&`, `^`, `~$var`, `>>`, `<<`
* [Операторы присвоения](./operators.md#assignment-operators) — `=`, `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `>>=`, `<<=` * Операторы присвоения — `=`, `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `>>=`, `<<=`
* [Строковый оператор](./operators.md#string-operator) — `$str1 ~ $str2` * Строковый оператор — `$str1 ~ $str2`
* [Тернарные операторы](./operators.md#ternary-operators) — `$a ? $b : $c`, `$a ! $b : $c`, `$a ?: $c`, `$a !: $c` * Тернарные операторы — `$a ? $b : $c`, `$a ! $b : $c`, `$a ?: $c`, `$a !: $c`
* [Проверяющие операторы](./operators.md#check-operators) — `$var?`, `$var!` * Проверяющие операторы — `$var?`, `$var!`
* [Оператор тестирование](./operators.md#test-operator) — `is`, `is not` * Оператор тестирование — `is`, `is not`
* [Оператор содержания](./operators.md#containment-operator) — `in`, `not in` * Оператор содержания — `in`, `not in`
Подробнее об [операторах](./operators.md) Подробнее об [операторах](./operators.md).
### Set variable
```smarty
{var $foo = "bar"}
{var $foo = "bar"|upper} {* apply modifier *}
{var $foo = 5}
{var $foo = $x + $y}
{var $foo = $x.y[z] + $y}
{var $foo = strlen($a)} {* work with functions *}
{var $foo = myfunct( ($x+$y)*3 )}
{var $foo.bar.baz = 1} {* multidimensional value support *}
{var $foo = $object->item->method($y, 'named')} {* work with object fine *}
```
Using block tag
```smarty
{var $foo}
content {$text|truncate:30}
{/var}
{var $foo|truncate:50} {* apply modifier to content *}
content {$text}
{/var}
```
Set array
```smarty
{var $foo = [1, 2, 3]} numeric array
{var $foo = ['y' => 'yellow', 'b' => 'blue']} associative array
{var $foo = [1, [9, 8], 3]} can be nested
{var $foo = [1, $two, $three * 3 + 9]}
{var $foo = [$a, $d.c, $a + $f]}
{var $foo = ['y' => 'yellow', $color|upper => $colors[ $color ]}
{var $foo = [1, [$parent, $a->method()], 3]}
```
See also [{var}](./tags/var.md) documentation.
### Static method support
```smarty
{Lib\Math::multiple x=3 y=4} static method as tag
{Lib\Math::multiple(3,4)} inline static method
{12 + Lib\Math::multiple(3,4)}
{12 + 3|Lib\Math::multiple:4} static method as modifier
```
You may disable call static methods in template, see in [security options](./settings.md) option `deny_static`
### Set variable
```smarty
{var $foo = "bar"}
{var $foo = "bar"|upper} {* apply modifier *}
{var $foo = 5}
{var $foo = $x + $y}
{var $foo = $x.y[z] + $y}
{var $foo = strlen($a)} {* work with functions *}
{var $foo = myfunct( ($x+$y)*3 )}
{var $foo.bar.baz = 1} {* multidimensional value support *}
{var $foo = $object->item->method($y, 'named')} {* work with object fine *}
```
Using block tag
```smarty
{var $foo}
content {$text|truncate:30}
{/var}
{var $foo|truncate:50} {* apply modifier to content *}
content {$text}
{/var}
```
Set array
```smarty
{var $foo = [1, 2, 3]} numeric array
{var $foo = ['y' => 'yellow', 'b' => 'blue']} associative array
{var $foo = [1, [9, 8], 3]} can be nested
{var $foo = [1, $two, $three * 3 + 9]}
{var $foo = [$a, $d.c, $a + $f]}
{var $foo = ['y' => 'yellow', $color|upper => $colors[ $color ]}
{var $foo = [1, [$parent, $a->method()], 3]}
```
See also [{var}](./tags/var.md) documentation.
## Scalar values
### Strings
When the string in double quotation marks, all the expressions in the string will be run.
The result of expressions will be inserted into the string instead it.
```smarty
{var $foo="Username"}
{var $user.name="Username"}
{"Hi, $foo"} outputs "Hi, Username"
{"Hi, {$foo}"} outputs "Hi, Username"
{"Hi, {$user.name}"} outputs "Hi, Username"
{"Hi, {$user.name|up}"} outputs "Hi, USERNAME"
{"Hi, {$user->getName(true)}"} outputs Hi, Username
{var $message = "Hi, {$user.name}"}
```
but if use single quote any template expressions will be on display as it is
```smarty
{'Hi, $foo'} outputs 'Hi, $foo'
{'Hi, {$foo}'} outputs 'Hi, {$foo}'
{'Hi, {$user.name}'} outputs 'Hi, {$user.name}'
{'Hi, {$user.name|up}'} outputs "Hi, {$user.name|up}"
```
### Numbers
```smarty
{2|pow:10}
{var $magick = 5381|calc}
{0.2|round}
{1e-6|round}
```
## Modifiers ## Modifiers
@@ -368,53 +250,11 @@ but if use single quote any template expressions will be on display as it is
[List of modifiers](./main.md#modifiers) [List of modifiers](./main.md#modifiers)
## Tags ## Функции
Basically, tag seems like ## Компиляторы
```smarty ### Игнорирование кода
{FUNCNAME attr1 = "val1" attr2 = $val2}
```
Tags starts with name and may have attributes
Это общий формат функций, но могут быть исключения, например функция [{var}](./tags/var.md), использованная выше.
```smarty
{include file="my.tpl"}
{var $foo=5}
{if $user.loggined}
Welcome, <span style="color: red">{$user.name}!</span>
{else}
Who are you?
{/if}
```
В общем случае аргументы принимают любой формат переменных, в том числе результаты арифметических операций и модификаторов.
```smarty
{funct arg=true}
{funct arg=5}
{funct arg=1.2}
{funct arg='string'}
{funct arg="string this {$var}"}
{funct arg=[1,2,34]}
{funct arg=$x}
{funct arg=$x.c}
```
```smarty
{funct arg="ivan"|upper}
{funct arg=$a.d.c|lower}
```
```smarty
{funct arg=1+2}
{funct arg=$a.d.c+4}
{funct arg=($a.d.c|count+4)/3}
```
### Ignoring template code
В шаблонизаторе Fenom используются фигурные скобки для отделения HTML от кода Fenom. В шаблонизаторе Fenom используются фигурные скобки для отделения HTML от кода Fenom.
Если требуется вывести текст, содержащий фигурные скобки, то есть следующие варианты это сделать: Если требуется вывести текст, содержащий фигурные скобки, то есть следующие варианты это сделать:

5
docs/ru/tags/cycle.md
View File

@@ -1,6 +1,9 @@
Tag {cycle} Тег {cycle}
=========== ===========
Тег {cycle} используется для прохода через множество значений.
С его помощью можно легко реализовать чередование двух или более заданных значений.
```smarty ```smarty
{for $i=$a.c..} {for $i=$a.c..}
<div class="{cycle ["odd", "even"]}"> <div class="{cycle ["odd", "even"]}">

47
docs/ru/tags/extends.md
View File

@@ -1,7 +1,7 @@
Tag {extends} [RU] Тег {extends}
================== =============
Тег `{extends}` реализует наследование шаблонов, иерархия, обратная {include}. То есть шаблон сам выбирает своего родителя. Тег `{extends}` реализует [наследование](../inheritance.md) шаблонов, иерархия, обратная {include}. То есть шаблон сам выбирает своего родителя.
### {extends} ### {extends}
@@ -11,15 +11,15 @@ Tag {extends} [RU]
{extends 'parent.tpl'} {extends 'parent.tpl'}
``` ```
Имя родительского шаблона может быть задан динамически, в этом случае производительность отрисовки может снизиться. **Замечание:**
Имя родительского шаблона может быть задан динамически, но в этом случае производительность шаблона значительно снижается.
```smarty ```smarty
{extends $parent_tpl} {extends $parent_tpl}
``` ```
### {block} ### {block}
Блок указывает фрагмент шаблона, который будет передан родителю. Имя блока может быть задано как явно Блок указывает фрагмент шаблона, который будет передан родителю. Имя блока должно быть задано явно:
```smarty ```smarty
{block bk1}content 1{/block} {block bk1}content 1{/block}
@@ -27,17 +27,6 @@ Tag {extends} [RU]
{block 'bk2'}content 2{/block} {block 'bk2'}content 2{/block}
``` ```
так и не явно, но в данном случае пострадает производительность
```smarty
{block "bk{$number}"}content {$number}{/block}
...
{if $condition}
{block "bk-if"}content, then 'if' is true{/block}
{else}
{block "bk{$fail}"}content, then 'if' is false{/block}
{/if}
```
### {use} ### {use}
@@ -47,11 +36,8 @@ Tag {extends} [RU]
{use 'blocks.tpl'} {use 'blocks.tpl'}
``` ```
### {parent} ### {parent}
Planned. Not supported yet. Feature #5.
```smarty ```smarty
{block 'block1'} {block 'block1'}
content ... content ...
@@ -59,24 +45,3 @@ Planned. Not supported yet. Feature #5.
content ... content ...
{/block} {/block}
``` ```
### Performance
Алгоритм реализации наследования шаблонов может работать в разных режимах, в зависимости от условий.
Каждый режим имеет свою производительность.
1. **Максимальная** производительность:
* Имена шаблонов в теге {extends } заданы явно, без использования переменных и условий.
* Имена блоков заданы явно, без использования переменных, условий и не вложены ни в какой другой тег.
2. **Средняя** производительность:
* Имена шаблонов в теге {extends } заданы явно, без использования переменных и условий.
* Имена блоков заданы **не** явно, с использованием переменныч, условий или могут быть вложенные в другие теги.
3. **Низкая** производительность:
* Имена шаблонов в теге {extends } заданы **не** явно, с использованием переменных и условий.
* Имена блоков заданы явно, без использования переменных, условий и не вложены ни в какой другой тег.
4. **Минимальная** производительность:
* Имена шаблонов в теге {extends } заданы **не** явно, с использованием переменных и условий.
* Имена блоков заданы **не** явно, с использованием переменных, условий или могут быть вложенные в другие теги.
Режим может идти только на понижение, при изменении условий во время прохождения по иерархии шаблонов.
При любом режиме работы не используется буферизация данных, то есть данные выводятся сразу.

4
docs/ru/tags/filter.md
View File

@@ -1,7 +1,7 @@
Tags {filter} Тег {filter}
============= =============
Позволяет применить модификаторы на фрагмент шаблона Тег {filter} позволяет применить модификаторы на фрагмент шаблона
```smarty ```smarty
{filter|strip_tags|truncate:20} {filter|strip_tags|truncate:20}

2
docs/ru/tags/for.md
View File

@@ -1,4 +1,4 @@
Tag {for} Тег {for}
========= =========
```smarty ```smarty

4
docs/ru/tags/foreach.md
View File

@@ -1,5 +1,5 @@
Tag {foreach} [RU] Тег {foreach}
================== =============
```smarty ```smarty
{foreach $list as [$key =>] $value [index=$index] [first=$first] [last=$last]} {foreach $list as [$key =>] $value [index=$index] [first=$first] [last=$last]}

8
docs/ru/tags/if.md
View File

@@ -1,5 +1,5 @@
Tag {if} [RU] Тег {if}
============= ========
Реализация оператора [if](http://docs.php.net/if) из PHP Реализация оператора [if](http://docs.php.net/if) из PHP
@@ -33,7 +33,7 @@ Tag {if} [RU]
{/if} {/if}
``` ```
Код, расположенный после тега `{elseif}` будет выполнен/выведен, если выражение <expression1> вернуло значение приводимое к **FALSE**, <expression2> - приводимое к **TRUE** Код, расположенный после тега `{elseif}` будет выполнен/выведен, если выражение <expression1> вернуло значение приводимое к **FALSE**, а <expression2> - приводимое к **TRUE**
### {else} ### {else}
@@ -46,4 +46,4 @@ Tag {if} [RU]
``` ```
Код, расположенный после тега `{else}` будет выполнен/выведен, если выражение <expression> вернуло значение приводимое к **FALSE** Код, расположенный после тега `{else}` будет выполнен/выведен, если выражение <expression> вернуло значение приводимое к **FALSE**
В тестируемых выражениях могут быть использованы логические операторы , что позволяет обрабатывать сочетания нескольких условий. В тестируемых выражениях могут быть использованы логические операторы, что позволяет обрабатывать сочетания нескольких условий.

2
docs/ru/tags/ignore.md
View File

@@ -1,4 +1,4 @@
Tag {ignore} Тег {ignore}
============ ============
{ignore} tags allow a block of data to be taken literally. {ignore} tags allow a block of data to be taken literally.

28
docs/ru/tags/include.md
View File

@@ -1,29 +1,35 @@
Tag {include} Tag {include}
============= =============
`{include}` tags are used for including other templates in the current template. Any variables available in the current template are also available within the included template. Тэги `{include}` используются для включения других шаблонов в текущий. Любые переменные, доступные в текущем шаблоне, доступны и во включаемом.
```smarty ```smarty
{include "about.tpl"} {include "about.tpl"}
``` ```
If you need to set yours variables for template list them in attributes. Вы также можете передать переменные в подключаемый шаблон в виде атрибутов.
Любая переменная, переданная в подключаемый шаблон, доступны только в области видимости подключаемого файла.
Переданные переменные имеют преимущество перед существующими переменными с аналогичными именами.
```smarty ```smarty
{include "about.tpl" page=$item limit=50} {include "pagination.tpl" count=$total_pages current=$.get.page}
``` ```
All variables changed in child template has no affect to variables in parent template. Все значения присвоенных переменных восстанавливаются после того, как подключаемый шаблон отработал.
Это значит, что вы можете использовать все переменные из подключающего шаблона в подключаемом, но изменения переменных внутри подключаемого шаблона не будут видны внутри подключающего шаблона после команды {include}.
### {insert} ### {insert}
The tag insert template code instead self. В отличии от `{include}` тег `{insert}` не вызывает дочерний шаблон во время отрисовки, в ставляет код дочернего шаблона в родительский на момент компиляции.
Это позволяет сэкономить ресурсы на проверке и чтении шаблона. Однако такой формат подключения шаблона имеет ограничения.
Имя шаблона должно быть задано явно, без использования переменных и выражений:
* No dynamic name allowed. ```smarty
* No variables as attribute allowed. {insert 'pagination.tpl'} {* отработает *}
* Increase performance because insert code as is in compilation time. {insert $pagination} {* вызовет ошибку *}
```
For example, main.tpl: Рассмотрим тега `{insert}` на примере. Допустим шаблон `main.tpl` имеет следующий код:
```smarty ```smarty
a: {$a} a: {$a}
@@ -31,13 +37,13 @@ a: {$a}
c: {$c} c: {$c}
``` ```
b.tpl: `b.tpl`:
``` ```
b: {$b} b: {$b}
``` ```
Code of `b.tpl` will be inserted into `main.tpl` as is: Компилятор увидит шаблон `main.tpl` таким:
```smarty ```smarty
a: {$a} a: {$a}

4
docs/ru/tags/macro.md
View File

@@ -1,5 +1,5 @@
Tag {macro} [RU] Тег {macro}
================ ===========
Макросы - фрагмент шаблона который можно повторить сколь угодно раз и в каком угодно месте. Макросы - фрагмент шаблона который можно повторить сколь угодно раз и в каком угодно месте.
Макросы не имеют общего пространства имен с шаблоном и могут оперировать только переданными переменными. Макросы не имеют общего пространства имен с шаблоном и могут оперировать только переданными переменными.

81
docs/ru/tags/set.md Normal file
View File

@@ -0,0 +1,81 @@
Тег {set}
=========
### {set}
Тег {set} используется для установки значения переменной в процессе выполнения шаблона.
```smarty
{set $var=(expr)}
```
```smarty
{set $var}
... any content ...
{/set}
```
```smarty
{set $var|modifiers}
... any content ...
{/set}
```
Имя переменной `$var` должно соответствовать [принятому правилу именования переменных](../syntax.md#Переменные).
Выражение `expr` может быть любое сочетание [переменных](../syntax.md#Переменные), [скалярных значений](../syntax.md#Скалярные+значения) и массивов.
```smarty
{set $v = 5}
{set $v = "value"}
{set $v = $x+$y}
{set $v = 4}
{set $v = $z++ + 1}
{set $v = --$z}
{set $v = $y/$x}
{set $v = $y-$x}
{set $v = $y*$x-2}
{set $v = ($y^$x)+7}
{set $v = [1,2,3]}
{set $v = []}
{set $v = ["one"|upper => 1, 4 => $x, "three" => 3]}
{set $v = ["key1" => $y*$x-2, "key2" => ["z" => $z]]}
{set $v = count([1,2,3])+7}
```
В качестве значения переменной можно задать результат отрисовки фрагмента шаблона:
```smarty
{set $v}
Some long {$text|trim}
{/var}
```
Такой вариант создания позволяет применить модификаторы к данным переде тем как они будут сохранены в переменную:
```smarty
{set $v|escape} {* применение можификатора к значению *}
Some long {$text|trim}
{/var}
```
### {add}
Тег {add} делает тоже самое что и тег {set} за исключением того что сначало проверяет наличие переменной и если переменной нет — задет новое значение.
```smarty
{add $var = 'value'}
```
Работу тега можнно описать следующим образом:
```smarty
{if $var is not set}
{set $var = 'value'}
{/if}
```
### {var}
Тег {var} старое название тега {set}, сейчас это одно и тоже.

63
docs/ru/tags/switch.md
View File

@@ -1,46 +1,61 @@
Tag {switch} Тег {switch}
============ ============
The `{switch}` tag is similar to a series of `{if}` statements on the same expression. Тег `{switch}` подобен серии операторов `{if}` с одинаковым условием.
In many occasions, you may want to compare the same variable (or expression) with many different values, Во многих случаях вам может понадобиться сравнивать одну и ту же переменную (или выражение) с множеством различных значений,
and execute a different piece of code depending on which value it equals to. This is exactly what the `{switch}` tag is for. и выполнять различные участки кода в зависимости от того, какое значение принимает эта переменная (или выражение).
Это именно тот случай, для которого удобен тег `{switch}`.
Tag `{switch}` accepts any expression. But `{case}` accepts only static scalar values or constants. Тег `{switch}` в качестве аргумента принимает любое выражение.
Каждый возможный случай описывается тегом `{case value}` значения `value` которых могут быть только явно заданные скалярные значения.
Случаи могут повторятся, в этом случае блоки для которых повторялся случай будут последовательно выполнены по направлению сверху вниз.
Случай `default` подразумевает обработку если ни один случай не произошел.
```smarty ```smarty
{switch <condition>} {switch <condition>}
{case <value1>} {case value1}
... ...
{case <value2>, <value3>, ...} {case value2, value3, ...}
... ...
{case <value3>} {case value3}
... ...
{case default, <value1>} {case default, <value1>}
... ...
{/switch} {/switch}
``` ```
For example, Рассмотрим пример:
```smarty ```smarty
{switch $type} {switch $color}
{case 'new'} {case 'red', 'scarlet'}
It is new item Оттенок красного цвета
{case 'current', 'new'} {case 'green', 'harlequin'}
It is new or current item Оттенок зеленого цвета
{case 'current'} {case 'black', 'grey', 'gray'}
It is current item Черный цвет
{case 'new', 'newer'} {case 'white', 'grey', 'gray'}
It is new item, again Белый цвет
{case default} {case default, 'unknown'}
I don't know the type {$type} Неизвестный цвет
{/switch} {/switch}
``` ```
if `$type = 'new'` then template output если задать `$color = 'red'` результатом будет:
``` ```
It is new item Оттенок красного цвета
It is new or current item ```
It is new item, again
для случая `$color = 'grey'` будут вызваны два бока:
```
Черный цвет
Белый цвет
```
случаи `$color = 'yellow'` и `$color = 'unknown'` будут обработаны последним блоком:
```
Неизвестный цвет
``` ```

64
docs/ru/tags/var.md
View File

@@ -1,64 +0,0 @@
Tag {var}
=========
The tag {var} is used for assigning template variables during the execution of a template.
```smarty
{var $var=EXPR}
```
```smarty
{var $var}
... any content ...
{/var}
```
```smarty
{var $var|modifiers}
... any content ...
{/var}
```
Variable names follow the same rules as other labels in PHP.
A valid variable name starts with a letter or underscore, followed by any number of letters, numbers, or underscores.
```smarty
{var $v = 5}
{var $v = "value"}
{var $v = $x+$y}
{var $v = 4}
{var $v = $z++ + 1}
{var $v = --$z}
{var $v = $y/$x}
{var $v = $y-$x}
{var $v = $y*$x-2}
{var $v = ($y^$x)+7}
```
Creating array
```smarty
{var $v = [1,2,3]}
{var $v = []}
{var $v = ["one"|upper => 1, 4 => $x, "three" => 3]}
{var $v = ["key1" => $y*$x-2, "key2" => ["z" => $z]]}
```
Getting function result into variable
```smarty
{var $v = count([1,2,3])+7}
```
Collect the output of the template into a variable
```smarty
{var $v}
Some long {$text|trim}
{/var}
{var $v|escape} {* apply modifier to variable*}
Some long {$text|trim}
{/var}
```

16
src/Fenom.php
View File

@@ -229,10 +229,20 @@ class Fenom
'type' => self::INLINE_COMPILER, 'type' => self::INLINE_COMPILER,
'parser' => 'Fenom\Compiler::tagInsert' 'parser' => 'Fenom\Compiler::tagInsert'
), ),
'var' => array( // {var ...} 'var' => array( // {var ...}
'type' => self::BLOCK_COMPILER, 'type' => self::BLOCK_COMPILER,
'open' => 'Fenom\Compiler::varOpen', 'open' => 'Fenom\Compiler::setOpen',
'close' => 'Fenom\Compiler::varClose' 'close' => 'Fenom\Compiler::setClose'
),
'set' => array( // {set ...}
'type' => self::BLOCK_COMPILER,
'open' => 'Fenom\Compiler::setOpen',
'close' => 'Fenom\Compiler::setClose'
),
'add' => array( // {add ...}
'type' => self::BLOCK_COMPILER,
'open' => 'Fenom\Compiler::setOpen',
'close' => 'Fenom\Compiler::setClose'
), ),
'block' => array( // {block ...} {parent} {/block} 'block' => array( // {block ...} {parent} {/block}
'type' => self::BLOCK_COMPILER, 'type' => self::BLOCK_COMPILER,