Framework/Mustache
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Extract cache interface

Browse Source 
Refactoring to allow for alternative cache implementations. Includes
implementations for the default noop (i.e. un-cached) behavior and a
filesystem-based cache whose configuration is consistent with the
existing Mustache_Engine constructor.

Includes updated and new tests.
This commit is contained in:
Amit Snyderman
2013-09-05 17:07:38 -04:00
parent 6634f44ca6
commit 60338e4956
6 changed files with 181 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Mustache/Cache.php
+7
View File
@@ -0,0 +1,7 @@
<?php
interface Mustache_Cache
{
public function get($key);
public function put($key, $value);
}
src/Mustache/Cache/FilesystemCache.php
+51
View File
@@ -0,0 +1,51 @@
<?php
class Mustache_Cache_FilesystemCache implements Mustache_Cache
{
private $directory;
private $fileMode;
public function __construct($directory, $fileMode = null)
{
$this->directory = $directory;
$this->fileMode = $fileMode;
}
public function get($key)
{
$fileName = $this->getCacheFilename($key);
return (is_file($fileName))
? file_get_contents($fileName)
: null;
}
public function put($key, $value)
{
$fileName = $this->getCacheFilename($key);
$dirName = dirname($fileName);
if (!is_dir($dirName)) {
@mkdir($dirName, 0777, true);
if (!is_dir($dirName)) {
throw new Mustache_Exception_RuntimeException(sprintf('Failed to create cache directory "%s".', $dirName));
}
}
$tempFile = tempnam($dirName, basename($fileName));
if (false !== @file_put_contents($tempFile, $value)) {
if (@rename($tempFile, $fileName)) {
$mode = isset($this->fileMode) ? $this->fileMode : (0666 & ~umask());
@chmod($fileName, $mode);
return;
}
}
throw new Mustache_Exception_RuntimeException(sprintf('Failed to write cache file "%s".', $fileName));
}
protected function getCacheFilename($name)
{
return sprintf('%s/%s.php', $this->directory, md5($name));
}
}
src/Mustache/Cache/NoopCache.php
+7
View File
@@ -0,0 +1,7 @@
<?php
class Mustache_Cache_NoopCache implements Mustache_Cache
{
public function get($key) { return null; }
public function put($key, $value) {}
}
src/Mustache/Engine.php
+49 -90
View File
@@ -33,8 +33,7 @@ class Mustache_Engine
// Environment
private $templateClassPrefix = '__Mustache_';
private $cache = null;
private $cacheFileMode = null;
private $cache;
private $loader;
private $partialsLoader;
private $helpers;
@@ -53,6 +52,9 @@ class Mustache_Engine
* // The class prefix for compiled templates. Defaults to '__Mustache_'.
* 'template_class_prefix' => '__MyTemplates_',
*
* // A Mustache cache instance. Uses a NoopCache if not specified.
* 'cacher' => new Mustache_Cache_FilesystemCache(dirname(__FILE__).'/tmp/cache/mustache'),
*
* // A cache directory for compiled templates. Mustache will not cache templates unless this is set
* 'cache' => dirname(__FILE__).'/tmp/cache/mustache',
*
@@ -111,12 +113,13 @@ class Mustache_Engine
$this->templateClassPrefix = $options['template_class_prefix'];
}
if (isset($options['cache'])) {
$this->cache = $options['cache'];
}
if (isset($options['cache_file_mode'])) {
$this->cacheFileMode = $options['cache_file_mode'];
if (isset($options['cacher'])) {
$this->cache = $options['cacher'];
} else if (isset($options['cache'])) {
$this->cache = new Mustache_Cache_FilesystemCache(
$options['cache'],
$options['cache_file_mode']
);
}
if (isset($options['loader'])) {
@@ -479,6 +482,38 @@ class Mustache_Engine
return $this->compiler;
}
/**
* Set the Mustache Tokenizer instance.
*
* @param Mustache_Cache $cache
*/
public function setCache(Mustache_Cache $cache)
{
$this->cache = $cache;
}
/**
* Get the current Mustache Cache instance.
*
* If no Cache instance has been explicitly specified, this method will instantiate and return a new one.
*
* @return Mustache_Cache
*/
public function getCache()
{
if (!isset($this->cache)) {
$this->cache = new Mustache_Cache_NoopCache();
$this->log(
Mustache_Logger::WARNING,
'Template cache disabled',
array()
);
}
return $this->cache;
}
/**
* Helper method to generate a Mustache template class.
*
@@ -580,27 +615,17 @@ class Mustache_Engine
if (!isset($this->templates[$className])) {
if (!class_exists($className, false)) {
if ($fileName = $this->getCacheFilename($source)) {
if (!is_file($fileName)) {
$cached = $this->getCache()->get($source);
if (!$cached) {
$this->log(
Mustache_Logger::DEBUG,
'Writing "{className}" class to template cache: "{fileName}"',
array('className' => $className, 'fileName' => $fileName)
);
$this->writeCacheFile($fileName, $this->compile($source));
}
require_once $fileName;
} else {
$this->log(
Mustache_Logger::WARNING,
'Template cache disabled, evaluating "{className}" class at runtime',
'Writing "{className}" class to template cache',
array('className' => $className)
);
eval('?>'.$this->compile($source));
$cached = $this->compile($source);
$this->getCache()->put($source, $cached);
}
eval('?>'.$cached);
}
$this->log(
@@ -666,72 +691,6 @@ class Mustache_Engine
return $this->getCompiler()->compile($source, $tree, $name, isset($this->escape), $this->charset, $this->strictCallables, $this->entityFlags);
}
/**
* Helper method to generate a Mustache Template class cache filename.
*
* @param string $source
*
* @return string Mustache Template class cache filename
*/
private function getCacheFilename($source)
{
if ($this->cache) {
return sprintf('%s/%s.php', $this->cache, $this->getTemplateClassName($source));
}
}
/**
* Helper method to dump a generated Mustache Template subclass to the file cache.
*
* @throws Mustache_Exception_RuntimeException if unable to create the cache directory or write to $fileName.
*
* @param string $fileName
* @param string $source
*
* @codeCoverageIgnore
*/
private function writeCacheFile($fileName, $source)
{
$dirName = dirname($fileName);
if (!is_dir($dirName)) {
$this->log(
Mustache_Logger::INFO,
'Creating Mustache template cache directory: "{dirName}"',
array('dirName' => $dirName)
);
@mkdir($dirName, 0777, true);
if (!is_dir($dirName)) {
throw new Mustache_Exception_RuntimeException(sprintf('Failed to create cache directory "%s".', $dirName));
}
}
$this->log(
Mustache_Logger::DEBUG,
'Caching compiled template to "{fileName}"',
array('fileName' => $fileName)
);
$tempFile = tempnam($dirName, basename($fileName));
if (false !== @file_put_contents($tempFile, $source)) {
if (@rename($tempFile, $fileName)) {
$mode = isset($this->cacheFileMode) ? $this->cacheFileMode : (0666 & ~umask());
@chmod($fileName, $mode);
return;
}
$this->log(
Mustache_Logger::ERROR,
'Unable to rename Mustache temp cache file: "{tempName}" -> "{fileName}"',
array('tempName' => $tempFile, 'fileName' => $fileName)
);
}
throw new Mustache_Exception_RuntimeException(sprintf('Failed to write cache file "%s".', $fileName));
}
/**
* Add a log record if logging is enabled.
*
test/Mustache/Test/Cache/FilesystemCacheTest.php
+58
View File
@@ -0,0 +1,58 @@
<?php
/**
* @group functional
*/
class Mustache_Test_Cache_FilesystemCacheTest extends PHPUnit_Framework_TestCase
{
private static $tempDir;
public static function setUpBeforeClass()
{
self::$tempDir = sys_get_temp_dir() . '/mustache_test';
if (file_exists(self::$tempDir)) {
self::rmdir(self::$tempDir);
}
}
public function testCacheGetNone()
{
$key = 'some key';
$cache = new Mustache_Cache_FilesystemCache(self::$tempDir);;
$cached = $cache->get($key);
$this->assertNull($cached);
}
public function testCachePut()
{
$key = 'some key';
$value = 'some value';
$cache = new Mustache_Cache_FilesystemCache(self::$tempDir);;
$cache->put($key, $value);
$cached = $cache->get($key);
$this->assertEquals($cached, $value);
}
private static function rmdir($path)
{
$path = rtrim($path, '/').'/';
$handle = opendir($path);
while (($file = readdir($handle)) !== false) {
if ($file == '.' || $file == '..') {
continue;
}
$fullpath = $path.$file;
if (is_dir($fullpath)) {
self::rmdir($fullpath);
} else {
unlink($fullpath);
}
}
closedir($handle);
rmdir($path);
}
}
test/Mustache/Test/EngineTest.php
+8 -4
View File
@@ -58,6 +58,7 @@ class Mustache_Test_EngineTest extends PHPUnit_Framework_TestCase
$this->assertTrue($mustache->hasHelper('foo'));
$this->assertTrue($mustache->hasHelper('bar'));
$this->assertFalse($mustache->hasHelper('baz'));
$this->assertInstanceOf('Mustache_Cache_FilesystemCache', $mustache->getCache());
}
public static function getFoo()
@@ -95,6 +96,7 @@ class Mustache_Test_EngineTest extends PHPUnit_Framework_TestCase
$parser = new Mustache_Parser;
$compiler = new Mustache_Compiler;
$mustache = new Mustache_Engine;
$cache = new Mustache_Cache_FilesystemCache(sys_get_temp_dir());
$this->assertNotSame($logger, $mustache->getLogger());
$mustache->setLogger($logger);
@@ -119,6 +121,10 @@ class Mustache_Test_EngineTest extends PHPUnit_Framework_TestCase
$this->assertNotSame($compiler, $mustache->getCompiler());
$mustache->setCompiler($compiler);
$this->assertSame($compiler, $mustache->getCompiler());
$this->assertNotSame($cache, $mustache->getCache());
$mustache->setCache($cache);
$this->assertSame($cache, $mustache->getCache());
}
/**
@@ -134,10 +140,8 @@ class Mustache_Test_EngineTest extends PHPUnit_Framework_TestCase
$source = '{{ foo }}';
$template = $mustache->loadTemplate($source);
$className = $mustache->getTemplateClassName($source);
$fileName = self::$tempDir . '/' . $className . '.php';
$this->assertInstanceOf($className, $template);
$this->assertFileExists($fileName);
$this->assertContains("\nclass $className extends Mustache_Template", file_get_contents($fileName));
}
/**
@@ -290,7 +294,7 @@ class Mustache_Test_EngineTest extends PHPUnit_Framework_TestCase
$result = $mustache->render('{{ foo }}', array('foo' => 'FOO'));
$this->assertEquals('FOO', $result);
$this->assertContains('WARNING: Template cache disabled, evaluating', file_get_contents($name));
$this->assertContains('WARNING: Template cache disabled', file_get_contents($name));
}
public function testLoggingIsNotTooAnnoying()