nur-sery/nur_src/txt.php

283 lines
9.2 KiB
PHP
Raw Normal View History

2023-12-03 22:10:18 +04:00
<?php
namespace nur;
/**
* Class txt: gestion des chaines de caractères multi-octets
*/
class txt {
/**
* Retourner $s converti en chaine, ou "" si $s est faux
*
* $strict indique s'il faut utiliser les règles de PHP pour décider si une
* valeur est fausse. Par exemple, en PHP la chaine "0" est fausse.
*
* ainsi:
* - with(0) vaut "0"
* - with("0") vaut "0"
* - with(0, true) vaut ""
* - with("0", true) vaut ""
*
* NB: cette méthode est identique à str::with()
*/
static final function with($s, bool $strict=false): string {
if (!is_string($s)) $s = strval($s);
if (!$strict) return $s;
elseif ($s) return $s;
else return "";
}
/**
* tronquer si nécessaire $s à la valeur $length
* la chaine $suffix est rajoutée le cas échéant de façon que la taille
* totale n'excède pas $length caractères.
*
* si $ellips est true et que le troncage est nécessaire, remplacer les 3
* derniers caractères par "..."
*/
static final function trunc($s, int $length, bool $ellips=false, ?string $suffix=null) {
if (base::z($s)) return $s;
$s = strval($s);
if ($suffix !== null) $length -= mb_strlen($suffix);
if (mb_strlen($s) > $length) {
if ($ellips && $length > 3) $s = mb_substr($s, 0, $length - 3)."...";
else $s = mb_substr($s, 0, $length);
}
if ($suffix !== null) $s .= $suffix;
return $s;
}
/** trimmer $s */
static final function trim($s) {
if (base::z($s)) return $s;
else return trim(strval($s));
}
/** trimmer $s à gauche */
static final function ltrim($s) {
if (base::z($s)) return $s;
else return ltrim(strval($s));
}
/** trimmer $s à droite */
static final function rtrim($s) {
if (base::z($s)) return $s;
else return rtrim(strval($s));
}
static final function lower($s) {
if (base::z($s)) return $s;
else return mb_strtolower(strval($s));
}
static final function lower1($s) {
if (base::z($s)) return $s;
$s = strval($s);
return mb_strtolower(mb_substr($s, 0, 1)).mb_substr($s, 1);
}
static final function upper($s) {
if (base::z($s)) return $s;
else return mb_strtoupper(strval($s));
}
static final function upper1($s) {
if (base::z($s)) return $s;
$s = strval($s);
return mb_strtoupper(mb_substr($s, 0, 1)).mb_substr($s, 1);
}
static final function upperw($s, ?string $delimiters=null) {
if (base::z($s)) return $s;
$s = strval($s);
if ($delimiters === null) $delimiters = " _-\t\r\n\f\v";
$pattern = "/([".preg_quote($delimiters)."])/u";
$words = preg_split($pattern, $s, -1, PREG_SPLIT_DELIM_CAPTURE);
$max = count($words) - 1;
$ucwords = [];
for ($i = 0; $i < $max; $i += 2) {
$s = $words[$i];
$ucwords[] = mb_strtoupper(mb_substr($s, 0, 1)).mb_substr($s, 1);
$ucwords[] = $words[$i + 1];
}
$s = $words[$max];
$ucwords[] = mb_strtoupper(mb_substr($s, 0, 1)).mb_substr($s, 1);
return implode("", $ucwords);
}
private static final function _starts_with(string $prefix, string $s, ?int $min_len=null): bool {
if ($prefix === $s) return true;
$len = mb_strlen($prefix);
if ($min_len !== null && ($len < $min_len || $len > mb_strlen($s))) return false;
return $len == 0 || $prefix === mb_substr($s, 0, $len);
}
/**
* tester si $s commence par $prefix
* par exemple:
* - starts_with("", "whatever") est true
* - starts_with("fi", "first") est true
* - starts_with("no", "yes") est false
*
* si $min_len n'est pas null, c'est la longueur minimum requise de $prefix
* pour qu'on teste la correspondance. dans le cas contraire, la valeur de
* retour est toujours false, sauf s'il y a égalité. e.g
* - starts_with("a", "abc", 2) est false
* - starts_with("a", "a", 2) est true
*/
static final function starts_with(?string $prefix, $s, ?int $min_len=null): bool {
if (base::z($s) || $prefix === null) return false;
else return self::_starts_with($prefix, strval($s), $min_len);
}
/** Retourner $s sans le préfixe $prefix s'il existe */
static final function without_prefix(?string $prefix, $s) {
if (base::z($s) || $prefix === null) return $s;
$s = strval($s);
if (self::_starts_with($prefix, $s)) {
$s = mb_substr($s, mb_strlen($prefix));
}
return $s;
}
/** modifier $s en place pour supprimer le préfixe $prefix s'il existe */
static final function del_prefix(&$s, ?string $prefix): void {
$s = self::without_prefix($prefix, $s);
}
/**
* Retourner $s avec le préfixe $prefix
*
* Si $unless_exists, ne pas ajouter le préfixe s'il existe déjà
*/
static final function with_prefix(?string $prefix, $s, ?string $sep=null, bool $unless_exists=false) {
if (base::z($s) || $prefix === null) return $s;
$s = strval($s);
if (!self::_starts_with($prefix, $s) || !$unless_exists) {
$s = $prefix.$sep.$s;
}
return $s;
}
/** modifier $s en place pour ajouter le préfixe $prefix */
static final function add_prefix(&$s, ?string $prefix, bool $unless_exists=true): void {
$s = self::with_prefix($prefix, $s, null, $unless_exists);
}
private static final function _ends_with(?string $suffix, string $s, ?int $min_len=null): bool {
if ($suffix === $s) return true;
$len = mb_strlen($suffix);
if ($min_len !== null && ($len < $min_len || $len > mb_strlen($s))) return false;
return $len == 0 || $suffix === mb_substr($s, -$len);
}
/**
* tester si $string se termine par $suffix. $prefix doit être de taille non nulle
* par exemple:
* - ends_with("", "whatever") est true
* - ends_with("st", "first") est true
* - ends_with("no", "yes") est false
*
* si $min_len n'est pas null, c'est la longueur minimum requise de $prefix
* pour qu'on teste la correspondance. dans le cas contraire, la valeur de
* retour est toujours false, sauf s'il y a égalité. e.g
* - ends_with("c", "abc", 2) est false
* - ends_with("c", "c", 2) est true
*/
static final function ends_with(?string $suffix, $s, ?int $min_len=null): bool {
if (base::z($s) || $suffix === null) return false;
else return self::_ends_with($suffix, strval($s), $min_len);
}
/** Retourner $s sans le suffixe $suffix s'il existe */
static final function without_suffix(?string $suffix, $s) {
if (base::z($s) || $suffix === null) return $s;
$s = strval($s);
if (self::_ends_with($suffix, $s)) {
$s = mb_substr($s, 0, -mb_strlen($suffix));
}
return $s;
}
/** modifier $s en place pour supprimer le suffixe $suffix s'il existe */
static final function del_suffix(&$s, ?string $suffix): void {
$s = self::without_suffix($suffix, $s);
}
/**
* Retourner $s avec le suffixe $suffix
*
* Si $unless_exists, ne pas ajouter le suffixe s'il existe déjà
*/
static final function with_suffix(?string $suffix, $s, ?string $sep=null, bool $unless_exists=false) {
if (base::z($s) || $suffix === null) return $s;
$s = strval($s);
if (!self::_ends_with($suffix, $s) || !$unless_exists) {
$s = $s.$sep.$suffix;
}
return $s;
}
/** modifier $s en place pour ajouter le suffixe $suffix */
static final function add_suffix(&$s, ?string $suffix, bool $unless_exists=true): void {
$s = self::with_suffix($suffix, $s, null, $unless_exists);
}
/**
* ajouter $sep$prefix$text$suffix à $s si $text est non vide
*
* NB: ne rajouter $sep que si $s est non vide
*/
static final function addsep(&$s, ?string $sep, ?string $text, ?string $prefix=null, ?string $suffix=null): void {
if (!$text) return;
if ($s) $s .= $sep;
$s .= $prefix.$text.$suffix;
}
/** si $text est non vide, ajouter $prefix$text$suffix à $s en séparant la valeur avec un espace */
static final function add(&$s, ?string $text, ?string $prefix=null, ?string $suffix=null): void {
self::addsep($s, " ", $text, $prefix, $suffix);
}
#############################################################################
# divers
/**
* convertir la chaine $text de l'utf-8 vers l'encoding $charset
*
* supprimer les caractères invalides éventuels, certaines versions de PHP
* ayant un bug avec iconv. (note: est-ce toujours le cas avec PHP >= 7.2 ?)
*/
static final function _convert_to(string $text, string $charset): string {
$text = mb_convert_encoding($text, "utf-8", "utf-8");
$text = @iconv("utf-8", $charset, $text);
if ($text === false) $text = "";
return $text;
}
static final function convert_to($text, string $charset) {
if (base::z($text)) return $text;
return self::_convert_to(strval($text), $charset);
}
/**
* supprimer les diacritiques de la chaine $text
*
* la translitération se fait avec les règles de la locale spécifiée.
* NB: la translitération ne fonctionne pas si LC_CTYPE == C ou POISX
*/
static final function _remove_diacritics(string $text, string $locale="fr_FR.UTF-8"): string {
#XXX est-ce thread-safe?
$olocale = setlocale(LC_CTYPE, 0);
setlocale(LC_CTYPE, $locale);
$text = @iconv("UTF-8", "US-ASCII//TRANSLIT", $text);
if ($text === false) $text = "";
setlocale(LC_CTYPE, $olocale);
return $text;
}
static final function remove_diacritics($text) {
if (base::z($text)) return $text;
return self::_remove_diacritics(strval($text));
}
}