Fix namespace selector matching similar namespaces

src/Selector/ClassNamespace.php

@@ -28,7 +28,7 @@ public function matches(ClassReflection $classReflection): bool
             return $this->matchesRegex($namespace);
         }
 
-        return str_starts_with(\trimSeparators($namespace), \trimSeparators($this->namespace));
+        return str_starts_with(\trimSeparators($namespace).'\\', \trimSeparators($this->namespace).'\\');
     }
 
     private function matchesRegex(string $namespace): bool

tests/fixtures/FixtureClass.php

@@ -60,13 +60,13 @@ public function usingStaticMethod(): void
     }
 
     /**
-     * @param  SimpleClass                                   $p
-     * @param  SimpleClassTwo                                $p2   Parameter with description
-     * @param  \Tests\PHPat\fixtures\Simple\SimpleClassThree $p3
-     * @param  array<SimpleClassFour>                        $p4
-     * @param  SimpleClassFive|SimpleClassSix                $p5_6
-     * @param  InterfaceWithTemplate<ClassImplementing>      $t
-     * @return SimpleInterface                               Some nice description here
+     * @param  SimpleClass                              $p
+     * @param  SimpleClassTwo                           $p2   Parameter with description
+     * @param  SimpleClassThree                         $p3
+     * @param  array<SimpleClassFour>                   $p4
+     * @param  SimpleClassFive|SimpleClassSix           $p5_6
+     * @param  InterfaceWithTemplate<ClassImplementing> $t
+     * @return SimpleInterface                          Some nice description here
      * @throws SimpleException
      */
     public function methodWithDocBlocks($p, $p2, $p3, $p4, $p5_6, $t)

tests/fixtures/Ns/Foo/ClassUnderFooNamespace.php

@@ -0,0 +1,5 @@
+<?php declare(strict_types=1);
+
+namespace Tests\PHPat\fixtures\Ns\Foo;
+
+class ClassUnderFooNamespace {}

tests/fixtures/Ns/FooBar/ClassUnderFooBarNamespace.php

@@ -0,0 +1,5 @@
+<?php declare(strict_types=1);
+
+namespace Tests\PHPat\fixtures\Ns\FooBar;
+
+class ClassUnderFooBarNamespace {}

tests/unit/rules/ShouldBeNamed/ClassnamespaceTest.php

@@ -0,0 +1,49 @@
+<?php declare(strict_types=1);
+
+namespace Tests\PHPat\unit\rules\ShouldBeNamed;
+
+use PHPat\Configuration;
+use PHPat\Rule\Assertion\Declaration\ShouldBeNamed\ClassnameRule;
+use PHPat\Rule\Assertion\Declaration\ShouldBeNamed\ShouldBeNamed;
+use PHPat\Selector\ClassNamespace;
+use PHPat\Statement\Builder\StatementBuilderFactory;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\FileTypeMapper;
+use Tests\PHPat\fixtures\Ns\Foo\ClassUnderFooNamespace;
+use Tests\PHPat\unit\FakeTestParser;
+
+/**
+ * @extends RuleTestCase<ClassnameRule>
+ * @internal
+ * @coversNothing
+ */
+class ClassnamespaceTest extends RuleTestCase
+{
+    public const RULE_NAME = 'test_FixtureClassUnderNamespaceShouldBeNamed';
+
+    public function testRule(): void
+    {
+        // Class under FooBar should not subject to the rule
+        $this->analyse(['tests/fixtures/Ns/FooBar/ClassUnderFooBarNamespace.php'], []);
+    }
+
+    protected function getRule(): Rule
+    {
+        $testParser = FakeTestParser::create(
+            self::RULE_NAME,
+            ShouldBeNamed::class,
+            [new ClassNamespace('Tests\PHPat\fixtures\Ns\Foo', false)],
+            [],
+            [],
+            ['isRegex' => false, 'classname' => ClassUnderFooNamespace::class]
+        );
+
+        return new ClassnameRule(
+            new StatementBuilderFactory($testParser),
+            new Configuration(false, true, false),
+            $this->createReflectionProvider(),
+            self::getContainer()->getByType(FileTypeMapper::class)
+        );
+    }
+}