refactored template name parser to occur independently of the loaders

fabpot · fabpot · commit 055d852736db · 2011-01-26T14:53:12.000+01:00
diff --git a/EngineInterface.php b/EngineInterface.php
@@ -14,15 +14,26 @@
 /**
  * EngineInterface is the interface each engine must implement.
  *
+ * All methods relies on a template name. A template name is a
+ * "logical" name for the template (an array), and as such it does not
+ * refers to a path on the filesystem (in fact, the template can be
+ * stored anywhere, like in a database).
+ *
+ * The methods should accept any name and if it is not an array, it should
+ * then use a TemplateNameParserInterface to convert the name to an array.
+ *
+ * Each template loader use the logical template name to look for
+ * the template.
+ *
  * @author Fabien Potencier <fabien.potencier@symfony-project.com>
  */
 interface EngineInterface
 {
     /**
      * Renders a template.
      *
-     * @param string $name       A template name
-     * @param array  $parameters An array of parameters to pass to the template
+     * @param mixed $name       A template name
+     * @param array $parameters An array of parameters to pass to the template
      *
      * @return string The evaluated template as a string
      *
diff --git a/Loader/CacheLoader.php b/Loader/CacheLoader.php
@@ -36,37 +36,33 @@ class CacheLoader extends Loader
      */
     public function __construct(Loader $loader, $dir)
     {
-        parent::__construct($loader->getTemplateNameParser());
-
         $this->loader = $loader;
         $this->dir = $dir;
     }
 
     /**
      * Loads a template.
      *
-     * @param string $template The logical template name
+     * @param array $template The template name as an array
      *
      * @return Storage|Boolean false if the template cannot be loaded, a Storage instance otherwise
      */
     public function load($template)
     {
-        $parameters = $this->nameParser->parse($template);
-
-        $tmp = md5(serialize($parameters)).'.tpl';
+        $tmp = md5(serialize($template)).'.tpl';
         $dir = $this->dir.DIRECTORY_SEPARATOR.substr($tmp, 0, 2);
         $file = substr($tmp, 2);
         $path = $dir.DIRECTORY_SEPARATOR.$file;
 
         if (file_exists($path)) {
             if (null !== $this->debugger) {
-                $this->debugger->log(sprintf('Fetching template "%s" from cache', $parameters['name']));
+                $this->debugger->log(sprintf('Fetching template "%s" from cache', $template['name']));
             }
 
             return new FileStorage($path);
         }
 
-        if (false === $storage = $this->loader->load($parameters['name'], $parameters)) {
+        if (false === $storage = $this->loader->load($template)) {
             return false;
         }
 
@@ -79,7 +75,7 @@ public function load($template)
         file_put_contents($path, $content);
 
         if (null !== $this->debugger) {
-            $this->debugger->log(sprintf('Storing template "%s" in cache', $parameters['name']));
+            $this->debugger->log(sprintf('Storing template "%s" in cache', $template['name']));
         }
 
         return new FileStorage($path);
@@ -88,7 +84,7 @@ public function load($template)
     /**
      * Returns true if the template is still fresh.
      *
-     * @param string    $template The template name
+     * @param array     $template The template name as an array
      * @param timestamp $time     The last modification time of the cached template
      */
     public function isFresh($template, $time)
diff --git a/Loader/ChainLoader.php b/Loader/ChainLoader.php
@@ -48,7 +48,7 @@ public function addLoader(Loader $loader)
     /**
      * Loads a template.
      *
-     * @param string $template The logical template name
+     * @param array $template The template name as an array
      *
      * @return Storage|Boolean false if the template cannot be loaded, a Storage instance otherwise
      */
@@ -66,7 +66,7 @@ public function load($template)
     /**
      * Returns true if the template is still fresh.
      *
-     * @param string    $template The template name
+     * @param array     $template The template name as an array
      * @param timestamp $time     The last modification time of the cached template
      */
     public function isFresh($template, $time)
diff --git a/Loader/FilesystemLoader.php b/Loader/FilesystemLoader.php
@@ -26,13 +26,10 @@ class FilesystemLoader extends Loader
     /**
      * Constructor.
      *
-     * @param TemplateNameParserInterface $nameParser           A TemplateNameParserInterface instance
-     * @param array                       $templatePathPatterns An array of path patterns to look for templates
+     * @param array $templatePathPatterns An array of path patterns to look for templates
      */
-    public function __construct(TemplateNameParserInterface $nameParser, $templatePathPatterns)
+    public function __construct($templatePathPatterns)
     {
-        parent::__construct($nameParser);
-
         if (!is_array($templatePathPatterns)) {
             $templatePathPatterns = array($templatePathPatterns);
         }
@@ -43,20 +40,18 @@ public function __construct(TemplateNameParserInterface $nameParser, $templatePa
     /**
      * Loads a template.
      *
-     * @param string $template The logical template name
+     * @param array $template The template name as an array
      *
      * @return Storage|Boolean false if the template cannot be loaded, a Storage instance otherwise
      */
     public function load($template)
     {
-        $parameters = $this->nameParser->parse($template);
-
-        if (self::isAbsolutePath($parameters['name']) && file_exists($parameters['name'])) {
-            return new FileStorage($parameters['name']);
+        if (self::isAbsolutePath($template['name']) && file_exists($template['name'])) {
+            return new FileStorage($template['name']);
         }
 
         $replacements = array();
-        foreach ($parameters as $key => $value) {
+        foreach ($template as $key => $value) {
             $replacements['%'.$key.'%'] = $value;
         }
 
@@ -87,7 +82,7 @@ public function load($template)
     /**
      * Returns true if the template is still fresh.
      *
-     * @param string    $template The template name
+     * @param array     $template The template name as an array
      * @param timestamp $time     The last modification time of the cached template
      */
     public function isFresh($template, $time)
diff --git a/Loader/Loader.php b/Loader/Loader.php
@@ -21,27 +21,6 @@
 abstract class Loader implements LoaderInterface
 {
     protected $debugger;
-    protected $nameParser;
-
-    /**
-     * Constructor.
-     *
-     * @param TemplateNameParserInterface $nameParser A TemplateNameParserInterface instance
-     */
-    public function __construct(TemplateNameParserInterface $nameParser)
-    {
-        $this->nameParser = $nameParser;
-    }
-
-    /**
-     * Gets the template name parser.
-     *
-     * @return TemplateNameParserInterface A TemplateNameParserInterface instance
-     */
-    public function getTemplateNameParser()
-    {
-        return $this->nameParser;
-    }
 
     /**
      * Sets the debugger to use for this loader.
diff --git a/Loader/LoaderInterface.php b/Loader/LoaderInterface.php
@@ -21,7 +21,7 @@ interface LoaderInterface
     /**
      * Loads a template.
      *
-     * @param string $template The logical template name
+     * @param array $template The template name as an array
      *
      * @return Storage|Boolean false if the template cannot be loaded, a Storage instance otherwise
      */
@@ -30,7 +30,7 @@ function load($template);
     /**
      * Returns true if the template is still fresh.
      *
-     * @param string    $template The template name
+     * @param array     $template The template name as an array
      * @param timestamp $time     The last modification time of the cached template
      */
     function isFresh($template, $time);
diff --git a/PhpEngine.php b/PhpEngine.php
@@ -33,15 +33,18 @@ class PhpEngine implements EngineInterface, \ArrayAccess
     protected $cache;
     protected $escapers;
     protected $globals;
+    protected $parser;
 
     /**
      * Constructor.
      *
-     * @param LoaderInterface $loader  A loader instance
-     * @param array           $helpers An array of helper instances
+     * @param TemplateNameParserInterface $parser  A TemplateNameParserInterface instance
+     * @param LoaderInterface             $loader  A loader instance
+     * @param array                       $helpers An array of helper instances
      */
-    public function __construct(LoaderInterface $loader, array $helpers = array())
+    public function __construct(TemplateNameParserInterface $parser, LoaderInterface $loader, array $helpers = array())
     {
+        $this->parser  = $parser;
         $this->loader  = $loader;
         $this->parents = array();
         $this->stack   = array();
@@ -60,8 +63,8 @@ public function __construct(LoaderInterface $loader, array $helpers = array())
     /**
      * Renders a template.
      *
-     * @param string $name       A template name
-     * @param array  $parameters An array of parameters to pass to the template
+     * @param mixed $name       A template name
+     * @param array $parameters An array of parameters to pass to the template
      *
      * @return string The evaluated template as a string
      *
@@ -100,7 +103,7 @@ public function render($name, array $parameters = array())
     /**
      * Returns true if the template exists.
      *
-     * @param string $name A template name
+     * @param mixed $name A template name
      *
      * @return Boolean true if the template exists, false otherwise
      */
@@ -118,40 +121,43 @@ public function exists($name)
     /**
      * Loads the given template.
      *
-     * @param string $name A template name
+     * @param mixed $name A template name
      *
      * @return Storage A Storage instance
      *
      * @throws \InvalidArgumentException if the template cannot be found
      */
     public function load($name)
     {
-        if (isset($this->cache[$name])) {
-            return $this->cache[$name];
+        $template = $this->parser->parse($name);
+
+        $key = md5(serialize($template));
+        if (isset($this->cache[$key])) {
+            return $this->cache[$key];
         }
 
         // load
-        $template = $this->loader->load($name);
+        $template = $this->loader->load($template);
 
         if (false === $template) {
             throw new \InvalidArgumentException(sprintf('The template "%s" does not exist.', $name));
         }
 
-        $this->cache[$name] = $template;
-
-        return $template;
+        return $this->cache[$key] = $template;
     }
 
     /**
      * Returns true if this class is able to render the given template.
      *
-     * @param string $name A template name
+     * @param mixed $name A template name
      *
      * @return Boolean True if this class supports the given resource, false otherwise
      */
     public function supports($name)
     {
-        return false !== strpos($name, '.php');
+        $template = $this->parser->parse($name);
+
+        return 'php' === $template['engine'];
     }
 
     /**
diff --git a/TemplateNameParser.php b/TemplateNameParser.php
@@ -9,26 +9,36 @@
  * file that was distributed with this source code.
  */
 
-namespace Symfony\Component\Templating\Loader;
+namespace Symfony\Component\Templating;
 
 /**
  * TemplateNameParser is the default implementation of TemplateNameParserInterface.
  *
+ * This implementation takes everything as the template name
+ * and the extension for the engine.
+ *
  * @author Fabien Potencier <fabien.potencier@symfony-project.com>
  */
 class TemplateNameParser implements TemplateNameParserInterface
 {
     /**
      * Parses a template to an array of parameters.
      *
-     * The only mandatory parameter is the template name (name).
-     *
      * @param string $name A template name
      *
      * @return array An array of parameters
      */
     public function parse($name)
     {
-        return array('name' => $name);
+        if (is_array($name)) {
+            return $name;
+        }
+
+        $engine = null;
+        if (false !== $pos = strrpos($name, '.')) {
+            $engine = substr($name, $pos + 1);
+        }
+
+        return array('name' => $name, 'engine' => $engine);
     }
 }
diff --git a/TemplateNameParserInterface.php b/TemplateNameParserInterface.php
@@ -9,10 +9,14 @@
  * file that was distributed with this source code.
  */
 
-namespace Symfony\Component\Templating\Loader;
+namespace Symfony\Component\Templating;
 
 /**
- * TemplateNameParserInterface parses template name to a template name and an array of options.
+ * TemplateNameParserInterface parses template names to a
+ * "normalized" array of template parameters.
+ *
+ * The template name array must always have at least a "name"
+ * and an "engine" key.
  *
  * @author Fabien Potencier <fabien.potencier@symfony-project.com>
  */
@@ -21,11 +25,9 @@ interface TemplateNameParserInterface
     /**
      * Parses a template to an array of parameters.
      *
-     * The only mandatory parameter is the template name (name).
-     *
      * @param string $name A template name
      *
-     * @return array An array of parameters
+     * @return array An array of template parameters
      */
     function parse($name);
 }

Original file line number	Diff line number	Diff line change
`@@ -14,15 +14,26 @@`
`14`	`14`	`/**`
`15`	`15`	`* EngineInterface is the interface each engine must implement.`
`16`	`16`	`*`
	`17`	`+ * All methods relies on a template name. A template name is a`
	`18`	`+ * "logical" name for the template (an array), and as such it does not`
	`19`	`+ * refers to a path on the filesystem (in fact, the template can be`
	`20`	`+ * stored anywhere, like in a database).`
	`21`	`+ *`
	`22`	`+ * The methods should accept any name and if it is not an array, it should`
	`23`	`+ * then use a TemplateNameParserInterface to convert the name to an array.`
	`24`	`+ *`
	`25`	`+ * Each template loader use the logical template name to look for`
	`26`	`+ * the template.`
	`27`	`+ *`
`17`	`28`	`* @author Fabien Potencier <[email protected]>`
`18`	`29`	`*/`
`19`	`30`	`interface EngineInterface`
`20`	`31`	`{`
`21`	`32`	`/**`
`22`	`33`	`* Renders a template.`
`23`	`34`	`*`
`24`		`- * @param string $name A template name`
`25`		`- * @param array $parameters An array of parameters to pass to the template`
	`35`	`+ * @param mixed $name A template name`
	`36`	`+ * @param array $parameters An array of parameters to pass to the template`
`26`	`37`	`*`
`27`	`38`	`* @return string The evaluated template as a string`
`28`	`39`	`*`
Original file line number	Diff line number	Diff line change
`@@ -36,37 +36,33 @@ class CacheLoader extends Loader`
`36`	`36`	`*/`
`37`	`37`	`public function __construct(Loader $loader, $dir)`
`38`	`38`	`{`
`39`		`- parent::__construct($loader->getTemplateNameParser());`
`40`		`-`
`41`	`39`	`$this->loader = $loader;`
`42`	`40`	`$this->dir = $dir;`
`43`	`41`	`}`
`44`	`42`
`45`	`43`	`/**`
`46`	`44`	`* Loads a template.`
`47`	`45`	`*`
`48`		`- * @param string $template The logical template name`
	`46`	`+ * @param array $template The template name as an array`
`49`	`47`	`*`
`50`	`48`	`* @return Storage\|Boolean false if the template cannot be loaded, a Storage instance otherwise`
`51`	`49`	`*/`
`52`	`50`	`public function load($template)`
`53`	`51`	`{`
`54`		`- $parameters = $this->nameParser->parse($template);`
`55`		`-`
`56`		`- $tmp = md5(serialize($parameters)).'.tpl';`
	`52`	`+ $tmp = md5(serialize($template)).'.tpl';`
`57`	`53`	`$dir = $this->dir.DIRECTORY_SEPARATOR.substr($tmp, 0, 2);`
`58`	`54`	`$file = substr($tmp, 2);`
`59`	`55`	`$path = $dir.DIRECTORY_SEPARATOR.$file;`
`60`	`56`
`61`	`57`	`if (file_exists($path)) {`
`62`	`58`	`if (null !== $this->debugger) {`
`63`		`- $this->debugger->log(sprintf('Fetching template "%s" from cache', $parameters['name']));`
	`59`	`+ $this->debugger->log(sprintf('Fetching template "%s" from cache', $template['name']));`
`64`	`60`	`}`
`65`	`61`
`66`	`62`	`return new FileStorage($path);`
`67`	`63`	`}`
`68`	`64`
`69`		`- if (false === $storage = $this->loader->load($parameters['name'], $parameters)) {`
	`65`	`+ if (false === $storage = $this->loader->load($template)) {`
`70`	`66`	`return false;`
`71`	`67`	`}`
`72`	`68`
`@@ -79,7 +75,7 @@ public function load($template)`
`79`	`75`	`file_put_contents($path, $content);`
`80`	`76`
`81`	`77`	`if (null !== $this->debugger) {`
`82`		`- $this->debugger->log(sprintf('Storing template "%s" in cache', $parameters['name']));`
	`78`	`+ $this->debugger->log(sprintf('Storing template "%s" in cache', $template['name']));`
`83`	`79`	`}`
`84`	`80`
`85`	`81`	`return new FileStorage($path);`
`@@ -88,7 +84,7 @@ public function load($template)`
`88`	`84`	`/**`
`89`	`85`	`* Returns true if the template is still fresh.`
`90`	`86`	`*`
`91`		`- * @param string $template The template name`
	`87`	`+ * @param array $template The template name as an array`
`92`	`88`	`* @param timestamp $time The last modification time of the cached template`
`93`	`89`	`*/`
`94`	`90`	`public function isFresh($template, $time)`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ public function addLoader(Loader $loader)`
`48`	`48`	`/**`
`49`	`49`	`* Loads a template.`
`50`	`50`	`*`
`51`		`- * @param string $template The logical template name`
	`51`	`+ * @param array $template The template name as an array`
`52`	`52`	`*`
`53`	`53`	`* @return Storage\|Boolean false if the template cannot be loaded, a Storage instance otherwise`
`54`	`54`	`*/`
`@@ -66,7 +66,7 @@ public function load($template)`
`66`	`66`	`/**`
`67`	`67`	`* Returns true if the template is still fresh.`
`68`	`68`	`*`
`69`		`- * @param string $template The template name`
	`69`	`+ * @param array $template The template name as an array`
`70`	`70`	`* @param timestamp $time The last modification time of the cached template`
`71`	`71`	`*/`
`72`	`72`	`public function isFresh($template, $time)`
Original file line number	Diff line number	Diff line change
`@@ -26,13 +26,10 @@ class FilesystemLoader extends Loader`
`26`	`26`	`/**`
`27`	`27`	`* Constructor.`
`28`	`28`	`*`
`29`		`- * @param TemplateNameParserInterface $nameParser A TemplateNameParserInterface instance`
`30`		`- * @param array $templatePathPatterns An array of path patterns to look for templates`
	`29`	`+ * @param array $templatePathPatterns An array of path patterns to look for templates`
`31`	`30`	`*/`
`32`		`- public function __construct(TemplateNameParserInterface $nameParser, $templatePathPatterns)`
	`31`	`+ public function __construct($templatePathPatterns)`
`33`	`32`	`{`
`34`		`- parent::__construct($nameParser);`
`35`		`-`
`36`	`33`	`if (!is_array($templatePathPatterns)) {`
`37`	`34`	`$templatePathPatterns = array($templatePathPatterns);`
`38`	`35`	`}`
`@@ -43,20 +40,18 @@ public function __construct(TemplateNameParserInterface $nameParser, $templatePa`
`43`	`40`	`/**`
`44`	`41`	`* Loads a template.`
`45`	`42`	`*`
`46`		`- * @param string $template The logical template name`
	`43`	`+ * @param array $template The template name as an array`
`47`	`44`	`*`
`48`	`45`	`* @return Storage\|Boolean false if the template cannot be loaded, a Storage instance otherwise`
`49`	`46`	`*/`
`50`	`47`	`public function load($template)`
`51`	`48`	`{`
`52`		`- $parameters = $this->nameParser->parse($template);`
`53`		`-`
`54`		`- if (self::isAbsolutePath($parameters['name']) && file_exists($parameters['name'])) {`
`55`		`- return new FileStorage($parameters['name']);`
	`49`	`+ if (self::isAbsolutePath($template['name']) && file_exists($template['name'])) {`
	`50`	`+ return new FileStorage($template['name']);`
`56`	`51`	`}`
`57`	`52`
`58`	`53`	`$replacements = array();`
`59`		`- foreach ($parameters as $key => $value) {`
	`54`	`+ foreach ($template as $key => $value) {`
`60`	`55`	`$replacements['%'.$key.'%'] = $value;`
`61`	`56`	`}`
`62`	`57`
`@@ -87,7 +82,7 @@ public function load($template)`
`87`	`82`	`/**`
`88`	`83`	`* Returns true if the template is still fresh.`
`89`	`84`	`*`
`90`		`- * @param string $template The template name`
	`85`	`+ * @param array $template The template name as an array`
`91`	`86`	`* @param timestamp $time The last modification time of the cached template`
`92`	`87`	`*/`
`93`	`88`	`public function isFresh($template, $time)`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ interface LoaderInterface`
`21`	`21`	`/**`
`22`	`22`	`* Loads a template.`
`23`	`23`	`*`
`24`		`- * @param string $template The logical template name`
	`24`	`+ * @param array $template The template name as an array`
`25`	`25`	`*`
`26`	`26`	`* @return Storage\|Boolean false if the template cannot be loaded, a Storage instance otherwise`
`27`	`27`	`*/`
`@@ -30,7 +30,7 @@ function load($template);`
`30`	`30`	`/**`
`31`	`31`	`* Returns true if the template is still fresh.`
`32`	`32`	`*`
`33`		`- * @param string $template The template name`
	`33`	`+ * @param array $template The template name as an array`
`34`	`34`	`* @param timestamp $time The last modification time of the cached template`
`35`	`35`	`*/`
`36`	`36`	`function isFresh($template, $time);`
Original file line number	Diff line number	Diff line change
`@@ -33,15 +33,18 @@ class PhpEngine implements EngineInterface, \ArrayAccess`
`33`	`33`	`protected $cache;`
`34`	`34`	`protected $escapers;`
`35`	`35`	`protected $globals;`
	`36`	`+ protected $parser;`
`36`	`37`
`37`	`38`	`/**`
`38`	`39`	`* Constructor.`
`39`	`40`	`*`
`40`		`- * @param LoaderInterface $loader A loader instance`
`41`		`- * @param array $helpers An array of helper instances`
	`41`	`+ * @param TemplateNameParserInterface $parser A TemplateNameParserInterface instance`
	`42`	`+ * @param LoaderInterface $loader A loader instance`
	`43`	`+ * @param array $helpers An array of helper instances`
`42`	`44`	`*/`
`43`		`- public function __construct(LoaderInterface $loader, array $helpers = array())`
	`45`	`+ public function __construct(TemplateNameParserInterface $parser, LoaderInterface $loader, array $helpers = array())`
`44`	`46`	`{`
	`47`	`+ $this->parser = $parser;`
`45`	`48`	`$this->loader = $loader;`
`46`	`49`	`$this->parents = array();`
`47`	`50`	`$this->stack = array();`
`@@ -60,8 +63,8 @@ public function __construct(LoaderInterface $loader, array $helpers = array())`
`60`	`63`	`/**`
`61`	`64`	`* Renders a template.`
`62`	`65`	`*`
`63`		`- * @param string $name A template name`
`64`		`- * @param array $parameters An array of parameters to pass to the template`
	`66`	`+ * @param mixed $name A template name`
	`67`	`+ * @param array $parameters An array of parameters to pass to the template`
`65`	`68`	`*`
`66`	`69`	`* @return string The evaluated template as a string`
`67`	`70`	`*`
`@@ -100,7 +103,7 @@ public function render($name, array $parameters = array())`
`100`	`103`	`/**`
`101`	`104`	`* Returns true if the template exists.`
`102`	`105`	`*`
`103`		`- * @param string $name A template name`
	`106`	`+ * @param mixed $name A template name`
`104`	`107`	`*`
`105`	`108`	`* @return Boolean true if the template exists, false otherwise`
`106`	`109`	`*/`
`@@ -118,40 +121,43 @@ public function exists($name)`
`118`	`121`	`/**`
`119`	`122`	`* Loads the given template.`
`120`	`123`	`*`
`121`		`- * @param string $name A template name`
	`124`	`+ * @param mixed $name A template name`
`122`	`125`	`*`
`123`	`126`	`* @return Storage A Storage instance`
`124`	`127`	`*`
`125`	`128`	`* @throws \InvalidArgumentException if the template cannot be found`
`126`	`129`	`*/`
`127`	`130`	`public function load($name)`
`128`	`131`	`{`
`129`		`- if (isset($this->cache[$name])) {`
`130`		`- return $this->cache[$name];`
	`132`	`+ $template = $this->parser->parse($name);`
	`133`	`+`
	`134`	`+ $key = md5(serialize($template));`
	`135`	`+ if (isset($this->cache[$key])) {`
	`136`	`+ return $this->cache[$key];`
`131`	`137`	`}`
`132`	`138`
`133`	`139`	`// load`
`134`		`- $template = $this->loader->load($name);`
	`140`	`+ $template = $this->loader->load($template);`
`135`	`141`
`136`	`142`	`if (false === $template) {`
`137`	`143`	`throw new \InvalidArgumentException(sprintf('The template "%s" does not exist.', $name));`
`138`	`144`	`}`
`139`	`145`
`140`		`- $this->cache[$name] = $template;`
`141`		`-`
`142`		`- return $template;`
	`146`	`+ return $this->cache[$key] = $template;`
`143`	`147`	`}`
`144`	`148`
`145`	`149`	`/**`
`146`	`150`	`* Returns true if this class is able to render the given template.`
`147`	`151`	`*`
`148`		`- * @param string $name A template name`
	`152`	`+ * @param mixed $name A template name`
`149`	`153`	`*`
`150`	`154`	`* @return Boolean True if this class supports the given resource, false otherwise`
`151`	`155`	`*/`
`152`	`156`	`public function supports($name)`
`153`	`157`	`{`
`154`		`- return false !== strpos($name, '.php');`
	`158`	`+ $template = $this->parser->parse($name);`
	`159`	`+`
	`160`	`+ return 'php' === $template['engine'];`
`155`	`161`	`}`
`156`	`162`
`157`	`163`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -9,26 +9,36 @@`
`9`	`9`	`* file that was distributed with this source code.`
`10`	`10`	`*/`
`11`	`11`
`12`		`-namespace Symfony\Component\Templating\Loader;`
	`12`	`+namespace Symfony\Component\Templating;`
`13`	`13`
`14`	`14`	`/**`
`15`	`15`	`* TemplateNameParser is the default implementation of TemplateNameParserInterface.`
`16`	`16`	`*`
	`17`	`+ * This implementation takes everything as the template name`
	`18`	`+ * and the extension for the engine.`
	`19`	`+ *`
`17`	`20`	`* @author Fabien Potencier <[email protected]>`
`18`	`21`	`*/`
`19`	`22`	`class TemplateNameParser implements TemplateNameParserInterface`
`20`	`23`	`{`
`21`	`24`	`/**`
`22`	`25`	`* Parses a template to an array of parameters.`
`23`	`26`	`*`
`24`		`- * The only mandatory parameter is the template name (name).`
`25`		`- *`
`26`	`27`	`* @param string $name A template name`
`27`	`28`	`*`
`28`	`29`	`* @return array An array of parameters`
`29`	`30`	`*/`
`30`	`31`	`public function parse($name)`
`31`	`32`	`{`
`32`		`- return array('name' => $name);`
	`33`	`+ if (is_array($name)) {`
	`34`	`+ return $name;`
	`35`	`+ }`
	`36`	`+`
	`37`	`+ $engine = null;`
	`38`	`+ if (false !== $pos = strrpos($name, '.')) {`
	`39`	`+ $engine = substr($name, $pos + 1);`
	`40`	`+ }`
	`41`	`+`
	`42`	`+ return array('name' => $name, 'engine' => $engine);`
`33`	`43`	`}`
`34`	`44`	`}`