Fix duplicate violations when reusing that() for multiple should() calls

This fixes issue #303 where reusing the result of that() for multiple
should() calls would cause duplicate violations due to shared mutable
state in the RuleBuilder.

The fix makes should() and andThat() clone the RuleBuilder before
adding constraints/specs, ensuring each rule branch gets an isolated
copy of the builder state.

Added RuleBuilder::__clone() to deep clone Specs and Constraints objects.

Author: claude

src/Rules/AndThatShould.php

@@ -19,15 +19,17 @@ public function __construct(RuleBuilder $expressionBuilder)
 
     public function andThat(Expression $expression): AndThatShouldParser
     {
-        $this->ruleBuilder->addThat($expression);
+        $ruleBuilder = clone $this->ruleBuilder;
+        $ruleBuilder->addThat($expression);
 
-        return $this;
+        return new self($ruleBuilder);
     }
 
     public function should(Expression $expression): BecauseParser
     {
-        $this->ruleBuilder->addShould($expression);
+        $ruleBuilder = clone $this->ruleBuilder;
+        $ruleBuilder->addShould($expression);
 
-        return new Because($this->ruleBuilder);
+        return new Because($ruleBuilder);
     }
 }

src/Rules/RuleBuilder.php

@@ -75,4 +75,10 @@ public function setRunOnlyThis(): self
 
         return $this;
     }
+
+    public function __clone()
+    {
+        $this->thats = clone $this->thats;
+        $this->shoulds = clone $this->shoulds;
+    }
 }

tests/Unit/Rules/RuleBuilderTest.php

@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Arkitect\Tests\Unit\Rules;
+
+use Arkitect\Analyzer\ClassDescription;
+use Arkitect\Expression\ForClasses\Extend;
+use Arkitect\Expression\ForClasses\HaveNameMatching;
+use Arkitect\Expression\ForClasses\ResideInOneOfTheseNamespaces;
+use Arkitect\Rules\Rule;
+use Arkitect\Rules\Violations;
+use PHPUnit\Framework\TestCase;
+
+class RuleBuilderTest extends TestCase
+{
+    /**
+     * @see https://github.com/phparkitect/arkitect/issues/303
+     */
+    public function test_reusing_that_for_multiple_should_does_not_produce_duplicate_violations(): void
+    {
+        // Create a class that violates both rules
+        $classDescription = ClassDescription::getBuilder('App\Rector\MyClass', 'src/Rector/MyClass.php')
+            ->build();
+
+        // Reuse the that() result for multiple should() calls - this is the pattern from issue #303
+        $rectors = Rule::allClasses()
+            ->that(new ResideInOneOfTheseNamespaces('App\Rector'));
+
+        $rule1 = $rectors
+            ->should(new HaveNameMatching('*Rector'))
+            ->because('rector classes should have Rector suffix');
+
+        $rule2 = $rectors
+            ->should(new Extend('Rector\Core\Rector\AbstractRector'))
+            ->because('rector classes should extend AbstractRector');
+
+        // Check violations for rule1 - should only check HaveNameMatching
+        $violations1 = new Violations();
+        $rule1->check($classDescription, $violations1);
+
+        // Check violations for rule2 - should only check Extend
+        $violations2 = new Violations();
+        $rule2->check($classDescription, $violations2);
+
+        // Each rule should produce exactly 1 violation, not 2
+        // rule1 should only report the name matching violation
+        // rule2 should only report the extend violation
+        self::assertCount(1, $violations1, 'Rule 1 should have exactly 1 violation (name matching)');
+        self::assertCount(1, $violations2, 'Rule 2 should have exactly 1 violation (extend)');
+
+        // Verify the violation messages are for the correct constraints
+        self::assertStringContainsString(
+            'should have a name that matches',
+            $violations1->get(0)->getError(),
+            'Rule 1 violation should be about name matching'
+        );
+        self::assertStringContainsString(
+            'should extend',
+            $violations2->get(0)->getError(),
+            'Rule 2 violation should be about extending'
+        );
+    }
+
+    /**
+     * @see https://github.com/phparkitect/arkitect/issues/303
+     */
+    public function test_reusing_that_for_multiple_and_that_does_not_share_state(): void
+    {
+        // Create a class that matches the base namespace
+        $classDescription = ClassDescription::getBuilder('App\Service\MyService', 'src/Service/MyService.php')
+            ->setFinal(true)
+            ->build();
+
+        // Reuse the that() result for multiple andThat() calls
+        $services = Rule::allClasses()
+            ->that(new ResideInOneOfTheseNamespaces('App\Service'));
+
+        $rule1 = $services
+            ->andThat(new ResideInOneOfTheseNamespaces('App\Service\Internal'))
+            ->should(new HaveNameMatching('*Service'))
+            ->because('internal services should have Service suffix');
+
+        $rule2 = $services
+            ->andThat(new ResideInOneOfTheseNamespaces('App\Service\External'))
+            ->should(new HaveNameMatching('*Client'))
+            ->because('external services should have Client suffix');
+
+        // The class is in App\Service but not in App\Service\Internal or App\Service\External
+        // So neither rule should match and produce violations
+        $violations1 = new Violations();
+        $rule1->check($classDescription, $violations1);
+
+        $violations2 = new Violations();
+        $rule2->check($classDescription, $violations2);
+
+        // Neither rule should produce violations because the class doesn't match andThat conditions
+        self::assertCount(0, $violations1, 'Rule 1 should have no violations (class not in Internal namespace)');
+        self::assertCount(0, $violations2, 'Rule 2 should have no violations (class not in External namespace)');
+    }
+}