Tom Dickman
ad5c8a8954
Mustache blocks nested in parent templates were incorrectly rendering the default language Moodle. This fix correctly passes the current language preference to all nested mustache templates such as blocks which are children of another template.
347 lines
14 KiB
PHP
347 lines
14 KiB
PHP
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* Load template source strings.
|
|
*
|
|
* @package core
|
|
* @category output
|
|
* @copyright 2018 Ryan Wyllie <ryan@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
namespace core\output;
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
use \Mustache_Tokenizer;
|
|
|
|
/**
|
|
* Load template source strings.
|
|
*
|
|
* @copyright 2018 Ryan Wyllie <ryan@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class mustache_template_source_loader {
|
|
|
|
/** @var $gettemplatesource Callback function to load the template source from full name */
|
|
private $gettemplatesource = null;
|
|
|
|
/**
|
|
* Constructor that takes a callback to allow the calling code to specify how to retrieve
|
|
* the source for a template name.
|
|
*
|
|
* If no callback is provided then default to the load from disk implementation.
|
|
*
|
|
* @param callable|null $gettemplatesource Callback to load template source by template name
|
|
*/
|
|
public function __construct(callable $gettemplatesource = null) {
|
|
if ($gettemplatesource) {
|
|
// The calling code has specified a function for retrieving the template source
|
|
// code by name and theme.
|
|
$this->gettemplatesource = $gettemplatesource;
|
|
} else {
|
|
// By default we will pull the template from disk.
|
|
$this->gettemplatesource = function($component, $name, $themename) {
|
|
$fulltemplatename = $component . '/' . $name;
|
|
$filename = mustache_template_finder::get_template_filepath($fulltemplatename, $themename);
|
|
return file_get_contents($filename);
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove comments from mustache template.
|
|
*
|
|
* @param string $templatestr
|
|
* @return string
|
|
*/
|
|
protected function strip_template_comments($templatestr) : string {
|
|
return preg_replace('/(?={{!)(.*)(}})/sU', '', $templatestr);
|
|
}
|
|
|
|
/**
|
|
* Load the template source from the component and template name.
|
|
*
|
|
* @param string $component The moodle component (e.g. core_message)
|
|
* @param string $name The template name (e.g. message_drawer)
|
|
* @param string $themename The theme to load the template for (e.g. boost)
|
|
* @param bool $includecomments If the comments should be stripped from the source before returning
|
|
* @return string The template source
|
|
*/
|
|
public function load(
|
|
string $component,
|
|
string $name,
|
|
string $themename,
|
|
bool $includecomments = false
|
|
) : string {
|
|
// Get the template source from the callback.
|
|
$source = ($this->gettemplatesource)($component, $name, $themename);
|
|
|
|
// Remove comments from template.
|
|
if (!$includecomments) {
|
|
$source = $this->strip_template_comments($source);
|
|
}
|
|
|
|
return $source;
|
|
}
|
|
|
|
/**
|
|
* Load a template and some of the dependencies that will be needed in order to render
|
|
* the template.
|
|
*
|
|
* The current implementation will return all of the templates and all of the strings in
|
|
* each of those templates (excluding string substitutions).
|
|
*
|
|
* The return format is an array indexed with the dependency type (e.g. templates / strings) then
|
|
* the component (e.g. core_message), and then the id (e.g. message_drawer).
|
|
*
|
|
* For example:
|
|
* * We have 3 templates in core named foo, bar, and baz.
|
|
* * foo includes bar and bar includes baz.
|
|
* * foo uses the string 'home' from core
|
|
* * baz uses the string 'help' from core
|
|
*
|
|
* If we load the template foo this function would return:
|
|
* [
|
|
* 'templates' => [
|
|
* 'core' => [
|
|
* 'foo' => '... template source ...',
|
|
* 'bar' => '... template source ...',
|
|
* 'baz' => '... template source ...',
|
|
* ]
|
|
* ],
|
|
* 'strings' => [
|
|
* 'core' => [
|
|
* 'home' => 'Home',
|
|
* 'help' => 'Help'
|
|
* ]
|
|
* ]
|
|
* ]
|
|
*
|
|
* @param string $templatecomponent The moodle component (e.g. core_message)
|
|
* @param string $templatename The template name (e.g. message_drawer)
|
|
* @param string $themename The theme to load the template for (e.g. boost)
|
|
* @param bool $includecomments If the comments should be stripped from the source before returning
|
|
* @param array $seentemplates List of templates already processed / to be skipped.
|
|
* @param array $seenstrings List of strings already processed / to be skipped.
|
|
* @param string|null $lang moodle translation language, null means use current.
|
|
* @return array
|
|
*/
|
|
public function load_with_dependencies(
|
|
string $templatecomponent,
|
|
string $templatename,
|
|
string $themename,
|
|
bool $includecomments = false,
|
|
array $seentemplates = [],
|
|
array $seenstrings = [],
|
|
string $lang = null
|
|
) : array {
|
|
// Initialise the return values.
|
|
$templates = [];
|
|
$strings = [];
|
|
$templatecomponent = trim($templatecomponent);
|
|
$templatename = trim($templatename);
|
|
// Get the requested template source.
|
|
$templatesource = $this->load($templatecomponent, $templatename, $themename, $includecomments);
|
|
// This is a helper function to save a value in one of the result arrays (either $templates or $strings).
|
|
$save = function(array $results, array $seenlist, string $component, string $id, $value) use ($lang) {
|
|
if (!isset($results[$component])) {
|
|
// If the results list doesn't already contain this component then initialise it.
|
|
$results[$component] = [];
|
|
}
|
|
|
|
// Save the value.
|
|
$results[$component][$id] = $value;
|
|
// Record that this item has been processed.
|
|
array_push($seenlist, "$component/$id");
|
|
// Return the updated results and seen list.
|
|
return [$results, $seenlist];
|
|
};
|
|
// This is a helper function for processing a dependency. Does stuff like ignore duplicate processing,
|
|
// common result formatting etc.
|
|
$handler = function(array $dependency, array $ignorelist, callable $processcallback) use ($lang) {
|
|
foreach ($dependency as $component => $ids) {
|
|
foreach ($ids as $id) {
|
|
$dependencyid = "$component/$id";
|
|
if (array_search($dependencyid, $ignorelist) === false) {
|
|
$processcallback($component, $id);
|
|
// Add this to our ignore list now that we've processed it so that we don't
|
|
// process it again.
|
|
array_push($ignorelist, $dependencyid);
|
|
}
|
|
}
|
|
}
|
|
|
|
return $ignorelist;
|
|
};
|
|
|
|
// Save this template as the first result in the $templates result array.
|
|
list($templates, $seentemplates) = $save($templates, $seentemplates, $templatecomponent, $templatename, $templatesource);
|
|
|
|
// Check the template for any dependencies that need to be loaded.
|
|
$dependencies = $this->scan_template_source_for_dependencies($templatesource);
|
|
|
|
// Load all of the lang strings that this template requires and add them to the
|
|
// returned values.
|
|
$seenstrings = $handler(
|
|
$dependencies['strings'],
|
|
$seenstrings,
|
|
// Include $strings and $seenstrings by reference so that their values can be updated
|
|
// outside of this anonymous function.
|
|
function($component, $id) use ($save, &$strings, &$seenstrings, $lang) {
|
|
$string = get_string_manager()->get_string($id, $component, null, $lang);
|
|
// Save the string in the $strings results array.
|
|
list($strings, $seenstrings) = $save($strings, $seenstrings, $component, $id, $string);
|
|
}
|
|
);
|
|
|
|
// Load any child templates that we've found in this template and add them to
|
|
// the return list of dependencies.
|
|
$seentemplates = $handler(
|
|
$dependencies['templates'],
|
|
$seentemplates,
|
|
// Include $strings, $seenstrings, $templates, and $seentemplates by reference so that their values can be updated
|
|
// outside of this anonymous function.
|
|
function($component, $id) use (
|
|
$themename,
|
|
$includecomments,
|
|
&$seentemplates,
|
|
&$seenstrings,
|
|
&$templates,
|
|
&$strings,
|
|
$save,
|
|
$lang
|
|
) {
|
|
// We haven't seen this template yet so load it and it's dependencies.
|
|
$subdependencies = $this->load_with_dependencies(
|
|
$component,
|
|
$id,
|
|
$themename,
|
|
$includecomments,
|
|
$seentemplates,
|
|
$seenstrings,
|
|
$lang
|
|
);
|
|
|
|
foreach ($subdependencies['templates'] as $component => $ids) {
|
|
foreach ($ids as $id => $value) {
|
|
// Include the child themes in our results.
|
|
list($templates, $seentemplates) = $save($templates, $seentemplates, $component, $id, $value);
|
|
}
|
|
};
|
|
|
|
foreach ($subdependencies['strings'] as $component => $ids) {
|
|
foreach ($ids as $id => $value) {
|
|
// Include any strings that the child templates need in our results.
|
|
list($strings, $seenstrings) = $save($strings, $seenstrings, $component, $id, $value);
|
|
}
|
|
}
|
|
}
|
|
);
|
|
|
|
return [
|
|
'templates' => $templates,
|
|
'strings' => $strings
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Scan over a template source string and return a list of dependencies it requires.
|
|
* At the moment the list will only include other templates and strings.
|
|
*
|
|
* The return format is an array indexed with the dependency type (e.g. templates / strings) then
|
|
* the component (e.g. core_message) with it's value being an array of the items required
|
|
* in that component.
|
|
*
|
|
* For example:
|
|
* If we have a template foo that includes 2 templates, bar and baz, and also 2 strings
|
|
* 'home' and 'help' from the core component then the return value would look like:
|
|
*
|
|
* [
|
|
* 'templates' => [
|
|
* 'core' => ['foo', 'bar', 'baz']
|
|
* ],
|
|
* 'strings' => [
|
|
* 'core' => ['home', 'help']
|
|
* ]
|
|
* ]
|
|
*
|
|
* @param string $source The template source
|
|
* @return array
|
|
*/
|
|
protected function scan_template_source_for_dependencies(string $source) : array {
|
|
$tokenizer = new Mustache_Tokenizer();
|
|
$tokens = $tokenizer->scan($source);
|
|
$templates = [];
|
|
$strings = [];
|
|
$addtodependencies = function($dependencies, $component, $id) {
|
|
$id = trim($id);
|
|
$component = trim($component);
|
|
|
|
if (!isset($dependencies[$component])) {
|
|
// Initialise the component if we haven't seen it before.
|
|
$dependencies[$component] = [];
|
|
}
|
|
|
|
// Add this id to the list of dependencies.
|
|
array_push($dependencies[$component], $id);
|
|
|
|
return $dependencies;
|
|
};
|
|
|
|
foreach ($tokens as $index => $token) {
|
|
$type = $token['type'];
|
|
$name = isset($token['name']) ? $token['name'] : null;
|
|
|
|
if ($name) {
|
|
switch ($type) {
|
|
case Mustache_Tokenizer::T_PARTIAL:
|
|
list($component, $id) = explode('/', $name);
|
|
$templates = $addtodependencies($templates, $component, $id);
|
|
break;
|
|
case Mustache_Tokenizer::T_PARENT:
|
|
list($component, $id) = explode('/', $name);
|
|
$templates = $addtodependencies($templates, $component, $id);
|
|
break;
|
|
case Mustache_Tokenizer::T_SECTION:
|
|
if ($name == 'str') {
|
|
// The token that containts the string identifiers (key and component) should
|
|
// immediately follow the #str token.
|
|
$identifiertoken = isset($tokens[$index + 1]) ? $tokens[$index + 1] : null;
|
|
|
|
if ($identifiertoken) {
|
|
// The string identifier is the key and component comma separated.
|
|
$identifierstring = $identifiertoken['value'];
|
|
$parts = explode(',', $identifierstring);
|
|
$id = $parts[0];
|
|
// Default to 'core' for the component, if not specified.
|
|
$component = isset($parts[1]) ? $parts[1] : 'core';
|
|
$strings = $addtodependencies($strings, $component, $id);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return [
|
|
'templates' => $templates,
|
|
'strings' => $strings
|
|
];
|
|
}
|
|
}
|