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

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