Create a And expression

This will allow for complex nested expressions, like ANDs inside ORs.

src/Expression/Boolean/Andx.php

@@ -0,0 +1,55 @@
+<?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 Andx implements Expression
+{
+    /** @var Expression[] */
+    private $expressions;
+
+    public function __construct(Expression ...$expressions)
+    {
+        $this->expressions = $expressions;
+    }
+
+    public function describe(ClassDescription $theClass, string $because): Description
+    {
+        $expressionsDescriptions = [];
+        foreach ($this->expressions as $expression) {
+            $expressionsDescriptions[] = $expression->describe($theClass, '')->toString();
+        }
+        return new Description(
+            'all expressions must be true (' . implode(', ', $expressionsDescriptions) . ')',
+            $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()) {
+                $violations->add(Violation::create(
+                    $theClass->getFQCN(),
+                    ViolationMessage::withDescription(
+                        $this->describe($theClass, $because),
+                        "The class '" . $theClass->getFQCN() . "' violated the expression "
+                        . $expression->describe($theClass, '')->toString()
+                    )
+                ));
+
+                return;
+            }
+        }
+    }
+}

tests/Unit/Expressions/Boolean/AndxTest.php

@@ -0,0 +1,105 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Arkitect\Tests\Unit\Expressions\Boolean;
+
+use Arkitect\Analyzer\ClassDescription;
+use Arkitect\Analyzer\FullyQualifiedClassName;
+use Arkitect\Expression\Boolean\Andx;
+use Arkitect\Expression\ForClasses\Extend;
+use Arkitect\Expression\ForClasses\Implement;
+use Arkitect\Rules\Violations;
+use PHPUnit\Framework\TestCase;
+
+class AndxTest extends TestCase
+{
+    public function test_it_should_pass_the_rule(): void
+    {
+        $interface = 'interface';
+        $class = 'SomeClass';
+        $classDescription = new ClassDescription(
+            FullyQualifiedClassName::fromString('HappyIsland'),
+            [],
+            [FullyQualifiedClassName::fromString($interface)],
+            FullyQualifiedClassName::fromString($class),
+            false,
+            false,
+            false,
+            false,
+            false
+        );
+        $implementConstraint = new Implement($interface);
+        $extendsConstraint = new Extend($class);
+        $andConstraint = new Andx($implementConstraint, $extendsConstraint);
+
+        $because = 'reasons';
+        $violations = new Violations();
+        $andConstraint->evaluate($classDescription, $violations, $because);
+
+        self::assertEquals(0, $violations->count());
+    }
+
+    public function test_it_should_pass_the_rule_when_and_is_empty(): void
+    {
+        $interface = 'interface';
+        $class = 'SomeClass';
+        $classDescription = new ClassDescription(
+            FullyQualifiedClassName::fromString('HappyIsland'),
+            [],
+            [FullyQualifiedClassName::fromString($interface)],
+            FullyQualifiedClassName::fromString($class),
+            false,
+            false,
+            false,
+            false,
+            false
+        );
+        $andConstraint = new Andx();
+
+        $because = 'reasons';
+        $violations = new Violations();
+        $andConstraint->evaluate($classDescription, $violations, $because);
+
+        self::assertEquals(0, $violations->count());
+    }
+
+    public function test_it_should_not_pass_the_rule(): void
+    {
+        $interface = 'SomeInterface';
+        $class = 'SomeClass';
+
+        $classDescription = new ClassDescription(
+            FullyQualifiedClassName::fromString('HappyIsland'),
+            [],
+            [FullyQualifiedClassName::fromString($interface)],
+            null,
+            false,
+            false,
+            false,
+            false,
+            false
+        );
+
+        $implementConstraint = new Implement($interface);
+        $extendsConstraint = new Extend($class);
+        $andConstraint = new Andx($implementConstraint, $extendsConstraint);
+
+        $because = 'reasons';
+        $violationError = $andConstraint->describe($classDescription, $because)->toString();
+
+        $violations = new Violations();
+        $andConstraint->evaluate($classDescription, $violations, $because);
+        self::assertNotEquals(0, $violations->count());
+
+        $this->assertEquals(
+            'all expressions must be true (should implement SomeInterface, should extend SomeClass) because reasons',
+            $violationError
+        );
+        $this->assertEquals(
+            "The class 'HappyIsland' violated the expression should extend SomeClass, but "
+            . "all expressions must be true (should implement SomeInterface, should extend SomeClass) because reasons",
+            $violations->get(0)->getError()
+        );
+    }
+}