NameProcessor: only inject nickname from primary NAME, anchor on last given name

Two correctness fixes for the nickname-injection feature:

getNickname() previously returned the first NICK across ALL NAME facts,
including `_MARNM` and other type-tagged variants. A nickname tied to
the married identity does not belong on the primary-identity name that
getFullName() returns. Skip non-primary NAME facts (TYPE != BIRTH/empty).

injectNickname() previously located the surname via strrpos and inserted
the quoted nickname before it. For trees that store surname particles
(`von`, `de la`, `van der`) outside the GEDCOM /SURN/ slashes, the
SURN attribute is just the family name (e.g. "Berg") and the particle
sits in the given-name area. The old algorithm produced
`Friedrich von "Fritz" Berg` — the nickname split the particle off
its surname. Anchor on the position after the last given name instead,
which keeps particles intact: `Friedrich von "Fritz" Berg` becomes
`Friedrich von "Fritz" Berg` if particles are inside the slashes
(SURN = "von Berg", firstNames = ["Friedrich"]) or
`Friedrich von "Fritz" Berg` if they sit outside (SURN = "Berg",
firstNames = ["Friedrich", "von"]). Tests cover both conventions
plus repeated given names, no given names, and idempotent re-injection.

Also fix .gitattributes: `/test/` was a typo for `/tests/`, so the
test suite was being shipped in composer --prefer-dist tarballs. Add
the rest of the dev-only paths (Make/, Makefile, AGENTS.md, compose.yaml,
.build/) for a leaner package.

Author: magicsunday

.gitattributes

@@ -8,4 +8,9 @@
 /phpstan-baseline.neon export-ignore
 /phpunit.xml           export-ignore
 /rector.php            export-ignore
-/test/                 export-ignore
+/tests/                export-ignore
+/Make/                 export-ignore
+/Makefile              export-ignore
+/AGENTS.md             export-ignore
+/compose.yaml          export-ignore
+/.build/               export-ignore

src/Processor/NameProcessor.php

@@ -183,15 +183,25 @@ public function getFullName(): string
     }
 
     /**
-     * Returns the GEDCOM `2 NICK` value of the individual's primary NAME fact, or
-     * an empty string when no nickname is set. The lookup walks all NAME facts and
-     * returns the first NICK it finds.
+     * Returns the GEDCOM `2 NICK` value of the individual's *primary* NAME fact, or
+     * an empty string when no nickname is set there. NAME facts whose `2 TYPE` is
+     * something other than the primary identity (e.g. `_MARNM`, `aka`) are skipped:
+     * a nickname attached to the married name belongs to the married identity, not
+     * the birth identity that `getFullName()` returns by default.
      *
      * @return string
      */
     public function getNickname(): string
     {
         foreach ($this->individual->facts(['NAME']) as $nameFact) {
+            $type = $nameFact->attribute('TYPE');
+
+            // Skip non-primary NAME variants (married name, also-known-as, etc.)
+            // so the nickname injection sticks to the birth-identity name.
+            if ($type !== '' && strtoupper($type) !== 'BIRTH') {
+                continue;
+            }
+
             $nick = $nameFact->attribute('NICK');
 
             if ($nick !== '') {
@@ -223,40 +233,50 @@ public function getFullNameWithNickname(): string
 
         return $this->injectNickname(
             $this->getFullName(),
-            implode(' ', $this->getLastNames()),
+            $this->getFirstNames(),
             $nick
         );
     }
 
     /**
-     * Inserts the quoted nickname before the surname in a flat name string.
+     * Inserts the quoted nickname after the last given name in a flat name string,
+     * which lands it before whatever comes next (a surname particle like `von`
+     * followed by the surname, the surname itself, a married-name suffix, etc.).
      * Idempotent: if the nickname is already present in quotes, the input is
      * returned unchanged.
      *
-     * @param string $fullName Plain full name (e.g. "Martin White")
-     * @param string $surname  Surname tokens joined by spaces (e.g. "White" or "Van Der Berg")
-     * @param string $nick     Nickname without quotes (e.g. "Chalky")
+     * Anchoring on the last given name (rather than the first surname token) keeps
+     * particles like `von`, `de la`, `van der` -- which webtrees renders inside
+     * the given-name area when they sit outside `/SURN/` slashes -- attached to the
+     * surname they belong to instead of letting the nickname split them off.
+     *
+     * @param string   $fullName   Plain full name (e.g. "Martin White")
+     * @param string[] $firstNames Given-name tokens as returned by getFirstNames()
+     * @param string   $nick       Nickname without quotes (e.g. "Chalky")
      *
      * @return string
      */
-    private function injectNickname(string $fullName, string $surname, string $nick): string
+    private function injectNickname(string $fullName, array $firstNames, string $nick): string
     {
         if ($nick === '' || str_contains($fullName, '"' . $nick . '"')) {
             return $fullName;
         }
 
-        $position = ($surname !== '') ? strrpos($fullName, $surname) : false;
+        $lastGivenName = end($firstNames);
 
-        if ($position !== false) {
-            return substr_replace(
-                $fullName,
-                '"' . $nick . '" ' . $surname,
-                $position,
-                strlen($surname)
-            );
+        if ($lastGivenName === false || $lastGivenName === '') {
+            return $fullName . ' "' . $nick . '"';
         }
 
-        return $fullName . ' "' . $nick . '"';
+        $position = strrpos($fullName, $lastGivenName);
+
+        if ($position === false) {
+            return $fullName . ' "' . $nick . '"';
+        }
+
+        $insertAt = $position + strlen($lastGivenName);
+
+        return substr_replace($fullName, ' "' . $nick . '"', $insertAt, 0);
     }
 
     /**

tests/NameProcessorTest.php

@@ -386,46 +386,57 @@ public function getMarriedSurnamesReturnsEmptyWhenSpouseSurnameDoesNotMatchAnyMa
     }
 
     /**
-     * @return array<string, array{string, string, string, string}>
+     * @return array<string, array{string, list<string>, string, string}>
      */
     public static function injectNicknameDataProvider(): array
     {
-        // [ fullName, surname, nick, expected ]
+        // [ fullName, firstNames, nick, expected ]
         return [
             'Empty nick returns input unchanged' => [
-                'Martin White', 'White', '', 'Martin White',
+                'Martin White', ['Martin'], '', 'Martin White',
             ],
-            'Inserts before single-word surname' => [
-                'Martin White', 'White', 'Chalky', 'Martin "Chalky" White',
+            'Inserts after last given name (single-word surname)' => [
+                'Martin White', ['Martin'], 'Chalky', 'Martin "Chalky" White',
             ],
-            'Inserts before multi-word surname' => [
-                'Hans Van Der Berg', 'Van Der Berg', 'Hänschen', 'Hans "Hänschen" Van Der Berg',
+            'Multiple given names: inserts after the last one' => [
+                'Friedrich Wilhelm August von Habsburg-Lothringen',
+                ['Friedrich', 'Wilhelm', 'August'],
+                'Fritz',
+                'Friedrich Wilhelm August "Fritz" von Habsburg-Lothringen',
             ],
-            'Idempotent: nick already inline' => [
-                'Martin "Chalky" White', 'White', 'Chalky', 'Martin "Chalky" White',
+            'Surname particle in given-name area: nickname stays before particle+surname' => [
+                'Friedrich von Berg',
+                ['Friedrich', 'von'],
+                'Fritz',
+                'Friedrich von "Fritz" Berg',
             ],
-            'No surname found: appends nick' => [
-                'Anonymous', 'White', 'Chalky', 'Anonymous "Chalky"',
+            'Idempotent: nick already inline' => [
+                'Martin "Chalky" White', ['Martin'], 'Chalky', 'Martin "Chalky" White',
             ],
-            'Empty surname: appends nick' => [
-                'Anonymous', '', 'Chalky', 'Anonymous "Chalky"',
+            'No given names: appends nick' => [
+                'Anonymous', [], 'Chalky', 'Anonymous "Chalky"',
             ],
-            'Hits last occurrence when surname is also a given name' => [
-                'White Robert White', 'White', 'Bob', 'White Robert "Bob" White',
+            'Hits last occurrence when given name repeats' => [
+                'Maria Anna Maria Schmidt',
+                ['Maria', 'Anna', 'Maria'],
+                'Mimi',
+                'Maria Anna Maria "Mimi" Schmidt',
             ],
         ];
     }
 
     /**
+     * @param list<string> $firstNames
+     *
      * @throws ReflectionException
      */
     #[Test]
     #[DataProvider('injectNicknameDataProvider')]
-    public function injectNickname(string $fullName, string $surname, string $nick, string $expected): void
+    public function injectNickname(string $fullName, array $firstNames, string $nick, string $expected): void
     {
         $processorStub    = self::createStub(NameProcessor::class);
         $reflectionMethod = (new ReflectionClass(NameProcessor::class))->getMethod('injectNickname');
-        $result           = $reflectionMethod->invoke($processorStub, $fullName, $surname, $nick);
+        $result           = $reflectionMethod->invoke($processorStub, $fullName, $firstNames, $nick);
 
         self::assertSame($expected, $result);
     }