Applied coding standards

Signed-off-by: Eric Richer [email protected] <[email protected]>
LM-Commons · Aug 20, 2024 · 26f2fd4 · 26f2fd4
1 parent f5a3735
commit 26f2fd4
Show file tree

Hide file tree

Showing 56 changed files with 438 additions and 514 deletions.
diff --git a/src/Assertion/AssertionContainer.php b/src/Assertion/AssertionContainer.php
@@ -26,19 +26,19 @@
 /**
  * Plugin manager to create assertions
  *
- * @author  Aeneas Rekkas
- * @licence MIT
  * @deprecated Use AssertionPluginManager
+ *
+ * @licence MIT
  * @codeCoverageIgnore
  */
 final class AssertionContainer extends AbstractPluginManager implements AssertionContainerInterface
 {
     protected $instanceOf = AssertionInterface::class;
 
     /**
-     * @inheritdoc
+     * @inheritDoc
      */
-    public function get($name, array $options = null): AssertionInterface
+    public function get($name, ?array $options = null): AssertionInterface
     {
         return parent::get($name);
     }

diff --git a/src/Assertion/AssertionContainerFactory.php b/src/Assertion/AssertionContainerFactory.php
@@ -26,9 +26,9 @@
 /**
  * Factory to create a assertion plugin manager
  *
- * @author  Aeneas Rekkas
- * @licence MIT
  * @deprecated Use AssertionPluginManagerFactory
+ *
+ * @licence MIT
  * @codeCoverageIgnore
  */
 class AssertionContainerFactory

diff --git a/src/Assertion/AssertionInterface.php b/src/Assertion/AssertionInterface.php
@@ -27,16 +27,13 @@
 /**
  * Interface that you can implement for dynamic assertions
  *
- * @author  Michaël Gallego <[email protected]>
- * @author  Aeneas Rekkas
- * @author  Daniel Gimenes  <[email protected]>
  * @licence MIT
  */
 interface AssertionInterface
 {
     public function assert(
         PermissionInterface|string $permission,
-        IdentityInterface $identity = null,
+        ?IdentityInterface $identity = null,
         mixed $context = null
     ): bool;
 }
diff --git a/src/Assertion/AssertionPluginManager.php b/src/Assertion/AssertionPluginManager.php
@@ -6,32 +6,31 @@
 
 use Laminas\ServiceManager\AbstractPluginManager;
 use Laminas\ServiceManager\Exception\InvalidServiceException;
+use Psr\Container\ContainerExceptionInterface;
+use Psr\Container\NotFoundExceptionInterface;
+
+use function sprintf;
 
 class AssertionPluginManager extends AbstractPluginManager implements AssertionPluginManagerInterface
 {
-    /**
-     * @param mixed $instance
-     * @return void
-     */
     public function validate(mixed $instance): void
     {
         if ($instance instanceof AssertionInterface) {
             return;
         }
         throw new InvalidServiceException(sprintf(
             'Assertions must implement "Lmc\Rbac\Assertion\AssertionInterface", but "%s" was given',
-            get_class($instance)
+            $instance::class
         ));
     }
 
     /**
-     * @param $name
+     * @param string $name
      * @param array|null $options
-     * @return AssertionInterface
-     * @throws \Psr\Container\ContainerExceptionInterface
-     * @throws \Psr\Container\NotFoundExceptionInterface
+     * @throws ContainerExceptionInterface
+     * @throws NotFoundExceptionInterface
      */
-    public function get($name, array $options = null): AssertionInterface
+    public function get($name, ?array $options = null): AssertionInterface
     {
         return parent::get($name, $options);
     }

diff --git a/src/Assertion/AssertionSet.php b/src/Assertion/AssertionSet.php
@@ -25,32 +25,39 @@
 use Lmc\Rbac\Identity\IdentityInterface;
 use Lmc\Rbac\Permission\PermissionInterface;
 
+use function count;
+use function gettype;
+use function is_array;
+use function is_callable;
+use function is_object;
+use function is_string;
+use function sprintf;
+
 class AssertionSet implements AssertionInterface
 {
     /**
      * Condition constants
      */
-    public const CONDITION_OR = 'condition_or';
+    public const CONDITION_OR  = 'condition_or';
     public const CONDITION_AND = 'condition_and';
 
-    /**
-     * @var array
-     */
+    /** @var array */
     private array $assertions;
 
-    private $condition = self::CONDITION_AND;
+    private string $condition = self::CONDITION_AND;
 
     /**
-     * @param AssertionPluginManagerInterface $assertionPluginManager
      * @param array $assertions
      */
     public function __construct(
         private readonly AssertionPluginManagerInterface $assertionPluginManager,
         array $assertions
     ) {
         if (isset($assertions['condition'])) {
-            if ($assertions['condition'] !== AssertionSet::CONDITION_AND
-                && $assertions['condition'] !== AssertionSet::CONDITION_OR) {
+            if (
+                $assertions['condition'] !== self::CONDITION_AND
+                && $assertions['condition'] !== self::CONDITION_OR
+            ) {
                 throw new Exception\InvalidArgumentException('Invalid assertion condition given.');
             }
 
@@ -62,8 +69,11 @@ public function __construct(
         $this->assertions = $assertions;
     }
 
-    public function assert(PermissionInterface|string $permission, IdentityInterface $identity = null, $context = null): bool
-    {
+    public function assert(
+        PermissionInterface|string $permission,
+        ?IdentityInterface $identity = null,
+        mixed $context = null
+    ): bool {
         if (empty($this->assertions)) {
             return false;
         }
@@ -85,23 +95,23 @@ public function assert(PermissionInterface|string $permission, IdentityInterface
                     break;
                 case is_array($assertion):
                     $this->assertions[$index] = $assertion = new AssertionSet($this->assertionPluginManager, $assertion);
-                    $asserted = $assertion->assert($permission, $identity, $context);
+                    $asserted                 = $assertion->assert($permission, $identity, $context);
                     break;
                 default:
                     throw new Exception\InvalidArgumentException(sprintf(
                         'Assertion must be callable, string, array or implement Lmc\Rbac\Assertion\AssertionInterface, "%s" given',
-                        is_object($assertion) ? get_class($assertion) : gettype($assertion)
+                        is_object($assertion) ? $assertion::class : gettype($assertion)
                     ));
             }
 
             switch ($this->condition) {
-                case AssertionSet::CONDITION_AND:
+                case self::CONDITION_AND:
                     if (false === $asserted) {
                         return false;
                     }
 
                     break;
-                case AssertionSet::CONDITION_OR:
+                case self::CONDITION_OR:
                     if (true === $asserted) {
                         return true;
                     }
@@ -111,7 +121,7 @@ public function assert(PermissionInterface|string $permission, IdentityInterface
             $assertedCount++;
         }
 
-        if (AssertionSet::CONDITION_AND === $this->condition && count($this->assertions) === $assertedCount) {
+        if (self::CONDITION_AND === $this->condition && count($this->assertions) === $assertedCount) {
             return true;
         }
 

diff --git a/src/ConfigProvider.php b/src/ConfigProvider.php
@@ -21,6 +21,22 @@
 
 namespace Lmc\Rbac;
 
+use Laminas\ServiceManager\Factory\InvokableFactory;
+use Lmc\Rbac\Assertion\AssertionPluginManager;
+use Lmc\Rbac\Assertion\AssertionPluginManagerFactory;
+use Lmc\Rbac\Assertion\AssertionPluginManagerInterface;
+use Lmc\Rbac\Options\ModuleOptions;
+use Lmc\Rbac\Options\ModuleOptionsFactory;
+use Lmc\Rbac\Rbac;
+use Lmc\Rbac\Role\InMemoryRoleProvider;
+use Lmc\Rbac\Role\InMemoryRoleProviderFactory;
+use Lmc\Rbac\Role\ObjectRepositoryRoleProvider;
+use Lmc\Rbac\Role\ObjectRepositoryRoleProviderFactory;
+use Lmc\Rbac\Service\AuthorizationServiceFactory;
+use Lmc\Rbac\Service\AuthorizationServiceInterface;
+use Lmc\Rbac\Service\RoleServiceFactory;
+use Lmc\Rbac\Service\RoleServiceInterface;
+
 /**
  * The configuration provider for the LmcRbac module
  *
@@ -32,24 +48,24 @@ public function __invoke(): array
     {
         return [
             'dependencies' => $this->getDependencyConfig(),
-            'lmc_rbac' => $this->getModuleConfig(),
+            'lmc_rbac'     => $this->getModuleConfig(),
         ];
     }
 
     public function getDependencyConfig(): array
     {
         return [
-            'aliases' => [
-                \Lmc\Rbac\Assertion\AssertionPluginManagerInterface::class => \Lmc\Rbac\Assertion\AssertionPluginManager::class,
+            'aliases'   => [
+                AssertionPluginManagerInterface::class => AssertionPluginManager::class,
             ],
             'factories' => [
-                \Lmc\Rbac\Assertion\AssertionPluginManager::class => \Lmc\Rbac\Assertion\AssertionPluginManagerFactory::class,
-                \Lmc\Rbac\Options\ModuleOptions::class => \Lmc\Rbac\Options\ModuleOptionsFactory::class,
-                \Lmc\Rbac\Role\InMemoryRoleProvider::class => \Lmc\Rbac\Role\InMemoryRoleProviderFactory::class,
-                \Lmc\Rbac\Role\ObjectRepositoryRoleProvider::class => \Lmc\Rbac\Role\ObjectRepositoryRoleProviderFactory::class,
-                \Lmc\Rbac\Service\AuthorizationServiceInterface::class => \Lmc\Rbac\Service\AuthorizationServiceFactory::class,
-                \Lmc\Rbac\Service\RoleServiceInterface::class => \Lmc\Rbac\Service\RoleServiceFactory::class,
-                \Lmc\Rbac\Rbac::class => \Laminas\ServiceManager\Factory\InvokableFactory::class,
+                AssertionPluginManager::class        => AssertionPluginManagerFactory::class,
+                ModuleOptions::class                 => ModuleOptionsFactory::class,
+                InMemoryRoleProvider::class          => InMemoryRoleProviderFactory::class,
+                ObjectRepositoryRoleProvider::class  => ObjectRepositoryRoleProviderFactory::class,
+                AuthorizationServiceInterface::class => AuthorizationServiceFactory::class,
+                RoleServiceInterface::class          => RoleServiceFactory::class,
+                Rbac::class                          => InvokableFactory::class,
             ],
         ];
     }

diff --git a/src/Exception/ExceptionInterface.php b/src/Exception/ExceptionInterface.php
@@ -24,8 +24,6 @@
 /**
  * Base exception interface for LmcRbac
  *
- * @author  Michaël Gallego <[email protected]>
- * @licence MIT
  */
 interface ExceptionInterface
 {

diff --git a/src/Exception/InvalidArgumentException.php b/src/Exception/InvalidArgumentException.php
@@ -25,9 +25,6 @@
 
 /**
  * InvalidArgumentException
- *
- * @author  Michaël Gallego <[email protected]>
- * @licence MIT
  */
 class InvalidArgumentException extends BaseInvalidArgumentException implements ExceptionInterface
 {

diff --git a/src/Exception/RoleNotFoundException.php b/src/Exception/RoleNotFoundException.php
@@ -25,14 +25,9 @@
 
 /**
  * Exception that is thrown when a role cannot be found (for instance from a provider)
- *
- * @author  Michaël Gallego <[email protected]>
- * @licence MIT
  */
 class RoleNotFoundException extends BaseRuntimeException implements ExceptionInterface
 {
-    /**
-     * @var string
-     */
+    /** @var string */
     protected $message = 'No role could be found';
 }
diff --git a/src/Exception/RuntimeException.php b/src/Exception/RuntimeException.php
@@ -26,8 +26,6 @@
 /**
  * RuntimeException
  *
- * @author  Michaël Gallego <[email protected]>
- * @licence MIT
  */
 class RuntimeException extends BaseRuntimeException implements ExceptionInterface
 {

diff --git a/src/Identity/IdentityInterface.php b/src/Identity/IdentityInterface.php
@@ -26,8 +26,6 @@
 /**
  * Interface for an identity
  *
- * @author  Michaël Gallego <[email protected]>
- * @licence MIT
  */
 interface IdentityInterface
 {

diff --git a/src/Module.php b/src/Module.php
@@ -29,10 +29,9 @@ final class Module
     public function getConfig(): array
     {
         $provider = new ConfigProvider();
-
         return [
             'service_manager' => $provider->getDependencyConfig(),
-            'lmc_rbac' => $provider->getModuleConfig(),
+            'lmc_rbac'        => $provider->getModuleConfig(),
         ];
     }
 }
diff --git a/src/Options/ModuleOptions.php b/src/Options/ModuleOptions.php
@@ -22,19 +22,16 @@
 namespace Lmc\Rbac\Options;
 
 use Laminas\Stdlib\AbstractOptions;
+use Lmc\Rbac\Role\InMemoryRoleProvider;
 
 /**
  * Options for LmcRbac module
  *
- * @author  Michaël Gallego <[email protected]>
- * @licence MIT
  */
 class ModuleOptions extends AbstractOptions
 {
     /**
      * Guest role (used when no identity is found)
-     *
-     * @var string
      */
     protected string $guestRole = 'guest';
 
@@ -52,7 +49,7 @@ class ModuleOptions extends AbstractOptions
      * @var array
      */
     protected array $roleProvider = [
-        'Lmc\Rbac\Role\InMemoryRoleProvider' => [],
+        InMemoryRoleProvider::class => [],
     ];
 
     /**
@@ -71,7 +68,6 @@ public function __construct($options = null)
      * Set the assertions options
      *
      * @param array $assertionMap
-     * @return void
      */
     public function setAssertionMap(array $assertionMap): void
     {
@@ -90,9 +86,6 @@ public function getAssertionMap(): array
 
     /**
      * Set the guest role (used when no identity is found)
-     *
-     * @param string $guestRole
-     * @return void
      */
     public function setGuestRole(string $guestRole): void
     {
@@ -101,8 +94,6 @@ public function setGuestRole(string $guestRole): void
 
     /**
      * Get the guest role (used when no identity is found)
-     *
-     * @return string
      */
     public function getGuestRole(): string
     {

diff --git a/src/Options/ModuleOptionsFactory.php b/src/Options/ModuleOptionsFactory.php
@@ -21,14 +21,10 @@
 
 namespace Lmc\Rbac\Options;
 
-use Lmc\Rbac\Options\ModuleOptions;
 use Psr\Container\ContainerInterface;
 
 /**
  * Factory for the module options
- *
- * @author  Michaël Gallego <[email protected]>
- * @licence MIT
  */
 class ModuleOptionsFactory
 {