From 238f0d6b9ada06c2fa37f813b34baf876436ccef Mon Sep 17 00:00:00 2001 From: upstream Date: Thu, 3 Sep 2026 14:14:10 +0200 Subject: [PATCH] Upstream filp/whoops state of the touched files before 75ce95dd56 --- src/Whoops/Util/TemplateHelper.php | 349 +++++++++++++++++++++++ tests/Whoops/Util/TemplateHelperTest.php | 140 +++++++++ 2 files changed, 489 insertions(+) create mode 100644 src/Whoops/Util/TemplateHelper.php create mode 100644 tests/Whoops/Util/TemplateHelperTest.php diff --git a/src/Whoops/Util/TemplateHelper.php b/src/Whoops/Util/TemplateHelper.php new file mode 100644 index 0000000..5612c0b --- /dev/null +++ b/src/Whoops/Util/TemplateHelper.php @@ -0,0 +1,349 @@ + + */ + +namespace Whoops\Util; + +use Symfony\Component\VarDumper\Caster\Caster; +use Symfony\Component\VarDumper\Cloner\AbstractCloner; +use Symfony\Component\VarDumper\Cloner\VarCloner; +use Symfony\Component\VarDumper\Dumper\HtmlDumper; +use Whoops\Exception\Frame; + +/** + * Exposes useful tools for working with/in templates + */ +class TemplateHelper +{ + /** + * An array of variables to be passed to all templates + * @var array + */ + private $variables = []; + + /** + * @var HtmlDumper + */ + private $htmlDumper; + + /** + * @var HtmlDumperOutput + */ + private $htmlDumperOutput; + + /** + * @var AbstractCloner + */ + private $cloner; + + /** + * @var string + */ + private $applicationRootPath; + + public function __construct() + { + // root path for ordinary composer projects + $this->applicationRootPath = dirname(dirname(dirname(dirname(dirname(dirname(__DIR__)))))); + } + + /** + * Escapes a string for output in an HTML document + * + * @param string $raw + * @return string + */ + public function escape($raw) + { + $flags = ENT_QUOTES; + + // HHVM has all constants defined, but only ENT_IGNORE + // works at the moment + if (defined("ENT_SUBSTITUTE") && !defined("HHVM_VERSION")) { + $flags |= ENT_SUBSTITUTE; + } else { + // This is for 5.3. + // The documentation warns of a potential security issue, + // but it seems it does not apply in our case, because + // we do not blacklist anything anywhere. + $flags |= ENT_IGNORE; + } + + $raw = str_replace(chr(9), ' ', $raw); + + return htmlspecialchars($raw, $flags, "UTF-8"); + } + + /** + * Escapes a string for output in an HTML document, but preserves + * URIs within it, and converts them to clickable anchor elements. + * + * @param string $raw + * @return string + */ + public function escapeButPreserveUris($raw) + { + $escaped = $this->escape($raw); + return preg_replace( + "@([A-z]+?://([-\w\.]+[-\w])+(:\d+)?(/([\w/_\.#-]*(\?\S+)?[^\.\s])?)?)@", + "$1", + $escaped + ); + } + + /** + * Makes sure that the given string breaks on the delimiter. + * + * @param string $delimiter + * @param string $s + * @return string + */ + public function breakOnDelimiter($delimiter, $s) + { + $parts = explode($delimiter, $s); + foreach ($parts as &$part) { + $part = '' . $part . ''; + } + + return implode($delimiter, $parts); + } + + /** + * Replace the part of the path that all files have in common. + * + * @param string $path + * @return string + */ + public function shorten($path) + { + if ($this->applicationRootPath != "/") { + $path = str_replace($this->applicationRootPath, '…', $path); + } + + return $path; + } + + private function getDumper() + { + if (!$this->htmlDumper && class_exists('Symfony\Component\VarDumper\Cloner\VarCloner')) { + $this->htmlDumperOutput = new HtmlDumperOutput(); + // re-use the same var-dumper instance, so it won't re-render the global styles/scripts on each dump. + $this->htmlDumper = new HtmlDumper($this->htmlDumperOutput); + + $styles = [ + 'default' => 'color:#FFFFFF; line-height:normal; font:12px "Inconsolata", "Fira Mono", "Source Code Pro", Monaco, Consolas, "Lucida Console", monospace !important; word-wrap: break-word; white-space: pre-wrap; position:relative; z-index:99999; word-break: normal', + 'num' => 'color:#BCD42A', + 'const' => 'color: #4bb1b1;', + 'str' => 'color:#BCD42A', + 'note' => 'color:#ef7c61', + 'ref' => 'color:#A0A0A0', + 'public' => 'color:#FFFFFF', + 'protected' => 'color:#FFFFFF', + 'private' => 'color:#FFFFFF', + 'meta' => 'color:#FFFFFF', + 'key' => 'color:#BCD42A', + 'index' => 'color:#ef7c61', + ]; + $this->htmlDumper->setStyles($styles); + } + + return $this->htmlDumper; + } + + /** + * Format the given value into a human readable string. + * + * @param mixed $value + * @return string + */ + public function dump($value) + { + $dumper = $this->getDumper(); + + if ($dumper) { + // re-use the same DumpOutput instance, so it won't re-render the global styles/scripts on each dump. + // exclude verbose information (e.g. exception stack traces) + if (class_exists('Symfony\Component\VarDumper\Caster\Caster')) { + $cloneVar = $this->getCloner()->cloneVar($value, Caster::EXCLUDE_VERBOSE); + // Symfony VarDumper 2.6 Caster class dont exist. + } else { + $cloneVar = $this->getCloner()->cloneVar($value); + } + + $dumper->dump( + $cloneVar, + $this->htmlDumperOutput + ); + + $output = $this->htmlDumperOutput->getOutput(); + $this->htmlDumperOutput->clear(); + + return $output; + } + + return htmlspecialchars(print_r($value, true)); + } + + /** + * Format the args of the given Frame as a human readable html string + * + * @param Frame $frame + * @return string the rendered html + */ + public function dumpArgs(Frame $frame) + { + // we support frame args only when the optional dumper is available + if (!$this->getDumper()) { + return ''; + } + + $html = ''; + $numFrames = count($frame->getArgs()); + + if ($numFrames > 0) { + $html = '
    '; + foreach ($frame->getArgs() as $j => $frameArg) { + $html .= '
  1. '. $this->dump($frameArg) .'
    2. '; + } + $html .= '
'; + } + + return $html; + } + + /** + * Convert a string to a slug version of itself + * + * @param string $original + * @return string + */ + public function slug($original) + { + $slug = str_replace(" ", "-", $original); + $slug = preg_replace('/[^\w\d\-\_]/i', '', $slug); + return strtolower($slug); + } + + /** + * Given a template path, render it within its own scope. This + * method also accepts an array of additional variables to be + * passed to the template. + * + * @param string $template + */ + public function render($template, ?array $additionalVariables = null) + { + $variables = $this->getVariables(); + + // Pass the helper to the template: + $variables["tpl"] = $this; + + if ($additionalVariables !== null) { + $variables = array_replace($variables, $additionalVariables); + } + + call_user_func(function () { + extract(func_get_arg(1)); + require func_get_arg(0); + }, $template, $variables); + } + + /** + * Sets the variables to be passed to all templates rendered + * by this template helper. + */ + public function setVariables(array $variables) + { + $this->variables = $variables; + } + + /** + * Sets a single template variable, by its name: + * + * @param string $variableName + * @param mixed $variableValue + */ + public function setVariable($variableName, $variableValue) + { + $this->variables[$variableName] = $variableValue; + } + + /** + * Gets a single template variable, by its name, or + * $defaultValue if the variable does not exist + * + * @param string $variableName + * @param mixed $defaultValue + * @return mixed + */ + public function getVariable($variableName, $defaultValue = null) + { + return isset($this->variables[$variableName]) ? + $this->variables[$variableName] : $defaultValue; + } + + /** + * Unsets a single template variable, by its name + * + * @param string $variableName + */ + public function delVariable($variableName) + { + unset($this->variables[$variableName]); + } + + /** + * Returns all variables for this helper + * + * @return array + */ + public function getVariables() + { + return $this->variables; + } + + /** + * Set the cloner used for dumping variables. + * + * @param AbstractCloner $cloner + */ + public function setCloner($cloner) + { + $this->cloner = $cloner; + } + + /** + * Get the cloner used for dumping variables. + * + * @return AbstractCloner + */ + public function getCloner() + { + if (!$this->cloner) { + $this->cloner = new VarCloner(); + } + return $this->cloner; + } + + /** + * Set the application root path. + * + * @param string $applicationRootPath + */ + public function setApplicationRootPath($applicationRootPath) + { + $this->applicationRootPath = $applicationRootPath; + } + + /** + * Return the application root path. + * + * @return string + */ + public function getApplicationRootPath() + { + return $this->applicationRootPath; + } +} diff --git a/tests/Whoops/Util/TemplateHelperTest.php b/tests/Whoops/Util/TemplateHelperTest.php new file mode 100644 index 0000000..086645a --- /dev/null +++ b/tests/Whoops/Util/TemplateHelperTest.php @@ -0,0 +1,140 @@ + + */ + +namespace Whoops\Util; + +use Whoops\TestCase; + +class TemplateHelperTest extends TestCase +{ + /** + * @var TemplateHelper + */ + private $helper; + + /** + * @before + */ + public function getReady() + { + $this->helper = new TemplateHelper(); + } + + /** + * @covers Whoops\Util\TemplateHelper::escapeButPreserveUris + * @covers Whoops\Util\TemplateHelper::escape + */ + public function testEscape() + { + $original = "This is a Foo test string"; + + $this->assertEquals( + $this->helper->escape($original), + "This is a <a href=''>Foo</a> test string" + ); + } + + public function testEscapeBrokenUtf8() + { + // The following includes an illegal utf-8 sequence to test. + // Encoded in base64 to survive possible encoding changes of this file. + $original = base64_decode('VGhpcyBpcyBhbiBpbGxlZ2FsIHV0Zi04IHNlcXVlbmNlOiDD'); + + // Test that the escaped string is kinda similar in length, not empty + $this->assertLessThan( + 10, + abs(strlen($original) - strlen($this->helper->escape($original))) + ); + } + + /** + * @covers Whoops\Util\TemplateHelper::escapeButPreserveUris + */ + public function testEscapeButPreserveUris() + { + $original = "This is a http://google.com test string"; + + $this->assertEquals( + $this->helper->escapeButPreserveUris($original), + "This is a <a href=''>http://google.com</a> test string" + ); + } + + /** + * @covers Whoops\Util\TemplateHelper::breakOnDelimiter + */ + public function testBreakOnDelimiter() + { + $this->assertSame( + 'abc-123-456', + $this->helper->breakOnDelimiter('-', 'abc-123-456') + ); + } + + /** + * @covers Whoops\Util\TemplateHelper::shorten + */ + public function testShorten() + { + $path = '/foo/bar/baz/abc.def'; + + $this->assertSame($path, $this->helper->shorten($path)); + + $this->helper->setApplicationRootPath('/foo/bar'); + $this->assertSame('…/baz/abc.def', $this->helper->shorten($path)); + } + + /** + * @covers Whoops\Util\TemplateHelper::slug + */ + public function testSlug() + { + $this->assertEquals("hello-world", $this->helper->slug("Hello, world!")); + $this->assertEquals("potato-class", $this->helper->slug("Potato class")); + } + + /** + * @covers Whoops\Util\TemplateHelper::render + */ + public function testRender() + { + $template = __DIR__ . "/../../fixtures/template.php"; + + ob_start(); + $this->helper->render($template, ["name" => "Bb"]); + $output = ob_get_clean(); + + $this->assertEquals( + $output, + "hello-world\nMy name is B<o>b" + ); + } + + /** + * @covers Whoops\Util\TemplateHelper::setVariables + * @covers Whoops\Util\TemplateHelper::getVariables + * @covers Whoops\Util\TemplateHelper::setVariable + * @covers Whoops\Util\TemplateHelper::getVariable + * @covers Whoops\Util\TemplateHelper::delVariable + */ + public function testTemplateVariables() + { + $this->helper->setVariables([ + "name" => "Whoops", + "type" => "library", + "desc" => "php errors for cool kids", + ]); + + $this->helper->setVariable("name", "Whoops!"); + $this->assertEquals($this->helper->getVariable("name"), "Whoops!"); + $this->helper->delVariable("type"); + + $this->assertEquals($this->helper->getVariables(), [ + "name" => "Whoops!", + "desc" => "php errors for cool kids", + ]); + } +}