|
|
<?php |
|
|
|
|
|
use ArrayAccess; |
|
|
use ArrayIterator; |
|
|
use Countable; |
|
|
use Exception; |
|
|
use InvalidArgumentException; |
|
|
use IteratorAggregate; |
|
|
use OutOfBoundsException; |
|
|
|
|
|
class mb_string implements Countable, IteratorAggregate, ArrayAccess |
|
|
{ |
|
|
/** |
|
|
* An instance's string. |
|
|
* |
|
|
* @var string |
|
|
*/ |
|
|
protected $str; |
|
|
|
|
|
/** |
|
|
* The string's encoding, which should be one of the mbstring module's |
|
|
* supported encodings. |
|
|
* |
|
|
* @var string |
|
|
*/ |
|
|
protected $encoding; |
|
|
|
|
|
/** |
|
|
* Modified by Trevor Herselman |
|
|
* Used when mapping a string to boolean with toBoolean() |
|
|
* |
|
|
* @var string |
|
|
*/ |
|
|
private static $boolMap = [ |
|
|
'true' => true, |
|
|
'1' => true, |
|
|
'on' => true, |
|
|
'yes' => true, |
|
|
'y' => true, // added by Trevor Herselman |
|
|
'false' => false, |
|
|
'0' => false, |
|
|
'off' => false, |
|
|
'no' => false, |
|
|
'n' => false // added by Trevor Herselman |
|
|
]; |
|
|
|
|
|
/** |
|
|
* Default string encoding. Will be used if no encoding is specified. |
|
|
* Value can changed at run-time with the static method {@link setDefaultEncoding()}. |
|
|
* Use null for auto-detection of encoding. |
|
|
* @var string |
|
|
*/ |
|
|
private static $_defaultEncoding = null; |
|
|
|
|
|
/** |
|
|
* Idea taken from CakePHP: https://api.cakephp.org/2.3/class-CakeRequest.html#$_detectors |
|
|
* https://api.cakephp.org/2.3/source-class-CakeRequest.html#92-117 |
|
|
* |
|
|
* @var mixed[] Array of built in detectors used with is($type) or is$type(), can be modified with addDetector(). |
|
|
*/ |
|
|
private static $_detectors = null; // ['dotcom' => function(&$uri){return substr($uri->host, -4) === '.com'}] eg. isDotCom() || is('DotCom') || is('.com') (the '.com' version cannot be tested with is.com()!) |
|
|
// ['domain' => function(&$uri, $domain){return substr($uri->host, -strlen($uri->host)) === $domain}] // isDomain('example.com') || isDomain('.com') || is('domain', '.com') |
|
|
|
|
|
/** |
|
|
* Initializes a Stringy object and assigns both str and encoding properties |
|
|
* the supplied values. $str is cast to a string prior to assignment, and if |
|
|
* $encoding is not specified, it defaults to mb_internal_encoding(). Throws |
|
|
* an InvalidArgumentException if the first argument is an array or object |
|
|
* without a __toString method. |
|
|
* |
|
|
* @param mixed $str Value to modify, after being cast to string |
|
|
* @param string $encoding The character encoding |
|
|
* @throws \InvalidArgumentException if an array or object without a |
|
|
* __toString method is passed as the first argument |
|
|
*/ |
|
|
public function __construct($str = '', $encoding = null) |
|
|
{ |
|
|
if ( ! is_string($str)) { |
|
|
if (is_array($str)) { |
|
|
throw new InvalidArgumentException('Passed value cannot be an array'; |
|
|
} elseif (is_object($str) && !method_exists($str, '__toString')) { |
|
|
throw new InvalidArgumentException('Passed object must have a __toString method'); |
|
|
} |
|
|
} |
|
|
|
|
|
$this->str = (string) $str; |
|
|
$this->encoding = $encoding ?: \mb_internal_encoding(); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Function added by Trevor Herselman |
|
|
* Concats a string and returns the new one. |
|
|
* Actually, it is the same as the dot operator. |
|
|
* @param string $args,... Variable number of strings to concatenate. Returns a single Mb object. |
|
|
* @return static A Stringy object |
|
|
*/ |
|
|
public function concat() |
|
|
{ |
|
|
$args = func_get_args(); |
|
|
$str = $this->str; |
|
|
foreach ($args as $arg) |
|
|
{ |
|
|
$str .= (string) $arg; |
|
|
} |
|
|
return new static($str); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Creates a Stringy object and assigns both str and encoding properties |
|
|
* the supplied values. $str is cast to a string prior to assignment, and if |
|
|
* $encoding is not specified, it defaults to mb_internal_encoding(). It |
|
|
* then returns the initialized object. Throws an InvalidArgumentException |
|
|
* if the first argument is an array or object without a __toString method. |
|
|
* |
|
|
* @param mixed $str Value to modify, after being cast to string |
|
|
* @param string $encoding The character encoding |
|
|
* @return static A Stringy object |
|
|
* @throws \InvalidArgumentException if an array or object without a |
|
|
* __toString method is passed as the first argument |
|
|
*/ |
|
|
public static function create($str = '', $encoding = null) |
|
|
{ |
|
|
return new static($str, $encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Added by Trevor Herselman |
|
|
* Alias of {@link auto()}. |
|
|
* |
|
|
* @param mixed $str Value to modify, after being cast to string |
|
|
* @param string $encoding The character encoding |
|
|
* @return static A Stringy object |
|
|
* @throws \InvalidArgumentException if an array or object without a |
|
|
* __toString method is passed as the first argument |
|
|
*/ |
|
|
public static function detect($str = '') |
|
|
{ |
|
|
return new static($str, mb_detect_encoding($str)); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Added by Trevor Herselman |
|
|
* Alias of {@link detect()}. |
|
|
* |
|
|
* @param mixed $str Value to modify, after being cast to string |
|
|
* @param string $encoding The character encoding |
|
|
* @return static A Stringy object |
|
|
* @throws \InvalidArgumentException if an array or object without a |
|
|
* __toString method is passed as the first argument |
|
|
*/ |
|
|
public static function auto($str = '') |
|
|
{ |
|
|
return new static($str, mb_detect_encoding($str)); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the value in $str. |
|
|
* |
|
|
* @return string The current value of the $str property |
|
|
*/ |
|
|
public function __toString() |
|
|
{ |
|
|
return $this->str; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a new string with $string appended. |
|
|
* |
|
|
* @param string $string The string to append |
|
|
* @return static Object with appended $string |
|
|
*/ |
|
|
public function append($string) |
|
|
{ |
|
|
return static::create($this->str . $string, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the character at $index, with indexes starting at 0. |
|
|
* |
|
|
* @param int $index Position of the character |
|
|
* @return static The character at $index |
|
|
*/ |
|
|
public function at($index) |
|
|
{ |
|
|
return $this->substr($index, 1); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the substring between $start and $end, if found, or an empty |
|
|
* string. An optional offset may be supplied from which to begin the |
|
|
* search for the start string. |
|
|
* |
|
|
* @param string $start Delimiter marking the start of the substring |
|
|
* @param string $end Delimiter marking the end of the substring |
|
|
* @param int $offset Index from which to begin the search |
|
|
* @return static Object whose $str is a substring between $start and $end |
|
|
*/ |
|
|
public function between($start, $end, $offset = 0) |
|
|
{ |
|
|
$startIndex = $this->indexOf($start, $offset); |
|
|
if ($startIndex === false) { |
|
|
return static::create('', $this->encoding); |
|
|
} |
|
|
|
|
|
$substrIndex = $startIndex + \mb_strlen($start, $this->encoding); |
|
|
$endIndex = $this->indexOf($end, $substrIndex); |
|
|
if ($endIndex === false) { |
|
|
return static::create('', $this->encoding); |
|
|
} |
|
|
|
|
|
return $this->substr($substrIndex, $endIndex - $substrIndex); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a camelCase version of the string. Trims surrounding spaces, |
|
|
* capitalizes letters following digits, spaces, dashes and underscores, |
|
|
* and removes spaces, dashes, as well as underscores. |
|
|
* |
|
|
* @return static Object with $str in camelCase |
|
|
*/ |
|
|
public function camelize() |
|
|
{ |
|
|
$encoding = $this->encoding; |
|
|
$stringy = $this->trim()->lowerCaseFirst(); |
|
|
$stringy->str = preg_replace('/^[-_]+/', '', $stringy->str); |
|
|
|
|
|
$stringy->str = preg_replace_callback( |
|
|
'/[-_\s]+(.)?/u', |
|
|
function ($match) use ($encoding) { |
|
|
if (isset($match[1])) { |
|
|
return \mb_strtoupper($match[1], $encoding); |
|
|
} |
|
|
|
|
|
return ''; |
|
|
}, |
|
|
$stringy->str |
|
|
); |
|
|
|
|
|
$stringy->str = preg_replace_callback( |
|
|
'/[\d]+(.)?/u', |
|
|
function ($match) use ($encoding) { |
|
|
return \mb_strtoupper($match[0], $encoding); |
|
|
}, |
|
|
$stringy->str |
|
|
); |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns an array consisting of the characters in the string. |
|
|
* |
|
|
* @return array An array of string chars |
|
|
*/ |
|
|
public function chars() |
|
|
{ |
|
|
$chars = []; |
|
|
for ($i = 0, $l = $this->length(); $i < $l; $i++) { |
|
|
$chars[] = $this->at($i)->str; |
|
|
} |
|
|
|
|
|
return $chars; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Trims the string and replaces consecutive whitespace characters with a |
|
|
* single space. This includes tabs and newline characters, as well as |
|
|
* multibyte whitespace such as the thin space and ideographic space. |
|
|
* |
|
|
* @return static Object with a trimmed $str and condensed whitespace |
|
|
*/ |
|
|
public function collapseWhitespace() |
|
|
{ |
|
|
return $this->regexReplace('[[:space:]]+', ' ')->trim(); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains $needle, false otherwise. By default |
|
|
* the comparison is case-sensitive, but can be made insensitive by setting |
|
|
* $caseSensitive to false. |
|
|
* |
|
|
* @param string $needle Substring to look for |
|
|
* @param bool $caseSensitive Whether or not to enforce case-sensitivity |
|
|
* @return bool Whether or not $str contains $needle |
|
|
*/ |
|
|
public function contains($needle, $caseSensitive = true) |
|
|
{ |
|
|
$encoding = $this->encoding; |
|
|
|
|
|
if ($caseSensitive) { |
|
|
return (\mb_strpos($this->str, $needle, 0, $encoding) !== false); |
|
|
} |
|
|
|
|
|
return (\mb_stripos($this->str, $needle, 0, $encoding) !== false); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains all $needles, false otherwise. By |
|
|
* default the comparison is case-sensitive, but can be made insensitive by |
|
|
* setting $caseSensitive to false. |
|
|
* |
|
|
* @param string[] $needles Substrings to look for |
|
|
* @param bool $caseSensitive Whether or not to enforce case-sensitivity |
|
|
* @return bool Whether or not $str contains $needle |
|
|
*/ |
|
|
public function containsAll($needles, $caseSensitive = true) |
|
|
{ |
|
|
if (empty($needles)) { |
|
|
return false; |
|
|
} |
|
|
|
|
|
foreach ($needles as $needle) { |
|
|
if (!$this->contains($needle, $caseSensitive)) { |
|
|
return false; |
|
|
} |
|
|
} |
|
|
|
|
|
return true; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains any $needles, false otherwise. By |
|
|
* default the comparison is case-sensitive, but can be made insensitive by |
|
|
* setting $caseSensitive to false. |
|
|
* |
|
|
* @param string[] $needles Substrings to look for |
|
|
* @param bool $caseSensitive Whether or not to enforce case-sensitivity |
|
|
* @return bool Whether or not $str contains $needle |
|
|
*/ |
|
|
public function containsAny($needles, $caseSensitive = true) |
|
|
{ |
|
|
if (empty($needles)) { |
|
|
return false; |
|
|
} |
|
|
|
|
|
foreach ($needles as $needle) { |
|
|
if ($this->contains($needle, $caseSensitive)) { |
|
|
return true; |
|
|
} |
|
|
} |
|
|
|
|
|
return false; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the length of the string, implementing the countable interface. |
|
|
* |
|
|
* @return int The number of characters in the string, given the encoding |
|
|
*/ |
|
|
public function count() |
|
|
{ |
|
|
return $this->length(); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the number of occurrences of $substring in the given string. |
|
|
* By default, the comparison is case-sensitive, but can be made insensitive |
|
|
* by setting $caseSensitive to false. |
|
|
* |
|
|
* @param string $substring The substring to search for |
|
|
* @param bool $caseSensitive Whether or not to enforce case-sensitivity |
|
|
* @return int The number of $substring occurrences |
|
|
*/ |
|
|
public function countSubstr($substring, $caseSensitive = true) |
|
|
{ |
|
|
if ($caseSensitive) { |
|
|
return \mb_substr_count($this->str, $substring, $this->encoding); |
|
|
} |
|
|
|
|
|
$str = \mb_strtoupper($this->str, $this->encoding); |
|
|
$substring = \mb_strtoupper($substring, $this->encoding); |
|
|
|
|
|
return \mb_substr_count($str, $substring, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a lowercase and trimmed string separated by dashes. Dashes are |
|
|
* inserted before uppercase characters (with the exception of the first |
|
|
* character of the string), and in place of spaces as well as underscores. |
|
|
* |
|
|
* @return static Object with a dasherized $str |
|
|
*/ |
|
|
public function dasherize() |
|
|
{ |
|
|
return $this->delimit('-'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a lowercase and trimmed string separated by the given delimiter. |
|
|
* Delimiters are inserted before uppercase characters (with the exception |
|
|
* of the first character of the string), and in place of spaces, dashes, |
|
|
* and underscores. Alpha delimiters are not converted to lowercase. |
|
|
* |
|
|
* @param string $delimiter Sequence used to separate parts of the string |
|
|
* @return static Object with a delimited $str |
|
|
*/ |
|
|
public function delimit($delimiter) |
|
|
{ |
|
|
$regexEncoding = $this->regexEncoding(); |
|
|
$this->regexEncoding($this->encoding); |
|
|
|
|
|
$str = $this->eregReplace('\B([A-Z])', '-\1', $this->trim()); |
|
|
$str = \mb_strtolower($str, $this->encoding); |
|
|
$str = $this->eregReplace('[-_\s]+', $delimiter, $str); |
|
|
|
|
|
$this->regexEncoding($regexEncoding); |
|
|
|
|
|
return static::create($str, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string ends with $substring, false otherwise. By |
|
|
* default, the comparison is case-sensitive, but can be made insensitive |
|
|
* by setting $caseSensitive to false. |
|
|
* |
|
|
* @param string $substring The substring to look for |
|
|
* @param bool $caseSensitive Whether or not to enforce case-sensitivity |
|
|
* @return bool Whether or not $str ends with $substring |
|
|
*/ |
|
|
public function endsWith($substring, $caseSensitive = true) |
|
|
{ |
|
|
$substringLength = \mb_strlen($substring, $this->encoding); |
|
|
$strLength = $this->length(); |
|
|
|
|
|
$endOfStr = \mb_substr($this->str, $strLength - $substringLength, |
|
|
$substringLength, $this->encoding); |
|
|
|
|
|
if (!$caseSensitive) { |
|
|
$substring = \mb_strtolower($substring, $this->encoding); |
|
|
$endOfStr = \mb_strtolower($endOfStr, $this->encoding); |
|
|
} |
|
|
|
|
|
return (string) $substring === $endOfStr; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string ends with any of $substrings, false otherwise. |
|
|
* By default, the comparison is case-sensitive, but can be made insensitive |
|
|
* by setting $caseSensitive to false. |
|
|
* |
|
|
* @param string[] $substrings Substrings to look for |
|
|
* @param bool $caseSensitive Whether or not to enforce |
|
|
* case-sensitivity |
|
|
* @return bool Whether or not $str ends with $substring |
|
|
*/ |
|
|
public function endsWithAny($substrings, $caseSensitive = true) |
|
|
{ |
|
|
if (empty($substrings)) { |
|
|
return false; |
|
|
} |
|
|
|
|
|
foreach ($substrings as $substring) { |
|
|
if ($this->endsWith($substring, $caseSensitive)) { |
|
|
return true; |
|
|
} |
|
|
} |
|
|
|
|
|
return false; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Ensures that the string begins with $substring. If it doesn't, it's |
|
|
* prepended. |
|
|
* |
|
|
* @param string $substring The substring to add if not present |
|
|
* @return static Object with its $str prefixed by the $substring |
|
|
*/ |
|
|
public function ensureLeft($substring) |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
|
|
|
if (!$stringy->startsWith($substring)) { |
|
|
$stringy->str = $substring . $stringy->str; |
|
|
} |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Ensures that the string ends with $substring. If it doesn't, it's |
|
|
* appended. |
|
|
* |
|
|
* @param string $substring The substring to add if not present |
|
|
* @return static Object with its $str suffixed by the $substring |
|
|
*/ |
|
|
public function ensureRight($substring) |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
|
|
|
if (!$stringy->endsWith($substring)) { |
|
|
$stringy->str .= $substring; |
|
|
} |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the first $n characters of the string. |
|
|
* |
|
|
* @param int $n Number of characters to retrieve from the start |
|
|
* @return static Object with its $str being the first $n chars |
|
|
*/ |
|
|
public function first($n) |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
|
|
|
if ($n < 0) { |
|
|
$stringy->str = ''; |
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
return $stringy->substr(0, $n); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the encoding used by the Stringy object. |
|
|
* |
|
|
* @return string The current value of the $encoding property |
|
|
*/ |
|
|
public function getEncoding() |
|
|
{ |
|
|
return $this->encoding; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a new ArrayIterator, thus implementing the IteratorAggregate |
|
|
* interface. The ArrayIterator's constructor is passed an array of chars |
|
|
* in the multibyte string. This enables the use of foreach with instances |
|
|
* of Stringy\Stringy. |
|
|
* |
|
|
* @return \ArrayIterator An iterator for the characters in the string |
|
|
*/ |
|
|
public function getIterator() |
|
|
{ |
|
|
return new ArrayIterator($this->chars()); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Name taken from .NET Framework: https://msdn.microsoft.com/en-us/library/system.uri.gethashcode.aspx |
|
|
* By default it uses `crc32`, which I think returns the hex values, but I think .NET returns the integer value, problem is with the negative values !?!? |
|
|
* |
|
|
* @return int |
|
|
*/ |
|
|
public function hash(string $algo = 'md5', bool $raw_output = false) |
|
|
{ |
|
|
return hash($algo, $this->str, $raw_output); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains a lower case char, false |
|
|
* otherwise. |
|
|
* |
|
|
* @return bool Whether or not the string contains a lower case character. |
|
|
*/ |
|
|
public function hasLowerCase() |
|
|
{ |
|
|
return $this->matchesPattern('.*[[:lower:]]'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains an upper case char, false |
|
|
* otherwise. |
|
|
* |
|
|
* @return bool Whether or not the string contains an upper case character. |
|
|
*/ |
|
|
public function hasUpperCase() |
|
|
{ |
|
|
return $this->matchesPattern('.*[[:upper:]]'); |
|
|
} |
|
|
|
|
|
|
|
|
/** |
|
|
* Convert all HTML entities to their applicable characters. An alias of |
|
|
* html_entity_decode. For a list of flags, refer to |
|
|
* http://php.net/manual/en/function.html-entity-decode.php |
|
|
* |
|
|
* @param int|null $flags Optional flags |
|
|
* @return static Object with the resulting $str after being html decoded. |
|
|
*/ |
|
|
public function htmlDecode($flags = ENT_COMPAT) |
|
|
{ |
|
|
return static::create(html_entity_decode($this->str, $flags, $this->encoding), $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Convert all applicable characters to HTML entities. An alias of |
|
|
* htmlentities. Refer to http://php.net/manual/en/function.htmlentities.php |
|
|
* for a list of flags. |
|
|
* |
|
|
* @param int|null $flags Optional flags |
|
|
* @return static Object with the resulting $str after being html encoded. |
|
|
*/ |
|
|
public function htmlEncode($flags = ENT_COMPAT) |
|
|
{ |
|
|
return static::create(htmlentities($this->str, $flags, $this->encoding), $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Capitalizes the first word of the string, replaces underscores with |
|
|
* spaces, and strips '_id'. |
|
|
* |
|
|
* @return static Object with a humanized $str |
|
|
*/ |
|
|
public function humanize() |
|
|
{ |
|
|
return static::create( |
|
|
str_replace(['_id', '_'], ['', ' '], $this->str), |
|
|
$this->encoding)->trim()->upperCaseFirst(); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the index of the first occurrence of $needle in the string, |
|
|
* and false if not found. Accepts an optional offset from which to begin |
|
|
* the search. |
|
|
* |
|
|
* @param string $needle Substring to look for |
|
|
* @param int $offset Offset from which to search |
|
|
* @return int|bool The occurrence's index if found, otherwise false |
|
|
*/ |
|
|
public function indexOf($needle, $offset = 0) |
|
|
{ |
|
|
return \mb_strpos($this->str, (string) $needle, (int) $offset, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the index of the last occurrence of $needle in the string, |
|
|
* and false if not found. Accepts an optional offset from which to begin |
|
|
* the search. Offsets may be negative to count from the last character |
|
|
* in the string. |
|
|
* |
|
|
* @param string $needle Substring to look for |
|
|
* @param int $offset Offset from which to search |
|
|
* @return int|bool The last occurrence's index if found, otherwise false |
|
|
*/ |
|
|
public function indexOfLast($needle, $offset = 0) |
|
|
{ |
|
|
return \mb_strrpos($this->str, (string) $needle, (int) $offset, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Inserts $substring into the string at the $index provided. |
|
|
* |
|
|
* @param string $substring String to be inserted |
|
|
* @param int $index The index at which to insert the substring |
|
|
* @return static Object with the resulting $str after the insertion |
|
|
*/ |
|
|
public function insert($substring, $index) |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
if ($index > $stringy->length()) { |
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
$start = \mb_substr($stringy->str, 0, $index, $stringy->encoding); |
|
|
$end = \mb_substr($stringy->str, $index, $stringy->length(), $stringy->encoding); |
|
|
|
|
|
$stringy->str = $start . $substring . $end; |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains only alphabetic chars, false |
|
|
* otherwise. |
|
|
* |
|
|
* @return bool Whether or not $str contains only alphabetic chars |
|
|
*/ |
|
|
public function isAlpha() |
|
|
{ |
|
|
return $this->matchesPattern('^[[:alpha:]]*$'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains only alphabetic and numeric chars, |
|
|
* false otherwise. |
|
|
* |
|
|
* @return bool Whether or not $str contains only alphanumeric chars |
|
|
*/ |
|
|
public function isAlphanumeric() |
|
|
{ |
|
|
return $this->matchesPattern('^[[:alnum:]]*$'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains only whitespace chars, false |
|
|
* otherwise. |
|
|
* |
|
|
* @return bool Whether or not $str contains only whitespace characters |
|
|
*/ |
|
|
public function isBlank() |
|
|
{ |
|
|
return $this->matchesPattern('^[[:space:]]*$'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains only hexadecimal chars, false |
|
|
* otherwise. |
|
|
* |
|
|
* @return bool Whether or not $str contains only hexadecimal chars |
|
|
*/ |
|
|
public function isHexadecimal() |
|
|
{ |
|
|
return $this->matchesPattern('^[[:xdigit:]]*$'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string is JSON, false otherwise. Unlike json_decode |
|
|
* in PHP 5.x, this method is consistent with PHP 7 and other JSON parsers, |
|
|
* in that an empty string is not considered valid JSON. |
|
|
* |
|
|
* @return bool Whether or not $str is JSON |
|
|
*/ |
|
|
public function isJson() |
|
|
{ |
|
|
if (!$this->length()) { |
|
|
return false; |
|
|
} |
|
|
|
|
|
json_decode($this->str); |
|
|
|
|
|
return (json_last_error() === JSON_ERROR_NONE); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains only lower case chars, false |
|
|
* otherwise. |
|
|
* |
|
|
* @return bool Whether or not $str contains only lower case characters |
|
|
*/ |
|
|
public function isLowerCase() |
|
|
{ |
|
|
return $this->matchesPattern('^[[:lower:]]*$'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string is serialized, false otherwise. |
|
|
* |
|
|
* @return bool Whether or not $str is serialized |
|
|
*/ |
|
|
public function isSerialized() |
|
|
{ |
|
|
return $this->str === 'b:0;' || @unserialize($this->str) !== false; |
|
|
} |
|
|
|
|
|
|
|
|
/** |
|
|
* Returns true if the string is base64 encoded, false otherwise. |
|
|
* |
|
|
* @return bool Whether or not $str is base64 encoded |
|
|
*/ |
|
|
public function isBase64() |
|
|
{ |
|
|
return (base64_encode(base64_decode($this->str, true)) === $this->str); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string contains only lower case chars, false |
|
|
* otherwise. |
|
|
* |
|
|
* @return bool Whether or not $str contains only lower case characters |
|
|
*/ |
|
|
public function isUpperCase() |
|
|
{ |
|
|
return $this->matchesPattern('^[[:upper:]]*$'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the last $n characters of the string. |
|
|
* |
|
|
* @param int $n Number of characters to retrieve from the end |
|
|
* @return static Object with its $str being the last $n chars |
|
|
*/ |
|
|
public function last($n) |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
|
|
|
if ($n <= 0) { |
|
|
$stringy->str = ''; |
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
return $stringy->substr(-$n); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the length of the string. An alias for PHP's mb_strlen() function. |
|
|
* |
|
|
* @return int The number of characters in $str given the encoding |
|
|
*/ |
|
|
public function length() |
|
|
{ |
|
|
return \mb_strlen($this->str, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Splits on newlines and carriage returns, returning an array of Stringy |
|
|
* objects corresponding to the lines in the string. |
|
|
* |
|
|
* @return static[] An array of Stringy objects |
|
|
*/ |
|
|
public function lines() |
|
|
{ |
|
|
$array = $this->split('[\r\n]{1,2}', $this->str); |
|
|
for ($i = 0; $i < count($array); $i++) { |
|
|
$array[$i] = static::create($array[$i], $this->encoding); |
|
|
} |
|
|
|
|
|
return $array; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the longest common prefix between the string and $otherStr. |
|
|
* |
|
|
* @param string $otherStr Second string for comparison |
|
|
* @return static Object with its $str being the longest common prefix |
|
|
*/ |
|
|
public function longestCommonPrefix($otherStr) |
|
|
{ |
|
|
$encoding = $this->encoding; |
|
|
$maxLength = min($this->length(), \mb_strlen($otherStr, $encoding)); |
|
|
|
|
|
$longestCommonPrefix = ''; |
|
|
for ($i = 0; $i < $maxLength; $i++) { |
|
|
$char = \mb_substr($this->str, $i, 1, $encoding); |
|
|
|
|
|
if ($char == \mb_substr($otherStr, $i, 1, $encoding)) { |
|
|
$longestCommonPrefix .= $char; |
|
|
} else { |
|
|
break; |
|
|
} |
|
|
} |
|
|
|
|
|
return static::create($longestCommonPrefix, $encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the longest common suffix between the string and $otherStr. |
|
|
* |
|
|
* @param string $otherStr Second string for comparison |
|
|
* @return static Object with its $str being the longest common suffix |
|
|
*/ |
|
|
public function longestCommonSuffix($otherStr) |
|
|
{ |
|
|
$encoding = $this->encoding; |
|
|
$maxLength = min($this->length(), \mb_strlen($otherStr, $encoding)); |
|
|
|
|
|
$longestCommonSuffix = ''; |
|
|
for ($i = 1; $i <= $maxLength; $i++) { |
|
|
$char = \mb_substr($this->str, -$i, 1, $encoding); |
|
|
|
|
|
if ($char == \mb_substr($otherStr, -$i, 1, $encoding)) { |
|
|
$longestCommonSuffix = $char . $longestCommonSuffix; |
|
|
} else { |
|
|
break; |
|
|
} |
|
|
} |
|
|
|
|
|
return static::create($longestCommonSuffix, $encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the longest common substring between the string and $otherStr. |
|
|
* In the case of ties, it returns that which occurs first. |
|
|
* |
|
|
* @param string $otherStr Second string for comparison |
|
|
* @return static Object with its $str being the longest common substring |
|
|
*/ |
|
|
public function longestCommonSubstring($otherStr) |
|
|
{ |
|
|
// Uses dynamic programming to solve |
|
|
// http://en.wikipedia.org/wiki/Longest_common_substring_problem |
|
|
$encoding = $this->encoding; |
|
|
$stringy = static::create($this->str, $encoding); |
|
|
$strLength = $stringy->length(); |
|
|
$otherLength = \mb_strlen($otherStr, $encoding); |
|
|
|
|
|
// Return if either string is empty |
|
|
if ($strLength == 0 || $otherLength == 0) { |
|
|
$stringy->str = ''; |
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
$len = 0; |
|
|
$end = 0; |
|
|
$table = array_fill(0, $strLength + 1, |
|
|
array_fill(0, $otherLength + 1, 0)); |
|
|
|
|
|
for ($i = 1; $i <= $strLength; $i++) { |
|
|
for ($j = 1; $j <= $otherLength; $j++) { |
|
|
$strChar = \mb_substr($stringy->str, $i - 1, 1, $encoding); |
|
|
$otherChar = \mb_substr($otherStr, $j - 1, 1, $encoding); |
|
|
|
|
|
if ($strChar == $otherChar) { |
|
|
$table[$i][$j] = $table[$i - 1][$j - 1] + 1; |
|
|
if ($table[$i][$j] > $len) { |
|
|
$len = $table[$i][$j]; |
|
|
$end = $i; |
|
|
} |
|
|
} else { |
|
|
$table[$i][$j] = 0; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
$stringy->str = \mb_substr($stringy->str, $end - $len, $len, $encoding); |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Converts the first character of the string to lower case. |
|
|
* |
|
|
* @return static Object with the first character of $str being lower case |
|
|
*/ |
|
|
public function lowerCaseFirst() |
|
|
{ |
|
|
$first = \mb_substr($this->str, 0, 1, $this->encoding); |
|
|
$rest = \mb_substr($this->str, 1, $this->length() - 1, |
|
|
$this->encoding); |
|
|
|
|
|
$str = \mb_strtolower($first, $this->encoding) . $rest; |
|
|
|
|
|
return static::create($str, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns whether or not a character exists at an index. Offsets may be |
|
|
* negative to count from the last character in the string. Implements |
|
|
* part of the ArrayAccess interface. |
|
|
* |
|
|
* @param mixed $offset The index to check |
|
|
* @return boolean Whether or not the index exists |
|
|
*/ |
|
|
public function offsetExists($offset) |
|
|
{ |
|
|
$length = $this->length(); |
|
|
$offset = (int) $offset; |
|
|
|
|
|
if ($offset >= 0) { |
|
|
return ($length > $offset); |
|
|
} |
|
|
|
|
|
return ($length >= abs($offset)); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the character at the given index. Offsets may be negative to |
|
|
* count from the last character in the string. Implements part of the |
|
|
* ArrayAccess interface, and throws an OutOfBoundsException if the index |
|
|
* does not exist. |
|
|
* |
|
|
* @param mixed $offset The index from which to retrieve the char |
|
|
* @return mixed The character at the specified index |
|
|
* @throws \OutOfBoundsException If the positive or negative offset does |
|
|
* not exist |
|
|
*/ |
|
|
public function offsetGet($offset) |
|
|
{ |
|
|
$offset = (int) $offset; |
|
|
$length = $this->length(); |
|
|
|
|
|
if (($offset >= 0 && $length <= $offset) || $length < abs($offset)) { |
|
|
throw new OutOfBoundsException('No character exists at the index'); |
|
|
} |
|
|
|
|
|
return \mb_substr($this->str, $offset, 1, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Implements part of the ArrayAccess interface, but throws an exception |
|
|
* when called. This maintains the immutability of Stringy objects. |
|
|
* |
|
|
* @param mixed $offset The index of the character |
|
|
* @param mixed $value Value to set |
|
|
* @throws \Exception When called |
|
|
*/ |
|
|
public function offsetSet($offset, $value) |
|
|
{ |
|
|
// Stringy is immutable, cannot directly set char |
|
|
throw new Exception('Stringy object is immutable, cannot modify char'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Implements part of the ArrayAccess interface, but throws an exception |
|
|
* when called. This maintains the immutability of Stringy objects. |
|
|
* |
|
|
* @param mixed $offset The index of the character |
|
|
* @throws \Exception When called |
|
|
*/ |
|
|
public function offsetUnset($offset) |
|
|
{ |
|
|
// Don't allow directly modifying the string |
|
|
throw new Exception('Stringy object is immutable, cannot unset char'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Pads the string to a given length with $padStr. If length is less than |
|
|
* or equal to the length of the string, no padding takes places. The |
|
|
* default string used for padding is a space, and the default type (one of |
|
|
* 'left', 'right', 'both') is 'right'. Throws an InvalidArgumentException |
|
|
* if $padType isn't one of those 3 values. |
|
|
* |
|
|
* @param int $length Desired string length after padding |
|
|
* @param string $padStr String used to pad, defaults to space |
|
|
* @param string $padType One of 'left', 'right', 'both' |
|
|
* @return static Object with a padded $str |
|
|
* @throws /InvalidArgumentException If $padType isn't one of 'right', |
|
|
* 'left' or 'both' |
|
|
*/ |
|
|
public function pad($length, $padStr = ' ', $padType = 'right') |
|
|
{ |
|
|
if (!in_array($padType, ['left', 'right', 'both'])) { |
|
|
throw new InvalidArgumentException('Pad expects $padType ' . |
|
|
"to be one of 'left', 'right' or 'both'"); |
|
|
} |
|
|
|
|
|
switch ($padType) { |
|
|
case 'left': |
|
|
return $this->padLeft($length, $padStr); |
|
|
case 'right': |
|
|
return $this->padRight($length, $padStr); |
|
|
default: |
|
|
return $this->padBoth($length, $padStr); |
|
|
} |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a new string of a given length such that both sides of the |
|
|
* string are padded. Alias for pad() with a $padType of 'both'. |
|
|
* |
|
|
* @param int $length Desired string length after padding |
|
|
* @param string $padStr String used to pad, defaults to space |
|
|
* @return static String with padding applied |
|
|
*/ |
|
|
public function padBoth($length, $padStr = ' ') |
|
|
{ |
|
|
$padding = $length - $this->length(); |
|
|
|
|
|
return $this->applyPadding(floor($padding / 2), ceil($padding / 2), $padStr); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a new string of a given length such that the beginning of the |
|
|
* string is padded. Alias for pad() with a $padType of 'left'. |
|
|
* |
|
|
* @param int $length Desired string length after padding |
|
|
* @param string $padStr String used to pad, defaults to space |
|
|
* @return static String with left padding |
|
|
*/ |
|
|
public function padLeft($length, $padStr = ' ') |
|
|
{ |
|
|
return $this->applyPadding($length - $this->length(), 0, $padStr); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a new string of a given length such that the end of the string |
|
|
* is padded. Alias for pad() with a $padType of 'right'. |
|
|
* |
|
|
* @param int $length Desired string length after padding |
|
|
* @param string $padStr String used to pad, defaults to space |
|
|
* @return static String with right padding |
|
|
*/ |
|
|
public function padRight($length, $padStr = ' ') |
|
|
{ |
|
|
return $this->applyPadding(0, $length - $this->length(), $padStr); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a new string starting with $string. |
|
|
* |
|
|
* @param string $string The string to append |
|
|
* @return static Object with appended $string |
|
|
*/ |
|
|
public function prepend($string) |
|
|
{ |
|
|
return static::create($string . $this->str, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Replaces all occurrences of $pattern in $str by $replacement. An alias |
|
|
* for mb_ereg_replace(). Note that the 'i' option with multibyte patterns |
|
|
* in mb_ereg_replace() requires PHP 5.6+ for correct results. This is due |
|
|
* to a lack of support in the bundled version of Oniguruma in PHP < 5.6, |
|
|
* and current versions of HHVM (3.8 and below). |
|
|
* |
|
|
* @param string $pattern The regular expression pattern |
|
|
* @param string $replacement The string to replace with |
|
|
* @param string $options Matching conditions to be used |
|
|
* @return static Object with the resulting $str after the replacements |
|
|
*/ |
|
|
public function regexReplace($pattern, $replacement, $options = 'msr') |
|
|
{ |
|
|
$regexEncoding = $this->regexEncoding(); |
|
|
$this->regexEncoding($this->encoding); |
|
|
|
|
|
$str = $this->eregReplace($pattern, $replacement, $this->str, $options); |
|
|
$this->regexEncoding($regexEncoding); |
|
|
|
|
|
return static::create($str, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a new string with the prefix $substring removed, if present. |
|
|
* |
|
|
* @param string $substring The prefix to remove |
|
|
* @return static Object having a $str without the prefix $substring |
|
|
*/ |
|
|
public function removeLeft($substring) |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
|
|
|
if ($stringy->startsWith($substring)) { |
|
|
$substringLength = \mb_strlen($substring, $stringy->encoding); |
|
|
return $stringy->substr($substringLength); |
|
|
} |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a new string with the suffix $substring removed, if present. |
|
|
* |
|
|
* @param string $substring The suffix to remove |
|
|
* @return static Object having a $str without the suffix $substring |
|
|
*/ |
|
|
public function removeRight($substring) |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
|
|
|
if ($stringy->endsWith($substring)) { |
|
|
$substringLength = \mb_strlen($substring, $stringy->encoding); |
|
|
return $stringy->substr(0, $stringy->length() - $substringLength); |
|
|
} |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a repeated string given a multiplier. An alias for str_repeat. |
|
|
* |
|
|
* @param int $multiplier The number of times to repeat the string |
|
|
* @return static Object with a repeated str |
|
|
*/ |
|
|
public function repeat($multiplier) |
|
|
{ |
|
|
return static::create(str_repeat($this->str, $multiplier), $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Replaces all occurrences of $search in $str by $replacement. |
|
|
* |
|
|
* @param string $search The needle to search for |
|
|
* @param string $replacement The string to replace with |
|
|
* @return static Object with the resulting $str after the replacements |
|
|
*/ |
|
|
public function replace($search, $replacement) |
|
|
{ |
|
|
return $this->regexReplace(preg_quote($search), $replacement); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a reversed string. A multibyte version of strrev(). |
|
|
* |
|
|
* @return static Object with a reversed $str |
|
|
*/ |
|
|
public function reverse() |
|
|
{ |
|
|
$strLength = $this->length(); |
|
|
$reversed = ''; |
|
|
|
|
|
// Loop from last index of string to first |
|
|
for ($i = $strLength - 1; $i >= 0; $i--) { |
|
|
$reversed .= \mb_substr($this->str, $i, 1, $this->encoding); |
|
|
} |
|
|
|
|
|
return static::create($reversed, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Truncates the string to a given length, while ensuring that it does not |
|
|
* split words. If $substring is provided, and truncating occurs, the |
|
|
* string is further truncated so that the substring may be appended without |
|
|
* exceeding the desired length. |
|
|
* |
|
|
* @param int $length Desired length of the truncated string |
|
|
* @param string $substring The substring to append if it can fit |
|
|
* @return static Object with the resulting $str after truncating |
|
|
*/ |
|
|
public function safeTruncate($length, $substring = '') |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
if ($length >= $stringy->length()) { |
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
// Need to further trim the string so we can append the substring |
|
|
$encoding = $stringy->encoding; |
|
|
$substringLength = \mb_strlen($substring, $encoding); |
|
|
$length = $length - $substringLength; |
|
|
|
|
|
$truncated = \mb_substr($stringy->str, 0, $length, $encoding); |
|
|
|
|
|
// If the last word was truncated |
|
|
if (mb_strpos($stringy->str, ' ', $length - 1, $encoding) != $length) { |
|
|
// Find pos of the last occurrence of a space, get up to that |
|
|
$lastPos = \mb_strrpos($truncated, ' ', 0, $encoding); |
|
|
if ($lastPos !== false) { |
|
|
$truncated = \mb_substr($truncated, 0, $lastPos, $encoding); |
|
|
} |
|
|
} |
|
|
|
|
|
$stringy->str = $truncated . $substring; |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/* |
|
|
* A multibyte str_shuffle() function. It returns a string with its |
|
|
* characters in random order. |
|
|
* |
|
|
* @return static Object with a shuffled $str |
|
|
*/ |
|
|
public function shuffle() |
|
|
{ |
|
|
$indexes = range(0, $this->length() - 1); |
|
|
shuffle($indexes); |
|
|
|
|
|
$shuffledStr = ''; |
|
|
foreach ($indexes as $i) { |
|
|
$shuffledStr .= \mb_substr($this->str, $i, 1, $this->encoding); |
|
|
} |
|
|
|
|
|
return static::create($shuffledStr, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Converts the string into an URL slug. This includes replacing non-ASCII |
|
|
* characters with their closest ASCII equivalents, removing remaining |
|
|
* non-ASCII and non-alphanumeric characters, and replacing whitespace with |
|
|
* $replacement. The replacement defaults to a single dash, and the string |
|
|
* is also converted to lowercase. The language of the source string can |
|
|
* also be supplied for language-specific transliteration. |
|
|
* |
|
|
* @param string $replacement The string used to replace whitespace |
|
|
* @param string $language Language of the source string |
|
|
* @return static Object whose $str has been converted to an URL slug |
|
|
*/ |
|
|
public function slugify($replacement = '-', $language = 'en') |
|
|
{ |
|
|
$stringy = $this->toAscii($language); |
|
|
|
|
|
$stringy->str = str_replace('@', $replacement, $stringy); |
|
|
$quotedReplacement = preg_quote($replacement); |
|
|
$pattern = "/[^a-zA-Z\d\s-_$quotedReplacement]/u"; |
|
|
$stringy->str = preg_replace($pattern, '', $stringy); |
|
|
|
|
|
return $stringy->toLowerCase()->delimit($replacement) |
|
|
->removeLeft($replacement)->removeRight($replacement); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string begins with $substring, false otherwise. By |
|
|
* default, the comparison is case-sensitive, but can be made insensitive |
|
|
* by setting $caseSensitive to false. |
|
|
* |
|
|
* @param string $substring The substring to look for |
|
|
* @param bool $caseSensitive Whether or not to enforce |
|
|
* case-sensitivity |
|
|
* @return bool Whether or not $str starts with $substring |
|
|
*/ |
|
|
public function startsWith($substring, $caseSensitive = true) |
|
|
{ |
|
|
$substringLength = \mb_strlen($substring, $this->encoding); |
|
|
$startOfStr = \mb_substr($this->str, 0, $substringLength, |
|
|
$this->encoding); |
|
|
|
|
|
if (!$caseSensitive) { |
|
|
$substring = \mb_strtolower($substring, $this->encoding); |
|
|
$startOfStr = \mb_strtolower($startOfStr, $this->encoding); |
|
|
} |
|
|
|
|
|
return (string) $substring === $startOfStr; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if the string begins with any of $substrings, false |
|
|
* otherwise. By default the comparison is case-sensitive, but can be made |
|
|
* insensitive by setting $caseSensitive to false. |
|
|
* |
|
|
* @param string[] $substrings Substrings to look for |
|
|
* @param bool $caseSensitive Whether or not to enforce |
|
|
* case-sensitivity |
|
|
* @return bool Whether or not $str starts with $substring |
|
|
*/ |
|
|
public function startsWithAny($substrings, $caseSensitive = true) |
|
|
{ |
|
|
if (empty($substrings)) { |
|
|
return false; |
|
|
} |
|
|
|
|
|
foreach ($substrings as $substring) { |
|
|
if ($this->startsWith($substring, $caseSensitive)) { |
|
|
return true; |
|
|
} |
|
|
} |
|
|
|
|
|
return false; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the substring beginning at $start, and up to, but not including |
|
|
* the index specified by $end. If $end is omitted, the function extracts |
|
|
* the remaining string. If $end is negative, it is computed from the end |
|
|
* of the string. |
|
|
* |
|
|
* @param int $start Initial index from which to begin extraction |
|
|
* @param int $end Optional index at which to end extraction |
|
|
* @return static Object with its $str being the extracted substring |
|
|
*/ |
|
|
public function slice($start, $end = null) |
|
|
{ |
|
|
if ($end === null) { |
|
|
$length = $this->length(); |
|
|
} elseif ($end >= 0 && $end <= $start) { |
|
|
return static::create('', $this->encoding); |
|
|
} elseif ($end < 0) { |
|
|
$length = $this->length() + $end - $start; |
|
|
} else { |
|
|
$length = $end - $start; |
|
|
} |
|
|
|
|
|
return $this->substr($start, $length); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Splits the string with the provided regular expression, returning an |
|
|
* array of Stringy objects. An optional integer $limit will truncate the |
|
|
* results. |
|
|
* |
|
|
* @param string $pattern The regex with which to split the string |
|
|
* @param int $limit Optional maximum number of results to return |
|
|
* @return static[] An array of Stringy objects |
|
|
*/ |
|
|
public function split($pattern, $limit = null) |
|
|
{ |
|
|
if ($limit === 0) { |
|
|
return []; |
|
|
} |
|
|
|
|
|
// mb_split errors when supplied an empty pattern in < PHP 5.4.13 |
|
|
// and HHVM < 3.8 |
|
|
if ($pattern === '') { |
|
|
return [static::create($this->str, $this->encoding)]; |
|
|
} |
|
|
|
|
|
$regexEncoding = $this->regexEncoding(); |
|
|
$this->regexEncoding($this->encoding); |
|
|
|
|
|
// mb_split returns the remaining unsplit string in the last index when |
|
|
// supplying a limit |
|
|
$limit = ($limit > 0) ? $limit += 1 : -1; |
|
|
|
|
|
static $functionExists; |
|
|
if ($functionExists === null) { |
|
|
$functionExists = function_exists('\mb_split'); |
|
|
} |
|
|
|
|
|
if ($functionExists) { |
|
|
$array = \mb_split($pattern, $this->str, $limit); |
|
|
} else if ($this->supportsEncoding()) { |
|
|
$array = \preg_split("/$pattern/", $this->str, $limit); |
|
|
} |
|
|
|
|
|
$this->regexEncoding($regexEncoding); |
|
|
|
|
|
if ($limit > 0 && count($array) === $limit) { |
|
|
array_pop($array); |
|
|
} |
|
|
|
|
|
for ($i = 0; $i < count($array); $i++) { |
|
|
$array[$i] = static::create($array[$i], $this->encoding); |
|
|
} |
|
|
|
|
|
return $array; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Strip all whitespace characters. This includes tabs and newline |
|
|
* characters, as well as multibyte whitespace such as the thin space |
|
|
* and ideographic space. |
|
|
* |
|
|
* @return static Object with whitespace stripped |
|
|
*/ |
|
|
public function stripWhitespace() |
|
|
{ |
|
|
return $this->regexReplace('[[:space:]]+', ''); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the length of the string. An alias for PHP's mb_strlen() function. |
|
|
* |
|
|
* @return int The number of characters in $str given the encoding |
|
|
*/ |
|
|
public function strlen() |
|
|
{ |
|
|
return \mb_strlen($this->str, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the substring beginning at $start with the specified $length. |
|
|
* It differs from the mb_substr() function in that providing a $length of |
|
|
* null will return the rest of the string, rather than an empty string. |
|
|
* |
|
|
* @param int $start Position of the first character to use |
|
|
* @param int $length Maximum number of characters used |
|
|
* @return static Object with its $str being the substring |
|
|
*/ |
|
|
public function substr($start, $length = null) |
|
|
{ |
|
|
$length = $length === null ? $this->length() : $length; |
|
|
|
|
|
return static::create(\mb_substr($this->str, $start, $length, $this->encoding), $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Surrounds $str with the given substring. |
|
|
* |
|
|
* @param string $substring The substring to add to both sides |
|
|
* @return static Object whose $str had the substring both prepended and |
|
|
* appended |
|
|
*/ |
|
|
public function surround($substring) |
|
|
{ |
|
|
return static::create(implode('', [$substring, $this->str, $substring]), $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a case swapped version of the string. |
|
|
* |
|
|
* @return static Object whose $str has each character's case swapped |
|
|
*/ |
|
|
public function swapCase() |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
$encoding = $stringy->encoding; |
|
|
|
|
|
$stringy->str = preg_replace_callback( |
|
|
'/[\S]/u', |
|
|
function ($match) use ($encoding) { |
|
|
if ($match[0] == \mb_strtoupper($match[0], $encoding)) { |
|
|
return \mb_strtolower($match[0], $encoding); |
|
|
} |
|
|
|
|
|
return \mb_strtoupper($match[0], $encoding); |
|
|
}, |
|
|
$stringy->str |
|
|
); |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a string with smart quotes, ellipsis characters, and dashes from |
|
|
* Windows-1252 (commonly used in Word documents) replaced by their ASCII |
|
|
* equivalents. |
|
|
* |
|
|
* @return static Object whose $str has those characters removed |
|
|
*/ |
|
|
public function tidy() |
|
|
{ |
|
|
$str = preg_replace([ |
|
|
'/\x{2026}/u', |
|
|
'/[\x{201C}\x{201D}]/u', |
|
|
'/[\x{2018}\x{2019}]/u', |
|
|
'/[\x{2013}\x{2014}]/u', |
|
|
], [ |
|
|
'...', |
|
|
'"', |
|
|
"'", |
|
|
'-', |
|
|
], $this->str); |
|
|
|
|
|
return static::create($str, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a trimmed string with the first letter of each word capitalized. |
|
|
* Also accepts an array, $ignore, allowing you to list words not to be |
|
|
* capitalized. |
|
|
* |
|
|
* @param array $ignore An array of words not to capitalize |
|
|
* @return static Object with a titleized $str |
|
|
*/ |
|
|
public function titleize($ignore = null) |
|
|
{ |
|
|
$stringy = static::create($this->trim(), $this->encoding); |
|
|
$encoding = $this->encoding; |
|
|
|
|
|
$stringy->str = preg_replace_callback( |
|
|
'/([\S]+)/u', |
|
|
function ($match) use ($encoding, $ignore) { |
|
|
if ($ignore && in_array($match[0], $ignore)) { |
|
|
return $match[0]; |
|
|
} |
|
|
|
|
|
$stringy = new Stringy($match[0], $encoding); |
|
|
|
|
|
return (string) $stringy->toLowerCase()->upperCaseFirst(); |
|
|
}, |
|
|
$stringy->str |
|
|
); |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns an ASCII version of the string. A set of non-ASCII characters are |
|
|
* replaced with their closest ASCII counterparts, and the rest are removed |
|
|
* by default. The language or locale of the source string can be supplied |
|
|
* for language-specific transliteration in any of the following formats: |
|
|
* en, en_GB, or en-GB. For example, passing "de" results in "äöü" mapping |
|
|
* to "aeoeue" rather than "aou" as in other languages. |
|
|
* |
|
|
* @param string $language Language of the source string |
|
|
* @param bool $removeUnsupported Whether or not to remove the |
|
|
* unsupported characters |
|
|
* @return static Object whose $str contains only ASCII characters |
|
|
*/ |
|
|
public function toAscii($language = 'en', $removeUnsupported = true) |
|
|
{ |
|
|
$str = $this->str; |
|
|
|
|
|
$langSpecific = $this->langSpecificCharsArray($language); |
|
|
if (!empty($langSpecific)) { |
|
|
$str = str_replace($langSpecific[0], $langSpecific[1], $str); |
|
|
} |
|
|
|
|
|
foreach ($this->charsArray() as $key => $value) { |
|
|
$str = str_replace($value, $key, $str); |
|
|
} |
|
|
|
|
|
if ($removeUnsupported) { |
|
|
$str = preg_replace('/[^\x20-\x7E]/u', '', $str); |
|
|
} |
|
|
|
|
|
return static::create($str, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a boolean representation of the given logical string value. |
|
|
* For example, 'true', '1', 'on' and 'yes' will return true. 'false', '0', |
|
|
* 'off', and 'no' will return false. In all instances, case is ignored. |
|
|
* For other numeric strings, their sign will determine the return value. |
|
|
* In addition, blank strings consisting of only whitespace will return |
|
|
* false. For all other strings, the return value is a result of a |
|
|
* boolean cast. |
|
|
* |
|
|
* @return bool A boolean value for the string |
|
|
*/ |
|
|
public function toBoolean() |
|
|
{ |
|
|
$key = ctype_lower($this->str) ? $this->str : strtolower($this->str); |
|
|
|
|
|
if (isset(self::$boolMap[$key])) |
|
|
return self::$boolMap[$key]; |
|
|
|
|
|
if (is_numeric($this->str)) |
|
|
return (intval($this->str) > 0); |
|
|
|
|
|
return (bool) $this->regexReplace('[[:space:]]', '')->str; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Alias of toBoolean() |
|
|
* |
|
|
* @return bool A boolean value for the string |
|
|
*/ |
|
|
public function toBool() |
|
|
{ |
|
|
return $this->toBoolean(); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Converts all characters in the string to lowercase. An alias for PHP's |
|
|
* mb_strtolower(). |
|
|
* |
|
|
* @return static Object with all characters of $str being lowercase |
|
|
*/ |
|
|
public function toLowerCase() |
|
|
{ |
|
|
return static::create(\mb_strtolower($this->str, $this->encoding), $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Converts each tab in the string to some number of spaces, as defined by |
|
|
* $tabLength. By default, each tab is converted to 4 consecutive spaces. |
|
|
* |
|
|
* @param int $tabLength Number of spaces to replace each tab with |
|
|
* @return static Object whose $str has had tabs switched to spaces |
|
|
*/ |
|
|
public function toSpaces($tabLength = 4) |
|
|
{ |
|
|
return static::create(str_replace("\t", str_repeat(' ', $tabLength), $this->str), $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Converts each occurrence of some consecutive number of spaces, as |
|
|
* defined by $tabLength, to a tab. By default, each 4 consecutive spaces |
|
|
* are converted to a tab. |
|
|
* |
|
|
* @param int $tabLength Number of spaces to replace with a tab |
|
|
* @return static Object whose $str has had spaces switched to tabs |
|
|
*/ |
|
|
public function toTabs($tabLength = 4) |
|
|
{ |
|
|
return static::create(str_replace(str_repeat(' ', $tabLength), "\t", $this->str), $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Converts the first character of each word in the string to uppercase. |
|
|
* |
|
|
* @return static Object with all characters of $str being title-cased |
|
|
*/ |
|
|
public function toTitleCase() |
|
|
{ |
|
|
return static::create(\mb_convert_case($this->str, \MB_CASE_TITLE, $this->encoding), $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Converts all characters in the string to uppercase. An alias for PHP's |
|
|
* mb_strtoupper(). |
|
|
* |
|
|
* @return static Object with all characters of $str being uppercase |
|
|
*/ |
|
|
public function toUpperCase() |
|
|
{ |
|
|
return static::create(\mb_strtoupper($this->str, $this->encoding), $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a string with whitespace removed from the start and end of the |
|
|
* string. Supports the removal of unicode whitespace. Accepts an optional |
|
|
* string of characters to strip instead of the defaults. |
|
|
* |
|
|
* @param string $chars Optional string of characters to strip |
|
|
* @return static Object with a trimmed $str |
|
|
*/ |
|
|
public function trim($chars = null) |
|
|
{ |
|
|
$chars = ($chars) ? preg_quote($chars) : '[:space:]'; |
|
|
|
|
|
return $this->regexReplace("^[$chars]+|[$chars]+\$", ''); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a string with whitespace removed from the start of the string. |
|
|
* Supports the removal of unicode whitespace. Accepts an optional |
|
|
* string of characters to strip instead of the defaults. |
|
|
* |
|
|
* @param string $chars Optional string of characters to strip |
|
|
* @return static Object with a trimmed $str |
|
|
*/ |
|
|
public function trimLeft($chars = null) |
|
|
{ |
|
|
$chars = ($chars) ? preg_quote($chars) : '[:space:]'; |
|
|
|
|
|
return $this->regexReplace("^[$chars]+", ''); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a string with whitespace removed from the end of the string. |
|
|
* Supports the removal of unicode whitespace. Accepts an optional |
|
|
* string of characters to strip instead of the defaults. |
|
|
* |
|
|
* @param string $chars Optional string of characters to strip |
|
|
* @return static Object with a trimmed $str |
|
|
*/ |
|
|
public function trimRight($chars = null) |
|
|
{ |
|
|
$chars = ($chars) ? preg_quote($chars) : '[:space:]'; |
|
|
|
|
|
return $this->regexReplace("[$chars]+\$", ''); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Truncates the string to a given length. If $substring is provided, and |
|
|
* truncating occurs, the string is further truncated so that the substring |
|
|
* may be appended without exceeding the desired length. |
|
|
* |
|
|
* @param int $length Desired length of the truncated string |
|
|
* @param string $substring The substring to append if it can fit |
|
|
* @return static Object with the resulting $str after truncating |
|
|
*/ |
|
|
public function truncate($length, $substring = '') |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
if ($length >= $stringy->length()) { |
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
// Need to further trim the string so we can append the substring |
|
|
$substringLength = \mb_strlen($substring, $stringy->encoding); |
|
|
$length = $length - $substringLength; |
|
|
|
|
|
$truncated = \mb_substr($stringy->str, 0, $length, $stringy->encoding); |
|
|
$stringy->str = $truncated . $substring; |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns a lowercase and trimmed string separated by underscores. |
|
|
* Underscores are inserted before uppercase characters (with the exception |
|
|
* of the first character of the string), and in place of spaces as well as |
|
|
* dashes. |
|
|
* |
|
|
* @return static Object with an underscored $str |
|
|
*/ |
|
|
public function underscored() |
|
|
{ |
|
|
return $this->delimit('_'); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns an UpperCamelCase version of the supplied string. It trims |
|
|
* surrounding spaces, capitalizes letters following digits, spaces, dashes |
|
|
* and underscores, and removes spaces, dashes, underscores. |
|
|
* |
|
|
* @return static Object with $str in UpperCamelCase |
|
|
*/ |
|
|
public function upperCamelize() |
|
|
{ |
|
|
return $this->camelize()->upperCaseFirst(); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Converts the first character of the supplied string to upper case. |
|
|
* |
|
|
* @return static Object with the first character of $str being upper case |
|
|
*/ |
|
|
public function upperCaseFirst() |
|
|
{ |
|
|
$first = \mb_substr($this->str, 0, 1, $this->encoding); |
|
|
$rest = \mb_substr($this->str, 1, $this->length() - 1, $this->encoding); |
|
|
|
|
|
$str = \mb_strtoupper($first, $this->encoding) . $rest; |
|
|
|
|
|
return static::create($str, $this->encoding); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns the replacements for the toAscii() method. |
|
|
* |
|
|
* @return array An array of replacements. |
|
|
*/ |
|
|
protected function charsArray() |
|
|
{ |
|
|
static $charsArray; |
|
|
if (isset($charsArray)) return $charsArray; |
|
|
|
|
|
return $charsArray = [ |
|
|
'0' => ['°', '₀', '۰', '0'], |
|
|
'1' => ['¹', '₁', '۱', '1'], |
|
|
'2' => ['²', '₂', '۲', '2'], |
|
|
'3' => ['³', '₃', '۳', '3'], |
|
|
'4' => ['⁴', '₄', '۴', '٤', '4'], |
|
|
'5' => ['⁵', '₅', '۵', '٥', '5'], |
|
|
'6' => ['⁶', '₆', '۶', '٦', '6'], |
|
|
'7' => ['⁷', '₇', '۷', '7'], |
|
|
'8' => ['⁸', '₈', '۸', '8'], |
|
|
'9' => ['⁹', '₉', '۹', '9'], |
|
|
'a' => ['à', 'á', 'ả', 'ã', 'ạ', 'ă', 'ắ', 'ằ', 'ẳ', 'ẵ', |
|
|
'ặ', 'â', 'ấ', 'ầ', 'ẩ', 'ẫ', 'ậ', 'ā', 'ą', 'å', |
|
|
'α', 'ά', 'ἀ', 'ἁ', 'ἂ', 'ἃ', 'ἄ', 'ἅ', 'ἆ', 'ἇ', |
|
|
'ᾀ', 'ᾁ', 'ᾂ', 'ᾃ', 'ᾄ', 'ᾅ', 'ᾆ', 'ᾇ', 'ὰ', 'ά', |
|
|
'ᾰ', 'ᾱ', 'ᾲ', 'ᾳ', 'ᾴ', 'ᾶ', 'ᾷ', 'а', 'أ', 'အ', |
|
|
'ာ', 'ါ', 'ǻ', 'ǎ', 'ª', 'ა', 'अ', 'ا', 'a', 'ä'], |
|
|
'b' => ['б', 'β', 'ب', 'ဗ', 'ბ', 'b'], |
|
|
'c' => ['ç', 'ć', 'č', 'ĉ', 'ċ', 'c'], |
|
|
'd' => ['ď', 'ð', 'đ', 'ƌ', 'ȡ', 'ɖ', 'ɗ', 'ᵭ', 'ᶁ', 'ᶑ', |
|
|
'д', 'δ', 'د', 'ض', 'ဍ', 'ဒ', 'დ', 'd'], |
|
|
'e' => ['é', 'è', 'ẻ', 'ẽ', 'ẹ', 'ê', 'ế', 'ề', 'ể', 'ễ', |
|
|
'ệ', 'ë', 'ē', 'ę', 'ě', 'ĕ', 'ė', 'ε', 'έ', 'ἐ', |
|
|
'ἑ', 'ἒ', 'ἓ', 'ἔ', 'ἕ', 'ὲ', 'έ', 'е', 'ё', 'э', |
|
|
'є', 'ə', 'ဧ', 'ေ', 'ဲ', 'ე', 'ए', 'إ', 'ئ', 'e'], |
|
|
'f' => ['ф', 'φ', 'ف', 'ƒ', 'ფ', 'f'], |
|
|
'g' => ['ĝ', 'ğ', 'ġ', 'ģ', 'г', 'ґ', 'γ', 'ဂ', 'გ', 'گ', |
|
|
'g'], |
|
|
'h' => ['ĥ', 'ħ', 'η', 'ή', 'ح', 'ه', 'ဟ', 'ှ', 'ჰ', 'h'], |
|
|
'i' => ['í', 'ì', 'ỉ', 'ĩ', 'ị', 'î', 'ï', 'ī', 'ĭ', 'į', |
|
|
'ı', 'ι', 'ί', 'ϊ', 'ΐ', 'ἰ', 'ἱ', 'ἲ', 'ἳ', 'ἴ', |
|
|
'ἵ', 'ἶ', 'ἷ', 'ὶ', 'ί', 'ῐ', 'ῑ', 'ῒ', 'ΐ', 'ῖ', |
|
|
'ῗ', 'і', 'ї', 'и', 'ဣ', 'ိ', 'ီ', 'ည်', 'ǐ', 'ი', |
|
|
'इ', 'ی', 'i'], |
|
|
'j' => ['ĵ', 'ј', 'Ј', 'ჯ', 'ج', 'j'], |
|
|
'k' => ['ķ', 'ĸ', 'к', 'κ', 'Ķ', 'ق', 'ك', 'က', 'კ', 'ქ', |
|
|
'ک', 'k'], |
|
|
'l' => ['ł', 'ľ', 'ĺ', 'ļ', 'ŀ', 'л', 'λ', 'ل', 'လ', 'ლ', |
|
|
'l'], |
|
|
'm' => ['м', 'μ', 'م', 'မ', 'მ', 'm'], |
|
|
'n' => ['ñ', 'ń', 'ň', 'ņ', 'ʼn', 'ŋ', 'ν', 'н', 'ن', 'န', |
|
|
'ნ', 'n'], |
|
|
'o' => ['ó', 'ò', 'ỏ', 'õ', 'ọ', 'ô', 'ố', 'ồ', 'ổ', 'ỗ', |
|
|
'ộ', 'ơ', 'ớ', 'ờ', 'ở', 'ỡ', 'ợ', 'ø', 'ō', 'ő', |
|
|
'ŏ', 'ο', 'ὀ', 'ὁ', 'ὂ', 'ὃ', 'ὄ', 'ὅ', 'ὸ', 'ό', |
|
|
'о', 'و', 'θ', 'ို', 'ǒ', 'ǿ', 'º', 'ო', 'ओ', 'o', |
|
|
'ö'], |
|
|
'p' => ['п', 'π', 'ပ', 'პ', 'پ', 'p'], |
|
|
'q' => ['ყ', 'q'], |
|
|
'r' => ['ŕ', 'ř', 'ŗ', 'р', 'ρ', 'ر', 'რ', 'r'], |
|
|
's' => ['ś', 'š', 'ş', 'с', 'σ', 'ș', 'ς', 'س', 'ص', 'စ', |
|
|
'ſ', 'ს', 's'], |
|
|
't' => ['ť', 'ţ', 'т', 'τ', 'ț', 'ت', 'ط', 'ဋ', 'တ', 'ŧ', |
|
|
'თ', 'ტ', 't'], |
|
|
'u' => ['ú', 'ù', 'ủ', 'ũ', 'ụ', 'ư', 'ứ', 'ừ', 'ử', 'ữ', |
|
|
'ự', 'û', 'ū', 'ů', 'ű', 'ŭ', 'ų', 'µ', 'у', 'ဉ', |
|
|
'ု', 'ူ', 'ǔ', 'ǖ', 'ǘ', 'ǚ', 'ǜ', 'უ', 'उ', 'u', |
|
|
'ў', 'ü'], |
|
|
'v' => ['в', 'ვ', 'ϐ', 'v'], |
|
|
'w' => ['ŵ', 'ω', 'ώ', 'ဝ', 'ွ', 'w'], |
|
|
'x' => ['χ', 'ξ', 'x'], |
|
|
'y' => ['ý', 'ỳ', 'ỷ', 'ỹ', 'ỵ', 'ÿ', 'ŷ', 'й', 'ы', 'υ', |
|
|
'ϋ', 'ύ', 'ΰ', 'ي', 'ယ', 'y'], |
|
|
'z' => ['ź', 'ž', 'ż', 'з', 'ζ', 'ز', 'ဇ', 'ზ', 'z'], |
|
|
'aa' => ['ع', 'आ', 'آ'], |
|
|
'ae' => ['æ', 'ǽ'], |
|
|
'ai' => ['ऐ'], |
|
|
'ch' => ['ч', 'ჩ', 'ჭ', 'چ'], |
|
|
'dj' => ['ђ', 'đ'], |
|
|
'dz' => ['џ', 'ძ'], |
|
|
'ei' => ['ऍ'], |
|
|
'gh' => ['غ', 'ღ'], |
|
|
'ii' => ['ई'], |
|
|
'ij' => ['ij'], |
|
|
'kh' => ['х', 'خ', 'ხ'], |
|
|
'lj' => ['љ'], |
|
|
'nj' => ['њ'], |
|
|
'oe' => ['œ', 'ؤ'], |
|
|
'oi' => ['ऑ'], |
|
|
'oii' => ['ऒ'], |
|
|
'ps' => ['ψ'], |
|
|
'sh' => ['ш', 'შ', 'ش'], |
|
|
'shch' => ['щ'], |
|
|
'ss' => ['ß'], |
|
|
'sx' => ['ŝ'], |
|
|
'th' => ['þ', 'ϑ', 'ث', 'ذ', 'ظ'], |
|
|
'ts' => ['ц', 'ც', 'წ'], |
|
|
'uu' => ['ऊ'], |
|
|
'ya' => ['я'], |
|
|
'yu' => ['ю'], |
|
|
'zh' => ['ж', 'ჟ', 'ژ'], |
|
|
'(c)' => ['©'], |
|
|
'A' => ['Á', 'À', 'Ả', 'Ã', 'Ạ', 'Ă', 'Ắ', 'Ằ', 'Ẳ', 'Ẵ', |
|
|
'Ặ', 'Â', 'Ấ', 'Ầ', 'Ẩ', 'Ẫ', 'Ậ', 'Å', 'Ā', 'Ą', |
|
|
'Α', 'Ά', 'Ἀ', 'Ἁ', 'Ἂ', 'Ἃ', 'Ἄ', 'Ἅ', 'Ἆ', 'Ἇ', |
|
|
'ᾈ', 'ᾉ', 'ᾊ', 'ᾋ', 'ᾌ', 'ᾍ', 'ᾎ', 'ᾏ', 'Ᾰ', 'Ᾱ', |
|
|
'Ὰ', 'Ά', 'ᾼ', 'А', 'Ǻ', 'Ǎ', 'A', 'Ä'], |
|
|
'B' => ['Б', 'Β', 'ब', 'B'], |
|
|
'C' => ['Ç','Ć', 'Č', 'Ĉ', 'Ċ', 'C'], |
|
|
'D' => ['Ď', 'Ð', 'Đ', 'Ɖ', 'Ɗ', 'Ƌ', 'ᴅ', 'ᴆ', 'Д', 'Δ', |
|
|
'D'], |
|
|
'E' => ['É', 'È', 'Ẻ', 'Ẽ', 'Ẹ', 'Ê', 'Ế', 'Ề', 'Ể', 'Ễ', |
|
|
'Ệ', 'Ë', 'Ē', 'Ę', 'Ě', 'Ĕ', 'Ė', 'Ε', 'Έ', 'Ἐ', |
|
|
'Ἑ', 'Ἒ', 'Ἓ', 'Ἔ', 'Ἕ', 'Έ', 'Ὲ', 'Е', 'Ё', 'Э', |
|
|
'Є', 'Ə', 'E'], |
|
|
'F' => ['Ф', 'Φ', 'F'], |
|
|
'G' => ['Ğ', 'Ġ', 'Ģ', 'Г', 'Ґ', 'Γ', 'G'], |
|
|
'H' => ['Η', 'Ή', 'Ħ', 'H'], |
|
|
'I' => ['Í', 'Ì', 'Ỉ', 'Ĩ', 'Ị', 'Î', 'Ï', 'Ī', 'Ĭ', 'Į', |
|
|
'İ', 'Ι', 'Ί', 'Ϊ', 'Ἰ', 'Ἱ', 'Ἳ', 'Ἴ', 'Ἵ', 'Ἶ', |
|
|
'Ἷ', 'Ῐ', 'Ῑ', 'Ὶ', 'Ί', 'И', 'І', 'Ї', 'Ǐ', 'ϒ', |
|
|
'I'], |
|
|
'J' => ['J'], |
|
|
'K' => ['К', 'Κ', 'K'], |
|
|
'L' => ['Ĺ', 'Ł', 'Л', 'Λ', 'Ļ', 'Ľ', 'Ŀ', 'ल', 'L'], |
|
|
'M' => ['М', 'Μ', 'M'], |
|
|
'N' => ['Ń', 'Ñ', 'Ň', 'Ņ', 'Ŋ', 'Н', 'Ν', 'N'], |
|
|
'O' => ['Ó', 'Ò', 'Ỏ', 'Õ', 'Ọ', 'Ô', 'Ố', 'Ồ', 'Ổ', 'Ỗ', |
|
|
'Ộ', 'Ơ', 'Ớ', 'Ờ', 'Ở', 'Ỡ', 'Ợ', 'Ø', 'Ō', 'Ő', |
|
|
'Ŏ', 'Ο', 'Ό', 'Ὀ', 'Ὁ', 'Ὂ', 'Ὃ', 'Ὄ', 'Ὅ', 'Ὸ', |
|
|
'Ό', 'О', 'Θ', 'Ө', 'Ǒ', 'Ǿ', 'O', 'Ö'], |
|
|
'P' => ['П', 'Π', 'P'], |
|
|
'Q' => ['Q'], |
|
|
'R' => ['Ř', 'Ŕ', 'Р', 'Ρ', 'Ŗ', 'R'], |
|
|
'S' => ['Ş', 'Ŝ', 'Ș', 'Š', 'Ś', 'С', 'Σ', 'S'], |
|
|
'T' => ['Ť', 'Ţ', 'Ŧ', 'Ț', 'Т', 'Τ', 'T'], |
|
|
'U' => ['Ú', 'Ù', 'Ủ', 'Ũ', 'Ụ', 'Ư', 'Ứ', 'Ừ', 'Ử', 'Ữ', |
|
|
'Ự', 'Û', 'Ū', 'Ů', 'Ű', 'Ŭ', 'Ų', 'У', 'Ǔ', 'Ǖ', |
|
|
'Ǘ', 'Ǚ', 'Ǜ', 'U', 'Ў', 'Ü'], |
|
|
'V' => ['В', 'V'], |
|
|
'W' => ['Ω', 'Ώ', 'Ŵ', 'W'], |
|
|
'X' => ['Χ', 'Ξ', 'X'], |
|
|
'Y' => ['Ý', 'Ỳ', 'Ỷ', 'Ỹ', 'Ỵ', 'Ÿ', 'Ῠ', 'Ῡ', 'Ὺ', 'Ύ', |
|
|
'Ы', 'Й', 'Υ', 'Ϋ', 'Ŷ', 'Y'], |
|
|
'Z' => ['Ź', 'Ž', 'Ż', 'З', 'Ζ', 'Z'], |
|
|
'AE' => ['Æ', 'Ǽ'], |
|
|
'Ch' => ['Ч'], |
|
|
'Dj' => ['Ђ'], |
|
|
'Dz' => ['Џ'], |
|
|
'Gx' => ['Ĝ'], |
|
|
'Hx' => ['Ĥ'], |
|
|
'Ij' => ['IJ'], |
|
|
'Jx' => ['Ĵ'], |
|
|
'Kh' => ['Х'], |
|
|
'Lj' => ['Љ'], |
|
|
'Nj' => ['Њ'], |
|
|
'Oe' => ['Œ'], |
|
|
'Ps' => ['Ψ'], |
|
|
'Sh' => ['Ш'], |
|
|
'Shch' => ['Щ'], |
|
|
'Ss' => ['ẞ'], |
|
|
'Th' => ['Þ'], |
|
|
'Ts' => ['Ц'], |
|
|
'Ya' => ['Я'], |
|
|
'Yu' => ['Ю'], |
|
|
'Zh' => ['Ж'], |
|
|
' ' => ["\xC2\xA0", "\xE2\x80\x80", "\xE2\x80\x81", |
|
|
"\xE2\x80\x82", "\xE2\x80\x83", "\xE2\x80\x84", |
|
|
"\xE2\x80\x85", "\xE2\x80\x86", "\xE2\x80\x87", |
|
|
"\xE2\x80\x88", "\xE2\x80\x89", "\xE2\x80\x8A", |
|
|
"\xE2\x80\xAF", "\xE2\x81\x9F", "\xE3\x80\x80", |
|
|
"\xEF\xBE\xA0"], |
|
|
]; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns language-specific replacements for the toAscii() method. |
|
|
* For example, German will map 'ä' to 'ae', while other languages |
|
|
* will simply return 'a'. |
|
|
* |
|
|
* @param string $language Language of the source string |
|
|
* @return array An array of replacements. |
|
|
*/ |
|
|
protected static function langSpecificCharsArray($language = 'en') |
|
|
{ |
|
|
$split = preg_split('/[-_]/', $language); |
|
|
$language = strtolower($split[0]); |
|
|
|
|
|
static $charsArray = []; |
|
|
if (isset($charsArray[$language])) { |
|
|
return $charsArray[$language]; |
|
|
} |
|
|
|
|
|
$languageSpecific = [ |
|
|
'de' => [ |
|
|
['ä', 'ö', 'ü', 'Ä', 'Ö', 'Ü' ], |
|
|
['ae', 'oe', 'ue', 'AE', 'OE', 'UE'], |
|
|
], |
|
|
'bg' => [ |
|
|
['х', 'Х', 'щ', 'Щ', 'ъ', 'Ъ', 'ь', 'Ь'], |
|
|
['h', 'H', 'sht', 'SHT', 'a', 'А', 'y', 'Y'] |
|
|
] |
|
|
]; |
|
|
|
|
|
if (isset($languageSpecific[$language])) { |
|
|
$charsArray[$language] = $languageSpecific[$language]; |
|
|
} else { |
|
|
$charsArray[$language] = []; |
|
|
} |
|
|
|
|
|
return $charsArray[$language]; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Adds the specified amount of left and right padding to the given string. |
|
|
* The default character used is a space. |
|
|
* |
|
|
* @param int $left Length of left padding |
|
|
* @param int $right Length of right padding |
|
|
* @param string $padStr String used to pad |
|
|
* @return static String with padding applied |
|
|
*/ |
|
|
protected function applyPadding($left = 0, $right = 0, $padStr = ' ') |
|
|
{ |
|
|
$stringy = static::create($this->str, $this->encoding); |
|
|
$length = \mb_strlen($padStr, $stringy->encoding); |
|
|
|
|
|
$strLength = $stringy->length(); |
|
|
$paddedLength = $strLength + $left + $right; |
|
|
|
|
|
if (!$length || $paddedLength <= $strLength) { |
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
$leftPadding = \mb_substr(str_repeat($padStr, ceil($left / $length)), 0, $left, $stringy->encoding); |
|
|
$rightPadding = \mb_substr(str_repeat($padStr, ceil($right / $length)), 0, $right, $stringy->encoding); |
|
|
|
|
|
$stringy->str = $leftPadding . $stringy->str . $rightPadding; |
|
|
|
|
|
return $stringy; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Returns true if $str matches the supplied pattern, false otherwise. |
|
|
* |
|
|
* @param string $pattern Regex pattern to match against |
|
|
* @return bool Whether or not $str matches the pattern |
|
|
*/ |
|
|
protected function matchesPattern($pattern) |
|
|
{ |
|
|
$regexEncoding = $this->regexEncoding(); |
|
|
$this->regexEncoding($this->encoding); |
|
|
|
|
|
$match = \mb_ereg_match($pattern, $this->str); |
|
|
$this->regexEncoding($regexEncoding); |
|
|
|
|
|
return $match; |
|
|
} |
|
|
|
|
|
/** |
|
|
* Alias for mb_ereg_replace with a fallback to preg_replace if the |
|
|
* mbstring module is not installed. |
|
|
*/ |
|
|
protected function eregReplace($pattern, $replacement, $string, $option = 'msr') |
|
|
{ |
|
|
static $functionExists; |
|
|
if ($functionExists === null) { |
|
|
$functionExists = function_exists('\mb_split'); |
|
|
} |
|
|
|
|
|
if ($functionExists) { |
|
|
return \mb_ereg_replace($pattern, $replacement, $string, $option); |
|
|
} else if ($this->supportsEncoding()) { |
|
|
$option = str_replace('r', '', $option); |
|
|
return \preg_replace("/$pattern/u$option", $replacement, $string); |
|
|
} |
|
|
} |
|
|
|
|
|
/** |
|
|
* Alias for mb_regex_encoding which default to a noop if the mbstring |
|
|
* module is not installed. |
|
|
*/ |
|
|
protected function regexEncoding() |
|
|
{ |
|
|
static $functionExists; |
|
|
|
|
|
if ($functionExists === null) { |
|
|
$functionExists = function_exists('\mb_regex_encoding'); |
|
|
} |
|
|
|
|
|
if ($functionExists) { |
|
|
$args = func_get_args(); |
|
|
return call_user_func_array('\mb_regex_encoding', $args); |
|
|
} |
|
|
} |
|
|
|
|
|
protected function supportsEncoding() |
|
|
{ |
|
|
$supported = ['UTF-8' => true, 'ASCII' => true]; |
|
|
|
|
|
if (isset($supported[$this->encoding])) { |
|
|
return true; |
|
|
} else { |
|
|
throw new \RuntimeException('Stringy method requires the ' . |
|
|
'mbstring module for encodings other than ASCII and UTF-8. ' . |
|
|
'Encoding used: ' . $this->encoding); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function __get($name) |
|
|
{ |
|
|
static $length; |
|
|
switch ($name) |
|
|
{ |
|
|
case 'encoding': return $this->encoding; |
|
|
case 'length': return \mb_strlen($this->str, $this->encoding); |
|
|
default: |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function __set($name, $value) |
|
|
{ |
|
|
static $length; |
|
|
switch ($name) |
|
|
{ |
|
|
case 'encoding': return $this->encoding = mb_internal_encoding(); |
|
|
case 'length': return strlen($this->_str); |
|
|
case 'test': return strlen($this->_str); |
|
|
} |
|
|
} |
|
|
|
|
|
}
|
|
|
|