Packages

  • Nette
    • Application
      • Diagnostics
      • Responses
      • Routers
      • UI
    • Caching
      • Storages
    • ComponentModel
    • Config
      • Adapters
      • Extensions
    • Database
      • Diagnostics
      • Drivers
      • Reflection
      • Table
    • DI
      • Diagnostics
    • Diagnostics
    • Forms
      • Controls
      • Rendering
    • Http
    • Iterators
    • Latte
      • Macros
    • Loaders
    • Localization
    • Mail
    • Reflection
    • Security
      • Diagnostics
    • Templating
    • Utils
      • PhpGenerator
  • NetteModule
  • None
  • PHP

Classes

  • FileTemplate
  • Template
  • TemplateHelpers

Interfaces

  • IFileTemplate
  • ITemplate

Exceptions

  • TemplateException
  • Overview
  • Package
  • Class
  • Tree
  • Deprecated
  1: <?php
  2: 
  3: /**
  4:  * This file is part of the Nette Framework (http://nette.org)
  5:  *
  6:  * Copyright (c) 2004 David Grudl (http://davidgrudl.com)
  7:  *
  8:  * For the full copyright and license information, please view
  9:  * the file license.txt that was distributed with this source code.
 10:  * @package Nette\Templating
 11:  */
 12: 
 13: 
 14: 
 15: /**
 16:  * Template helpers.
 17:  *
 18:  * @author     David Grudl
 19:  * @package Nette\Templating
 20:  */
 21: final class TemplateHelpers
 22: {
 23:     private static $helpers = array(
 24:         'normalize' => 'Strings::normalize',
 25:         'toascii' => 'Strings::toAscii',
 26:         'webalize' => 'Strings::webalize',
 27:         'truncate' => 'Strings::truncate',
 28:         'lower' => 'Strings::lower',
 29:         'upper' => 'Strings::upper',
 30:         'firstupper' => 'Strings::firstUpper',
 31:         'capitalize' => 'Strings::capitalize',
 32:         'trim' => 'Strings::trim',
 33:         'padleft' => 'Strings::padLeft',
 34:         'padright' => 'Strings::padRight',
 35:         'reverse' =>  'Strings::reverse',
 36:         'replacere' => 'Strings::replace',
 37:         'url' => 'rawurlencode',
 38:         'striptags' => 'strip_tags',
 39:         'substr' => 'Strings::substring',
 40:         'repeat' => 'str_repeat',
 41:         'implode' => 'implode',
 42:         'number' => 'number_format',
 43:     );
 44: 
 45:     /** @var string default date format */
 46:     public static $dateFormat = '%x';
 47: 
 48: 
 49:     /**
 50:      * Try to load the requested helper.
 51:      * @param  string  helper name
 52:      * @return callable
 53:      */
 54:     public static function loader($helper)
 55:     {
 56:         if (method_exists(__CLASS__, $helper)) {
 57:             return new Callback(__CLASS__, $helper);
 58:         } elseif (isset(self::$helpers[$helper])) {
 59:             return self::$helpers[$helper];
 60:         }
 61:     }
 62: 
 63: 
 64:     /**
 65:      * Escapes string for use inside HTML template.
 66:      * @param  mixed  UTF-8 encoding
 67:      * @param  int    optional attribute quotes
 68:      * @return string
 69:      */
 70:     public static function escapeHtml($s, $quotes = ENT_QUOTES)
 71:     {
 72:         if (is_object($s) && ($s instanceof ITemplate || $s instanceof Html || $s instanceof Form)) {
 73:             return $s->__toString(TRUE);
 74:         }
 75:         return htmlSpecialChars($s, $quotes);
 76:     }
 77: 
 78: 
 79:     /**
 80:      * Escapes string for use inside HTML comments.
 81:      * @param  string  UTF-8 encoding
 82:      * @return string
 83:      */
 84:     public static function escapeHtmlComment($s)
 85:     {
 86:         return ' ' . str_replace('-', '- ', $s); // dash is very problematic character in comments
 87:     }
 88: 
 89: 
 90:     /**
 91:      * Escapes string for use inside XML 1.0 template.
 92:      * @param  string UTF-8 encoding
 93:      * @return string
 94:      */
 95:     public static function escapeXML($s)
 96:     {
 97:         // XML 1.0: \x09 \x0A \x0D and C1 allowed directly, C0 forbidden
 98:         // XML 1.1: \x00 forbidden directly and as a character reference,
 99:         //   \x09 \x0A \x0D \x85 allowed directly, C0, C1 and \x7F allowed as character references
100:         return htmlSpecialChars(preg_replace('#[\x00-\x08\x0B\x0C\x0E-\x1F]+#', '', $s), ENT_QUOTES);
101:     }
102: 
103: 
104:     /**
105:      * Escapes string for use inside CSS template.
106:      * @param  string UTF-8 encoding
107:      * @return string
108:      */
109:     public static function escapeCss($s)
110:     {
111:         // http://www.w3.org/TR/2006/WD-CSS21-20060411/syndata.html#q6
112:         return addcslashes($s, "\x00..\x1F!\"#$%&'()*+,./:;<=>?@[\\]^`{|}~");
113:     }
114: 
115: 
116:     /**
117:      * Escapes variables for use inside <script>.
118:      * @param  mixed  UTF-8 encoding
119:      * @return string
120:      */
121:     public static function escapeJs($s)
122:     {
123:         if (is_object($s) && ($s instanceof ITemplate || $s instanceof Html || $s instanceof Form)) {
124:             $s = $s->__toString(TRUE);
125:         }
126:         return str_replace(array(']]>', '<!'), array(']]\x3E', '\x3C!'), Json::encode($s));
127:     }
128: 
129: 
130:     /**
131:      * Escapes string for use inside iCal template.
132:      * @param  mixed  UTF-8 encoding
133:      * @return string
134:      */
135:     public static function escapeICal($s)
136:     {
137:         // http://www.ietf.org/rfc/rfc5545.txt
138:         return addcslashes(preg_replace('#[\x00-\x08\x0B\x0C-\x1F]+#', '', $s), "\";\\,:\n");
139:     }
140: 
141: 
142:     /**
143:      * Replaces all repeated white spaces with a single space.
144:      * @param  string UTF-8 encoding or 8-bit
145:      * @return string
146:      */
147:     public static function strip($s)
148:     {
149:         return Strings::replace(
150:             $s,
151:             '#(</textarea|</pre|</script|^).*?(?=<textarea|<pre|<script|\z)#si',
152:             create_function('$m', '
153:                 return trim(preg_replace(\'#[ \\t\\r\\n]+#\', " ", $m[0]));
154:             '));
155:     }
156: 
157: 
158:     /**
159:      * Indents the HTML content from the left.
160:      * @param  string UTF-8 encoding or 8-bit
161:      * @param  int
162:      * @param  string
163:      * @return string
164:      */
165:     public static function indent($s, $level = 1, $chars = "\t")
166:     {
167:         if ($level >= 1) {
168:             $s = Strings::replace($s, '#<(textarea|pre).*?</\\1#si', create_function('$m', '
169:                 return strtr($m[0], " \\t\\r\\n", "\\x1F\\x1E\\x1D\\x1A");
170:             '));
171:             $s = Strings::indent($s, $level, $chars);
172:             $s = strtr($s, "\x1F\x1E\x1D\x1A", " \t\r\n");
173:         }
174:         return $s;
175:     }
176: 
177: 
178:     /**
179:      * Date/time formatting.
180:      * @param  string|int|DateTime
181:      * @param  string
182:      * @return string
183:      */
184:     public static function date($time, $format = NULL)
185:     {
186:         if ($time == NULL) { // intentionally ==
187:             return NULL;
188:         }
189: 
190:         if (!isset($format)) {
191:             $format = self::$dateFormat;
192:         }
193: 
194:         $time = DateTime53::from($time);
195:         return Strings::contains($format, '%')
196:             ? strftime($format, $time->format('U')) // formats according to locales
197:             : $time->format($format); // formats using date()
198:     }
199: 
200: 
201:     /**
202:      * Converts to human readable file size.
203:      * @param  int
204:      * @param  int
205:      * @return string
206:      */
207:     public static function bytes($bytes, $precision = 2)
208:     {
209:         $bytes = round($bytes);
210:         $units = array('B', 'kB', 'MB', 'GB', 'TB', 'PB');
211:         foreach ($units as $unit) {
212:             if (abs($bytes) < 1024 || $unit === end($units)) {
213:                 break;
214:             }
215:             $bytes = $bytes / 1024;
216:         }
217:         return round($bytes, $precision) . ' ' . $unit;
218:     }
219: 
220: 
221:     /**
222:      * Returns array of string length.
223:      * @param  mixed
224:      * @return int
225:      */
226:     public static function length($var)
227:     {
228:         return is_string($var) ? Strings::length($var) : count($var);
229:     }
230: 
231: 
232:     /**
233:      * Performs a search and replace.
234:      * @param  string
235:      * @param  string
236:      * @param  string
237:      * @return string
238:      */
239:     public static function replace($subject, $search, $replacement = '')
240:     {
241:         return str_replace($search, $replacement, $subject);
242:     }
243: 
244: 
245:     /**
246:      * The data: URI generator.
247:      * @param  string
248:      * @param  string
249:      * @return string
250:      */
251:     public static function dataStream($data, $type = NULL)
252:     {
253:         if ($type === NULL) {
254:             $type = MimeTypeDetector::fromString($data);
255:         }
256:         return 'data:' . ($type ? "$type;" : '') . 'base64,' . base64_encode($data);
257:     }
258: 
259: 
260:     /**
261:      * /dev/null.
262:      * @param  mixed
263:      * @return string
264:      */
265:     public static function null($value)
266:     {
267:         return '';
268:     }
269: 
270: 
271:     /**
272:      * @param  string
273:      * @return string
274:      */
275:     public static function nl2br($value)
276:     {
277:         return nl2br($value, Html::$xhtml);
278:     }
279: 
280: 
281:     /********************* Template tools ****************d*g**/
282: 
283: 
284:     /**
285:      * Removes unnecessary blocks of PHP code.
286:      * @param  string
287:      * @return string
288:      */
289:     public static function optimizePhp($source, $lineLength = 80, $existenceOfThisParameterSolvesDamnBugInPHP535 = NULL)
290:     {
291:         $res = $php = '';
292:         $lastChar = ';';
293:         $tokens = new ArrayIterator(token_get_all($source));
294:         foreach ($tokens as $key => $token) {
295:             if (is_array($token)) {
296:                 if ($token[0] === T_INLINE_HTML) {
297:                     $lastChar = '';
298:                     $res .= $token[1];
299: 
300:                 } elseif ($token[0] === T_CLOSE_TAG) {
301:                     $next = isset($tokens[$key + 1]) ? $tokens[$key + 1] : NULL;
302:                     if (substr($res, -1) !== '<' && preg_match('#^<\?php\s*\z#', $php)) {
303:                         $php = ''; // removes empty (?php ?), but retains ((?php ?)?php
304: 
305:                     } elseif (is_array($next) && $next[0] === T_OPEN_TAG) { // remove ?)(?php
306:                         if (!strspn($lastChar, ';{}:/')) {
307:                             $php .= $lastChar = ';';
308:                         }
309:                         if (substr($next[1], -1) === "\n") {
310:                             $php .= "\n";
311:                         }
312:                         $tokens->next();
313: 
314:                     } elseif ($next) {
315:                         $res .= preg_replace('#;?(\s)*\z#', '$1', $php) . $token[1]; // remove last semicolon before ?)
316:                         if (strlen($res) - strrpos($res, "\n") > $lineLength
317:                             && (!is_array($next) || strpos($next[1], "\n") === FALSE)
318:                         ) {
319:                             $res .= "\n";
320:                         }
321:                         $php = '';
322: 
323:                     } else { // remove last ?)
324:                         if (!strspn($lastChar, '};')) {
325:                             $php .= ';';
326:                         }
327:                     }
328: 
329:                 } elseif ($token[0] === T_ELSE || $token[0] === T_ELSEIF) {
330:                     if ($tokens[$key + 1] === ':' && $lastChar === '}') {
331:                         $php .= ';'; // semicolon needed in if(): ... if() ... else:
332:                     }
333:                     $lastChar = '';
334:                     $php .= $token[1];
335: 
336:                 } else {
337:                     if (!in_array($token[0], array(T_WHITESPACE, T_COMMENT, T_DOC_COMMENT, T_OPEN_TAG))) {
338:                         $lastChar = '';
339:                     }
340:                     $php .= $token[1];
341:                 }
342:             } else {
343:                 $php .= $lastChar = $token;
344:             }
345:         }
346:         return $res . $php;
347:     }
348: 
349: }
350: 
Nette Framework 2.0.13 (for PHP 5.2, un-prefixed) API API documentation generated by ApiGen 2.8.0