vendor/contao/core-bundle/src/Resources/contao/library/Contao/Template.php line 322

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of Contao.
  5.  *
  6.  * (c) Leo Feyer
  7.  *
  8.  * @license LGPL-3.0-or-later
  9.  */
  11. namespace Contao;
  13. use Contao\CoreBundle\Routing\ResponseContext\JsonLd\JsonLdManager;
  14. use Contao\Image\ImageInterface;
  15. use Contao\Image\PictureConfiguration;
  16. use MatthiasMullie\Minify\CSS;
  17. use MatthiasMullie\Minify\JS;
  18. use Spatie\SchemaOrg\Graph;
  19. use Symfony\Component\HttpFoundation\Response;
  20. use Symfony\Component\VarDumper\VarDumper;
  22. /**
  23.  * Parses and outputs template files
  24.  *
  25.  * The class supports loading template files, adding variables to them and then
  26.  * printing them to the screen. It functions as abstract parent class for the
  27.  * two core classes "BackendTemplate" and "FrontendTemplate".
  28.  *
  29.  * Usage:
  30.  *
  31.  *     $template = new BackendTemplate();
  32.  *     $template->name = 'Leo Feyer';
  33.  *     $template->output();
  34.  *
  35.  * @property string       $style
  36.  * @property array|string $cssID
  37.  * @property string       $class
  38.  * @property string       $inColumn
  39.  * @property string       $headline
  40.  * @property array        $hl
  41.  * @property string       $content
  42.  * @property string       $action
  43.  * @property string       $enforceTwoFactor
  44.  * @property string       $targetPath
  45.  * @property string       $message
  46.  * @property string       $href
  47.  * @property string       $twoFactor
  48.  * @property string       $explain
  49.  * @property string       $active
  50.  * @property string       $enableButton
  51.  * @property string       $disableButton
  52.  * @property boolean      $enable
  53.  * @property boolean      $isEnabled
  54.  * @property string       $secret
  55.  * @property string       $textCode
  56.  * @property string       $qrCode
  57.  * @property string       $scan
  58.  * @property string       $verify
  59.  * @property string       $verifyHelp
  60.  * @property boolean      $showBackupCodes
  61.  * @property array        $backupCodes
  62.  * @property boolean      $trustedDevicesEnabled
  63.  * @property array        $trustedDevices
  64.  * @property string       $currentDevice
  65.  */
  66. abstract class Template extends Controller
  67. {
  68.     use TemplateInheritance;
  70.     /**
  71.      * Output buffer
  72.      * @var string
  73.      */
  74.     protected $strBuffer;
  76.     /**
  77.      * Content type
  78.      * @var string
  79.      */
  80.     protected $strContentType;
  82.     /**
  83.      * Template data
  84.      * @var array
  85.      */
  86.     protected $arrData = array();
  88.     /**
  89.      * Valid JavaScipt types
  90.      * @var array
  91.      * @see http://www.w3.org/TR/html5/scripting-1.html#scriptingLanguages
  92.      */
  93.     protected static $validJavaScriptTypes = array
  94.     (
  95.         'application/ecmascript',
  96.         'application/javascript',
  97.         'application/x-ecmascript',
  98.         'application/x-javascript',
  99.         'text/ecmascript',
  100.         'text/javascript',
  101.         'text/javascript1.0',
  102.         'text/javascript1.1',
  103.         'text/javascript1.2',
  104.         'text/javascript1.3',
  105.         'text/javascript1.4',
  106.         'text/javascript1.5',
  107.         'text/jscript',
  108.         'text/livescript',
  109.         'text/x-ecmascript',
  110.         'text/x-javascript',
  111.     );
  113.     /**
  114.      * Create a new template object
  115.      *
  116.      * @param string $strTemplate    The template name
  117.      * @param string $strContentType The content type (defaults to "text/html")
  118.      */
  119.     public function __construct($strTemplate='', $strContentType='text/html')
  120.     {
  121.         parent::__construct();
  123.         $this->strTemplate = $strTemplate;
  124.         $this->strContentType = $strContentType;
  125.     }
  127.     /**
  128.      * Set an object property
  129.      *
  130.      * @param string $strKey   The property name
  131.      * @param mixed  $varValue The property value
  132.      */
  133.     public function __set($strKey, $varValue)
  134.     {
  135.         $this->arrData[$strKey] = $varValue;
  136.     }
  138.     /**
  139.      * Return an object property
  140.      *
  141.      * @param string $strKey The property name
  142.      *
  143.      * @return mixed The property value
  144.      */
  145.     public function __get($strKey)
  146.     {
  147.         if (isset($this->arrData[$strKey]))
  148.         {
  149.             if (\is_object($this->arrData[$strKey]) && \is_callable($this->arrData[$strKey]))
  150.             {
  151.                 return $this->arrData[$strKey]();
  152.             }
  154.             return $this->arrData[$strKey];
  155.         }
  157.         return parent::__get($strKey);
  158.     }
  160.     /**
  161.      * Execute a callable and return the result
  162.      *
  163.      * @param string $strKey    The name of the key
  164.      * @param array  $arrParams The parameters array
  165.      *
  166.      * @return mixed The callable return value
  167.      *
  168.      * @throws \InvalidArgumentException If the callable does not exist
  169.      */
  170.     public function __call($strKey, $arrParams)
  171.     {
  172.         if (!isset($this->arrData[$strKey]) || !\is_callable($this->arrData[$strKey]))
  173.         {
  174.             throw new \InvalidArgumentException("$strKey is not set or not a callable");
  175.         }
  177.         return ($this->arrData[$strKey])(...$arrParams);
  178.     }
  180.     /**
  181.      * Check whether a property is set
  182.      *
  183.      * @param string $strKey The property name
  184.      *
  185.      * @return boolean True if the property is set
  186.      */
  187.     public function __isset($strKey)
  188.     {
  189.         return isset($this->arrData[$strKey]);
  190.     }
  192.     /**
  193.      * Set the template data from an array
  194.      *
  195.      * @param array $arrData The data array
  196.      */
  197.     public function setData($arrData)
  198.     {
  199.         $this->arrData = $arrData;
  200.     }
  202.     /**
  203.      * Return the template data as array
  204.      *
  205.      * @return array The data array
  206.      */
  207.     public function getData()
  208.     {
  209.         return $this->arrData;
  210.     }
  212.     /**
  213.      * Set the template name
  214.      *
  215.      * @param string $strTemplate The template name
  216.      */
  217.     public function setName($strTemplate)
  218.     {
  219.         $this->strTemplate = $strTemplate;
  220.     }
  222.     /**
  223.      * Return the template name
  224.      *
  225.      * @return string The template name
  226.      */
  227.     public function getName()
  228.     {
  229.         return $this->strTemplate;
  230.     }
  232.     /**
  233.      * Set the output format
  234.      *
  235.      * @param string $strFormat The output format
  236.      */
  237.     public function setFormat($strFormat)
  238.     {
  239.         $this->strFormat = $strFormat;
  240.     }
  242.     /**
  243.      * Return the output format
  244.      *
  245.      * @return string The output format
  246.      */
  247.     public function getFormat()
  248.     {
  249.         return $this->strFormat;
  250.     }
  252.     /**
  253.      * Print all template variables to the screen using print_r
  254.      *
  255.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.
  256.      *             Use Template::dumpTemplateVars() instead.
  257.      */
  258.     public function showTemplateVars()
  259.     {
  260.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Template::showTemplateVars()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Template::dumpTemplateVars()" instead.');
  262.         $this->dumpTemplateVars();
  263.     }
  265.     /**
  266.      * Print all template variables to the screen using the Symfony VarDumper component
  267.      */
  268.     public function dumpTemplateVars()
  269.     {
  270.         VarDumper::dump($this->arrData);
  271.     }
  273.     /**
  274.      * Parse the template file and return it as string
  275.      *
  276.      * @return string The template markup
  277.      */
  278.     public function parse()
  279.     {
  280.         if (!$this->strTemplate)
  281.         {
  282.             return '';
  283.         }
  285.         // HOOK: add custom parse filters
  286.         if (isset($GLOBALS['TL_HOOKS']['parseTemplate']) && \is_array($GLOBALS['TL_HOOKS']['parseTemplate']))
  287.         {
  288.             foreach ($GLOBALS['TL_HOOKS']['parseTemplate'] as $callback)
  289.             {
  290.                 $this->import($callback[0]);
  291.                 $this->{$callback[0]}->{$callback[1]}($this);
  292.             }
  293.         }
  295.         return $this->inherit();
  296.     }
  298.     /**
  299.      * Parse the template file and print it to the screen
  300.      *
  301.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  302.      *             Use Template::getResponse() instead.
  303.      */
  304.     public function output()
  305.     {
  306.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Template::output()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Template::getResponse()" instead.');
  308.         $this->compile();
  310.         header('Content-Type: ' . $this->strContentType . '; charset=' . System::getContainer()->getParameter('kernel.charset'));
  312.         echo $this->strBuffer;
  313.     }
  315.     /**
  316.      * Return a response object
  317.      *
  318.      * @return Response The response object
  319.      */
  320.     public function getResponse()
  321.     {
  322.         $this->compile();
  324.         $response = new Response($this->strBuffer);
  325.         $response->headers->set('Content-Type', $this->strContentType);
  326.         $response->setCharset(System::getContainer()->getParameter('kernel.charset'));
  328.         return $response;
  329.     }
  331.     /**
  332.      * Return a route relative to the base URL
  333.      *
  334.      * @param string $strName   The route name
  335.      * @param array  $arrParams The route parameters
  336.      *
  337.      * @return string The route
  338.      */
  339.     public function route($strName, $arrParams=array())
  340.     {
  341.         $strUrl = System::getContainer()->get('router')->generate($strName, $arrParams);
  342.         $strUrl = substr($strUrl, \strlen(Environment::get('path')) + 1);
  344.         return StringUtil::ampersand($strUrl);
  345.     }
  347.     /**
  348.      * Return the preview route
  349.      *
  350.      * @param string $strName   The route name
  351.      * @param array  $arrParams The route parameters
  352.      *
  353.      * @return string The route
  354.      */
  355.     public function previewRoute($strName, $arrParams=array())
  356.     {
  357.         $container = System::getContainer();
  359.         if (!$previewScript = $container->getParameter('contao.preview_script'))
  360.         {
  361.             return $this->route($strName, $arrParams);
  362.         }
  364.         $router = $container->get('router');
  366.         $context = $router->getContext();
  367.         $context->setBaseUrl($previewScript);
  369.         $strUrl = $router->generate($strName, $arrParams);
  370.         $strUrl = substr($strUrl, \strlen(Environment::get('path')) + 1);
  372.         $context->setBaseUrl('');
  374.         return StringUtil::ampersand($strUrl);
  375.     }
  377.     /**
  378.      * Returns a translated message
  379.      *
  380.      * @param string $strId
  381.      * @param array  $arrParams
  382.      * @param string $strDomain
  383.      *
  384.      * @return string
  385.      */
  386.     public function trans($strId, array $arrParams=array(), $strDomain='contao_default')
  387.     {
  388.         return System::getContainer()->get('translator')->trans($strId, $arrParams, $strDomain);
  389.     }
  391.     /**
  392.      * Helper method to allow quick access in the Contao templates for safe raw (unencoded) output.
  393.      * It replaces (or optionally removes) Contao insert tags and removes all HTML.
  394.      *
  395.      * Be careful when using this. It must NOT be used within regular HTML when $value
  396.      * is uncontrolled user input. It's useful to ensure raw values within e.g. <code> examples
  397.      * or JSON-LD arrays.
  398.      */
  399.     public function rawPlainText(string $value, bool $removeInsertTags = false): string
  400.     {
  401.         return System::getContainer()->get('contao.string.html_decoder')->inputEncodedToPlainText($value, $removeInsertTags);
  402.     }
  404.     /**
  405.      * Helper method to allow quick access in the Contao templates for safe raw (unencoded) output.
  406.      *
  407.      * Compared to $this->rawPlainText() it adds new lines before and after block level HTML elements
  408.      * and only then removes the rest of the HTML tags.
  409.      *
  410.      * Be careful when using this. It must NOT be used within regular HTML when $value
  411.      * is uncontrolled user input. It's useful to ensure raw values within e.g. <code> examples
  412.      * or JSON-LD arrays.
  413.      */
  414.     public function rawHtmlToPlainText(string $value, bool $removeInsertTags = false): string
  415.     {
  416.         return System::getContainer()->get('contao.string.html_decoder')->htmlToPlainText($value, $removeInsertTags);
  417.     }
  419.     /**
  420.      * Adds schema.org JSON-LD data to the current response context
  421.      */
  422.     public function addSchemaOrg(array $jsonLd): void
  423.     {
  424.         $responseContext = System::getContainer()->get('contao.routing.response_context_accessor')->getResponseContext();
  426.         if (!$responseContext || !$responseContext->has(JsonLdManager::class))
  427.         {
  428.             return;
  429.         }
  431.         /** @var JsonLdManager $jsonLdManager */
  432.         $jsonLdManager = $responseContext->get(JsonLdManager::class);
  433.         $type = $jsonLdManager->createSchemaOrgTypeFromArray($jsonLd);
  435.         $jsonLdManager
  436.             ->getGraphForSchema(JsonLdManager::SCHEMA_ORG)
  437.             ->set($type, $jsonLd['identifier'] ?? Graph::IDENTIFIER_DEFAULT)
  438.         ;
  439.     }
  441.     /**
  442.      * Render a figure
  443.      *
  444.      * The provided configuration array is used to configure a FigureBuilder.
  445.      * If not explicitly set, the default template "image.html5" will be used
  446.      * to render the results. To use the core's default Twig template, pass
  447.      * "@ContaoCore/Image/Studio/figure.html.twig" as $template argument.
  448.      *
  449.      * @param int|string|FilesModel|ImageInterface       $from          Can be a FilesModel, an ImageInterface, a tl_files UUID/ID/path or a file system path
  450.      * @param int|string|array|PictureConfiguration|null $size          A picture size configuration or reference
  451.      * @param array<string, mixed>                       $configuration Configuration for the FigureBuilder
  452.      * @param string                                     $template      A Contao or Twig template
  453.      *
  454.      * @return string|null Returns null if the resource is invalid
  455.      */
  456.     public function figure($from, $size, $configuration = array(), $template = 'image')
  457.     {
  458.         return System::getContainer()->get('contao.image.studio.figure_renderer')->render($from, $size, $configuration, $template);
  459.     }
  461.     /**
  462.      * Returns an asset path
  463.      *
  464.      * @param string      $path
  465.      * @param string|null $packageName
  466.      *
  467.      * @return string
  468.      */
  469.     public function asset($path, $packageName = null)
  470.     {
  471.         $url = System::getContainer()->get('assets.packages')->getUrl($path, $packageName);
  473.         $basePath = '/';
  474.         $request = System::getContainer()->get('request_stack')->getMainRequest();
  476.         if ($request !== null)
  477.         {
  478.             $basePath = $request->getBasePath() . '/';
  479.         }
  481.         if (0 === strncmp($url, $basePath, \strlen($basePath)))
  482.         {
  483.             return substr($url, \strlen($basePath));
  484.         }
  486.         // Contao paths are relative to the <base> tag, so remove leading slashes
  487.         return $url;
  488.     }
  490.     /**
  491.      * Returns an asset version
  492.      *
  493.      * @param string      $path
  494.      * @param string|null $packageName
  495.      *
  496.      * @return string
  497.      */
  498.     public function assetVersion($path, $packageName = null)
  499.     {
  500.         return System::getContainer()->get('assets.packages')->getVersion($path, $packageName);
  501.     }
  503.     /**
  504.      * Returns a container parameter
  505.      *
  506.      * @param string $strKey
  507.      *
  508.      * @return mixed
  509.      */
  510.     public function param($strKey)
  511.     {
  512.         return System::getContainer()->getParameter($strKey);
  513.     }
  515.     /**
  516.      * Compile the template
  517.      *
  518.      * @internal Do not call this method in your code. It will be made private in Contao 5.0.
  519.      */
  520.     protected function compile()
  521.     {
  522.         if (!$this->strBuffer)
  523.         {
  524.             $this->strBuffer = $this->parse();
  525.         }
  526.     }
  528.     /**
  529.      * Return the debug bar string
  530.      *
  531.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  532.      */
  533.     protected function getDebugBar()
  534.     {
  535.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Template::getDebugBar()" has been deprecated and will no longer work in Contao 5.0.');
  536.     }
  538.     /**
  539.      * Minify the HTML markup preserving pre, script, style and textarea tags
  540.      *
  541.      * @param string $strHtml The HTML markup
  542.      *
  543.      * @return string The minified HTML markup
  544.      */
  545.     public function minifyHtml($strHtml)
  546.     {
  547.         if (System::getContainer()->getParameter('kernel.debug'))
  548.         {
  549.             return $strHtml;
  550.         }
  552.         // Split the markup based on the tags that shall be preserved
  553.         $arrChunks = preg_split('@(</?pre[^>]*>)|(</?script[^>]*>)|(</?style[^>]*>)|( ?</?textarea[^>]*>)@i', $strHtml, -1, PREG_SPLIT_DELIM_CAPTURE|PREG_SPLIT_NO_EMPTY);
  555.         $strHtml = '';
  556.         $blnPreserveNext = false;
  557.         $blnOptimizeNext = false;
  558.         $strType = null;
  560.         // Check for valid JavaScript types (see #7927)
  561.         $isJavaScript = static function ($strChunk)
  562.         {
  563.             $typeMatch = array();
  565.             if (preg_match('/\stype\s*=\s*(?:(?J)(["\'])\s*(?<type>.*?)\s*\1|(?<type>[^\s>]+))/i', $strChunk, $typeMatch) && !\in_array(strtolower($typeMatch['type']), static::$validJavaScriptTypes))
  566.             {
  567.                 return false;
  568.             }
  570.             if (preg_match('/\slanguage\s*=\s*(?:(?J)(["\'])\s*(?<type>.*?)\s*\1|(?<type>[^\s>]+))/i', $strChunk, $typeMatch) && !\in_array('text/' . strtolower($typeMatch['type']), static::$validJavaScriptTypes))
  571.             {
  572.                 return false;
  573.             }
  575.             return true;
  576.         };
  578.         // Recombine the markup
  579.         foreach ($arrChunks as $strChunk)
  580.         {
  581.             if (strncasecmp($strChunk, '<pre', 4) === 0 || strncasecmp(ltrim($strChunk), '<textarea', 9) === 0)
  582.             {
  583.                 $blnPreserveNext = true;
  584.             }
  585.             elseif (strncasecmp($strChunk, '<script', 7) === 0)
  586.             {
  587.                 if ($isJavaScript($strChunk))
  588.                 {
  589.                     $blnOptimizeNext = true;
  590.                     $strType = 'js';
  591.                 }
  592.                 else
  593.                 {
  594.                     $blnPreserveNext = true;
  595.                 }
  596.             }
  597.             elseif (strncasecmp($strChunk, '<style', 6) === 0)
  598.             {
  599.                 $blnOptimizeNext = true;
  600.                 $strType = 'css';
  601.             }
  602.             elseif ($blnPreserveNext)
  603.             {
  604.                 $blnPreserveNext = false;
  605.             }
  606.             elseif ($blnOptimizeNext)
  607.             {
  608.                 $blnOptimizeNext = false;
  610.                 // Minify inline scripts
  611.                 if ($strType == 'js')
  612.                 {
  613.                     $objMinify = new JS();
  614.                     $objMinify->add($strChunk);
  615.                     $strChunk = $objMinify->minify();
  616.                 }
  617.                 elseif ($strType == 'css')
  618.                 {
  619.                     $objMinify = new CSS();
  620.                     $objMinify->add($strChunk);
  621.                     $strChunk = $objMinify->minify();
  622.                 }
  623.             }
  624.             else
  625.             {
  626.                 // Remove line indentations and trailing spaces
  627.                 $strChunk = str_replace("\r", '', $strChunk);
  628.                 $strChunk = preg_replace(array('/^[\t ]+/m', '/[\t ]+$/m', '/\n\n+/'), array('', '', "\n"), $strChunk);
  629.             }
  631.             $strHtml .= $strChunk;
  632.         }
  634.         return trim($strHtml);
  635.     }
  637.     /**
  638.      * Generate the markup for a style sheet tag
  639.      *
  640.      * @param string $href  The script path
  641.      * @param string $media The media type string
  642.      * @param mixed  $mtime The file mtime
  643.      *
  644.      * @return string The markup string
  645.      */
  646.     public static function generateStyleTag($href, $media=null, $mtime=false)
  647.     {
  648.         // Add the filemtime if not given and not an external file
  649.         if ($mtime === null && !preg_match('@^https?://@', $href))
  650.         {
  651.             $container = System::getContainer();
  652.             $projectDir = $container->getParameter('kernel.project_dir');
  654.             if (file_exists($projectDir . '/' . $href))
  655.             {
  656.                 $mtime = filemtime($projectDir . '/' . $href);
  657.             }
  658.             else
  659.             {
  660.                 $webDir = StringUtil::stripRootDir($container->getParameter('contao.web_dir'));
  662.                 // Handle public bundle resources in the contao.web_dir folder
  663.                 if (file_exists($projectDir . '/' . $webDir . '/' . $href))
  664.                 {
  665.                     $mtime = filemtime($projectDir . '/' . $webDir . '/' . $href);
  666.                 }
  667.             }
  668.         }
  670.         if ($mtime)
  671.         {
  672.             $href .= '?v=' . substr(md5($mtime), 0, 8);
  673.         }
  675.         return '<link rel="stylesheet" href="' . $href . '"' . (($media && $media != 'all') ? ' media="' . $media . '"' : '') . '>';
  676.     }
  678.     /**
  679.      * Generate the markup for inline CSS code
  680.      *
  681.      * @param string $script The CSS code
  682.      *
  683.      * @return string The markup string
  684.      */
  685.     public static function generateInlineStyle($script)
  686.     {
  687.         return '<style>' . $script . '</style>';
  688.     }
  690.     /**
  691.      * Generate the markup for a JavaScript tag
  692.      *
  693.      * @param string      $src            The script path
  694.      * @param boolean     $async          True to add the async attribute
  695.      * @param mixed       $mtime          The file mtime
  696.      * @param string|null $hash           An optional integrity hash
  697.      * @param string|null $crossorigin    An optional crossorigin attribute
  698.      * @param string|null $referrerpolicy An optional referrerpolicy attribute
  699.      *
  700.      * @return string The markup string
  701.      */
  702.     public static function generateScriptTag($src, $async=false, $mtime=false, $hash=null, $crossorigin=null, $referrerpolicy=null)
  703.     {
  704.         // Add the filemtime if not given and not an external file
  705.         if ($mtime === null && !preg_match('@^https?://@', $src))
  706.         {
  707.             $container = System::getContainer();
  708.             $projectDir = $container->getParameter('kernel.project_dir');
  710.             if (file_exists($projectDir . '/' . $src))
  711.             {
  712.                 $mtime = filemtime($projectDir . '/' . $src);
  713.             }
  714.             else
  715.             {
  716.                 $webDir = StringUtil::stripRootDir($container->getParameter('contao.web_dir'));
  718.                 // Handle public bundle resources in the contao.web_dir folder
  719.                 if (file_exists($projectDir . '/' . $webDir . '/' . $src))
  720.                 {
  721.                     $mtime = filemtime($projectDir . '/' . $webDir . '/' . $src);
  722.                 }
  723.             }
  724.         }
  726.         if ($mtime)
  727.         {
  728.             $src .= '?v=' . substr(md5($mtime), 0, 8);
  729.         }
  731.         return '<script src="' . $src . '"' . ($async ? ' async' : '') . ($hash ? ' integrity="' . $hash . '"' : '') . ($crossorigin ? ' crossorigin="' . $crossorigin . '"' : '') . ($referrerpolicy ? ' referrerpolicy="' . $referrerpolicy . '"' : '') . '></script>';
  732.     }
  734.     /**
  735.      * Generate the markup for an inline JavaScript
  736.      *
  737.      * @param string $script The JavaScript code
  738.      *
  739.      * @return string The markup string
  740.      */
  741.     public static function generateInlineScript($script)
  742.     {
  743.         return '<script>' . $script . '</script>';
  744.     }
  746.     /**
  747.      * Generate the markup for an RSS feed tag
  748.      *
  749.      * @param string $href   The script path
  750.      * @param string $format The feed format
  751.      * @param string $title  The feed title
  752.      *
  753.      * @return string The markup string
  754.      */
  755.     public static function generateFeedTag($href, $format, $title)
  756.     {
  757.         return '<link type="application/' . $format . '+xml" rel="alternate" href="' . $href . '" title="' . StringUtil::specialchars($title) . '">';
  758.     }
  760.     /**
  761.      * Flush the output buffers
  762.      *
  763.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  764.      */
  765.     public function flushAllData()
  766.     {
  767.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Template::flushAllData()" has been deprecated and will no longer work in Contao 5.0.');
  769.         if (\function_exists('fastcgi_finish_request'))
  770.         {
  771.             fastcgi_finish_request();
  772.         }
  773.         elseif (\PHP_SAPI !== 'cli')
  774.         {
  775.             $status = ob_get_status(true);
  776.             $level = \count($status);
  778.             while ($level-- > 0 && (!empty($status[$level]['del']) || (isset($status[$level]['flags']) && ($status[$level]['flags'] & PHP_OUTPUT_HANDLER_REMOVABLE) && ($status[$level]['flags'] & PHP_OUTPUT_HANDLER_FLUSHABLE))))
  779.             {
  780.                 ob_end_flush();
  781.             }
  783.             flush();
  784.         }
  785.     }
  786. }
  788. class_alias(Template::class, 'Template');