- Fixed a deprecated attribute not supported on properties.

@

composer.json

@@ -16,5 +16,14 @@
     },
     "require": {
         "psr/http-message": "^1.0"
+    },
+    "extra": {
+        "lean": {
+            "autoload": {
+                "definitions": [
+                    "meta/definitions.php"
+                ]
+            }
+        }
     }
-}
+}

docs/02-control-structure-view-include-block.md

@@ -96,9 +96,9 @@ You can do so by using `define` and `slot`.
 ```html
 {% arguments string $name, string $anchor, int $index = 0 %}
 
-{% define slot %}
+{% define "attributes" %}
 
-<a {% slot "attributes" %}href="{{ $anchor }}" tabindex="{{ $index }}"{% endslot %}>{{ $name }}"</a>
+<a {% slot "attributes" %}{% endslot %} href="{{ $anchor }}" tabindex="{{ $index }}"{% endslot %}>{{ $name }}"</a>
 ```
 
 **[HTML]** Would render the same as the `view` example :

meta/definitions.php

@@ -0,0 +1,59 @@
+<?php
+
+use function DI\autowire, DI\create, DI\get;
+
+use Picea\{
+    Caching\Cache,
+    Caching\Opcache,
+    Compiler,
+    Compiler\Context,
+    Compiler\BaseContext,
+    FileFetcher,
+    Method\Request
+};
+
+use Picea\Extension\{ LanguageHandlerInterface, LanguageExtension, TitleExtension, NumberExtension, UrlExtension };
+
+return [
+    Picea\Picea::class => function($c) {
+        return new Picea\Picea($c->get(Context::class), $c->get(Cache::class), $c->get(Compiler::class), null, $c->get(FileFetcher::class), null, getenv("DEBUG"));
+    },
+
+    Context::class => function($c) {
+        return new BaseContext($c->get(Lean\Lean::class)->getPiceaContext());
+    },
+
+    Compiler::class => autowire(Compiler::class),
+
+    Request::class => autowire(Request::class),
+
+    LanguageExtension::class => create(LanguageExtension::class)->constructor(get(LanguageHandlerInterface::class)),
+
+    # LanguageHandlerInterface::class => autowire(\Lean\LanguageHandler::class),
+
+    # LanguageRegistration::class => create(\Lean\PiceaDefaultRegistration::class)->constructor(get('picea.extensions'), [], [], get(Ui::class), null),
+
+    'picea.extensions' => function(\Psr\Container\ContainerInterface $c) {
+        return array_merge([
+            $c->get(LanguageExtension::class),
+            $c->get(TitleExtension::class),
+            $c->get(NumberExtension::class),
+            $c->get(UrlExtension::class),
+            $c->get(Request::class),
+        ], class_exists(\Taxus\Picea\Extension::class) ? [ $c->get(\Taxus\Picea\Extension::class) ] : [],
+            array_map(fn($class) => $c->get($class), $c->get(Lean\Lean::class)->getPiceaExtensions())
+        );
+    },
+
+    TitleExtension::class => autowire(TitleExtension::class),
+
+    NumberExtension::class => autowire(NumberExtension::class),
+
+    UrlExtension::class => create(UrlExtension::class)->constructor(getenv("URL_BASE"), get('git.commit'), explode(',', getenv('APP_URL')), (bool) getenv('FORCE_SSL')),
+
+    Cache::class => create(Opcache::class)->constructor(getenv("CACHE_PATH"), get(Context::class)),
+
+    FileFetcher::class => function($c) {
+        return new FileFetcher($c->get(Lean\Lean::class)->getViewPaths());
+    },
+];

src/Builder.php

@@ -21,7 +21,7 @@ class Builder
 
         $replace = [
             '%NAMESPACE%' => $context->namespace,
-            '%USE%' => ( $uses = $context->renderUses() ) ? "use $uses;" : false,
+            '%USE%' => ( $uses = $context->renderUses() ) ? $uses : false,
             '%CLASSNAME%' => $context->className,
             '%PATHNAME%' => $path($context->viewPath),
             '%FULLPATH%' => $path($context->filePath),

src/Compiler/Context.php

@@ -57,7 +57,7 @@ abstract class Context {
 
     public function renderUses() : string
     {
-        return implode(",", $this->useStack ?? []);
+        return implode(PHP_EOL, array_map(fn($use) => "use $use;", $this->useStack ?? []));
     }
 
     public function renderFunctions() : string

src/ControlStructure/BlockToken.php

@@ -8,17 +8,22 @@ class BlockToken implements ControlStructure {
 
     public function parse(\Picea\Compiler\Context &$context, ?string $arguments, string $token, array $options = []) : string
     {
+        static $depth = 0;
         static $slotDefinitions = [];
 
+        # dump($depth, $token, $arguments, $slotDefinitions);
+
         switch($token) {
             case "block":
                 $slotDefinitions[] = $this->slotDefinitions();
-                
+                $depth++;
+
                 return "<?php \$___block = \Picea\ControlStructure\BlockToken::instanciateBlock($arguments); ?>";
-            
+
             case "endblock":
+                $depth--;
                 return "<?php echo \$___block->render(\$___class__template); unset(\$___block); ?>";
-            
+
             case "arguments":
                 $class = static::class;
 
@@ -36,19 +41,19 @@ class BlockToken implements ControlStructure {
                         }
                     /*%EXCEPTION_LINE_BASE%*/?>
                 PHP;
-            
+
             case "define":
                 list($name, $definition) = array_pad(explode(',', $arguments, 2), 2, "");
-                
+
-                end($slotDefinitions)->setDefinition(eval("return $name;"), $definition);
+                ( $slotDefinitions[$depth] ?? end($slotDefinitions) )->setDefinition(eval("return $name;"), $definition);
-                
+
                 return <<<PHP
-                    <?php \$this->defineSlot($name, function($definition) {}); ?>
+                <?php \$this->defineSlot($name, function($definition) {}); ?>
                 PHP;
-                    
+
             case "slot":
-                $def = end($slotDefinitions);
+                $def = ( $slotDefinitions[$depth] ?? end($slotDefinitions) );
-                
+
                 list($name, $definition) = array_pad(explode(',', $arguments, 2), 2, "");
 
                 $loops = count($context->iterationStack ?? []) ? ",". implode(', ', array_filter(array_column($context->iterationStack, 'uid'), fn($e) => strpos($e, '[') === false)) : null;
@@ -57,7 +62,7 @@ class BlockToken implements ControlStructure {
                     $slotName = eval("return $name;");
                     $def->currentSlot = $slotName;
                     $def->setDefinitionVars($slotName, $definition);
-                    
+
                     $definition = $def->printDefinition($slotName);
 
                     if ($definition) {
@@ -65,53 +70,53 @@ class BlockToken implements ControlStructure {
                     }
 
                     return <<<PHP
-                        <?php \$this->printSlot($name, function($definition array \$___using = []) use (\$picea $loops) { extract(\$___using, \EXTR_SKIP); ?>
+                    <?php \$this->printSlot($name, function($definition array \$___using = []) use (\$picea $loops) { extract(\$___using, \EXTR_SKIP); ?>
                     PHP;
                 }
                 else {
                     if ($definition) {
                         $definition .= ",";
                     }
-                    
-                    return <<<PHP
-                        <?php (\$___block ?? \$this)->slotIsSet($name) || \$___block->setSlot($name, function($definition array \$___using = []) use (\$picea $loops) { extract(\$___using, \EXTR_SKIP); ?>
-                    PHP;
-                }
-                    
-            case "endslot":
-                $def =end($slotDefinitions);
-                
-                if ($def->hasDefinitions() ) {
-                    $definition = $def->getCurrentSlotDefinitionVars();
-                    
-                    if ($definition) {
-                        $definition .= ",";
-                    }
 
                     return <<<PHP
-                        <?php })->call(\$this, $definition array_merge(get_defined_vars(), \$this->using)); ?>
+                    <?php (\$___block ?? \$this)->slotIsSet($name) || (\$___block ?? \$this)->setSlot($name, function($definition array \$___using = []) use (\$picea $loops) { extract(\$___using, \EXTR_SKIP); ?>
+                    PHP;
+                }
+
+            case "endslot":
+                $def = ( $slotDefinitions[$depth] ?? end($slotDefinitions) );
+
+                if ($def->hasDefinitions() ) {
+                    $definition = $def->getCurrentSlotDefinitionVars();
+
+                    if ($definition) {
+                        $definition .= ",";
+                    }
+
+                    return <<<PHP
+                    <?php })->call(\$this, $definition array_merge(get_defined_vars(), \$this->using)); ?>
                     PHP;
                 }
                 else {
                     return "<?php }); ?>";
                 }
-                
+
             case "using":
                 return "<?php \$___block->setUsing($arguments); ?>";
         }
     }
-    
+
-    
+
     public function inlineHtml(? object $proxy, string $viewPath, ... $variables) {
         return $this->renderHtml($viewPath, [ 'inlineVariables' => $variables ], $proxy);
     }
-    
+
     public static function parseSlotArguments(Callable $method) : array
     {
-        #return 
+        #return
     }
-        
+
-        
+
     public static function parseArguments(Callable $method, array $arguments) : array
     {
         try{
@@ -119,10 +124,10 @@ class BlockToken implements ControlStructure {
         }
         catch(\TypeError $ex) {
             throw $ex;
-        } 
+        }
-        
+
         $parameters = [];
-        
+
         foreach((new \ReflectionFunction($method))->getParameters() as $key => $value) {
             if ( isset($arguments[$key]) ) {
                 $parameters[ $value->getName() ] = $arguments[$key];
@@ -137,115 +142,119 @@ class BlockToken implements ControlStructure {
                 $parameters[ $value->getName() ] = null;
             }
         }
-        
+
         return $parameters;
     }
-    
+
     public static function slotDefinitions() {
         return new class() {
-            
+
             public array $definitions = [];
-            
+
             public array $variables = [];
-            
+
             public bool $rendering = false;
-            
+
             public string $currentSlot;
-            
+
-            public function setDefinition(string $name, string $definition) : self 
+            public function setDefinition(string $name, string $definition) : self
             {
                 $this->definitions[$name] = $definition;
-                
+
                 return $this;
             }
-            
+
             public function setDefinitionVars(string $name, string $variables) : self
             {
                 $this->variables[$name] = $variables;
-                
+
                 return $this;
             }
-            
+
             public function getDefinitionVars(string $name) : string
             {
                 return $this->variables[$name] ?? "";
             }
-            
+
             public function getCurrentSlotDefinitionVars() : string
             {
                 return $this->getDefinitionVars($this->currentSlot);
             }
-            
+
             public function hasDefinitions() : bool
             {
                 return count($this->definitions) > 0;
             }
-            
+
             public function printDefinition(string $name) : string
             {
                 if ( ! isset($this->definitions[$name]) ) {
-                    throw new \Exception("Slot definition for `$name` was not found. Have you defined it in your block header ?");
+                    throw new \Exception("Slot definition for `$name` was not found. Have you defined it in your block header using something like '{% define \"$name\", ...\$arguments %}' ?");
                 }
-                
+
                 return $this->definitions[$name];
             }
-            
+
             public function render() : void
             {
                 $this->rendering = true;
             }
-            
         };
     }
-    
+
-    public static function instanciateBlock(string $viewPath, ... $arguments) 
+    public static function instanciateBlock(string $viewPath, ... $arguments)
     {
         return new class($viewPath, ...$arguments) {
-            
+
             public bool $rendering = false;
-            
+
             public string $viewPath;
-            
+
             public array $using = [];
-            
+
             public array $arguments = [];
-            
+
             public array $slots = [];
-            
+
             public array $definition = [];
-            
+
             public function __construct(string $viewPath, ...$arguments) {
                 $this->viewPath = $viewPath;
                 $this->arguments = $arguments;
             }
-            
+
             public function render(object $classTemplate) : string
             {
                 $this->rendering = true;
 
-                return $classTemplate->picea->inlineBlock($this, $this->viewPath, ...$this->arguments);
+                if ($this->using['this'] ?? false) {
+                    $thisProxy = $this->using['this'];
+                    unset($this->using['this']);
+                }
+                
+                return $classTemplate->picea->inlineBlock($thisProxy ?? $this, $this->viewPath, ...$this->arguments);
             }
-            
+
             public function setSlot(string $name, Callable $method) : void
             {
                 $this->slots[$name] = $method;
             }
-            
+
             public function defineSlot(string $name, Callable $method) : void
             {
                 $this->definition[$name] = $method;
             }
-            
+
             public function slotIsSet(string $name) : bool
             {
                 return ! empty($this->slots[$name]);
             }
-            
+
             public function printSlot(string $name, Callable $default)
             {
                 return $this->slotIsSet($name) ? $this->slots[$name] : $default;
             }
-            
+
             public function setUsing(array $variables) {
                 $this->using = $variables;
             }

src/ControlStructure/FunctionToken.php

@@ -33,7 +33,9 @@ class FunctionToken implements ControlStructure {
 
     protected function printFunction($context, ?string $arguments) : string
     {
-        return "<?php function $arguments { ?>";
+        $name = trim(explode('(', $arguments, 2)[0]);
+
+        return "<?php if (! function_exists(__NAMESPACE__ . '\\$name')) { function $arguments { ?>";
     }
 
     protected function printReturn($context, ?string $arguments) : string
@@ -43,6 +45,6 @@ class FunctionToken implements ControlStructure {
 
     protected function printEndFunction($context) : string
     {
-        return "<?php } ?>";
+        return "<?php } } ?>";
     }
 }

src/ControlStructure/SectionToken.php

@@ -33,6 +33,8 @@ class SectionToken implements ControlStructure {
                     throw new \RuntimeException("A section closing tag {% endsection %} was found without an opening {% section %} tag");
                 }
 
+                $this->action = PrintActionEnum::default;
+
                 return $this->printEndSection($context);
         }
     }

src/ControlStructure/TryCatchToken.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Picea\ControlStructure;
+
+class TryCatchToken implements ControlStructure {
+
+    public array $token = [ "try", "catch", "finally", "endtry" ];
+
+    public function parse(\Picea\Compiler\Context &$context, ?string $arguments, string $token, array $options = []) : string {
+        switch($token) {
+            case "try":
+
+                return "<?php try { ?>";
+                
+            case "catch":
+                return "<?php } catch($arguments) { ?>";
+
+            case "finally":
+                return "<?php } finally { ?>";
+
+            case "endtry":
+                return "<?php } ?>";
+        }
+    }
+}

src/Event/Extension/BuildAssetUrl.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Picea\Event\Extension;
+
+interface BuildAssetUrl
+{
+    public function execute(string $uri, array $parameters = [], bool $appendVersion = true) : mixed;
+}

src/Extension/NumberExtension.php

@@ -15,6 +15,7 @@ class NumberExtension implements Extension, FunctionExtension {
         public string $title = "",
     ) {
         $this->locale = explode('.', \Locale::getDefault())[0];
+        $this->formatter = new \NumberFormatter($this->locale, \NumberFormatter::CURRENCY);
     }
 
     public function exportFunctions(): array
@@ -55,8 +56,6 @@ class NumberExtension implements Extension, FunctionExtension {
 
     public function money(float $money, ? string $currency = null) /* : string|false */
     {
-        $this->formatter ??= new \NumberFormatter($this->locale, \NumberFormatter::CURRENCY);
-
         $this->formatter->setTextAttribute(\NumberFormatter::CURRENCY_CODE, 'CAD');
 
         $this->formatter->setPattern( str_replace('¤#','¤ #', $this->formatter->getPattern() ) );

src/Extension/PrintExtension.php

@@ -8,7 +8,7 @@ class PrintExtension implements Extension {
 
     public array $token = [ "echo", "print", "printf", "no_html" ];
     
-    public int $flag = \ENT_QUOTES;
+    public int $flag = \ENT_QUOTES | \ENT_DISALLOWED | \ENT_SUBSTITUTE;
 
     public string $encoding;
 

src/Extension/UrlExtension.php

@@ -2,15 +2,10 @@
 
 namespace Picea\Extension;
 
-use Notes\Route\Attribute\Object\Route;
 use Picea\EventTrait;
-use Picea\Compiler\Context;
-
 use Picea\Event\Extension\{ UrlBuildAssetEvent, UrlBuildUrlEvent, UrlBuildRouteEvent, UrlRegisterRouteEvent };
 
 class UrlExtension implements Extension, FunctionExtension {
-    use \Picea\EventTrait;
-
     use EventTrait;
 
     public const URLIZE_PATTERN_URL = <<<PATTERN
@@ -35,7 +30,7 @@ PATTERN;
 
     public array $tokens = [ "url" , "route", "asset", "slug" ];
 
-    #[\Deprecated]
+    ##[\Deprecated]
     protected bool $enforceExistingArguments = true;
 
     public function __construct(string $urlBase = "", string $assetToken = "", array $appUrl = [], bool $forceSSL = false) {
@@ -68,7 +63,7 @@ PATTERN;
                 return "<?php echo \$picea->compiler->getExtensionFromToken('$token')->slug($arguments) ?>";
         }
 
-        throw new \ParseExtensionException("Unknown token given $token in UrlExtension.");
+        throw new \Exception("Unknown token given $token in UrlExtension.");
     }
 
     public function exportFunctions(): array
@@ -125,7 +120,7 @@ PATTERN;
 
     public function buildRouteUrl(string $name, array $parameters = [], bool $appendVersion = false) : string
     {
-        if ( false !== ( $route = $this->routes[$name] ?? false ) ) {
+        if ( false !== $route = $this->findRoute($name) ) {
             return $this->buildUrl($this->prepareRoute($route, $parameters), $parameters, $appendVersion);
         }
 
@@ -154,14 +149,28 @@ PATTERN;
 
     public function registerRoute(string $name, string $route, string $class, string $method, array $routeMethods) : void
     {
-        $this->routes[$name] = [
+        $this->routes[] = $array = [
+            'name' => $name,
             'route' => $route,
-            'routeMethods' => $routeMethods,
+            'routeMethods' => array_map('strtoupper', $routeMethods),
             'class' => $class,
             'classMethod' => $method,
         ];
 
-        $this->eventExecute(UrlRegisterRouteEvent::class, $name, $this->routes[$name]);
+        $this->eventExecute(UrlRegisterRouteEvent::class, $name, $array);
+    }
+
+    protected function findRoute(string $name, string $method = "*") : false|array
+    {
+        foreach($this->routes as $route) {
+            if ( $route['name'] === $name ) {
+                if ($method === '*' || in_array(strtoupper($method), $route['routeMethods']) ) {
+                    return $route;
+                }
+            }
+        }
+
+        return false;
     }
 
     /**
@@ -280,7 +289,7 @@ PATTERN;
                     if ($default ?? false) {
                         $value = $default;
                     }
-                    elseif ( strpos($route, "[{$matches[0][0]}]") !== false && $this->enforceExistingArguments) {
+                    elseif ( $this->enforceExistingArguments && ! preg_match(sprintf("/\[\/?%s]/i", $item[0]), $route) ) {
                         throw new \RuntimeException(sprintf("Error while preparing route %s : could not match variable '%s' into given arguments ( %s ) from %s::%s", $route, $variable, json_encode($arguments), $routeParam['class'], $routeParam['classMethod']));
                     }
                 }

src/Language/DefaultRegistrations.php

@@ -32,6 +32,7 @@ class DefaultRegistrations implements LanguageRegistration
 
     public function registerControlStructure(Compiler $compiler) : void
     {
+        $compiler->registerControlStructure(new \Picea\ControlStructure\TryCatchToken());
         $compiler->registerControlStructure(new \Picea\ControlStructure\NamespaceToken());
         $compiler->registerControlStructure(new \Picea\ControlStructure\UseToken());
         $compiler->registerControlStructure(new \Picea\ControlStructure\IfToken());

src/Picea.php

@@ -180,6 +180,7 @@ class Picea implements LanguageRegistration
     {
         if ( $this->debug || ! $this->cache->compiled( $context->cacheFilename() ) ) {
             $context = $this->compileContext($context);
+
             $this->cache->save($context);
         }