Upgrade from Smarty 3 to Smarty 4 to be PHP 8.1 compatible
Remove all Smarty4 dedicated tests, all are done in the same test file like before
This commit is contained in:
Clemens Schwaighofer
@@ -0,0 +1,84 @@
|
||||
Escaping Smarty Parsing {#language.escaping}
|
||||
=======================
|
||||
|
||||
It is sometimes desirable or even necessary to have Smarty ignore
|
||||
sections it would otherwise parse. A classic example is embedding
|
||||
Javascript or CSS code in a template. The problem arises as those
|
||||
languages use the { and } characters which are also the default
|
||||
[delimiters](#language.function.ldelim) for Smarty.
|
||||
|
||||
> **Note**
|
||||
>
|
||||
> A good practice for avoiding escapement altogether is by separating
|
||||
> your Javascript/CSS into their own files and use standard HTML methods
|
||||
> to access them. This will also take advantage of browser script
|
||||
> caching. When you need to embed Smarty variables/functions into your
|
||||
> Javascript/CSS, then the following applies.
|
||||
|
||||
In Smarty templates, the { and } braces will be ignored so long as they
|
||||
are surrounded by white space. This behavior can be disabled by setting
|
||||
the Smarty class variable [`$auto_literal`](#variable.auto.literal) to
|
||||
false.
|
||||
|
||||
|
||||
<script>
|
||||
// the following braces are ignored by Smarty
|
||||
// since they are surrounded by whitespace
|
||||
function foobar {
|
||||
alert('foobar!');
|
||||
}
|
||||
// this one will need literal escapement
|
||||
{literal}
|
||||
function bazzy {alert('foobar!');}
|
||||
{/literal}
|
||||
</script>
|
||||
|
||||
|
||||
|
||||
[`{literal}..{/literal}`](#language.function.literal) blocks are used
|
||||
for escaping blocks of template logic. You can also escape the braces
|
||||
individually with
|
||||
[`{ldelim}`](#language.function.ldelim),[`{rdelim}`](#language.function.ldelim)
|
||||
tags or
|
||||
[`{$smarty.ldelim}`,`{$smarty.rdelim}`](#language.variables.smarty.ldelim)
|
||||
variables.
|
||||
|
||||
Smarty\'s default delimiters { and } cleanly represent presentational
|
||||
content. However if another set of delimiters suit your needs better,
|
||||
you can change them with Smarty\'s
|
||||
[`$left_delimiter`](#variable.left.delimiter) and
|
||||
[`$right_delimiter`](#variable.right.delimiter) values.
|
||||
|
||||
> **Note**
|
||||
>
|
||||
> Changing delimiters affects ALL template syntax and escapement. Be
|
||||
> sure to clear out cache and compiled files if you decide to change
|
||||
> them.
|
||||
|
||||
|
||||
<?php
|
||||
|
||||
$smarty->left_delimiter = '<!--{';
|
||||
$smarty->right_delimiter = '}-->';
|
||||
|
||||
$smarty->assign('foo', 'bar');
|
||||
$smarty->assign('name', 'Albert');
|
||||
$smarty->display('example.tpl');
|
||||
|
||||
?>
|
||||
|
||||
|
||||
|
||||
Where the template is:
|
||||
|
||||
|
||||
Welcome <!--{$name}--> to Smarty
|
||||
<script language="javascript">
|
||||
var foo = <!--{$foo}-->;
|
||||
function dosomething() {
|
||||
alert("foo is " + foo);
|
||||
}
|
||||
dosomething();
|
||||
</script>
|
||||
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
Math {#language.math}
|
||||
====
|
||||
|
||||
Math can be applied directly to variable values.
|
||||
|
||||
|
||||
{$foo+1}
|
||||
|
||||
{$foo*$bar}
|
||||
|
||||
{* some more complicated examples *}
|
||||
|
||||
{$foo->bar-$bar[1]*$baz->foo->bar()-3*7}
|
||||
|
||||
{if ($foo+$bar.test%$baz*134232+10+$b+10)}
|
||||
|
||||
{$foo|truncate:"`$fooTruncCount/$barTruncFactor-1`"}
|
||||
|
||||
{assign var="foo" value="`$foo+$bar`"}
|
||||
|
||||
|
||||
|
||||
> **Note**
|
||||
>
|
||||
> Although Smarty can handle some very complex expressions and syntax,
|
||||
> it is a good rule of thumb to keep the template syntax minimal and
|
||||
> focused on presentation. If you find your template syntax getting too
|
||||
> complex, it may be a good idea to move the bits that do not deal
|
||||
> explicitly with presentation to PHP by way of plugins or modifiers.
|
||||
@@ -0,0 +1,50 @@
|
||||
Attributes {#language.syntax.attributes}
|
||||
==========
|
||||
|
||||
Most of the [functions](#language.syntax.functions) take attributes that
|
||||
specify or modify their behavior. Attributes to Smarty functions are
|
||||
much like HTML attributes. Static values don\'t have to be enclosed in
|
||||
quotes, but it is required for literal strings. Variables with or
|
||||
without modifiers may also be used, and should not be in quotes. You can
|
||||
even use PHP function results, plugin results and complex expressions.
|
||||
|
||||
Some attributes require boolean values (TRUE or FALSE). These can be
|
||||
specified as `true` and `false`. If an attribute has no value assigned
|
||||
it gets the default boolean value of true.
|
||||
|
||||
|
||||
{include file="header.tpl"}
|
||||
|
||||
{include file="header.tpl" nocache} // is equivalent to nocache=true
|
||||
|
||||
{include file="header.tpl" attrib_name="attrib value"}
|
||||
|
||||
{include file=$includeFile}
|
||||
|
||||
{include file=#includeFile# title="My Title"}
|
||||
|
||||
{assign var=foo value={counter}} // plugin result
|
||||
|
||||
{assign var=foo value=substr($bar,2,5)} // PHP function result
|
||||
|
||||
{assign var=foo value=$bar|strlen} // using modifier
|
||||
|
||||
{assign var=foo value=$buh+$bar|strlen} // more complex expression
|
||||
|
||||
{html_select_date display_days=true}
|
||||
|
||||
{mailto address="smarty@example.com"}
|
||||
|
||||
<select name="company_id">
|
||||
{html_options options=$companies selected=$company_id}
|
||||
</select>
|
||||
|
||||
|
||||
|
||||
> **Note**
|
||||
>
|
||||
> Although Smarty can handle some very complex expressions and syntax,
|
||||
> it is a good rule of thumb to keep the template syntax minimal and
|
||||
> focused on presentation. If you find your template syntax getting too
|
||||
> complex, it may be a good idea to move the bits that do not deal
|
||||
> explicitly with presentation to PHP by way of plugins or modifiers.
|
||||
@@ -0,0 +1,71 @@
|
||||
Comments {#language.syntax.comments}
|
||||
========
|
||||
|
||||
Template comments are surrounded by asterisks, and that is surrounded by
|
||||
the [delimiter](#variable.left.delimiter) tags like so:
|
||||
|
||||
::: {.informalexample}
|
||||
|
||||
{* this is a comment *}
|
||||
|
||||
|
||||
:::
|
||||
|
||||
Smarty comments are NOT displayed in the final output of the template,
|
||||
unlike `<!-- HTML comments -->`. These are useful for making internal
|
||||
notes in the templates which no one will see ;-)
|
||||
|
||||
|
||||
{* I am a Smarty comment, I don't exist in the compiled output *}
|
||||
<html>
|
||||
<head>
|
||||
<title>{$title}</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
{* another single line smarty comment *}
|
||||
<!-- HTML comment that is sent to the browser -->
|
||||
|
||||
{* this multiline smarty
|
||||
comment is
|
||||
not sent to browser
|
||||
*}
|
||||
|
||||
{*********************************************************
|
||||
Multi line comment block with credits block
|
||||
@ author: bg@example.com
|
||||
@ maintainer: support@example.com
|
||||
@ para: var that sets block style
|
||||
@ css: the style output
|
||||
**********************************************************}
|
||||
|
||||
{* The header file with the main logo and stuff *}
|
||||
{include file='header.tpl'}
|
||||
|
||||
|
||||
{* Dev note: the $includeFile var is assigned in foo.php script *}
|
||||
<!-- Displays main content block -->
|
||||
{include file=$includeFile}
|
||||
|
||||
{* this <select> block is redundant *}
|
||||
{*
|
||||
<select name="company">
|
||||
{html_options options=$vals selected=$selected_id}
|
||||
</select>
|
||||
*}
|
||||
|
||||
<!-- Show header from affiliate is disabled -->
|
||||
{* $affiliate|upper *}
|
||||
|
||||
{* you cannot nest comments *}
|
||||
{*
|
||||
<select name="company">
|
||||
{* <option value="0">-- none -- </option> *}
|
||||
{html_options options=$vals selected=$selected_id}
|
||||
</select>
|
||||
*}
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
Functions {#language.syntax.functions}
|
||||
=========
|
||||
|
||||
Every Smarty tag either prints a [variable](#language.variables) or
|
||||
invokes some sort of function. These are processed and displayed by
|
||||
enclosing the function and its [attributes](#language.syntax.attributes)
|
||||
within delimiters like so: `{funcname attr1="val1" attr2="val2"}`.
|
||||
|
||||
|
||||
{config_load file="colors.conf"}
|
||||
|
||||
{include file="header.tpl"}
|
||||
{insert file="banner_ads.tpl" title="My Site"}
|
||||
|
||||
{if $logged_in}
|
||||
Welcome, <span style="color:{#fontColor#}">{$name}!</span>
|
||||
{else}
|
||||
hi, {$name}
|
||||
{/if}
|
||||
|
||||
{include file="footer.tpl"}
|
||||
|
||||
|
||||
|
||||
- Both [built-in functions](#language.builtin.functions) and [custom
|
||||
functions](#language.custom.functions) have the same syntax within
|
||||
templates.
|
||||
|
||||
- Built-in functions are the **inner** workings of Smarty, such as
|
||||
[`{if}`](#language.function.if),
|
||||
[`{section}`](#language.function.section) and
|
||||
[`{strip}`](#language.function.strip). There should be no need to
|
||||
change or modify them.
|
||||
|
||||
- Custom functions are **additional** functions implemented via
|
||||
[plugins](#plugins). They can be modified to your liking, or you can
|
||||
create new ones. [`{html_options}`](#language.function.html.options)
|
||||
is an example of a custom function.
|
||||
|
||||
See also [`registerPlugin()`](#api.register.plugin)
|
||||
@@ -0,0 +1,61 @@
|
||||
Embedding Vars in Double Quotes {#language.syntax.quotes}
|
||||
===============================
|
||||
|
||||
- Smarty will recognize [assigned](#api.assign)
|
||||
[variables](#language.syntax.variables) embedded in \"double
|
||||
quotes\" so long as the variable name contains only numbers, letters
|
||||
and under\_scores. See [naming](&url.php-manual;language.variables)
|
||||
for more detail.
|
||||
|
||||
- With any other characters, for example a period(.) or
|
||||
`$object->reference`, then the variable must be surrounded by
|
||||
`` `backticks` ``.
|
||||
|
||||
- In addition Smarty3 does allow embedded Smarty tags in double quoted
|
||||
strings. This is useful if you want to include variables with
|
||||
modifiers, plugin or PHP function results.
|
||||
|
||||
<!-- -->
|
||||
|
||||
|
||||
{func var="test $foo test"} // sees $foo
|
||||
{func var="test $foo_bar test"} // sees $foo_bar
|
||||
{func var="test `$foo[0]` test"} // sees $foo[0]
|
||||
{func var="test `$foo[bar]` test"} // sees $foo[bar]
|
||||
{func var="test $foo.bar test"} // sees $foo (not $foo.bar)
|
||||
{func var="test `$foo.bar` test"} // sees $foo.bar
|
||||
{func var="test `$foo.bar` test"|escape} // modifiers outside quotes!
|
||||
{func var="test {$foo|escape} test"} // modifiers inside quotes!
|
||||
{func var="test {time()} test"} // PHP function result
|
||||
{func var="test {counter} test"} // plugin result
|
||||
{func var="variable foo is {if !$foo}not {/if} defined"} // Smarty block function
|
||||
|
||||
|
||||
|
||||
|
||||
{* will replace $tpl_name with value *}
|
||||
{include file="subdir/$tpl_name.tpl"}
|
||||
|
||||
{* does NOT replace $tpl_name *}
|
||||
{include file='subdir/$tpl_name.tpl'} // vars require double quotes!
|
||||
|
||||
{* must have backticks as it contains a dot "." *}
|
||||
{cycle values="one,two,`$smarty.config.myval`"}
|
||||
|
||||
{* must have backticks as it contains a dot "." *}
|
||||
{include file="`$module.contact`.tpl"}
|
||||
|
||||
{* can use variable with dot syntax *}
|
||||
{include file="`$module.$view`.tpl"}
|
||||
|
||||
|
||||
|
||||
> **Note**
|
||||
>
|
||||
> Although Smarty can handle some very complex expressions and syntax,
|
||||
> it is a good rule of thumb to keep the template syntax minimal and
|
||||
> focused on presentation. If you find your template syntax getting too
|
||||
> complex, it may be a good idea to move the bits that do not deal
|
||||
> explicitly with presentation to PHP by way of plugins or modifiers.
|
||||
|
||||
See also [`escape`](#language.modifier.escape).
|
||||
@@ -0,0 +1,111 @@
|
||||
Variables {#language.syntax.variables}
|
||||
=========
|
||||
|
||||
Template variables start with the \$dollar sign. They can contain
|
||||
numbers, letters and underscores, much like a [PHP
|
||||
variable](&url.php-manual;language.variables). You can reference arrays
|
||||
by index numerically or non-numerically. Also reference object
|
||||
properties and methods.
|
||||
|
||||
[Config file variables](#language.config.variables) are an exception to
|
||||
the \$dollar syntax and are instead referenced with surrounding
|
||||
\#hashmarks\#, or via the
|
||||
[`$smarty.config`](#language.variables.smarty.config) variable.
|
||||
|
||||
|
||||
{$foo} <-- displaying a simple variable (non array/object)
|
||||
{$foo[4]} <-- display the 5th element of a zero-indexed array
|
||||
{$foo.bar} <-- display the "bar" key value of an array, similar to PHP $foo['bar']
|
||||
{$foo.$bar} <-- display variable key value of an array, similar to PHP $foo[$bar]
|
||||
{$foo->bar} <-- display the object property "bar"
|
||||
{$foo->bar()} <-- display the return value of object method "bar"
|
||||
{#foo#} <-- display the config file variable "foo"
|
||||
{$smarty.config.foo} <-- synonym for {#foo#}
|
||||
{$foo[bar]} <-- syntax only valid in a section loop, see {section}
|
||||
{assign var=foo value='baa'}{$foo} <-- displays "baa", see {assign}
|
||||
|
||||
Many other combinations are allowed
|
||||
|
||||
{$foo.bar.baz}
|
||||
{$foo.$bar.$baz}
|
||||
{$foo[4].baz}
|
||||
{$foo[4].$baz}
|
||||
{$foo.bar.baz[4]}
|
||||
{$foo->bar($baz,2,$bar)} <-- passing parameters
|
||||
{"foo"} <-- static values are allowed
|
||||
|
||||
{* display the server variable "SERVER_NAME" ($_SERVER['SERVER_NAME'])*}
|
||||
{$smarty.server.SERVER_NAME}
|
||||
|
||||
Math and embedding tags:
|
||||
|
||||
{$x+$y} // will output the sum of x and y.
|
||||
{assign var=foo value=$x+$y} // in attributes
|
||||
{$foo[$x+3]} // as array index
|
||||
{$foo={counter}+3} // tags within tags
|
||||
{$foo="this is message {counter}"} // tags within double quoted strings
|
||||
|
||||
Defining Arrays:
|
||||
|
||||
{assign var=foo value=[1,2,3]}
|
||||
{assign var=foo value=['y'=>'yellow','b'=>'blue']}
|
||||
{assign var=foo value=[1,[9,8],3]} // can be nested
|
||||
|
||||
Short variable assignment:
|
||||
|
||||
{$foo=$bar+2}
|
||||
{$foo = strlen($bar)} // function in assignment
|
||||
{$foo = myfunct( ($x+$y)*3 )} // as function parameter
|
||||
{$foo.bar=1} // assign to specific array element
|
||||
{$foo.bar.baz=1}
|
||||
{$foo[]=1} // appending to an array
|
||||
|
||||
Smarty "dot" syntax (note: embedded {} are used to address ambiguities):
|
||||
|
||||
{$foo.a.b.c} => $foo['a']['b']['c']
|
||||
{$foo.a.$b.c} => $foo['a'][$b]['c'] // with variable index
|
||||
{$foo.a.{$b+4}.c} => $foo['a'][$b+4]['c'] // with expression as index
|
||||
{$foo.a.{$b.c}} => $foo['a'][$b['c']] // with nested index
|
||||
|
||||
PHP-like syntax, alternative to "dot" syntax:
|
||||
|
||||
{$foo[1]} // normal access
|
||||
{$foo['bar']}
|
||||
{$foo['bar'][1]}
|
||||
{$foo[$x+$x]} // index may contain any expression
|
||||
{$foo[$bar[1]]} // nested index
|
||||
{$foo[section_name]} // smarty {section} access, not array access!
|
||||
|
||||
Variable variables:
|
||||
|
||||
$foo // normal variable
|
||||
$foo_{$bar} // variable name containing other variable
|
||||
$foo_{$x+$y} // variable name containing expressions
|
||||
$foo_{$bar}_buh_{$blar} // variable name with multiple segments
|
||||
{$foo_{$x}} // will output the variable $foo_1 if $x has a value of 1.
|
||||
|
||||
Object chaining:
|
||||
|
||||
{$object->method1($x)->method2($y)}
|
||||
|
||||
Direct PHP function access:
|
||||
|
||||
{time()}
|
||||
|
||||
|
||||
|
||||
|
||||
> **Note**
|
||||
>
|
||||
> Although Smarty can handle some very complex expressions and syntax,
|
||||
> it is a good rule of thumb to keep the template syntax minimal and
|
||||
> focused on presentation. If you find your template syntax getting too
|
||||
> complex, it may be a good idea to move the bits that do not deal
|
||||
> explicitly with presentation to PHP by way of plugins or modifiers.
|
||||
|
||||
Request variables such as `$_GET`, `$_SESSION`, etc are available via
|
||||
the reserved [`$smarty`](#language.variables.smarty) variable.
|
||||
|
||||
See also [`$smarty`](#language.variables.smarty), [config
|
||||
variables](#language.config.variables)
|
||||
[`{assign}`](#language.function.assign) and [`assign()`](#api.assign).
|
||||
Reference in New Issue
Block a user