refactor: rename branch to pathFromRoot and createLeaf() to withLeaf() in Ltree and LtreeInterface, update related methods and tests

landure · landure · commit 1acf3eaf1e88 · 2025-08-14T14:35:48.000+02:00
diff --git a/docs/LTREE-TYPE.md b/docs/LTREE-TYPE.md
@@ -122,15 +122,15 @@ class MyEntity implements \Stringable
             throw new \InvalidArgumentException("Parent MyEntity can't be self");
         }
 
-        if (in_array($this->getId()->toBase58(), $parent->getPath()->getBranch(), true)) {
+        if (in_array($this->getId()->toBase58(), $parent->getPath()->getPathFromRoot(), true)) {
             throw new \InvalidArgumentException("Parent MyEntity can't be a child of the current MyEntity");
         }
 
         $this->parent = $parent;
 
-        // Use createLeaf() to create a new Ltree instance
+        // Use withLeaf() to create a new Ltree instance
         // with the parent's path and the current entity's ID.
-        $this->path = $parent->getPath()->createLeaf($this->id->toBase58());
+        $this->path = $parent->getPath()->withLeaf($this->id->toBase58());
     }
 }
 ```
diff --git a/src/MartinGeorgiev/Doctrine/DBAL/Types/ValueObject/Ltree.php b/src/MartinGeorgiev/Doctrine/DBAL/Types/ValueObject/Ltree.php
@@ -10,20 +10,20 @@
 class Ltree implements LtreeInterface
 {
     /**
-     * @param list<non-empty-string> $branch
+     * @param list<non-empty-string> $pathFromRoot
      *
-     * @throws \InvalidArgumentException if the branch contains empty strings or is not a list
+     * @throws \InvalidArgumentException if the pathFromRoot contains empty strings or is not a list
      */
     public function __construct(
-        private readonly array $branch,
+        private readonly array $pathFromRoot,
     ) {
-        self::assertListOfNonEmptyStrings($branch);
+        self::assertListOfNonEmptyStrings($pathFromRoot);
     }
 
     #[\Override]
     public function __toString(): string
     {
-        return \implode('.', $this->branch);
+        return \implode('.', $this->pathFromRoot);
     }
 
     #[\Override]
@@ -33,19 +33,19 @@ public static function fromString(string $ltree): static
             return new static([]);
         }
 
-        $branch = \explode('.', $ltree);
+        $pathFromRoot = \explode('.', $ltree);
 
-        return new static($branch); // @phpstan-ignore-line argument.type
+        return new static($pathFromRoot); // @phpstan-ignore-line argument.type
     }
 
     #[\Override]
     public function jsonSerialize(): array
     {
-        return $this->branch;
+        return $this->pathFromRoot;
     }
 
     #[\Override]
-    public function createLeaf(string $leaf): static
+    public function withLeaf(string $leaf): static
     {
         if ('' === $leaf) {
             throw new \InvalidArgumentException('Leaf cannot be empty.');
@@ -55,49 +55,49 @@ public function createLeaf(string $leaf): static
             throw new \InvalidArgumentException('Leaf cannot contain dot.');
         }
 
-        $newBranch = [...$this->branch, $leaf];
+        $newBranch = [...$this->pathFromRoot, $leaf];
 
         return new static($newBranch);
     }
 
     #[\Override]
-    public function getBranch(): array
+    public function getPathFromRoot(): array
     {
-        return $this->branch;
+        return $this->pathFromRoot;
     }
 
     #[\Override]
     public function equals(LtreeInterface $ltree): bool
     {
-        return $this->branch === $ltree->getBranch();
+        return $this->pathFromRoot === $ltree->getPathFromRoot();
     }
 
     #[\Override]
     public function isAncestorOf(LtreeInterface $ltree): bool
     {
-        return [] === $this->branch || \str_starts_with((string) $ltree, \sprintf('%s.', (string) $this));
+        return [] === $this->pathFromRoot || \str_starts_with((string) $ltree, \sprintf('%s.', (string) $this));
     }
 
     #[\Override]
-    public function isDescendantOf(LtreeInterface $ltree): bool
+    public function isLeafOf(LtreeInterface $ltree): bool
     {
         return \str_starts_with((string) $this, \sprintf('%s.', (string) $ltree));
     }
 
     #[\Override]
     public function isRoot(): bool
     {
-        return 1 >= \count($this->branch);
+        return 1 >= \count($this->pathFromRoot);
     }
 
     #[\Override]
     public function getParent(): static
     {
-        if ([] === $this->branch) {
+        if ([] === $this->pathFromRoot) {
             throw new \LogicException('Empty ltree has no parent.');
         }
 
-        $parentBranch = \array_slice($this->branch, 0, -1);
+        $parentBranch = \array_slice($this->pathFromRoot, 0, -1);
         self::assertListOfNonEmptyStrings($parentBranch);
 
         return new static($parentBranch);
diff --git a/src/MartinGeorgiev/Doctrine/DBAL/Types/ValueObject/LtreeInterface.php b/src/MartinGeorgiev/Doctrine/DBAL/Types/ValueObject/LtreeInterface.php
@@ -7,11 +7,11 @@
 interface LtreeInterface extends \Stringable, \JsonSerializable
 {
     /**
-     * @param list<non-empty-string> $branch
+     * @param list<non-empty-string> $pathFromRoot
      *
-     * @throws \InvalidArgumentException if the branch is empty
+     * @throws \InvalidArgumentException if the pathFromRoot is empty
      */
-    public function __construct(array $branch);
+    public function __construct(array $pathFromRoot);
 
     /**
      * @throws \InvalidArgumentException if the ltree is empty
@@ -29,18 +29,18 @@ public function jsonSerialize(): array;
      *
      * @throws \InvalidArgumentException if the leaf is empty or contains dot
      */
-    public function createLeaf(string $leaf): static;
+    public function withLeaf(string $leaf): static;
 
     /**
      * @return list<non-empty-string>
      */
-    public function getBranch(): array;
+    public function getPathFromRoot(): array;
 
     public function equals(LtreeInterface $ltree): bool;
 
     public function isAncestorOf(LtreeInterface $ltree): bool;
 
-    public function isDescendantOf(LtreeInterface $ltree): bool;
+    public function isLeafOf(LtreeInterface $ltree): bool;
 
     public function isRoot(): bool;
 
diff --git a/tests/Unit/MartinGeorgiev/Doctrine/DBAL/Types/ValueObject/LtreeTest.php b/tests/Unit/MartinGeorgiev/Doctrine/DBAL/Types/ValueObject/LtreeTest.php
@@ -21,7 +21,7 @@ public function test_construct_trows_on_non_list(): void
         new Ltree([0 => 'a', 2 => 'b', 3 => 'c']); // @phpstan-ignore argument.type
     }
 
-    public function test_construct_trows_on_empty_string_in_branch(): void
+    public function test_construct_trows_on_empty_string_in_path_from_root(): void
     {
         $this->expectException(\InvalidArgumentException::class);
         new Ltree(['a', '', 'c']); // @phpstan-ignore argument.type
@@ -30,22 +30,22 @@ public function test_construct_trows_on_empty_string_in_branch(): void
     public function test_from_string(): void
     {
         $ltree = Ltree::fromString('x.y.z');
-        self::assertSame(['x', 'y', 'z'], $ltree->getBranch());
+        self::assertSame(['x', 'y', 'z'], $ltree->getPathFromRoot());
         self::assertSame('x.y.z', (string) $ltree);
     }
 
     public function test_from_string_empty(): void
     {
         $ltree = Ltree::fromString('');
-        self::assertSame([], $ltree->getBranch());
+        self::assertSame([], $ltree->getPathFromRoot());
         self::assertSame('', (string) $ltree);
     }
 
     public function test_json_serialize(): void
     {
-        $branch = ['a', 'b', 'c'];
-        $ltree = new Ltree($branch);
-        self::assertSame($branch, $ltree->jsonSerialize());
+        $pathFromRoot = ['a', 'b', 'c'];
+        $ltree = new Ltree($pathFromRoot);
+        self::assertSame($pathFromRoot, $ltree->jsonSerialize());
     }
 
     public function test_json_encode(): void
@@ -55,11 +55,11 @@ public function test_json_encode(): void
         self::assertSame('["a","b","c"]', $json);
     }
 
-    public function test_create_leaf(): void
+    public function test_with_leaf(): void
     {
         $ltree = new Ltree(['root']);
-        $newLtree = $ltree->createLeaf('leaf');
-        self::assertSame(['root', 'leaf'], $newLtree->getBranch());
+        $newLtree = $ltree->withLeaf('leaf');
+        self::assertSame(['root', 'leaf'], $newLtree->getPathFromRoot());
         self::assertSame('root.leaf', (string) $newLtree);
     }
 
@@ -75,17 +75,17 @@ public function test_equals(): void
     public function test_is_ancestor_of(): void
     {
         $ancestor = new Ltree(['a', 'b']);
-        $descendant = new Ltree(['a', 'b', 'c']);
-        self::assertTrue($ancestor->isAncestorOf($descendant));
-        self::assertFalse($descendant->isAncestorOf($ancestor));
+        $leaf = new Ltree(['a', 'b', 'c']);
+        self::assertTrue($ancestor->isAncestorOf($leaf));
+        self::assertFalse($leaf->isAncestorOf($ancestor));
     }
 
-    public function test_is_descendant_of(): void
+    public function test_is_leaf_of(): void
     {
         $ancestor = new Ltree(['a', 'b']);
-        $descendant = new Ltree(['a', 'b', 'c']);
-        self::assertTrue($descendant->isDescendantOf($ancestor));
-        self::assertFalse($ancestor->isDescendantOf($descendant));
+        $leaf = new Ltree(['a', 'b', 'c']);
+        self::assertTrue($leaf->isLeafOf($ancestor));
+        self::assertFalse($ancestor->isLeafOf($leaf));
     }
 
     public function test_is_root(): void
@@ -102,7 +102,7 @@ public function test_get_parent(): void
     {
         $ltree = new Ltree(['a', 'b', 'c']);
         $parent = $ltree->getParent();
-        self::assertSame(['a', 'b'], $parent->getBranch());
+        self::assertSame(['a', 'b'], $parent->getPathFromRoot());
         self::assertSame('a.b', (string) $parent);
     }
 
@@ -111,15 +111,15 @@ public function test_get_parent_respect_immutability(): void
         $ltree = new Ltree(['a', 'b', 'c']);
         $parent = $ltree->getParent();
         self::assertNotSame($ltree, $parent);
-        self::assertSame(['a', 'b', 'c'], $ltree->getBranch());
+        self::assertSame(['a', 'b', 'c'], $ltree->getPathFromRoot());
         self::assertSame('a.b.c', (string) $ltree);
     }
 
     public function test_get_parent_on_root(): void
     {
         $ltree = new Ltree(['a']);
         $parent = $ltree->getParent();
-        self::assertSame([], $parent->getBranch());
+        self::assertSame([], $parent->getPathFromRoot());
     }
 
     public function test_get_parent_throws_on_empty(): void
@@ -128,17 +128,17 @@ public function test_get_parent_throws_on_empty(): void
         (new Ltree([]))->getParent();
     }
 
-    public function test_create_leaf_empty_throws(): void
+    public function test_with_leaf_empty_throws(): void
     {
         $ltree = new Ltree(['a']);
         $this->expectException(\InvalidArgumentException::class);
-        $ltree->createLeaf(''); // @phpstan-ignore argument.type
+        $ltree->withLeaf(''); // @phpstan-ignore argument.type
     }
 
-    public function test_create_leaf_with_dot_throws(): void
+    public function test_with_leaf_with_dot_throws(): void
     {
         $ltree = new Ltree(['a']);
         $this->expectException(\InvalidArgumentException::class);
-        $ltree->createLeaf('foo.bar');
+        $ltree->withLeaf('foo.bar');
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -122,15 +122,15 @@ class MyEntity implements \Stringable`
`122`	`122`	`throw new \InvalidArgumentException("Parent MyEntity can't be self");`
`123`	`123`	`}`
`124`	`124`
`125`		`- if (in_array($this->getId()->toBase58(), $parent->getPath()->getBranch(), true)) {`
	`125`	`+ if (in_array($this->getId()->toBase58(), $parent->getPath()->getPathFromRoot(), true)) {`
`126`	`126`	`throw new \InvalidArgumentException("Parent MyEntity can't be a child of the current MyEntity");`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`$this->parent = $parent;`
`130`	`130`
`131`		`- // Use createLeaf() to create a new Ltree instance`
	`131`	`+ // Use withLeaf() to create a new Ltree instance`
`132`	`132`	`// with the parent's path and the current entity's ID.`
`133`		`- $this->path = $parent->getPath()->createLeaf($this->id->toBase58());`
	`133`	`+ $this->path = $parent->getPath()->withLeaf($this->id->toBase58());`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`	```
Original file line number	Diff line number	Diff line change
`@@ -10,20 +10,20 @@`
`10`	`10`	`class Ltree implements LtreeInterface`
`11`	`11`	`{`
`12`	`12`	`/**`
`13`		`- * @param list<non-empty-string> $branch`
	`13`	`+ * @param list<non-empty-string> $pathFromRoot`
`14`	`14`	`*`
`15`		`- * @throws \InvalidArgumentException if the branch contains empty strings or is not a list`
	`15`	`+ * @throws \InvalidArgumentException if the pathFromRoot contains empty strings or is not a list`
`16`	`16`	`*/`
`17`	`17`	`public function __construct(`
`18`		`- private readonly array $branch,`
	`18`	`+ private readonly array $pathFromRoot,`
`19`	`19`	`) {`
`20`		`- self::assertListOfNonEmptyStrings($branch);`
	`20`	`+ self::assertListOfNonEmptyStrings($pathFromRoot);`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`#[\Override]`
`24`	`24`	`public function __toString(): string`
`25`	`25`	`{`
`26`		`- return \implode('.', $this->branch);`
	`26`	`+ return \implode('.', $this->pathFromRoot);`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`#[\Override]`
`@@ -33,19 +33,19 @@ public static function fromString(string $ltree): static`
`33`	`33`	`return new static([]);`
`34`	`34`	`}`
`35`	`35`
`36`		`- $branch = \explode('.', $ltree);`
	`36`	`+ $pathFromRoot = \explode('.', $ltree);`
`37`	`37`
`38`		`- return new static($branch); // @phpstan-ignore-line argument.type`
	`38`	`+ return new static($pathFromRoot); // @phpstan-ignore-line argument.type`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`#[\Override]`
`42`	`42`	`public function jsonSerialize(): array`
`43`	`43`	`{`
`44`		`- return $this->branch;`
	`44`	`+ return $this->pathFromRoot;`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`#[\Override]`
`48`		`- public function createLeaf(string $leaf): static`
	`48`	`+ public function withLeaf(string $leaf): static`
`49`	`49`	`{`
`50`	`50`	`if ('' === $leaf) {`
`51`	`51`	`throw new \InvalidArgumentException('Leaf cannot be empty.');`
`@@ -55,49 +55,49 @@ public function createLeaf(string $leaf): static`
`55`	`55`	`throw new \InvalidArgumentException('Leaf cannot contain dot.');`
`56`	`56`	`}`
`57`	`57`
`58`		`- $newBranch = [...$this->branch, $leaf];`
	`58`	`+ $newBranch = [...$this->pathFromRoot, $leaf];`
`59`	`59`
`60`	`60`	`return new static($newBranch);`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`#[\Override]`
`64`		`- public function getBranch(): array`
	`64`	`+ public function getPathFromRoot(): array`
`65`	`65`	`{`
`66`		`- return $this->branch;`
	`66`	`+ return $this->pathFromRoot;`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`#[\Override]`
`70`	`70`	`public function equals(LtreeInterface $ltree): bool`
`71`	`71`	`{`
`72`		`- return $this->branch === $ltree->getBranch();`
	`72`	`+ return $this->pathFromRoot === $ltree->getPathFromRoot();`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`#[\Override]`
`76`	`76`	`public function isAncestorOf(LtreeInterface $ltree): bool`
`77`	`77`	`{`
`78`		`- return [] === $this->branch \|\| \str_starts_with((string) $ltree, \sprintf('%s.', (string) $this));`
	`78`	`+ return [] === $this->pathFromRoot \|\| \str_starts_with((string) $ltree, \sprintf('%s.', (string) $this));`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`#[\Override]`
`82`		`- public function isDescendantOf(LtreeInterface $ltree): bool`
	`82`	`+ public function isLeafOf(LtreeInterface $ltree): bool`
`83`	`83`	`{`
`84`	`84`	`return \str_starts_with((string) $this, \sprintf('%s.', (string) $ltree));`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`#[\Override]`
`88`	`88`	`public function isRoot(): bool`
`89`	`89`	`{`
`90`		`- return 1 >= \count($this->branch);`
	`90`	`+ return 1 >= \count($this->pathFromRoot);`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`#[\Override]`
`94`	`94`	`public function getParent(): static`
`95`	`95`	`{`
`96`		`- if ([] === $this->branch) {`
	`96`	`+ if ([] === $this->pathFromRoot) {`
`97`	`97`	`throw new \LogicException('Empty ltree has no parent.');`
`98`	`98`	`}`
`99`	`99`
`100`		`- $parentBranch = \array_slice($this->branch, 0, -1);`
	`100`	`+ $parentBranch = \array_slice($this->pathFromRoot, 0, -1);`
`101`	`101`	`self::assertListOfNonEmptyStrings($parentBranch);`
`102`	`102`
`103`	`103`	`return new static($parentBranch);`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public function test_construct_trows_on_non_list(): void`
`21`	`21`	`new Ltree([0 => 'a', 2 => 'b', 3 => 'c']); // @phpstan-ignore argument.type`
`22`	`22`	`}`
`23`	`23`
`24`		`- public function test_construct_trows_on_empty_string_in_branch(): void`
	`24`	`+ public function test_construct_trows_on_empty_string_in_path_from_root(): void`
`25`	`25`	`{`
`26`	`26`	`$this->expectException(\InvalidArgumentException::class);`
`27`	`27`	`new Ltree(['a', '', 'c']); // @phpstan-ignore argument.type`
`@@ -30,22 +30,22 @@ public function test_construct_trows_on_empty_string_in_branch(): void`
`30`	`30`	`public function test_from_string(): void`
`31`	`31`	`{`
`32`	`32`	`$ltree = Ltree::fromString('x.y.z');`
`33`		`- self::assertSame(['x', 'y', 'z'], $ltree->getBranch());`
	`33`	`+ self::assertSame(['x', 'y', 'z'], $ltree->getPathFromRoot());`
`34`	`34`	`self::assertSame('x.y.z', (string) $ltree);`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`public function test_from_string_empty(): void`
`38`	`38`	`{`
`39`	`39`	`$ltree = Ltree::fromString('');`
`40`		`- self::assertSame([], $ltree->getBranch());`
	`40`	`+ self::assertSame([], $ltree->getPathFromRoot());`
`41`	`41`	`self::assertSame('', (string) $ltree);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public function test_json_serialize(): void`
`45`	`45`	`{`
`46`		`- $branch = ['a', 'b', 'c'];`
`47`		`- $ltree = new Ltree($branch);`
`48`		`- self::assertSame($branch, $ltree->jsonSerialize());`
	`46`	`+ $pathFromRoot = ['a', 'b', 'c'];`
	`47`	`+ $ltree = new Ltree($pathFromRoot);`
	`48`	`+ self::assertSame($pathFromRoot, $ltree->jsonSerialize());`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`public function test_json_encode(): void`
`@@ -55,11 +55,11 @@ public function test_json_encode(): void`
`55`	`55`	`self::assertSame('["a","b","c"]', $json);`
`56`	`56`	`}`
`57`	`57`
`58`		`- public function test_create_leaf(): void`
	`58`	`+ public function test_with_leaf(): void`
`59`	`59`	`{`
`60`	`60`	`$ltree = new Ltree(['root']);`
`61`		`- $newLtree = $ltree->createLeaf('leaf');`
`62`		`- self::assertSame(['root', 'leaf'], $newLtree->getBranch());`
	`61`	`+ $newLtree = $ltree->withLeaf('leaf');`
	`62`	`+ self::assertSame(['root', 'leaf'], $newLtree->getPathFromRoot());`
`63`	`63`	`self::assertSame('root.leaf', (string) $newLtree);`
`64`	`64`	`}`
`65`	`65`
`@@ -75,17 +75,17 @@ public function test_equals(): void`
`75`	`75`	`public function test_is_ancestor_of(): void`
`76`	`76`	`{`
`77`	`77`	`$ancestor = new Ltree(['a', 'b']);`
`78`		`- $descendant = new Ltree(['a', 'b', 'c']);`
`79`		`- self::assertTrue($ancestor->isAncestorOf($descendant));`
`80`		`- self::assertFalse($descendant->isAncestorOf($ancestor));`
	`78`	`+ $leaf = new Ltree(['a', 'b', 'c']);`
	`79`	`+ self::assertTrue($ancestor->isAncestorOf($leaf));`
	`80`	`+ self::assertFalse($leaf->isAncestorOf($ancestor));`
`81`	`81`	`}`
`82`	`82`
`83`		`- public function test_is_descendant_of(): void`
	`83`	`+ public function test_is_leaf_of(): void`
`84`	`84`	`{`
`85`	`85`	`$ancestor = new Ltree(['a', 'b']);`
`86`		`- $descendant = new Ltree(['a', 'b', 'c']);`
`87`		`- self::assertTrue($descendant->isDescendantOf($ancestor));`
`88`		`- self::assertFalse($ancestor->isDescendantOf($descendant));`
	`86`	`+ $leaf = new Ltree(['a', 'b', 'c']);`
	`87`	`+ self::assertTrue($leaf->isLeafOf($ancestor));`
	`88`	`+ self::assertFalse($ancestor->isLeafOf($leaf));`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`public function test_is_root(): void`
`@@ -102,7 +102,7 @@ public function test_get_parent(): void`
`102`	`102`	`{`
`103`	`103`	`$ltree = new Ltree(['a', 'b', 'c']);`
`104`	`104`	`$parent = $ltree->getParent();`
`105`		`- self::assertSame(['a', 'b'], $parent->getBranch());`
	`105`	`+ self::assertSame(['a', 'b'], $parent->getPathFromRoot());`
`106`	`106`	`self::assertSame('a.b', (string) $parent);`
`107`	`107`	`}`
`108`	`108`
`@@ -111,15 +111,15 @@ public function test_get_parent_respect_immutability(): void`
`111`	`111`	`$ltree = new Ltree(['a', 'b', 'c']);`
`112`	`112`	`$parent = $ltree->getParent();`
`113`	`113`	`self::assertNotSame($ltree, $parent);`
`114`		`- self::assertSame(['a', 'b', 'c'], $ltree->getBranch());`
	`114`	`+ self::assertSame(['a', 'b', 'c'], $ltree->getPathFromRoot());`
`115`	`115`	`self::assertSame('a.b.c', (string) $ltree);`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`public function test_get_parent_on_root(): void`
`119`	`119`	`{`
`120`	`120`	`$ltree = new Ltree(['a']);`
`121`	`121`	`$parent = $ltree->getParent();`
`122`		`- self::assertSame([], $parent->getBranch());`
	`122`	`+ self::assertSame([], $parent->getPathFromRoot());`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`public function test_get_parent_throws_on_empty(): void`
`@@ -128,17 +128,17 @@ public function test_get_parent_throws_on_empty(): void`
`128`	`128`	`(new Ltree([]))->getParent();`
`129`	`129`	`}`
`130`	`130`
`131`		`- public function test_create_leaf_empty_throws(): void`
	`131`	`+ public function test_with_leaf_empty_throws(): void`
`132`	`132`	`{`
`133`	`133`	`$ltree = new Ltree(['a']);`
`134`	`134`	`$this->expectException(\InvalidArgumentException::class);`
`135`		`- $ltree->createLeaf(''); // @phpstan-ignore argument.type`
	`135`	`+ $ltree->withLeaf(''); // @phpstan-ignore argument.type`
`136`	`136`	`}`
`137`	`137`
`138`		`- public function test_create_leaf_with_dot_throws(): void`
	`138`	`+ public function test_with_leaf_with_dot_throws(): void`
`139`	`139`	`{`
`140`	`140`	`$ltree = new Ltree(['a']);`
`141`	`141`	`$this->expectException(\InvalidArgumentException::class);`
`142`		`- $ltree->createLeaf('foo.bar');`
	`142`	`+ $ltree->withLeaf('foo.bar');`
`143`	`143`	`}`
`144`	`144`	`}`