Implement logical or expression

src/Analyzer/ClassDescriptionBuilder.php

@@ -11,13 +11,13 @@ class ClassDescriptionBuilder
     private $classDependencies = [];
 
     /** @var ?FullyQualifiedClassName */
-    private $FQCN = null;
+    private $FQCN;
 
     /** @var list<FullyQualifiedClassName> */
     private $interfaces = [];
 
     /** @var ?FullyQualifiedClassName */
-    private $extend = null;
+    private $extend;
 
     /** @var bool */
     private $final = false;

src/Analyzer/FileVisitor.php

@@ -72,8 +72,8 @@ public function enterNode(Node $node): void
          *
          * @see FileVisitorTest::test_it_should_return_errors_for_const_outside_namespace
          */
-        if ($node instanceof Node\Expr\ClassConstFetch &&
-            method_exists($node->class, 'toString')
+        if ($node instanceof Node\Expr\ClassConstFetch
+            && method_exists($node->class, 'toString')
         ) {
             if ($this->isSelfOrStaticOrParent($node->class->toString())) {
                 return;
@@ -89,8 +89,8 @@ public function enterNode(Node $node): void
          *
          * @see FileVisitorTest::test_should_returns_all_dependencies
          */
-        if ($node instanceof Node\Expr\StaticCall &&
-            method_exists($node->class, 'toString')
+        if ($node instanceof Node\Expr\StaticCall
+            && method_exists($node->class, 'toString')
         ) {
             if ($this->isSelfOrStaticOrParent($node->class->toString())) {
                 return;
@@ -100,8 +100,8 @@ public function enterNode(Node $node): void
                 ->addDependency(new ClassDependency($node->class->toString(), $node->getLine()));
         }
 
-        if ($node instanceof Node\Expr\Instanceof_ &&
-            method_exists($node->class, 'toString')
+        if ($node instanceof Node\Expr\Instanceof_
+            && method_exists($node->class, 'toString')
         ) {
             if ($this->isSelfOrStaticOrParent($node->class->toString())) {
                 return;
@@ -110,11 +110,11 @@ public function enterNode(Node $node): void
                 ->addDependency(new ClassDependency($node->class->toString(), $node->getLine()));
         }
 
-        if ($node instanceof Node\Expr\New_ &&
-            !($node->class instanceof Node\Expr\Variable)
+        if ($node instanceof Node\Expr\New_
+            && !($node->class instanceof Node\Expr\Variable)
         ) {
-            if ((method_exists($node->class, 'isAnonymous') && $node->class->isAnonymous()) ||
-                !method_exists($node->class, 'toString')) {
+            if ((method_exists($node->class, 'isAnonymous') && $node->class->isAnonymous())
+                || !method_exists($node->class, 'toString')) {
                 return;
             }
 

src/Analyzer/NameResolver.php

@@ -175,7 +175,7 @@ public function enterNode(Node $node)
 
             if ($this->parseCustomAnnotations && !($node->type instanceof FullyQualified)) {
                 foreach ($phpDocNode->getTags() as $tagValue) {
-                    if ('@' === $tagValue->name[0] && false === strpos($tagValue->name, '@var')) {
+                    if ('@' === $tagValue->name[0] && !str_contains($tagValue->name, '@var')) {
                         $customTag = str_replace('@', '', $tagValue->name);
                         $type = $this->resolveName(new Node\Name($customTag), Use_::TYPE_NORMAL);
                         $node->type = $type;
@@ -365,8 +365,6 @@ private function resolveSignature($node): void
      * @psalm-suppress MissingParamType
      * @psalm-suppress PossiblyNullArgument
      * @psalm-suppress MissingReturnType
-     *
-     * @param mixed $node
      */
     private function resolveType($node)
     {

src/Analyzer/PatternString.php

@@ -38,10 +38,10 @@ public function toString(): string
     private function containsWildcard(string $pattern): bool
     {
         return
-            str_contains($pattern, '*') ||
-            str_contains($pattern, '?') ||
-            str_contains($pattern, '.') ||
-            str_contains($pattern, '[');
+            str_contains($pattern, '*')
+            || str_contains($pattern, '?')
+            || str_contains($pattern, '.')
+            || str_contains($pattern, '[');
     }
 
     private function startsWithPattern(string $pattern): bool

src/Expression/Boolean/Orx.php

@@ -0,0 +1,43 @@
+<?php
+declare(strict_types=1);
+
+namespace Arkitect\Expression\Boolean;
+
+use Arkitect\Analyzer\ClassDescription;
+use Arkitect\Expression\Description;
+use Arkitect\Expression\Expression;
+use Arkitect\Rules\Violation;
+use Arkitect\Rules\ViolationMessage;
+use Arkitect\Rules\Violations;
+
+final class Orx implements Expression
+{
+    /** @var Expression[] */
+    private $expressions;
+
+    public function __construct(array $expressions)
+    {
+        $this->expressions = $expressions;
+    }
+
+    public function describe(ClassDescription $theClass, string $because): Description
+    {
+        return new Description('at least one expression must be true', $because);
+    }
+
+    public function evaluate(ClassDescription $theClass, Violations $violations, string $because): void
+    {
+        foreach ($this->expressions as $expression) {
+            $newViolations = new Violations();
+            $expression->evaluate($theClass, $newViolations, $because);
+            if (0 === $newViolations->count()) {
+                return;
+            }
+        }
+
+        $violations->add(Violation::create(
+            $theClass->getFQCN(),
+            ViolationMessage::selfExplanatory($this->describe($theClass, $because))
+        ));
+    }
+}

src/Expression/ForClasses/DependsOnlyOnTheseNamespaces.php

@@ -36,8 +36,8 @@ public function evaluate(ClassDescription $theClass, Violations $violations, str
         /** @var ClassDependency $dependency */
         foreach ($dependencies as $dependency) {
             if (
-                '' === $dependency->getFQCN()->namespace() ||
-                $theClass->namespaceMatches($dependency->getFQCN()->namespace())
+                '' === $dependency->getFQCN()->namespace()
+                || $theClass->namespaceMatches($dependency->getFQCN()->namespace())
             ) {
                 continue;
             }

src/Rules/Violation.php

@@ -15,7 +15,7 @@ class Violation implements \JsonSerializable
     /** @var string */
     private $error;
 
-    public function __construct(string $fqcn, string $error, ?int $line = null)
+    public function __construct(string $fqcn, string $error, int $line = null)
     {
         $this->fqcn = $fqcn;
         $this->error = $error;

tests/E2E/Cli/CheckCommandTest.php

@@ -149,7 +149,7 @@ public function test_you_can_ignore_the_default_baseline(): void
     protected function runCheck(
         $configFilePath = null,
         bool $stopOnFailure = null,
-        ?string $useBaseline = null,
+        string $useBaseline = null,
         $generateBaseline = false,
         bool $skipBaseline = false
     ): ApplicationTester {

tests/Unit/Expressions/Boolean/OrxTest.php

@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace Arkitect\Tests\Unit\Expressions\Boolean;
+
+use Arkitect\Analyzer\ClassDescriptionBuilder;
+use Arkitect\Expression\Boolean\Orx;
+use Arkitect\Expression\ForClasses\Extend;
+use Arkitect\Rules\Violations;
+use PHPUnit\Framework\TestCase;
+
+final class OrxTest extends TestCase
+{
+    public function test_it_should_return_no_violation_on_success(): void
+    {
+        $or = new Orx([new Extend('My\BaseClass'), new Extend('Your\OtherClass')]);
+
+        $classDescription = (new ClassDescriptionBuilder())
+            ->setClassName('My\Class')
+            ->setExtends('My\BaseClass', 10)
+            ->build();
+
+        $violations = new Violations();
+        $or->evaluate($classDescription, $violations, 'because');
+
+        self::assertEquals(0, $violations->count());
+    }
+}

tests/Unit/Expressions/ForClasses/ResideInOneOfTheseNamespacesTest.php

@@ -30,10 +30,6 @@ public function shouldMatchNamespacesProvider(): array
 
     /**
      * @dataProvider shouldMatchNamespacesProvider
-     *
-     * @param mixed $expectedNamespace
-     * @param mixed $actualFQCN
-     * @param mixed $explanation
      */
     public function test_it_should_match_namespace_and_descendants($expectedNamespace, $actualFQCN, $explanation): void
     {