refactor(string): centralize string encoding and normalization in StringEncoder & StringHelper, normalize BrandName to titleCase
This commit is contained in:
parent
9dab38e722
commit
71f97b16e3
20 changed files with 725 additions and 196 deletions
|
|
@ -5,15 +5,21 @@ declare(strict_types=1);
|
|||
namespace Domain\Models\ValueObjects\Brand;
|
||||
|
||||
use Shared\DDD\Model\Equatable;
|
||||
use Shared\Helpers\StringHelper;
|
||||
|
||||
final readonly class BrandName implements Equatable
|
||||
{
|
||||
public string $value;
|
||||
|
||||
public function __construct(
|
||||
public string $value,
|
||||
string $value,
|
||||
) {
|
||||
if (empty(trim($this->value))) {
|
||||
$trimmed = trim($value);
|
||||
if ($trimmed === '') {
|
||||
throw new \DomainException('Brand name cannot be empty.');
|
||||
}
|
||||
|
||||
$this->value = StringHelper::titleCase($trimmed);
|
||||
}
|
||||
|
||||
#[\Override]
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@ namespace Domain\Services;
|
|||
|
||||
use Domain\Models\ValueObjects\Brand\BrandCode;
|
||||
use Domain\Models\ValueObjects\Brand\BrandName;
|
||||
use Shared\Helpers\StringHelper;
|
||||
|
||||
final readonly class BrandCodeGenerator
|
||||
{
|
||||
|
|
@ -118,9 +119,7 @@ final readonly class BrandCodeGenerator
|
|||
|
||||
private function normalizeString(string $value): string
|
||||
{
|
||||
$ascii = transliterator_transliterate('Any-Latin; Latin-ASCII; Upper();', $value);
|
||||
|
||||
return is_string($ascii) ? $ascii : mb_strtoupper($value);
|
||||
return mb_strtoupper(StringHelper::transliterate($value));
|
||||
}
|
||||
|
||||
private function randomTwoDigits(): string
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@ use Infra\Adapters\Parsers\IncoIngredientParser;
|
|||
use Infra\Adapters\Parsers\IncoParser;
|
||||
use Infra\Adapters\Parsers\IncoStringParser;
|
||||
use Shared\Helpers\DatesHelper;
|
||||
use Shared\Helpers\StringHelper;
|
||||
|
||||
final readonly class IncoMapper
|
||||
{
|
||||
|
|
@ -72,7 +73,7 @@ final readonly class IncoMapper
|
|||
|
||||
$name = IncoStringParser::beautifyText($rawDesc);
|
||||
if ($name === null || trim($name) === '') {
|
||||
$name = $rawDenom !== '' ? IncoStringParser::words($rawDenom, 4, '') : "Produit {$incoId->value}";
|
||||
$name = $rawDenom !== '' ? StringHelper::words($rawDenom, 4, '') : "Produit {$incoId->value}";
|
||||
}
|
||||
|
||||
$label = IncoStringParser::beautifyName($rawDenom !== '' ? $rawDenom : ($name !== '' ? $name : "Produit {$incoId->value}"));
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ use Domain\Models\Entities\Inco\IncoShortSheet;
|
|||
use Domain\Models\ValueObjects\Inco\IncoId;
|
||||
use Infra\Adapters\Parsers\IncoStringParser;
|
||||
use Shared\Helpers\DatesHelper;
|
||||
use Shared\Helpers\StringHelper;
|
||||
|
||||
final readonly class IncoShortMapper
|
||||
{
|
||||
|
|
@ -40,7 +41,7 @@ final readonly class IncoShortMapper
|
|||
|
||||
$name = IncoStringParser::beautifyText($rawDesc);
|
||||
if ($name === null || trim($name) === '') {
|
||||
$name = $rawDenom !== '' ? IncoStringParser::words($rawDenom, 4, '') : "Produit {$incoId->value}";
|
||||
$name = $rawDenom !== '' ? StringHelper::words($rawDenom, 4, '') : "Produit {$incoId->value}";
|
||||
}
|
||||
|
||||
$label = IncoStringParser::beautifyName($rawDenom !== '' ? $rawDenom : ($name !== '' ? $name : "Produit {$incoId->value}"));
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ declare(strict_types=1);
|
|||
namespace Infra\Adapters\Parsers;
|
||||
|
||||
use Domain\Models\ValueObjects\Inco\Ingredients;
|
||||
use Shared\Helpers\StringHelper;
|
||||
|
||||
final readonly class IncoIngredientParser
|
||||
{
|
||||
|
|
@ -174,7 +175,7 @@ final readonly class IncoIngredientParser
|
|||
$elements = self::tokenizeIngredientPart($tokenString, ':', 2);
|
||||
|
||||
$labelRaw = $elements[0] ?? '';
|
||||
$labelSlug = IncoStringParser::slugify($labelRaw);
|
||||
$labelSlug = StringHelper::slugify($labelRaw, ' ');
|
||||
$hasLabel = count($elements) > 1;
|
||||
|
||||
$trimmedLabel = trim($labelRaw);
|
||||
|
|
@ -182,7 +183,7 @@ final readonly class IncoIngredientParser
|
|||
$labelHasParen = (bool) preg_match('/[()]/', $trimmedLabel);
|
||||
$labelIsTooLong = mb_strlen($trimmedLabel, 'UTF-8') > 40;
|
||||
|
||||
$tokenSlug = IncoStringParser::slugify($tokenString);
|
||||
$tokenSlug = StringHelper::slugify($tokenString, ' ');
|
||||
$isInfoLine = str_starts_with($tokenSlug, 'fabrique dans')
|
||||
|| str_starts_with($tokenSlug, 'certifie')
|
||||
|| str_starts_with($tokenSlug, 'a consommer')
|
||||
|
|
@ -276,12 +277,12 @@ final readonly class IncoIngredientParser
|
|||
$ingredientPartString = implode('', $result);
|
||||
|
||||
$delimiters = "\n\t{$charToEscape}";
|
||||
$tok = IncoStringParser::mbStrtok($delimiters, $ingredientPartString);
|
||||
$tok = StringHelper::mbStrtok($delimiters, $ingredientPartString);
|
||||
$parts = [];
|
||||
|
||||
while ($tok !== false) {
|
||||
$parts[] = $tok;
|
||||
$tok = IncoStringParser::mbStrtok($delimiters);
|
||||
$tok = StringHelper::mbStrtok($delimiters);
|
||||
}
|
||||
|
||||
$limitChar = chr(27);
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ use Domain\Models\ValueObjects\Inco\Nutriscore;
|
|||
use Domain\Models\ValueObjects\Inco\PortionAmount;
|
||||
use Domain\Models\ValueObjects\Inco\PortionType;
|
||||
use Domain\Models\ValueObjects\Inco\StorageCondition;
|
||||
use Shared\Helpers\StringHelper;
|
||||
|
||||
final readonly class IncoParser
|
||||
{
|
||||
|
|
@ -41,12 +42,12 @@ final readonly class IncoParser
|
|||
}
|
||||
|
||||
$delimiters = '–,';
|
||||
$tok = IncoStringParser::mbStrtok($delimiters, $rawText);
|
||||
$tok = StringHelper::mbStrtok($delimiters, $rawText);
|
||||
$parts = [];
|
||||
|
||||
while ($tok !== false) {
|
||||
$parts[] = $tok;
|
||||
$tok = IncoStringParser::mbStrtok($delimiters);
|
||||
$tok = StringHelper::mbStrtok($delimiters);
|
||||
}
|
||||
|
||||
$parts = array_values(array_filter($parts, static function (string $item): bool {
|
||||
|
|
@ -57,7 +58,7 @@ final readonly class IncoParser
|
|||
|
||||
$parts = array_map(static function (string $item): string {
|
||||
$value = IncoStringParser::toPhrase($item);
|
||||
$cleaned = IncoStringParser::protectiveDataFilter($value);
|
||||
$cleaned = StringHelper::sanitize($value);
|
||||
|
||||
return $cleaned ?? '';
|
||||
}, $parts);
|
||||
|
|
@ -203,7 +204,7 @@ final readonly class IncoParser
|
|||
return null;
|
||||
}
|
||||
|
||||
$cleaned = IncoStringParser::protectiveDataFilter($str);
|
||||
$cleaned = StringHelper::sanitize($str);
|
||||
if ($cleaned === null || trim($cleaned) === '') {
|
||||
return null;
|
||||
}
|
||||
|
|
@ -361,12 +362,12 @@ final readonly class IncoParser
|
|||
private static function tokenize(string $value): array
|
||||
{
|
||||
$delimiters = " \n\tà/\\-_de";
|
||||
$tok = IncoStringParser::mbStrtok($delimiters, $value);
|
||||
$tok = StringHelper::mbStrtok($delimiters, $value);
|
||||
$parts = [];
|
||||
|
||||
while ($tok !== false) {
|
||||
$parts[] = $tok;
|
||||
$tok = IncoStringParser::mbStrtok($delimiters);
|
||||
$tok = StringHelper::mbStrtok($delimiters);
|
||||
}
|
||||
|
||||
return $parts;
|
||||
|
|
|
|||
|
|
@ -4,42 +4,8 @@ declare(strict_types=1);
|
|||
|
||||
namespace Infra\Adapters\Parsers;
|
||||
|
||||
use Shared\Helpers\StringHelper;
|
||||
|
||||
final readonly class IncoStringParser
|
||||
{
|
||||
/**
|
||||
* Nettoie et normalise une ligne texte (pas de HTML, pas de caractères de contrôle, UTF-8 valide).
|
||||
*/
|
||||
public static function protectiveDataFilter(?string $line): ?string
|
||||
{
|
||||
if ($line === null || $line === '') {
|
||||
return $line;
|
||||
}
|
||||
|
||||
// Decode HTML entities then strip tags
|
||||
$line = html_entity_decode($line, ENT_QUOTES | ENT_HTML5, 'UTF-8');
|
||||
$line = strip_tags($line);
|
||||
|
||||
// Normalize newlines, temporarily convert to <br /> to preserve paragraph breaks
|
||||
$line = str_replace(["\r\n", "\r"], "\n", $line);
|
||||
$line = str_replace("\n", '<br />', $line);
|
||||
|
||||
// Ensure valid UTF-8 (handling Windows-1252 / ISO-8859-1 legacy strings)
|
||||
$line = self::ensureUtf8($line);
|
||||
|
||||
// Remove astral symbols (4-byte UTF-8) that may break storage/processing
|
||||
$line = preg_replace('/[\x{10000}-\x{10FFFF}]/u', '', $line) ?? '';
|
||||
|
||||
// Remove control/non-printable characters but keep TAB(0x09), LF(0x0A) and CR(0x0D)
|
||||
$line = preg_replace('/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F\xA0\xAD]/u', '', $line) ?? '';
|
||||
|
||||
// Revert <br /> back to newlines and final strip_tags as safety
|
||||
$line = str_replace('<br />', "\n", $line);
|
||||
|
||||
return strip_tags($line);
|
||||
}
|
||||
|
||||
/**
|
||||
* Formate un libellé en phrase standard (1ère lettre en majuscule, sans point final trailing).
|
||||
*/
|
||||
|
|
@ -178,81 +144,4 @@ final readonly class IncoStringParser
|
|||
|
||||
return str_replace($floatingPointEsc, '.', $result);
|
||||
}
|
||||
|
||||
/**
|
||||
* Multibyte-safe tokenizer similar to strtok.
|
||||
*/
|
||||
public static function mbStrtok(string $delimiters, ?string $str = null): string | false
|
||||
{
|
||||
/** @var int $pos */
|
||||
static $pos = 0;
|
||||
/** @var string $string */
|
||||
static $string = '';
|
||||
|
||||
if ($str !== null) {
|
||||
$pos = 0;
|
||||
$string = $str;
|
||||
}
|
||||
|
||||
$token = '';
|
||||
$len = mb_strlen($string, 'UTF-8');
|
||||
|
||||
while ($pos < $len) {
|
||||
$char = mb_substr($string, $pos, 1, 'UTF-8');
|
||||
$pos++;
|
||||
|
||||
if (mb_strpos($delimiters, $char, 0, 'UTF-8') === false) {
|
||||
$token .= $char;
|
||||
} else {
|
||||
if ($token !== '') {
|
||||
return $token;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($token !== '') {
|
||||
return $token;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Slugify a string for token comparisons.
|
||||
*/
|
||||
public static function slugify(string $value): string
|
||||
{
|
||||
$ascii = StringHelper::transliterate($value);
|
||||
|
||||
return strtolower(trim($ascii));
|
||||
}
|
||||
|
||||
/**
|
||||
* Truncate a string to a max number of words.
|
||||
*/
|
||||
public static function words(string $value, int $words = 100, string $end = ' ...'): string
|
||||
{
|
||||
preg_match('/^\s*+(?:\S+\s*+){1,' . $words . '}/u', $value, $matches);
|
||||
|
||||
if (! isset($matches[0]) || mb_strlen($value, 'UTF-8') === mb_strlen($matches[0], 'UTF-8')) {
|
||||
return $value;
|
||||
}
|
||||
|
||||
return rtrim($matches[0]) . $end;
|
||||
}
|
||||
|
||||
private static function ensureUtf8(string $string): string
|
||||
{
|
||||
if ($string === '') {
|
||||
return '';
|
||||
}
|
||||
|
||||
if (mb_check_encoding($string, 'UTF-8')) {
|
||||
return $string;
|
||||
}
|
||||
|
||||
$converted = mb_convert_encoding($string, 'UTF-8', 'Windows-1252, ISO-8859-15, ISO-8859-1');
|
||||
|
||||
return is_string($converted) ? $converted : $string;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
330
src/Shared/Helpers/StringEncoder.php
Normal file
330
src/Shared/Helpers/StringEncoder.php
Normal file
|
|
@ -0,0 +1,330 @@
|
|||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Shared\Helpers;
|
||||
|
||||
/**
|
||||
* Converts strings from Western European single-byte encodings to UTF-8.
|
||||
*
|
||||
* Supported source encodings:
|
||||
* - UTF-8 (passthrough with validation)
|
||||
* - Windows-1252 (superset of ISO-8859-1, covers Latin-1 in practice)
|
||||
* - ISO-8859-15 (Latin-9: Latin-1 + €, œ, Œ, Š, š, Ž, ž, Ÿ)
|
||||
*
|
||||
* Auto-detection is inherently unreliable for single-byte encodings.
|
||||
* Always prefer toUtf8() with an explicit encoding.
|
||||
*/
|
||||
final class StringEncoder
|
||||
{
|
||||
/** UTF-8 BOM sequence (EF BB BF). */
|
||||
private const string UTF8_BOM = "\xEF\xBB\xBF";
|
||||
|
||||
/**
|
||||
* Canonical encodings supported by this class.
|
||||
*
|
||||
* @var list<string>
|
||||
*/
|
||||
private const array CANONICAL_ENCODINGS = [
|
||||
'UTF-8',
|
||||
'Windows-1252',
|
||||
'ISO-8859-15',
|
||||
];
|
||||
|
||||
/**
|
||||
* Lowercase alias -> canonical name.
|
||||
*
|
||||
* Windows-1252 absorbs ISO-8859-1/Latin-1 because it is a strict superset:
|
||||
* bytes 0xA0-0xFF are identical, and 0x80-0x9F are defined in Win-1252
|
||||
* but undefined (and useless) in ISO-8859-1.
|
||||
*
|
||||
* @var array<string, string>
|
||||
*/
|
||||
private const array ENCODING_ALIASES = [
|
||||
// UTF-8
|
||||
'utf8' => 'UTF-8',
|
||||
'utf-8' => 'UTF-8',
|
||||
|
||||
// Windows-1252 (absorbs Latin-1 / ISO-8859-1)
|
||||
'win1252' => 'Windows-1252',
|
||||
'windows1252' => 'Windows-1252',
|
||||
'cp1252' => 'Windows-1252',
|
||||
'latin1' => 'Windows-1252',
|
||||
'latin-1' => 'Windows-1252',
|
||||
'iso-8859-1' => 'Windows-1252',
|
||||
|
||||
// ISO-8859-15 (Latin-9)
|
||||
'latin9' => 'ISO-8859-15',
|
||||
'latin-9' => 'ISO-8859-15',
|
||||
'iso-8859-15' => 'ISO-8859-15',
|
||||
];
|
||||
|
||||
/**
|
||||
* Windows-1252 specific codepoints (0x80-0x9F) absent from ISO-8859-1.
|
||||
*
|
||||
* Bytes 0x81, 0x8D, 0x8F, 0x90, 0x9D are officially undefined in Windows-1252.
|
||||
* They are intentionally absent - encountering them triggers the
|
||||
* Latin-1 fallback (Unicode codepoint = byte value).
|
||||
*
|
||||
* @var array<int, string> Byte value -> UTF-8 character.
|
||||
*/
|
||||
private const array WIN1252_SPECIAL_BYTES = [
|
||||
0x80 => "\u{20AC}", // €
|
||||
0x82 => "\u{201A}", // ‚
|
||||
0x83 => "\u{0192}", // ƒ
|
||||
0x84 => "\u{201E}", // „
|
||||
0x85 => "\u{2026}", // …
|
||||
0x86 => "\u{2020}", // †
|
||||
0x87 => "\u{2021}", // ‡
|
||||
0x88 => "\u{02C6}", // ˆ
|
||||
0x89 => "\u{2030}", // ‰
|
||||
0x8A => "\u{0160}", // Š
|
||||
0x8B => "\u{2039}", // ‹
|
||||
0x8C => "\u{0152}", // Œ
|
||||
0x8E => "\u{017D}", // Ž
|
||||
0x91 => "\u{2018}", // '
|
||||
0x92 => "\u{2019}", // '
|
||||
0x93 => "\u{201C}", // "
|
||||
0x94 => "\u{201D}", // "
|
||||
0x95 => "\u{2022}", // •
|
||||
0x96 => "\u{2013}", // –
|
||||
0x97 => "\u{2014}", // —
|
||||
0x98 => "\u{02DC}", // ˜
|
||||
0x99 => "\u{2122}", // ™
|
||||
0x9A => "\u{0161}", // š
|
||||
0x9B => "\u{203A}", // ›
|
||||
0x9C => "\u{0153}", // œ
|
||||
0x9E => "\u{017E}", // ž
|
||||
0x9F => "\u{0178}", // Ÿ
|
||||
];
|
||||
|
||||
/**
|
||||
* ISO-8859-15 bytes that differ from ISO-8859-1.
|
||||
* Only 8 codepoints differ between Latin-1 and Latin-9.
|
||||
*
|
||||
* @var array<int, string> Byte value -> UTF-8 character.
|
||||
*/
|
||||
private const array LATIN9_OVERRIDES = [
|
||||
0xA4 => "\u{20AC}", // € (replaces ¤)
|
||||
0xA6 => "\u{0160}", // Š (replaces ¦)
|
||||
0xA8 => "\u{0161}", // š (replaces ¨)
|
||||
0xB4 => "\u{017D}", // Ž (replaces ´)
|
||||
0xB8 => "\u{017E}", // ž (replaces ¸)
|
||||
0xBC => "\u{0152}", // Œ (replaces ¼)
|
||||
0xBD => "\u{0153}", // œ (replaces ½)
|
||||
0xBE => "\u{0178}", // Ÿ (replaces ¾)
|
||||
];
|
||||
|
||||
private function __construct()
|
||||
{
|
||||
// Static class
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a string from a known encoding to UTF-8.
|
||||
*
|
||||
* @param bool $stripBom Remove UTF-8 BOM from the result if present.
|
||||
*
|
||||
* @throws \ValueError If encoding is unsupported or the string is invalid.
|
||||
*/
|
||||
public static function toUtf8(
|
||||
string $string,
|
||||
string $sourceEncoding,
|
||||
bool $stripBom = true,
|
||||
): string {
|
||||
if ($string === '') {
|
||||
return '';
|
||||
}
|
||||
|
||||
$canonical = self::resolveEncoding($sourceEncoding);
|
||||
|
||||
$result = match ($canonical) {
|
||||
'UTF-8' => self::ensureValidUtf8($string),
|
||||
'Windows-1252' => self::fromSingleByte($string, self::WIN1252_SPECIAL_BYTES),
|
||||
'ISO-8859-15' => self::fromSingleByte($string, self::LATIN9_OVERRIDES),
|
||||
default => throw new \ValueError(sprintf(
|
||||
'Unsupported encoding "%s". Supported: %s',
|
||||
$canonical,
|
||||
implode(', ', self::supportedEncodings()),
|
||||
))
|
||||
};
|
||||
|
||||
return $stripBom ? self::stripUtf8Bom($result) : $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to detect the encoding and convert to UTF-8.
|
||||
*
|
||||
* Detection strategy:
|
||||
* 1. If the string is valid UTF-8, it is treated as UTF-8.
|
||||
* 2. Otherwise, the configured fallback encoding is used.
|
||||
*
|
||||
* This two-step approach is more reliable than mb_detect_encoding
|
||||
* for single-byte encodings (which accept any byte sequence).
|
||||
*
|
||||
* @param string $fallbackEncoding Encoding to assume when the string is not valid UTF-8.
|
||||
* Defaults to 'Windows-1252' (covers most Western European legacy data).
|
||||
* @param bool $stripBom Remove UTF-8 BOM from the result if present.
|
||||
*
|
||||
* @throws \ValueError If fallbackEncoding is unsupported or is 'UTF-8'.
|
||||
*/
|
||||
public static function detectAndConvertToUtf8(
|
||||
string $string,
|
||||
string $fallbackEncoding = 'Windows-1252',
|
||||
bool $stripBom = true,
|
||||
): string {
|
||||
if ($string === '') {
|
||||
return '';
|
||||
}
|
||||
|
||||
$canonical = self::resolveEncoding($fallbackEncoding);
|
||||
|
||||
if ($canonical === 'UTF-8') {
|
||||
throw new \ValueError(
|
||||
'Fallback encoding cannot be UTF-8. Use toUtf8() for explicit UTF-8 validation.',
|
||||
);
|
||||
}
|
||||
|
||||
// UTF-8 is the only encoding we can reliably detect:
|
||||
// it has strict byte sequence rules that reject invalid sequences.
|
||||
if (mb_check_encoding($string, 'UTF-8')) {
|
||||
$result = $string;
|
||||
} else {
|
||||
$result = self::toUtf8($string, $canonical, stripBom: false);
|
||||
}
|
||||
|
||||
return $stripBom ? self::stripUtf8Bom($result) : $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts an array of strings to UTF-8 from a known encoding.
|
||||
*
|
||||
* @param list<string> $strings
|
||||
* @return list<string>
|
||||
*/
|
||||
public static function arrayToUtf8(
|
||||
array $strings,
|
||||
string $sourceEncoding,
|
||||
bool $stripBom = true,
|
||||
): array {
|
||||
return array_map(
|
||||
static fn (string $s): string => self::toUtf8($s, $sourceEncoding, $stripBom),
|
||||
$strings,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all supported encoding names (canonical + aliases).
|
||||
*
|
||||
* @return list<string>
|
||||
*/
|
||||
public static function supportedEncodings(): array
|
||||
{
|
||||
return array_values(array_unique([
|
||||
...self::CANONICAL_ENCODINGS,
|
||||
...array_keys(self::ENCODING_ALIASES),
|
||||
]));
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves a user-supplied encoding name to its canonical form.
|
||||
*
|
||||
* @throws \ValueError If encoding is unknown.
|
||||
*/
|
||||
private static function resolveEncoding(string $encoding): string
|
||||
{
|
||||
$normalized = strtolower(trim($encoding));
|
||||
|
||||
if (isset(self::ENCODING_ALIASES[$normalized])) {
|
||||
return self::ENCODING_ALIASES[$normalized];
|
||||
}
|
||||
|
||||
$match = array_find(
|
||||
self::CANONICAL_ENCODINGS,
|
||||
static fn (string $canonical): bool => strtolower($canonical) === $normalized,
|
||||
);
|
||||
|
||||
if ($match !== null) {
|
||||
return $match;
|
||||
}
|
||||
|
||||
throw new \ValueError(sprintf(
|
||||
'Unsupported encoding "%s". Supported: %s',
|
||||
$encoding,
|
||||
implode(', ', self::supportedEncodings()),
|
||||
));
|
||||
}
|
||||
|
||||
/**
|
||||
* Validates that a string is well-formed UTF-8.
|
||||
*
|
||||
* @throws \ValueError If the string contains invalid UTF-8 sequences.
|
||||
*/
|
||||
private static function ensureValidUtf8(string $string): string
|
||||
{
|
||||
if (! mb_check_encoding($string, 'UTF-8')) {
|
||||
throw new \ValueError('String is not valid UTF-8.');
|
||||
}
|
||||
|
||||
return $string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a single-byte encoded string to UTF-8.
|
||||
*
|
||||
* All supported single-byte encodings share the same base:
|
||||
* - 0x00-0x7F: ASCII (identity)
|
||||
* - 0x80-0xFF: Encoding-specific - use overrides map first, then Latin-1 identity.
|
||||
*
|
||||
* @param array<int, string> $overrides Byte -> UTF-8 mapping for encoding-specific codepoints.
|
||||
* For Windows-1252: the 0x80-0x9F special range.
|
||||
* For ISO-8859-15: the 8 bytes that differ from Latin-1.
|
||||
*/
|
||||
private static function fromSingleByte(string $string, array $overrides): string
|
||||
{
|
||||
/** @var array<int, int> $bytes keyed from 1 (unpack behavior) */
|
||||
$bytes = unpack('C*', $string);
|
||||
$parts = [];
|
||||
|
||||
foreach ($bytes as $byte) {
|
||||
$parts[] = match (true) {
|
||||
$byte >= 0 && $byte <= 0x7F => chr($byte),
|
||||
isset($overrides[$byte]) => $overrides[$byte],
|
||||
default => self::encodeLatin1ByteAsUtf8($byte),
|
||||
};
|
||||
}
|
||||
|
||||
return implode('', $parts);
|
||||
}
|
||||
|
||||
/**
|
||||
* Encodes a single byte (0x80-0xFF) as a two-byte UTF-8 sequence.
|
||||
*
|
||||
* For Latin-1 / ISO-8859-1, the Unicode codepoint equals the byte value,
|
||||
* so the UTF-8 encoding is: 110xxxxx 10xxxxxx.
|
||||
*
|
||||
* @throws \ValueError If the byte is outside the expected range.
|
||||
*/
|
||||
private static function encodeLatin1ByteAsUtf8(int $byte): string
|
||||
{
|
||||
if ($byte < 0x80 || $byte > 0xFF) {
|
||||
throw new \ValueError(
|
||||
sprintf('Byte must be in range 0x80-0xFF, got 0x%02X.', $byte),
|
||||
);
|
||||
}
|
||||
|
||||
return chr(0xC0 | ($byte >> 6)) . chr(0x80 | ($byte & 0x3F));
|
||||
}
|
||||
|
||||
/**
|
||||
* Strips the UTF-8 BOM (EF BB BF) if present at the start of the string.
|
||||
*/
|
||||
private static function stripUtf8Bom(string $string): string
|
||||
{
|
||||
if (str_starts_with($string, self::UTF8_BOM)) {
|
||||
return substr($string, 3);
|
||||
}
|
||||
|
||||
return $string;
|
||||
}
|
||||
}
|
||||
|
|
@ -25,4 +25,172 @@ final readonly class StringHelper
|
|||
|
||||
return (string) iconv('UTF-8', 'ASCII//TRANSLIT//IGNORE', $value);
|
||||
}
|
||||
|
||||
public static function mbStrtok(string $delimiters, ?string $str = null): string | false
|
||||
{
|
||||
/** @var int $pos */
|
||||
static $pos = 0;
|
||||
/** @var string $string */
|
||||
static $string = '';
|
||||
|
||||
if ($str !== null) {
|
||||
$pos = 0;
|
||||
$string = $str;
|
||||
}
|
||||
|
||||
$token = '';
|
||||
$len = mb_strlen($string, 'UTF-8');
|
||||
|
||||
while ($pos < $len) {
|
||||
$char = mb_substr($string, $pos, 1, 'UTF-8');
|
||||
$pos++;
|
||||
|
||||
if (mb_strpos($delimiters, $char, 0, 'UTF-8') === false) {
|
||||
$token .= $char;
|
||||
} else {
|
||||
if ($token !== '') {
|
||||
return $token;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($token !== '') {
|
||||
return $token;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Transliterates and formats a string into a URL-friendly slug.
|
||||
*/
|
||||
public static function slugify(string $value, string $separator = '-'): string
|
||||
{
|
||||
$transliterated = self::transliterate($value);
|
||||
$cleaned = preg_replace('/[^a-zA-Z0-9]+/u', $separator, $transliterated) ?? '';
|
||||
|
||||
return strtolower(trim($cleaned, $separator));
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a string to snake_case.
|
||||
*/
|
||||
public static function snakeCase(string $value): string
|
||||
{
|
||||
return mb_strtolower(implode('_', self::splitWords($value)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a string to kebab-case.
|
||||
*/
|
||||
public static function kebabCase(string $value): string
|
||||
{
|
||||
return mb_strtolower(implode('-', self::splitWords($value)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a string to Title Case.
|
||||
*/
|
||||
public static function titleCase(string $value): string
|
||||
{
|
||||
$trimmed = trim($value);
|
||||
if ($trimmed === '') {
|
||||
return '';
|
||||
}
|
||||
|
||||
return mb_convert_case(
|
||||
mb_strtolower($trimmed, 'UTF-8'),
|
||||
\MB_CASE_TITLE,
|
||||
'UTF-8'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a string to PascalCase (StudlyCase).
|
||||
*/
|
||||
public static function pascalCase(string $value): string
|
||||
{
|
||||
$words = array_map(
|
||||
static fn (string $word): string => mb_ucfirst(mb_strtolower($word)),
|
||||
self::splitWords($value)
|
||||
);
|
||||
|
||||
return implode('', $words);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a string to camelCase.
|
||||
*/
|
||||
public static function camelCase(string $value): string
|
||||
{
|
||||
return mb_lcfirst(self::pascalCase($value));
|
||||
}
|
||||
|
||||
/**
|
||||
* Split a string into words, respecting Unicode word boundaries.
|
||||
*/
|
||||
public static function words(string $value, int $words = 100, string $end = ' ...'): string
|
||||
{
|
||||
preg_match('/^\s*+(?:\S+\s*+){1,' . $words . '}/u', $value, $matches);
|
||||
|
||||
if (! isset($matches[0]) || mb_strlen($value) === mb_strlen($matches[0])) {
|
||||
return $value;
|
||||
}
|
||||
|
||||
return rtrim($matches[0]) . $end;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sanitizes and normalizes a text string (strips HTML, removes non-printable control characters, ensures valid UTF-8).
|
||||
*/
|
||||
public static function sanitize(?string $value): ?string
|
||||
{
|
||||
if ($value === null || $value === '') {
|
||||
return $value;
|
||||
}
|
||||
|
||||
// Decode HTML entities then strip tags
|
||||
$value = html_entity_decode($value, ENT_QUOTES | ENT_HTML5, 'UTF-8');
|
||||
$value = strip_tags($value);
|
||||
|
||||
// Normalize newlines, temporarily convert to <br /> to preserve paragraph breaks
|
||||
$value = str_replace(["\r\n", "\r"], "\n", $value);
|
||||
$value = str_replace("\n", '<br />', $value);
|
||||
|
||||
// Ensure valid UTF-8 (handling Windows-1252 / ISO-8859-1 legacy strings)
|
||||
$value = StringEncoder::detectAndConvertToUtf8($value);
|
||||
|
||||
// Remove astral symbols (4-byte UTF-8) that may break storage/processing
|
||||
$value = preg_replace('/[\x{10000}-\x{10FFFF}]/u', '', $value) ?? '';
|
||||
|
||||
// Remove control/non-printable characters but keep TAB(0x09), LF(0x0A) and CR(0x0D)
|
||||
$value = preg_replace('/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F\xA0\xAD]/u', '', $value) ?? '';
|
||||
|
||||
// Revert <br /> back to newlines and final strip_tags as safety
|
||||
$value = str_replace('<br />', "\n", $value);
|
||||
|
||||
return strip_tags($value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Split an arbitrary string into individual word tokens.
|
||||
*
|
||||
* @return list<string>
|
||||
*/
|
||||
private static function splitWords(string $value): array
|
||||
{
|
||||
// 1. Separate camelCase transitions (e.g., "fooBar" -> "foo Bar")
|
||||
$value = preg_replace('/(?<=[a-z0-9])([A-Z])/u', ' $1', $value) ?? $value;
|
||||
|
||||
// 2. Separate acronyms followed by regular words (e.g., "HTTPResponse" -> "HTTP Response")
|
||||
$value = preg_replace('/(?<=[A-Z])([A-Z][a-z])/u', ' $1', $value) ?? $value;
|
||||
|
||||
// 3. Replace non-alphanumeric characters with whitespace
|
||||
$value = preg_replace('/[^\p{L}\p{N}]+/u', ' ', $value) ?? $value;
|
||||
|
||||
return array_values(array_filter(
|
||||
explode(' ', trim($value)),
|
||||
static fn (string $word): bool => $word !== ''
|
||||
));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ describe('IncoSheets Index Feature API', function (): void {
|
|||
$response->assertStatus(200);
|
||||
$response->assertJsonPath('incoSheets.0.id', '9999001')
|
||||
->assertJsonPath('incoSheets.0.brand.code', $brand->code->value)
|
||||
->assertJsonPath('incoSheets.0.brand.label', 'LE GAULOIS PROFESSIONNEL');
|
||||
->assertJsonPath('incoSheets.0.brand.label', 'Le Gaulois Professionnel');
|
||||
});
|
||||
|
||||
it('returns 422 Unprocessable Entity when brand code format is invalid', function (): void {
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ describe('EloquentBrandRepository Integration Tests', function (): void {
|
|||
|
||||
BrandModel::query()->create([
|
||||
'id' => $rawId,
|
||||
'name' => 'Maître CoQ',
|
||||
'name' => 'Maître Coq',
|
||||
'arcadia_id' => 10,
|
||||
'uwil_public_id' => 'MCQ01',
|
||||
]);
|
||||
|
|
@ -87,7 +87,7 @@ describe('EloquentBrandRepository Integration Tests', function (): void {
|
|||
->and($secondResult)->not->toBeNull()
|
||||
->and($secondResult->id()->value)->toBe($brandId->value)
|
||||
->and($secondResult->code->value)->toBe('MCQ01')
|
||||
->and($secondResult->name->value)->toBe('Maître CoQ');
|
||||
->and($secondResult->name->value)->toBe('Maître Coq');
|
||||
});
|
||||
|
||||
it('finds a brand by BrandCode and serves subsequent calls from cache', function (): void {
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ describe('FindAllBrands Usecase Unit Tests', function (): void {
|
|||
|
||||
// Second item was generated and persisted
|
||||
expect($result->brands[1]->arcadiaId->value)->toBe('2')
|
||||
->and($result->brands[1]->name->value)->toBe('Maître CoQ')
|
||||
->and($result->brands[1]->name->value)->toBe('Maître Coq')
|
||||
->and(str_starts_with($result->brands[1]->code->value, 'MCQ'))->toBeTrue();
|
||||
|
||||
// Check that the second brand was persisted in repository
|
||||
|
|
@ -92,7 +92,7 @@ describe('FindAllBrands Usecase Unit Tests', function (): void {
|
|||
it('slices brands according to pagination', function () use ($arcadiaDirectory, $brandRepository, $codeGenerator, $dispatcher): void {
|
||||
// GIVEN
|
||||
$arcadia1 = new ArcadiaBrand(new ArcadiaId('1'), new BrandName('Le Gaulois'));
|
||||
$arcadia2 = new ArcadiaBrand(new ArcadiaId('2'), new BrandName('Maître CoQ'));
|
||||
$arcadia2 = new ArcadiaBrand(new ArcadiaId('2'), new BrandName('Maître Coq'));
|
||||
$arcadia3 = new ArcadiaBrand(new ArcadiaId('3'), new BrandName('Loué'));
|
||||
$arcadiaDirectory->add($arcadia1, $arcadia2, $arcadia3);
|
||||
|
||||
|
|
|
|||
|
|
@ -9,15 +9,16 @@ use Domain\Models\ValueObjects\Brand\BrandName;
|
|||
covers(BrandName::class);
|
||||
|
||||
describe('BrandName Value Object Instantiation', function (): void {
|
||||
it('accepts valid brand names', function (): void {
|
||||
it('accepts valid brand names and normalizes to Title Case', function (): void {
|
||||
// GIVEN
|
||||
$value = 'Le Gaulois';
|
||||
$value = 'LE GAULOIS';
|
||||
|
||||
// WHEN
|
||||
$brandName = new BrandName($value);
|
||||
|
||||
// THEN
|
||||
expect($brandName->value)->toBe($value);
|
||||
expect($brandName->value)->toBe('Le Gaulois')
|
||||
->and(new BrandName('maître coq')->value)->toBe('Maître Coq');
|
||||
});
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ describe('BrandResolver Unit Tests', function (): void {
|
|||
|
||||
// THEN
|
||||
expect($resolved->arcadiaId->value)->toBe('2')
|
||||
->and($resolved->name->value)->toBe('Maître CoQ')
|
||||
->and($resolved->name->value)->toBe('Maître Coq')
|
||||
->and(str_starts_with($resolved->code->value, 'MCQ'))->toBeTrue();
|
||||
|
||||
expect($brandRepository->findByArcadiaId(new ArcadiaId('2')))->not->toBeNull();
|
||||
|
|
@ -97,7 +97,7 @@ describe('BrandResolver Unit Tests', function (): void {
|
|||
/** @var BrandCreated $event */
|
||||
$event = $dispatcher->dispatched[0];
|
||||
expect($event->arcadiaId->value)->toBe('2')
|
||||
->and($event->brandName->value)->toBe('Maître CoQ')
|
||||
->and($event->brandName->value)->toBe('Maître Coq')
|
||||
->and($event->brandCode->value)->toBe($resolved->code->value)
|
||||
->and($event->brandId->value)->toBe($resolved->id->value);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ describe('ArcadiaBrandMapper', function (): void {
|
|||
|
||||
expect($domain)->toBeInstanceOf(ArcadiaBrand::class)
|
||||
->and((string) $domain->id->value)->toBe('1')
|
||||
->and($domain->name->value)->toBe('LE GAULOIS');
|
||||
->and($domain->name->value)->toBe('Le Gaulois');
|
||||
});
|
||||
|
||||
it('maps an object row to ArcadiaBrand domain VO', function (): void {
|
||||
|
|
@ -36,7 +36,7 @@ describe('ArcadiaBrandMapper', function (): void {
|
|||
|
||||
expect($domain)->toBeInstanceOf(ArcadiaBrand::class)
|
||||
->and((string) $domain->id->value)->toBe('2')
|
||||
->and($domain->name->value)->toBe('MAITRE COQ');
|
||||
->and($domain->name->value)->toBe('Maitre Coq');
|
||||
});
|
||||
|
||||
it('generates fallback name when libelle is empty', function (): void {
|
||||
|
|
@ -59,6 +59,6 @@ describe('ArcadiaBrandMapper', function (): void {
|
|||
$domain = ArcadiaBrandMapper::toDomain($row);
|
||||
|
||||
expect((string) $domain->id->value)->toBe('3')
|
||||
->and($domain->name->value)->toBe('LOUE');
|
||||
->and($domain->name->value)->toBe('Loue');
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -12,26 +12,6 @@ covers(IncoStringParser::class);
|
|||
uses(TestCase::class);
|
||||
|
||||
describe('IncoStringParser', function (): void {
|
||||
describe('protectiveDataFilter', function (): void {
|
||||
it('returns null when input is null', function (): void {
|
||||
expect(IncoStringParser::protectiveDataFilter(null))->toBeNull();
|
||||
});
|
||||
|
||||
it('returns empty string when input is empty', function (): void {
|
||||
expect(IncoStringParser::protectiveDataFilter(''))->toBe('');
|
||||
});
|
||||
|
||||
it('strips HTML tags and decodes HTML entities', function (): void {
|
||||
$input = '<p>Poulet & <strong>Dinde</strong></p>';
|
||||
expect(IncoStringParser::protectiveDataFilter($input))->toBe('Poulet & Dinde');
|
||||
});
|
||||
|
||||
it('preserves newlines and removes non-printable control characters', function (): void {
|
||||
$input = "Ligne 1\x00\x08\r\nLigne 2\x1F";
|
||||
expect(IncoStringParser::protectiveDataFilter($input))->toBe("Ligne 1\nLigne 2");
|
||||
});
|
||||
});
|
||||
|
||||
describe('toPhrase', function (): void {
|
||||
it('formats string as phrase with capitalized first letter and no trailing period', function (): void {
|
||||
expect(IncoStringParser::toPhrase('VOLAILLE DE QUALITE.'))->toBe('Volaille de qualite')
|
||||
|
|
@ -63,35 +43,4 @@ describe('IncoStringParser', function (): void {
|
|||
->and($result)->toContain('Cuisson au four.');
|
||||
});
|
||||
});
|
||||
|
||||
describe('mbStrtok', function (): void {
|
||||
it('tokenizes multibyte strings with delimiters', function (): void {
|
||||
$str = 'Gluten;Lait,Œufs';
|
||||
$delim = ';,';
|
||||
$first = IncoStringParser::mbStrtok($delim, $str);
|
||||
$second = IncoStringParser::mbStrtok($delim);
|
||||
$third = IncoStringParser::mbStrtok($delim);
|
||||
$fourth = IncoStringParser::mbStrtok($delim);
|
||||
|
||||
expect($first)->toBe('Gluten')
|
||||
->and($second)->toBe('Lait')
|
||||
->and($third)->toBe('Œufs')
|
||||
->and($fourth)->toBeFalse();
|
||||
});
|
||||
});
|
||||
|
||||
describe('slugify', function (): void {
|
||||
it('transliterates utf8 to ascii lowercase', function (): void {
|
||||
expect(IncoStringParser::slugify('Émincés & Rôti'))->toBe('eminces & roti');
|
||||
});
|
||||
});
|
||||
|
||||
describe('words', function (): void {
|
||||
it('truncates text to specified word count', function (): void {
|
||||
$text = 'Un deux trois quatre cinq six sept';
|
||||
|
||||
expect(IncoStringParser::words($text, 3, '...'))->toBe('Un deux trois...')
|
||||
->and(IncoStringParser::words($text, 10))->toBe($text);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -95,7 +95,7 @@ describe('BrandCache Unit Tests', function (): void {
|
|||
|
||||
$cacheData = [
|
||||
'id' => $uuid,
|
||||
'name' => 'Maître CoQ',
|
||||
'name' => 'Maître Coq',
|
||||
'code' => 'MCQ01',
|
||||
'arcadiaId' => '10',
|
||||
];
|
||||
|
|
@ -119,7 +119,7 @@ describe('BrandCache Unit Tests', function (): void {
|
|||
assert($result !== null);
|
||||
expect($result)->not->toBeNull()
|
||||
->and($result->arcadiaId->value)->toBe('10')
|
||||
->and($result->name->value)->toBe('Maître CoQ');
|
||||
->and($result->name->value)->toBe('Maître Coq');
|
||||
});
|
||||
|
||||
it('returns null and recovers gracefully when cache data is corrupted', function (): void {
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ describe('BrandDto Unit Tests', function (): void {
|
|||
it('creates BrandDto from BrandItem', function (): void {
|
||||
// GIVEN
|
||||
$id = new BrandId(Uuid::uuid7());
|
||||
$name = new BrandName('Maître CoQ');
|
||||
$name = new BrandName('Maître Coq');
|
||||
$code = new BrandCode('MCQ02');
|
||||
$arcadiaId = new ArcadiaId('2');
|
||||
$createdAt = new \DateTimeImmutable('2024-01-15T08:00:00Z');
|
||||
|
|
@ -72,7 +72,7 @@ describe('BrandDto Unit Tests', function (): void {
|
|||
|
||||
// THEN
|
||||
expect($dto->id)->toBe((string) $id)
|
||||
->and($dto->name)->toBe('Maître CoQ')
|
||||
->and($dto->name)->toBe('Maître Coq')
|
||||
->and($dto->code)->toBe('MCQ02')
|
||||
->and($dto->arcadiaId)->toBe('2');
|
||||
});
|
||||
|
|
|
|||
114
tests/Unit/Shared/Helpers/StringEncoderTest.php
Normal file
114
tests/Unit/Shared/Helpers/StringEncoderTest.php
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Tests\Unit\Shared\Helpers;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
use Shared\Helpers\StringEncoder;
|
||||
|
||||
covers(StringEncoder::class);
|
||||
|
||||
uses(TestCase::class);
|
||||
|
||||
describe('StringEncoder Unit Tests', function (): void {
|
||||
it('prevents direct instantiation', function (): void {
|
||||
$reflection = new \ReflectionClass(StringEncoder::class);
|
||||
|
||||
expect(fn () => $reflection->newInstance())
|
||||
->toThrow(\ReflectionException::class);
|
||||
});
|
||||
|
||||
describe('toUtf8', function (): void {
|
||||
it('returns empty string for empty input', function (): void {
|
||||
expect(StringEncoder::toUtf8('', 'UTF-8'))->toBe('')
|
||||
->and(StringEncoder::toUtf8('', 'Windows-1252'))->toBe('');
|
||||
});
|
||||
|
||||
it('passes valid UTF-8 through unchanged', function (): void {
|
||||
$utf8 = 'Émincés & Rôti de poulet fermier';
|
||||
expect(StringEncoder::toUtf8($utf8, 'UTF-8'))->toBe($utf8);
|
||||
});
|
||||
|
||||
it('converts Windows-1252 special characters to UTF-8', function (): void {
|
||||
// 0x80 (€), 0x8C (Œ), 0x9C (œ), 0x92 (’)
|
||||
$win1252 = "\x80 50 \x8Cuf \x9Cuf l\x92arbre";
|
||||
$expected = '€ 50 Œuf œuf l’arbre';
|
||||
|
||||
expect(StringEncoder::toUtf8($win1252, 'Windows-1252'))->toBe($expected);
|
||||
});
|
||||
|
||||
it('converts ISO-8859-15 specific characters to UTF-8', function (): void {
|
||||
// 0xA4 (€ in Latin-9), 0xBC (Œ), 0xBD (œ)
|
||||
$latin9 = "\xA4 50 \xBCuf \xBDuf";
|
||||
$expected = '€ 50 Œuf œuf';
|
||||
|
||||
expect(StringEncoder::toUtf8($latin9, 'ISO-8859-15'))->toBe($expected);
|
||||
});
|
||||
|
||||
it('supports encoding aliases case-insensitively', function (string $alias): void {
|
||||
$input = "\xE9"; // é in Latin-1/Win-1252
|
||||
expect(StringEncoder::toUtf8($input, $alias))->toBe('é');
|
||||
})->with(['windows-1252', 'WIN1252', 'cp1252', 'latin1', 'latin-1', 'iso-8859-1']);
|
||||
|
||||
it('strips UTF-8 BOM when stripBom is true', function (): void {
|
||||
$withBom = "\xEF\xBB\xBFHello World";
|
||||
expect(StringEncoder::toUtf8($withBom, 'UTF-8', stripBom: true))->toBe('Hello World')
|
||||
->and(StringEncoder::toUtf8($withBom, 'UTF-8', stripBom: false))->toBe($withBom);
|
||||
});
|
||||
|
||||
it('throws ValueError for unsupported encoding', function (): void {
|
||||
expect(fn () => StringEncoder::toUtf8('test', 'Shift-JIS'))
|
||||
->toThrow(\ValueError::class);
|
||||
});
|
||||
|
||||
it('throws ValueError for invalid UTF-8 in toUtf8 with UTF-8 encoding', function (): void {
|
||||
$invalidUtf8 = "\xC3\x28"; // Invalid UTF-8 sequence
|
||||
expect(fn () => StringEncoder::toUtf8($invalidUtf8, 'UTF-8'))
|
||||
->toThrow(\ValueError::class);
|
||||
});
|
||||
});
|
||||
|
||||
describe('detectAndConvertToUtf8', function (): void {
|
||||
it('returns empty string for empty input', function (): void {
|
||||
expect(StringEncoder::detectAndConvertToUtf8(''))->toBe('');
|
||||
});
|
||||
|
||||
it('preserves valid UTF-8 without re-encoding', function (): void {
|
||||
$utf8 = 'Volaille rôti bio';
|
||||
expect(StringEncoder::detectAndConvertToUtf8($utf8))->toBe($utf8);
|
||||
});
|
||||
|
||||
it('converts non-UTF8 strings using fallback encoding', function (): void {
|
||||
// Non-UTF-8: "é" in Windows-1252 is 0xE9
|
||||
$win1252 = "R\xE9gal du Volailler";
|
||||
expect(StringEncoder::detectAndConvertToUtf8($win1252, 'Windows-1252'))->toBe('Régal du Volailler');
|
||||
});
|
||||
|
||||
it('throws ValueError when fallbackEncoding is UTF-8', function (): void {
|
||||
expect(fn () => StringEncoder::detectAndConvertToUtf8('test', 'UTF-8'))
|
||||
->toThrow(\ValueError::class);
|
||||
});
|
||||
});
|
||||
|
||||
describe('arrayToUtf8', function (): void {
|
||||
it('converts an array of strings to UTF-8', function (): void {
|
||||
$inputs = ["\xE9", "\xE0", "\xE8"];
|
||||
$expected = ['é', 'à', 'è'];
|
||||
|
||||
expect(StringEncoder::arrayToUtf8($inputs, 'Windows-1252'))->toBe($expected);
|
||||
});
|
||||
});
|
||||
|
||||
describe('supportedEncodings', function (): void {
|
||||
it('returns list of all supported canonical and alias encodings', function (): void {
|
||||
$encodings = StringEncoder::supportedEncodings();
|
||||
|
||||
expect($encodings)->toContain('UTF-8')
|
||||
->and($encodings)->toContain('Windows-1252')
|
||||
->and($encodings)->toContain('ISO-8859-15')
|
||||
->and($encodings)->toContain('latin1')
|
||||
->and($encodings)->toContain('cp1252');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
|
@ -38,4 +38,73 @@ describe('StringHelper Unit Tests', function (): void {
|
|||
expect(StringHelper::transliterate($empty))->toBe('')
|
||||
->and(StringHelper::transliterate($ascii))->toBe('hello world 123');
|
||||
});
|
||||
|
||||
it('slugifies strings with custom separator', function (): void {
|
||||
expect(StringHelper::slugify('Émincés & Rôti'))->toBe('eminces-roti')
|
||||
->and(StringHelper::slugify('Émincés & Rôti', '_'))->toBe('eminces_roti')
|
||||
->and(StringHelper::slugify('Émincés & Rôti', ' '))->toBe('eminces roti')
|
||||
->and(StringHelper::slugify(''))->toBe('');
|
||||
});
|
||||
|
||||
it('converts strings to snake_case', function (): void {
|
||||
expect(StringHelper::snakeCase('fooBarBaz'))->toBe('foo_bar_baz')
|
||||
->and(StringHelper::snakeCase('HTTPResponseCode'))->toBe('http_response_code')
|
||||
->and(StringHelper::snakeCase('Le Gaulois Volaille'))->toBe('le_gaulois_volaille');
|
||||
});
|
||||
|
||||
it('converts strings to kebab-case', function (): void {
|
||||
expect(StringHelper::kebabCase('fooBarBaz'))->toBe('foo-bar-baz')
|
||||
->and(StringHelper::kebabCase('HTTPResponseCode'))->toBe('http-response-code');
|
||||
});
|
||||
|
||||
it('converts strings to titleCase, pascalCase, and camelCase', function (): void {
|
||||
expect(StringHelper::titleCase('LE GAULOIS'))->toBe('Le Gaulois')
|
||||
->and(StringHelper::titleCase('maître coq'))->toBe('Maître Coq')
|
||||
->and(StringHelper::titleCase(''))->toBe('')
|
||||
->and(StringHelper::pascalCase('foo_bar_baz'))->toBe('FooBarBaz')
|
||||
->and(StringHelper::camelCase('foo_bar_baz'))->toBe('fooBarBaz')
|
||||
->and(StringHelper::camelCase('HTTP_RESPONSE'))->toBe('httpResponse');
|
||||
});
|
||||
|
||||
it('truncates strings to word limits with custom ending', function (): void {
|
||||
$text = 'Un deux trois quatre cinq six';
|
||||
|
||||
expect(StringHelper::words($text, 3, '...'))->toBe('Un deux trois...')
|
||||
->and(StringHelper::words($text, 10))->toBe($text)
|
||||
->and(StringHelper::words(''))->toBe('');
|
||||
});
|
||||
|
||||
it('tokenizes multibyte strings with delimiters using mbStrtok', function (): void {
|
||||
$str = 'Gluten;Lait,Œufs';
|
||||
$delim = ';,';
|
||||
$first = StringHelper::mbStrtok($delim, $str);
|
||||
$second = StringHelper::mbStrtok($delim);
|
||||
$third = StringHelper::mbStrtok($delim);
|
||||
$fourth = StringHelper::mbStrtok($delim);
|
||||
|
||||
expect($first)->toBe('Gluten')
|
||||
->and($second)->toBe('Lait')
|
||||
->and($third)->toBe('Œufs')
|
||||
->and($fourth)->toBeFalse();
|
||||
});
|
||||
|
||||
describe('sanitize', function (): void {
|
||||
it('returns null when input is null', function (): void {
|
||||
expect(StringHelper::sanitize(null))->toBeNull();
|
||||
});
|
||||
|
||||
it('returns empty string when input is empty', function (): void {
|
||||
expect(StringHelper::sanitize(''))->toBe('');
|
||||
});
|
||||
|
||||
it('strips HTML tags and decodes HTML entities', function (): void {
|
||||
$input = '<p>Poulet & <strong>Dinde</strong></p>';
|
||||
expect(StringHelper::sanitize($input))->toBe('Poulet & Dinde');
|
||||
});
|
||||
|
||||
it('preserves newlines and removes non-printable control characters', function (): void {
|
||||
$input = "Ligne 1\x00\x08\r\nLigne 2\x1F";
|
||||
expect(StringHelper::sanitize($input))->toBe("Ligne 1\nLigne 2");
|
||||
});
|
||||
});
|
||||
});
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue