Camel case to separator number handling

docs/book/v3/migration/v2-to-v3.md

@@ -48,6 +48,36 @@ The impact of the removal of these aliases will not affect you if you use a FQCN
 
 ### Changes to Individual Filters
 
+#### `CamelCaseToDash`
+
+The following methods have been removed:
+
+- `setOptions`
+- `getOptions`
+- `isOptions`
+- `setSeparator`
+- `getSeparator`
+
+#### `CamelCaseToSeparator`
+
+The following methods have been removed:
+
+- `setOptions`
+- `getOptions`
+- `isOptions`
+- `setSeparator`
+- `getSeparator`
+
+#### `CamelCaseToUnderscore`
+
+The following methods have been removed:
+
+- `setOptions`
+- `getOptions`
+- `isOptions`
+- `setSeparator`
+- `getSeparator`
+
 #### `DashToSeparator`
 
 The following methods have been removed:

docs/book/v3/word.md

@@ -35,8 +35,7 @@ The following options are supported for `Laminas\Filter\Word\CamelCaseToSeparato
 ### Basic Usage
 
 ```php
-$filter = new Laminas\Filter\Word\CamelCaseToSeparator(':');
-// or new Laminas\Filter\Word\CamelCaseToSeparator(array('separator' => ':'));
+$filter = new Laminas\Filter\Word\CamelCaseToSeparator(['separator' => ':']);
 
 print $filter->filter('ThisIsMyContent');
 ```

psalm-baseline.xml

@@ -965,12 +965,6 @@
       <code><![CDATA[returnUnfilteredDataProvider]]></code>
     </PossiblyUnusedMethod>
   </file>
-  <file src="test/Word/CamelCaseToUnderscoreTest.php">
-    <MixedAssignment>
-      <code><![CDATA[$filtered]]></code>
-      <code><![CDATA[$filtered]]></code>
-    </MixedAssignment>
-  </file>
   <file src="test/Word/DashToSeparatorTest.php">
     <PossiblyUnusedMethod>
       <code><![CDATA[returnNonStringScalarValues]]></code>

src/Word/CamelCaseToDash.php

@@ -4,18 +4,26 @@
 
 namespace Laminas\Filter\Word;
 
+use Laminas\Filter\FilterInterface;
+
 /**
  * @psalm-type Options = array{
  *     separator?: string,
- *     ...
  * }
  * @template TOptions of Options
- * @extends CamelCaseToSeparator<TOptions>
+ * @implements FilterInterface<string|array<array-key, string|mixed>>
  */
-final class CamelCaseToDash extends CamelCaseToSeparator
+final class CamelCaseToDash implements FilterInterface
 {
-    public function __construct()
+    public function filter(mixed $value): mixed
+    {
+        $filter = new CamelCaseToSeparator(['separator' => '-']);
+
+        return $filter->filter($value);
+    }
+
+    public function __invoke(mixed $value): mixed
     {
-        parent::__construct('-');
+        return $this->filter($value);
     }
 }

src/Word/CamelCaseToSeparator.php

@@ -4,43 +4,51 @@
 
 namespace Laminas\Filter\Word;
 
-use Closure;
-use Laminas\Stdlib\StringUtils;
+use Laminas\Filter\FilterInterface;
+use Laminas\Filter\ScalarOrArrayFilterCallback;
 
-use function preg_replace;
+use function implode;
+use function preg_split;
+
+use const PREG_SPLIT_DELIM_CAPTURE;
+use const PREG_SPLIT_NO_EMPTY;
 
 /**
  * @psalm-type Options = array{
  *     separator?: string,
- *     ...
  * }
  * @template TOptions of Options
- * @extends AbstractSeparator<TOptions>
+ * @implements FilterInterface<string|array<array-key, string|mixed>>
  */
-class CamelCaseToSeparator extends AbstractSeparator
+final class CamelCaseToSeparator implements FilterInterface
 {
-    public function filter(mixed $value): mixed
+    private readonly string $separator;
+
+    /** @param Options $options */
+    public function __construct(array $options = [])
     {
-        return self::applyFilterOnlyToStringableValuesAndStringableArrayValues(
-            $value,
-            Closure::fromCallable([$this, 'filterNormalizedValue'])
-        );
+        $this->separator = $options['separator'] ?? ' ';
     }
 
-    /**
-     * @param  string|string[] $value
-     * @return string|string[]
-     */
-    private function filterNormalizedValue(string|array $value): string|array
+    public function __invoke(mixed $value): mixed
     {
-        if (StringUtils::hasPcreUnicodeSupport()) {
-            $pattern     = ['#(?<=(?:\p{Lu}))(\p{Lu}\p{Ll})#', '#(?<=(?:\p{Ll}|\p{Nd}))(\p{Lu})#'];
-            $replacement = [$this->separator . '\1', $this->separator . '\1'];
-        } else {
-            $pattern     = ['#(?<=(?:[A-Z]))([A-Z]+)([A-Z][a-z])#', '#(?<=(?:[a-z0-9]))([A-Z])#'];
-            $replacement = ['\1' . $this->separator . '\2', $this->separator . '\1'];
-        }
-
-        return preg_replace($pattern, $replacement, $value);
+        return $this->filter($value);
+    }
+
+    public function filter(mixed $value): mixed
+    {
+        return ScalarOrArrayFilterCallback::applyRecursively(
+            $value,
+            fn (string $input): string =>
+            implode(
+                $this->separator,
+                preg_split(
+                    '#(\p{Lu}\p{Ll}+)#',
+                    $input,
+                    -1,
+                    PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY
+                )
+            )
+        );
     }
 }

src/Word/CamelCaseToUnderscore.php

@@ -4,18 +4,26 @@
 
 namespace Laminas\Filter\Word;
 
+use Laminas\Filter\FilterInterface;
+
 /**
  * @psalm-type Options = array{
  *     separator?: string,
- *     ...
  * }
  * @template TOptions of Options
- * @extends CamelCaseToSeparator<TOptions>
+ * @implements FilterInterface<string|array<array-key, string|mixed>>
  */
-final class CamelCaseToUnderscore extends CamelCaseToSeparator
+final class CamelCaseToUnderscore implements FilterInterface
 {
-    public function __construct()
+    public function filter(mixed $value): mixed
+    {
+        $filter = new CamelCaseToSeparator(['separator' => '_']);
+
+        return $filter->filter($value);
+    }
+
+    public function __invoke(mixed $value): mixed
     {
-        parent::__construct('_');
+        return $this->filter($value);
     }
 }

test/Word/CamelCaseToSeparatorTest.php

@@ -21,24 +21,39 @@
         self::assertSame('Camel Cased Words', $filtered);
     }
 
-    public function testFilterSeparatesCamelCasedWordsWithProvidedSeparator(): void
+    public static function camelCasedWordsProvider(): array
     {
-        $string   = 'CamelCasedWords';
-        $filter   = new CamelCaseToSeparatorFilter(':-#');
-        $filtered = $filter($string);
+        return [
+            ['CamelCasedWords', 'Camel-Cased-Words'],
+            ['123LeadingNumber', '123-Leading-Number'],
+            ['Number12InTheMiddle', 'Number-12-In-The-Middle'],
+            ['ANumberAtTheEnd42', 'A-Number-At-The-End-42'],
+            ['SomePDFFile', 'Some-PDF-File'],
+            ['Has-ExistingSeparator', 'Has-Existing-Separator'],
+            ['What_Happens_Here', 'What_Happens_Here'],
+            ['leadingLowerCase', 'leading-Lower-Case'],
+            ['¿MïsÜsingUnicödeSŷmbols?', '¿Mïs-Üsing-Unicöde-Sŷmbols?'],
+        ];
+    }
 
-        self::assertNotEquals($string, $filtered);
-        self::assertSame('Camel:-#Cased:-#Words', $filtered);
+    #[DataProvider('camelCasedWordsProvider')]
+    public function testFilterSeparatesCamelCasedWordsWithProvidedSeparator(string $input, string $expected): void
+    {
+        $filter   = new CamelCaseToSeparatorFilter(['separator' => '-']);
+        $filtered = $filter($input);
+
+        self::assertNotEquals($input, $filtered);
+        self::assertSame($expected, $filtered);
     }
 
     public function testFilterSeperatesMultipleUppercasedLettersAndUnderscores(): void
     {
         $string   = 'TheseAre_SOME_CamelCASEDWords';
-        $filter   = new CamelCaseToSeparatorFilter('_');
+        $filter   = new CamelCaseToSeparatorFilter(['separator' => '_']);
         $filtered = $filter($string);
 
         self::assertNotEquals($string, $filtered);
         self::assertSame('These_Are_SOME_Camel_CASED_Words', $filtered);
     }
 
     public function testFilterSupportArray(): void