Lazy renderer initialization

src/Phug/OptionsBundle.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Phug;
+
+use Phug\Util\Partial\OptionTrait;
+
+class OptionsBundle
+{
+    use OptionTrait;
+}

src/Phug/Partial/FacadeOptionsTrait.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Phug\Partial;
+
+use ArrayObject;
+use Phug\OptionsBundle;
+
+trait FacadeOptionsTrait
+{
+    /**
+     * @var OptionsBundle
+     */
+    private static $options = null;
+
+    protected static function resetFacadeOptions()
+    {
+        static::$options = null;
+    }
+
+    protected static function callOption($method, array $arguments)
+    {
+        if (!static::$options) {
+            static::$options = new OptionsBundle();
+        }
+
+        return call_user_func_array([static::$options, $method], $arguments);
+    }
+
+    protected static function isOptionMethod($method)
+    {
+        return in_array($method, [
+            'hasOption',
+            'getOption',
+            'setOption',
+            'setOptions',
+            'setOptionsRecursive',
+            'setOptionsDefaults',
+            'unsetOption',
+        ]);
+    }
+
+    protected static function getFacadeOptions()
+    {
+        $options = static::$options ? (static::$options->getOptions() ?: []) : [];
+
+        return $options instanceof ArrayObject ? $options->getArrayCopy() : $options;
+    }
+}

src/Phug/Phug.php

@@ -3,10 +3,12 @@
 namespace Phug;
 
 use Phug\Partial\ExtensionsTrait;
+use Phug\Partial\FacadeOptionsTrait;
 
 class Phug
 {
     use ExtensionsTrait;
+    use FacadeOptionsTrait;
 
     /**
      * List of global filters stored as array where keys are filter names, and values the action callback.
@@ -48,7 +50,7 @@ private static function normalizeKeywordName($name)
 
     private static function getOptions(array $options = [])
     {
-        $extras = [];
+        $extras = static::getFacadeOptions();
         foreach (['filters', 'keywords'] as $option) {
             $method = 'get'.ucfirst($option);
             $extras[$option] = static::$method();
@@ -108,6 +110,7 @@ public static function removeOptions($path, $options)
      */
     public static function reset()
     {
+        static::resetFacadeOptions();
         self::$renderer = null;
         self::$extensions = [];
         self::$filters = [];
@@ -492,6 +495,10 @@ public static function textualCacheDirectory($source, $destination = null, $opti
      */
     public static function __callStatic($name, $arguments)
     {
+        if (!self::$renderer && static::isOptionMethod($name)) {
+            return static::callOption($name, $arguments);
+        }
+
         return call_user_func_array([static::getRenderer(), $name], $arguments);
     }
 }

tests/Phug/DefaultOptionsTest.php

@@ -193,6 +193,9 @@
 use Phug\Renderer\Adapter\StreamAdapter;
 use Phug\Util\OptionInterface;
 
+/**
+ * @coversDefaultClass \Phug\Partial\FacadeOptionsTrait
+ */
 class DefaultOptionsTest extends AbstractPhugTest
 {
     private static function isCallable($expected)
@@ -540,4 +543,22 @@ public function testLexerOptions()
             'on_token'   => null,
         ], Phug::getRenderer()->getCompiler()->getParser()->getLexer());
     }
+
+    /**
+     * @covers \Phug\Phug::__callStatic
+     * @covers ::resetFacadeOptions
+     * @covers ::callOption
+     * @covers ::isOptionMethod
+     * @covers ::getFacadeOptions
+     */
+    public function testInitialOption()
+    {
+        include_once __DIR__.'/Util/TCompiler.php';
+        include_once __DIR__.'/Util/TParser.php';
+        Phug::reset();
+        Phug::setOption('parser_class_name', \TParser::class);
+        Phug::setOption('compiler_class_name', \TCompiler::class);
+        self::assertInstanceOf(\TCompiler::class, Phug::getRenderer()->getCompiler());
+        self::assertInstanceOf(\TParser::class, Phug::getRenderer()->getCompiler()->getParser());
+    }
 }

tests/Phug/Util/TCompiler.php

@@ -0,0 +1,5 @@
+<?php
+
+class TCompiler extends \Phug\Compiler
+{
+}

tests/Phug/Util/TParser.php

@@ -0,0 +1,5 @@
+<?php
+
+class TParser extends \Phug\Parser
+{
+}