Conditions (#51)

* Condition Attributes

* Attribute repeatable

* Attribute repeatable

* Target all

* Construct conditions with DI

* Remove init watcher

* Use cubex

* Share cubex as DI

Author: bajb

composer.json

@@ -23,7 +23,7 @@
     "packaged/config": "~1.5",
     "packaged/context": "^1.11",
     "packaged/context-i18n": "~1.0",
-    "packaged/di-container": "~1.0",
+    "packaged/di-container": "dev-master as 1.7",
     "packaged/event": "~1.2",
     "packaged/figlet": "~0.0",
     "packaged/helpers": "^2.15",

src/Attributes/AbstractConditionAttribute.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Cubex\Attributes;
+
+use Packaged\DiContainer\DependencyInjector;
+
+abstract class AbstractConditionAttribute
+{
+  protected string $_class = '';
+  protected array $_args = [];
+
+  public function __construct(string $class, array $args = [])
+  {
+    $this->_class = $class;
+    $this->_args = $args;
+  }
+
+  public function getClass(): string
+  {
+    return $this->_class;
+  }
+
+  public function result(?DependencyInjector $di): ConditionResult
+  {
+    $obj = null;
+
+    if($di)
+    {
+      $obj = $di->resolve($this->_class, ...$this->_args);
+    }
+    else if(class_exists($this->_class))
+    {
+      $obj = new $this->_class(...$this->_args);
+    }
+
+    if($obj instanceof ConditionResult)
+    {
+      return $obj;
+    }
+
+    throw new \RuntimeException("Class {$this->_class} does not exist, or is not a ConditionResult");
+  }
+}

src/Attributes/ConditionResult.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Cubex\Attributes;
+
+use Packaged\Context\Context;
+
+interface ConditionResult
+{
+  // Returns null or a value to be returned from the method
+  public function process(Context $ctx): mixed;
+}

src/Attributes/PreCondition.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Cubex\Attributes;
+
+use Attribute;
+
+#[Attribute(\Attribute::IS_REPEATABLE | \Attribute::TARGET_ALL)]
+class PreCondition extends AbstractConditionAttribute
+{
+}

src/Attributes/SkipCondition.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Cubex\Attributes;
+
+use Attribute;
+
+#[Attribute(\Attribute::IS_REPEATABLE | \Attribute::TARGET_ALL)]
+class SkipCondition extends AbstractConditionAttribute
+{
+}

src/Cubex.php

@@ -63,6 +63,7 @@ public function __construct($projectRoot, ClassLoader $loader = null, $global =
     $this->_eventChannel = new Channel('cubex');
     //Setup Context
     $this->share(ClassLoader::class, $loader);
+    $this->share(DependencyInjector::class, $this);
     $this->factory(Context::class, $this->_defaultContextFactory());
 
     if($global && self::$_cubex === null)

src/Routing/ConditionProcessor.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace Cubex\Routing;
+
+use Cubex\Attributes\PreCondition;
+use Cubex\Attributes\SkipCondition;
+use Cubex\Cubex;
+use Cubex\CubexAwareTrait;
+use Packaged\Context\ContextAwareTrait;
+use Packaged\DiContainer\AttributeWatcher;
+use Packaged\DiContainer\ReflectionInterrupt;
+use Packaged\DiContainer\ReflectionObserver;
+
+class ConditionProcessor extends AttributeWatcher implements ReflectionInterrupt, ReflectionObserver
+{
+  use ContextAwareTrait;
+  use CubexAwareTrait;
+
+  public function __construct(Cubex $cubex)
+  {
+    $this->setCubex($cubex);
+    $this->setContext($cubex->getContext());
+    $this->clear();
+  }
+
+  /**
+   * @var \Cubex\Attributes\PreCondition[]
+   */
+  protected array $_conditions = [];
+  protected bool $_processed = false;
+
+  protected mixed $_handled = null;
+
+  protected function _processAttributes()
+  {
+    if($this->_processed)
+    {
+      return;
+    }
+
+    $skipClasses = [];
+    $this->_conditions = [];
+    foreach($this->attributes() as $attribute)
+    {
+      if($attribute->getName() === SkipCondition::class)
+      {
+        $skipClasses[] = $attribute->newInstance()->getClass();
+      }
+      if($attribute->getName() === PreCondition::class)
+      {
+        /** @var \Cubex\Attributes\AbstractConditionAttribute $condition */
+        $condition = $attribute->newInstance();
+        $this->_conditions[$condition->getClass()] = $condition;
+      }
+    }
+
+    foreach($skipClasses as $skipClass)
+    {
+      if(isset($this->_conditions[$skipClass]))
+      {
+        unset($this->_conditions[$skipClass]);
+      }
+    }
+
+    $this->_processed = true;
+  }
+
+  public function shouldInterruptMethod(): bool
+  {
+    $this->_processAttributes();
+    if(empty($this->_conditions))
+    {
+      return false;
+    }
+
+    foreach($this->_conditions as $condition)
+    {
+      $inst = $condition->result($this->getCubex());
+      $res = $inst->process($this->getContext());
+      if($res !== null)
+      {
+        $this->_handled = $res;
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  public function interruptMethod(): mixed
+  {
+    return $this->_handled;
+  }
+}