1.9.0

Just a little bit of tweaking

CHANGELOG.md

@@ -1,3 +1,13 @@
+### 1.9.0 (2015-02-09)
+
+ * Added hasUpperCase and hasLowerCase
+ * Added $removeUnsupported parameter to toAscii()
+ * Improved toAscii support with additional Unicode spaces, Vietnamese chars,
+   and numerous other characters
+ * Separated the charsArray from toAscii as a protected method that may be
+   extended by inheriting classes
+ * Chars array is cached for better performance
+
 ### 1.8.1 (2015-01-08)
 
  * Optimized chars()

README.md

@@ -26,6 +26,8 @@ PHP 5.3+ and HHVM. Inspired by underscore.string.js.
     * [ensureRight](#ensureright)
     * [first](#first)
     * [getEncoding](#getencoding)
+    * [hasLowerCase](#haslowercase)
+    * [hasUpperCase](#hasuppercase)
     * [humanize](#humanize)
     * [insert](#insert)
     * [isAlpha](#isalpha)
@@ -83,7 +85,7 @@ in your composer.json file:
 ```json
 {
     "require": {
-        "danielstjules/stringy": "~1.8"
+        "danielstjules/stringy": "~1.9"
     }
 }
 ```
@@ -314,7 +316,7 @@ S::countSubstr('Ο συγγραφέας είπε', 'α', 'UTF-8');  // 2
 
 #### create
 
-S::create(mixed $str, [, $encoding ])
+S::create(mixed $str [, $encoding ])
 
 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
@@ -405,6 +407,32 @@ Returns the encoding used by the Stringy object.
 S::create('fòô bàř', 'UTF-8')->getEncoding();  // 'UTF-8'
 ```
 
+#### hasLowerCase
+
+$stringy->hasLowerCase()
+
+S::hasLowerCase(string $str [, string $encoding ])
+
+Returns true if the string contains a lower case char, false otherwise.
+
+```php
+S::create('fòô bàř', 'UTF-8')->hasLowerCase();
+S::hasLowerCase('fòô bàř', 'UTF-8');  // true
+```
+
+#### hasUpperCase
+
+$stringy->hasUpperCase()
+
+S::hasUpperCase(string $str [, string $encoding ])
+
+Returns true if the string contains an upper case char, false otherwise.
+
+```php
+S::create('fòô bàř', 'UTF-8')->hasUpperCase();
+S::hasUpperCase('fòô bàř', 'UTF-8');  // false
+```
+
 #### humanize
 
 $stringy->humanize()
@@ -734,7 +762,7 @@ S::replace('fòô bàř fòô bàř', 'fòô ', '', 'UTF-8');  // 'bàř bàř'
 
 $stringy->reverse()
 
-S::reverse(string $str, [, string $encoding ])
+S::reverse(string $str [, string $encoding ])
 
 Returns a reversed string. A multibyte version of strrev().
 
@@ -745,9 +773,9 @@ S::reverse('fòô bàř', 'UTF-8');  // 'řàb ôòf'
 
 #### safeTruncate
 
-$stringy->safeTruncate(int $length, [, string $substring = '' ])
+$stringy->safeTruncate(int $length [, string $substring = '' ])
 
-S::safeTruncate(string $str, int $length, [, string $substring = '' [, string $encoding ]])
+S::safeTruncate(string $str, int $length [, string $substring = '' [, string $encoding ]])
 
 Truncates the string to a given length, while ensuring that it does not
 split words. If $substring is provided, and truncating occurs, the
@@ -881,10 +909,11 @@ S::titleize('i like to watch DVDs at home', $ignore, 'UTF-8');
 
 $stringy->toAscii()
 
-S::toAscii(string $str)
+S::toAscii(string $str [, boolean $removeUnsupported = true])
 
 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.
+replaced with their closest ASCII counterparts, and the rest are removed
+unless instructed otherwise.
 
 ```php
 S::create('fòô bàř')->toAscii();
@@ -909,7 +938,7 @@ S::toLowerCase('FÒÔ BÀŘ', 'UTF-8');  // 'fòô bàř'
 
 $stringy->toSpaces([ tabLength = 4 ])
 
-S::toSpaces(string $str, [, int $tabLength = 4 ])
+S::toSpaces(string $str [, int $tabLength = 4 ])
 
 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.
@@ -923,7 +952,7 @@ S::toSpaces('   String speech = "Hi"');  // '    String speech = "Hi"'
 
 $stringy->toTabs([ tabLength = 4 ])
 
-S::toTabs(string $str, [, int $tabLength = 4 ])
+S::toTabs(string $str [, int $tabLength = 4 ])
 
 Converts each occurrence of some consecutive number of spaces, as defined
 by $tabLength, to a tab. By default, each 4 consecutive spaces are
@@ -976,9 +1005,9 @@ S::trim(' fòô bàř ');  // 'fòô bàř'
 
 #### truncate
 
-$stringy->truncate(int $length, [, string $substring = '' ])
+$stringy->truncate(int $length [, string $substring = '' ])
 
-S::truncate(string $str, int $length, [, string $substring = '' [, string $encoding ]])
+S::truncate(string $str, int $length [, string $substring = '' [, string $encoding ]])
 
 Truncates the string to a given length. If $substring is provided, and
 truncating occurs, the string is further truncated so that the substring

src/StaticStringy.php

@@ -166,14 +166,17 @@ class StaticStringy
 
     /**
      * 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.
+     * replaced with their closest ASCII counterparts, and the rest are removed
+     * unless instructed otherwise.
      *
-     * @param  string $str A string with non-ASCII characters
+     * @param  string $str               A string with non-ASCII characters
+     * @param  bool   $removeUnsupported Whether or not to remove the
+     *                                   unsupported characters
      * @return string A string containing only ASCII characters
      */
-    public static function toAscii($str)
+    public static function toAscii($str, $removeUnsupported = true)
     {
-        return (string) Stringy::create($str)->toAscii();
+        return (string) Stringy::create($str)->toAscii($removeUnsupported);
     }
 
     /**
@@ -683,6 +686,32 @@ class StaticStringy
         return (string) Stringy::create($str, $encoding)->removeRight($substring);
     }
 
+    /**
+     * Returns true if the string contains a lower case char, false
+     * otherwise.
+     *
+     * @param  string $str      String to check
+     * @param  string $encoding The character encoding
+     * @return bool   Whether or not $str contains a lower case character.
+     */
+    public static function hasLowerCase($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->hasLowerCase();
+    }
+
+    /**
+     * Returns true if the string contains an upper case char, false
+     * otherwise.
+     *
+     * @param  string $str      String to check
+     * @param  string $encoding The character encoding
+     * @return bool   Whether or not $str contains an upper case character.
+     */
+    public static function hasUpperCase($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->hasUpperCase();
+    }
+
     /**
      * Returns true if the string contains only alphabetic chars, false
      * otherwise.
@@ -815,7 +844,7 @@ class StaticStringy
     public static function replace($str, $search, $replacement, $encoding = null)
     {
         return (string) Stringy::create($str, $encoding)
-            ->replace($search,$replacement);
+            ->replace($search, $replacement);
     }
 
     /**

src/Stringy.php

@@ -235,14 +235,14 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
     public function camelize()
     {
         $encoding = $this->encoding;
-        $stringy = static::create($this->str, $this->encoding);
+        $stringy = $this->trim()->lowerCaseFirst();
 
         $camelCase = preg_replace_callback(
             '/[-_\s]+(.)?/u',
             function ($match) use ($encoding) {
                 return $match[1] ? mb_strtoupper($match[1], $encoding) : '';
             },
-            $stringy->trim()->lowerCaseFirst()->str
+            $stringy->str
         );
 
         $stringy->str = preg_replace_callback(
@@ -277,7 +277,7 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
      */
     public function dasherize()
     {
-        return $this->applyDelimeter('-');
+        return $this->applyDelimiter('-');
     }
 
     /**
@@ -290,7 +290,7 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
      */
     public function underscored()
     {
-        return $this->applyDelimeter('_');
+        return $this->applyDelimiter('_');
     }
 
     /**
@@ -299,13 +299,13 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
      * @param  string  $delimiter Sequence used to separate parts of the string
      * @return Stringy Object with a delimited $str
      */
-    protected function applyDelimeter($delimiter)
+    protected function applyDelimiter($delimiter)
     {
         // Save current regex encoding so we can reset it after
         $regexEncoding = mb_regex_encoding();
         mb_regex_encoding($this->encoding);
 
-        $str = mb_ereg_replace('\B([A-Z])', $delimiter .'\1', trim($this->str));
+        $str = mb_ereg_replace('\B([A-Z])', $delimiter .'\1', $this->trim());
         $str = mb_ereg_replace('[-_\s]+', $delimiter, $str);
         $str = mb_strtolower($str, $this->encoding);
 
@@ -354,7 +354,7 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
 
         $buffer = preg_replace_callback(
             '/([\S]+)/u',
-            function ($match) use (&$encoding, &$ignore) {
+            function ($match) use ($encoding, $ignore) {
                 if ($ignore && in_array($match[0], $ignore)) {
                     return $match[0];
                 } else {
@@ -419,107 +419,161 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
 
     /**
      * 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.
+     * replaced with their closest ASCII counterparts, and the rest are removed
+     * unless instructed otherwise.
      *
+     * @param  bool    $removeUnsupported Whether or not to remove the
+     *                                    unsupported characters
      * @return Stringy Object whose $str contains only ASCII characters
      */
-    public function toAscii()
+    public function toAscii($removeUnsupported = true)
     {
         $str = $this->str;
-        $charsArray = array(
+
-            'a'    => array('à', 'á', 'â', 'ä', 'ã', 'ā', 'ą', 'ă', 'å', 'α',
+        foreach ($this->charsArray() as $key => $value) {
-                            'ά', 'ἀ', 'ἁ', 'ἂ', 'ἃ', 'ἄ', 'ἅ', 'ἆ', 'ἇ', 'ᾀ',
+            $str = str_replace($value, $key, $str);
-                            'ᾁ', 'ᾂ', 'ᾃ', 'ᾄ', 'ᾅ', 'ᾆ', 'ᾇ', 'ὰ', 'ά', 'ᾰ',
+        }
-                            'ᾱ', 'ᾲ', 'ᾳ', 'ᾴ', 'ᾶ', 'ᾷ', 'а'),
+
-            'b'    => array('б', 'β'),
+        if ($removeUnsupported) {
+            $str = preg_replace('/[^\x20-\x7E]/u', '', $str);
+        }
+
+        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 = array(
+            'a'    => array(
+                            'à', 'á', 'ả', 'ã', 'ạ', 'ă', 'ắ', 'ằ', 'ẳ', 'ẵ',
+                            'ặ', 'â', 'ấ', 'ầ', 'ẩ', 'ẫ', 'ậ', 'ä', 'ā', 'ą',
+                            'å', 'α', 'ά', 'ἀ', 'ἁ', 'ἂ', 'ἃ', 'ἄ', 'ἅ', 'ἆ',
+                            'ἇ', 'ᾀ', 'ᾁ', 'ᾂ', 'ᾃ', 'ᾄ', 'ᾅ', 'ᾆ', 'ᾇ', 'ὰ',
+                            'ά', 'ᾰ', 'ᾱ', 'ᾲ', 'ᾳ', 'ᾴ', 'ᾶ', 'ᾷ', 'а', 'أ'),
+            'b'    => array('б', 'β', 'Ъ', 'Ь', 'ب'),
             'c'    => array('ç', 'ć', 'č', 'ĉ', 'ċ'),
             'd'    => array('ď', 'ð', 'đ', 'ƌ', 'ȡ', 'ɖ', 'ɗ', 'ᵭ', 'ᶁ', 'ᶑ',
-                            'д'),
+                            'д', 'δ', 'د', 'ض'),
-            'e'    => array('è', 'é', 'ê', 'ë', 'ē', 'ę', 'ě', 'ĕ', 'ė', 'ε',
+            'e'    => array('é', 'è', 'ẻ', 'ẽ', 'ẹ', 'ê', 'ế', 'ề', 'ể', 'ễ',
-                            'έ', 'ἐ', 'ἑ', 'ἒ', 'ἓ', 'ἔ', 'ἕ', 'ὲ', 'έ', 'е',
+                            'ệ', 'ë', 'ē', 'ę', 'ě', 'ĕ', 'ė', 'ε', 'έ', 'ἐ',
-                            'ё', 'э', 'є'),
+                            'ἑ', 'ἒ', 'ἓ', 'ἔ', 'ἕ', 'ὲ', 'έ', 'е', 'ё', 'э',
-            'f'    => array('ф'),
+                            'є', 'ə'),
-            'g'    => array('ĝ', 'ğ', 'ġ', 'ģ', 'г', 'ґ'),
+            'f'    => array('ф', 'φ', 'ف'),
-            'h'    => array('ĥ', 'ħ'),
+            'g'    => array('ĝ', 'ğ', 'ġ', 'ģ', 'г', 'ґ', 'γ', 'ج'),
-            'i'    => array('ì', 'í', 'î', 'ï', 'ī', 'ĩ', 'ĭ', 'į', 'ı', 'ι',
+            'h'    => array('ĥ', 'ħ', 'η', 'ή', 'ح', 'ه'),
-                            'ί', 'ϊ', 'ΐ', 'ἰ', 'ἱ', 'ἲ', 'ἳ', 'ἴ', 'ἵ', 'ἶ',
+            'i'    => array('í', 'ì', 'ỉ', 'ĩ', 'ị', 'î', 'ï', 'ī', 'ĭ', 'į',
-                            'ἷ', 'ὶ', 'ί', 'ῐ', 'ῑ', 'ῒ', 'ΐ', 'ῖ', 'ῗ', 'і',
+                            'ı', 'ι', 'ί', 'ϊ', 'ΐ', 'ἰ', 'ἱ', 'ἲ', 'ἳ', 'ἴ',
-                            'ї', 'и'),
+                            'ἵ', 'ἶ', 'ἷ', 'ὶ', 'ί', 'ῐ', 'ῑ', 'ῒ', 'ΐ', 'ῖ',
-            'j'    => array('ĵ'),
+                            'ῗ', 'і', 'ї', 'и'),
-            'k'    => array('ķ', 'ĸ', 'к'),
+            'j'    => array('ĵ', 'ј', 'Ј'),
-            'l'    => array('ł', 'ľ', 'ĺ', 'ļ', 'ŀ', 'л'),
+            'k'    => array('ķ', 'ĸ', 'к', 'κ', 'Ķ', 'ق', 'ك'),
-            'm'    => array('м'),
+            'l'    => array('ł', 'ľ', 'ĺ', 'ļ', 'ŀ', 'л', 'λ', 'ل'),
-            'n'    => array('ñ', 'ń', 'ň', 'ņ', 'ʼn', 'ŋ', 'ν', 'н'),
+            'm'    => array('м', 'μ', 'م'),
-            'o'    => array('ò', 'ó', 'ô', 'õ', 'ø', 'ō', 'ő', 'ŏ', 'ο', 'ό',
+            'n'    => array('ñ', 'ń', 'ň', 'ņ', 'ʼn', 'ŋ', 'ν', 'н', 'ن'),
-                            'ὀ', 'ὁ', 'ὂ', 'ὃ', 'ὄ', 'ὅ', 'ὸ', 'ό', 'ö', 'о'),
+            'o'    => array('ó', 'ò', 'ỏ', 'õ', 'ọ', 'ô', 'ố', 'ồ', 'ổ', 'ỗ',
-            'p'    => array('п'),
+                            'ộ', 'ơ', 'ớ', 'ờ', 'ở', 'ỡ', 'ợ', 'ø', 'ō', 'ő',
-            'r'    => array('ŕ', 'ř', 'ŗ', 'р'),
+                            'ŏ', 'ο', 'ὀ', 'ὁ', 'ὂ', 'ὃ', 'ὄ', 'ὅ', 'ὸ', 'ό',
-            's'    => array('ś', 'š', 'ş', 'с'),
+                            'ö', 'о', 'و', 'θ'),
-            't'    => array('ť', 'ţ', 'т'),
+            'p'    => array('п', 'π'),
-            'u'    => array('ü', 'ù', 'ú', 'û', 'ū', 'ů', 'ű', 'ŭ', 'ũ', 'ų',
+            'r'    => array('ŕ', 'ř', 'ŗ', 'р', 'ρ', 'ر'),
-                            'µ', 'у'),
+            's'    => array('ś', 'š', 'ş', 'с', 'σ', 'ș', 'ς', 'س', 'ص'),
+            't'    => array('ť', 'ţ', 'т', 'τ', 'ț', 'ت', 'ط'),
+            'u'    => array('ú', 'ù', 'ủ', 'ũ', 'ụ', 'ư', 'ứ', 'ừ', 'ử', 'ữ',
+                            'ự', 'ü', 'û', 'ū', 'ů', 'ű', 'ŭ', 'ų', 'µ', 'у'),
             'v'    => array('в'),
-            'w'    => array('ŵ'),
+            'w'    => array('ŵ', 'ω', 'ώ'),
-            'y'    => array('ÿ', 'ý', 'ŷ', 'й', 'ы'),
+            'x'    => array('χ'),
-            'z'    => array('ź', 'ž', 'ż', 'з'),
+            'y'    => array('ý', 'ỳ', 'ỷ', 'ỹ', 'ỵ', 'ÿ', 'ŷ', 'й', 'ы', 'υ',
+                            'ϋ', 'ύ', 'ΰ', 'ي'),
+            'z'    => array('ź', 'ž', 'ż', 'з', 'ζ', 'ز'),
+            'aa'   => array('ع'),
+            'ae'   => array('æ'),
             'ch'   => array('ч'),
-            'kh'   => array('х'),
+            'dj'   => array('ђ', 'đ'),
+            'dz'   => array('џ'),
+            'gh'   => array('غ'),
+            'kh'   => array('х', 'خ'),
+            'lj'   => array('љ'),
+            'nj'   => array('њ'),
             'oe'   => array('œ'),
+            'ps'   => array('ψ'),
             'sh'   => array('ш'),
             'shch' => array('щ'),
+            'ss'   => array('ß'),
+            'th'   => array('þ', 'ث', 'ذ', 'ظ'),
             'ts'   => array('ц'),
             'ya'   => array('я'),
             'yu'   => array('ю'),
             'zh'   => array('ж'),
-            'A'    => array('Á', 'Â', 'Ä', 'Ã', 'Å', 'Ā', 'Ą', 'Ă', 'Α', 'Ά',
+            '(c)'  => array('©'),
-                            'Ἀ', 'Ἁ', 'Ἂ', 'Ἃ', 'Ἄ', 'Ἅ', 'Ἆ', 'Ἇ', 'ᾈ', 'ᾉ',
+            'A'    => array('Á', 'À', 'Ả', 'Ã', 'Ạ', 'Ă', 'Ắ', 'Ằ', 'Ẳ', 'Ẵ',
-                            'ᾊ', 'ᾋ', 'ᾌ', 'ᾍ', 'ᾎ', 'ᾏ', 'Ᾰ', 'Ᾱ', 'Ὰ', 'Ά',
+                            'Ặ', 'Â', 'Ấ', 'Ầ', 'Ẩ', 'Ẫ', 'Ậ', 'Ä', 'Å', 'Ā',
-                            'ᾼ', 'А'),
+                            'Ą', 'Α', 'Ά', 'Ἀ', 'Ἁ', 'Ἂ', 'Ἃ', 'Ἄ', 'Ἅ', 'Ἆ',
-            'B'    => array('Б'),
+                            'Ἇ', 'ᾈ', 'ᾉ', 'ᾊ', 'ᾋ', 'ᾌ', 'ᾍ', 'ᾎ', 'ᾏ', 'Ᾰ',
+                            'Ᾱ', 'Ὰ', 'Ά', 'ᾼ', 'А'),
+            'B'    => array('Б', 'Β'),
             'C'    => array('Ć', 'Č', 'Ĉ', 'Ċ'),
-            'D'    => array('Ď', 'Ð', 'Đ', 'Ɖ', 'Ɗ', 'Ƌ', 'ᴅ', 'ᴆ', 'Д'),
+            'D'    => array('Ď', 'Ð', 'Đ', 'Ɖ', 'Ɗ', 'Ƌ', 'ᴅ', 'ᴆ', 'Д', 'Δ'),
-            'E'    => array('É', 'Ê', 'Ë', 'Ē', 'Ę', 'Ě', 'Ĕ', 'Ė', 'Ε', 'Έ',
+            'E'    => array('É', 'È', 'Ẻ', 'Ẽ', 'Ẹ', 'Ê', 'Ế', 'Ề', 'Ể', 'Ễ',
-                            'Ἐ', 'Ἑ', 'Ἒ', 'Ἓ', 'Ἔ', 'Ἕ', 'Έ', 'Ὲ', 'Е', 'Ё',
+                            'Ệ', 'Ë', 'Ē', 'Ę', 'Ě', 'Ĕ', 'Ė', 'Ε', 'Έ', 'Ἐ',
-                            'Э', 'Є'),
+                            'Ἑ', 'Ἒ', 'Ἓ', 'Ἔ', 'Ἕ', 'Έ', 'Ὲ', 'Е', 'Ё', 'Э',
-            'F'    => array('Ф'),
+                            'Є', 'Ə'),
-            'G'    => array('Ğ', 'Ġ', 'Ģ', 'Г', 'Ґ'),
+            'F'    => array('Ф', 'Φ'),
-            'I'    => array('Í', 'Î', 'Ï', 'Ī', 'Ĩ', 'Ĭ', 'Į', 'İ', 'Ι', 'Ί',
+            'G'    => array('Ğ', 'Ġ', 'Ģ', 'Г', 'Ґ', 'Γ'),
-                            'Ϊ', 'Ἰ', 'Ἱ', 'Ἳ', 'Ἴ', 'Ἵ', 'Ἶ', 'Ἷ', 'Ῐ', 'Ῑ',
+            'H'    => array('Η', 'Ή'),
-                            'Ὶ', 'Ί', 'И', 'І', 'Ї'),
+            'I'    => array('Í', 'Ì', 'Ỉ', 'Ĩ', 'Ị', 'Î', 'Ï', 'Ī', 'Ĭ', 'Į',
-            'K'    => array('К'),
+                            'İ', 'Ι', 'Ί', 'Ϊ', 'Ἰ', 'Ἱ', 'Ἳ', 'Ἴ', 'Ἵ', 'Ἶ',
-            'L'    => array('Ĺ', 'Ł', 'Л'),
+                            'Ἷ', 'Ῐ', 'Ῑ', 'Ὶ', 'Ί', 'И', 'І', 'Ї'),
-            'M'    => array('М'),
+            'K'    => array('К', 'Κ'),
-            'N'    => array('Ń', 'Ñ', 'Ň', 'Ņ', 'Ŋ', 'Н'),
+            'L'    => array('Ĺ', 'Ł', 'Л', 'Λ', 'Ļ'),
-            'O'    => array('Ó', 'Ô', 'Ö', 'Õ', 'Ø', 'Ō', 'Ő', 'Ŏ', 'Ο', 'Ό',
+            'M'    => array('М', 'Μ'),
-                            'Ὀ', 'Ὁ', 'Ὂ', 'Ὃ', 'Ὄ', 'Ὅ', 'Ὸ', 'Ό', 'О'),
+            'N'    => array('Ń', 'Ñ', 'Ň', 'Ņ', 'Ŋ', 'Н', 'Ν'),
-            'P'    => array('П'),
+            'O'    => array('Ó', 'Ò', 'Ỏ', 'Õ', 'Ọ', 'Ô', 'Ố', 'Ồ', 'Ổ', 'Ỗ',
-            'R'    => array('Ř', 'Ŕ', 'Р'),
+                            'Ộ', 'Ơ', 'Ớ', 'Ờ', 'Ở', 'Ỡ', 'Ợ', 'Ö', 'Ø', 'Ō',
-            'S'    => array('Ş', 'Ŝ', 'Ș', 'Š', 'Ś', 'С'),
+                            'Ő', 'Ŏ', 'Ο', 'Ό', 'Ὀ', 'Ὁ', 'Ὂ', 'Ὃ', 'Ὄ', 'Ὅ',
-            'T'    => array('Ť', 'Ţ', 'Ŧ', 'Ț', 'Т'),
+                            'Ὸ', 'Ό', 'О', 'Θ', 'Ө'),
-            'U'    => array('Ù', 'Ú', 'Û', 'Ü', 'Ū', 'Ů', 'Ű', 'Ŭ', 'Ũ', 'Ų',
+            'P'    => array('П', 'Π'),
-                            'У'),
+            'R'    => array('Ř', 'Ŕ', 'Р', 'Ρ'),
+            'S'    => array('Ş', 'Ŝ', 'Ș', 'Š', 'Ś', 'С', 'Σ'),
+            'T'    => array('Ť', 'Ţ', 'Ŧ', 'Ț', 'Т', 'Τ'),
+            'U'    => array('Ú', 'Ù', 'Ủ', 'Ũ', 'Ụ', 'Ư', 'Ứ', 'Ừ', 'Ử', 'Ữ',
+                            'Ự', 'Û', 'Ü', 'Ū', 'Ů', 'Ű', 'Ŭ', 'Ų', 'У'),
             'V'    => array('В'),
-            'Y'    => array('Ý', 'Ÿ', 'Ῠ', 'Ῡ', 'Ὺ', 'Ύ', 'Ы', 'Й'),
+            'W'    => array('Ω', 'Ώ'),
-            'Z'    => array('Ź', 'Ž', 'Ż', 'З'),
+            'X'    => array('Χ'),
+            'Y'    => array('Ý', 'Ỳ', 'Ỷ', 'Ỹ', 'Ỵ', 'Ÿ', 'Ῠ', 'Ῡ', 'Ὺ', 'Ύ',
+                            'Ы', 'Й', 'Υ', 'Ϋ'),
+            'Z'    => array('Ź', 'Ž', 'Ż', 'З', 'Ζ'),
+            'AE'   => array('Æ'),
             'CH'   => array('Ч'),
+            'DJ'   => array('Ђ'),
+            'DZ'   => array('Џ'),
             'KH'   => array('Х'),
+            'LJ'   => array('Љ'),
+            'NJ'   => array('Њ'),
+            'PS'   => array('Ψ'),
             'SH'   => array('Ш'),
             'SHCH' => array('Щ'),
+            'SS'   => array('ẞ'),
+            'TH'   => array('Þ'),
             'TS'   => array('Ц'),
             'YA'   => array('Я'),
             'YU'   => array('Ю'),
             'ZH'   => array('Ж'),
-            ' '    => array("\xC2\xA0", "\xE2\x80\x89", "\xE2\x80\xAF",
+            ' '    => array("\xC2\xA0", "\xE2\x80\x80", "\xE2\x80\x81",
-                            "\xE3\x80\x80"),
+                            "\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"),
         );
-
-        foreach ($charsArray as $key => $value) {
-            $str = str_replace($value, $key, $str);
-        }
-
-        $str = preg_replace('/[^\x20-\x7E]/u', '', $str);
-
-        return static::create($str, $this->encoding);
     }
 
     /**
@@ -618,8 +672,8 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
 
         $leftPadding = mb_substr(str_repeat($padStr, ceil($left / $length)), 0,
             $left, $stringy->encoding);
-        $rightPadding = mb_substr(str_repeat($padStr, ceil($right / $length)), 0,
+        $rightPadding = mb_substr(str_repeat($padStr, ceil($right / $length)),
-            $right, $stringy->encoding);
+            0, $right, $stringy->encoding);
 
         $stringy->str = $leftPadding . $stringy->str . $rightPadding;
 
@@ -755,13 +809,13 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
      */
     public function slugify($replacement = '-')
     {
-        $stringy = static::create($this->str, $this->encoding);
+        $stringy = $this->toAscii();
 
         $quotedReplacement = preg_quote($replacement);
         $pattern = "/[^a-zA-Z\d\s-_$quotedReplacement]/u";
-        $stringy->str = preg_replace($pattern, '', $stringy->toAscii());
+        $stringy->str = preg_replace($pattern, '', $stringy);
 
-        return $stringy->toLowerCase()->applyDelimeter($replacement)
+        return $stringy->toLowerCase()->applyDelimiter($replacement)
                        ->removeLeft($replacement)->removeRight($replacement);
     }
 
@@ -837,7 +891,8 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
      * Surrounds $str with the given substring.
      *
      * @param  string  $substring The substring to add to both sides
-     * @return Stringy Object whose $str had the substring prepended and appended
+     * @return Stringy Object whose $str had the substring both prepended and
+     *                 appended
      */
     public function surround($substring)
     {
@@ -1052,7 +1107,8 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
 
         $len = 0;
         $end = 0;
-        $table = array_fill(0, $strLength + 1, array_fill(0, $otherLength + 1, 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++) {
@@ -1241,6 +1297,28 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
         return $match;
     }
 
+    /**
+     * 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:]]');
+    }
+
     /**
      * Returns true if the string contains only alphabetic chars, false
      * otherwise.

tests/CommonTest.php

@@ -174,9 +174,12 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
             array('test string', 'test string'),
             array('Ο συγγραφέας', '   Ο     συγγραφέας  '),
             array('123', ' 123 '),
-            array('', ' ', 'UTF-8'), // no-break space
+            array('', ' ', 'UTF-8'), // no-break space (U+00A0)
-            array('1 2 3', '　　1　　2　　3　　', 'UTF-8'), // ideographic spaces
+            array('', '           ', 'UTF-8'), // spaces U+2000 to U+200A
-            array('', '   ', 'UTF-8'), // thin space and space
+            array('', ' ', 'UTF-8'), // narrow no-break space (U+202F)
+            array('', ' ', 'UTF-8'), // medium mathematical space (U+205F)
+            array('', '　', 'UTF-8'), // ideographic space (U+3000)
+            array('1 2 3', '  1  2  3　　', 'UTF-8'),
             array('', ' '),
             array('', ''),
         );
@@ -187,14 +190,21 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
         return array(
             array('foo bar', 'fòô bàř'),
             array(' TEST ', ' ŤÉŚŢ '),
-            array(' = z = 3', 'φ = ź = 3'),
+            array('f = z = 3', 'φ = ź = 3'),
             array('perevirka', 'перевірка'),
             array('lysaya gora', 'лысая гора'),
             array('shchuka', 'щука'),
             array('', '漢字'),
-            array(' ', ' '), // no-break space
+            array('xin chao the gioi', 'xin chào thế giới'),
-            array('  1  2  3  ', '　　1　　2　　3　　'), // ideographic spaces
+            array('XIN CHAO THE GIOI', 'XIN CHÀO THẾ GIỚI'),
-            array('   ', '   '), // thin space and space
+            array('dam phat chet luon', 'đấm phát chết luôn'),
+            array(' ', ' '), // no-break space (U+00A0)
+            array('           ', '           '), // spaces U+2000 to U+200A
+            array(' ', ' '), // narrow no-break space (U+202F)
+            array(' ', ' '), // medium mathematical space (U+205F)
+            array(' ', '　'), // ideographic space (U+3000)
+            array('', '𐍉'), // some uncommon, unsupported character (U+10349)
+            array('𐍉', '𐍉', false),
         );
     }
 
@@ -365,7 +375,6 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
             array('foo-dbar', " Foo d'Bar "),
             array('a-string-with-dashes', 'A string-with-dashes'),
             array('using-strings-like-foo-bar', 'Using strings like fòô bàř'),
-            array('unrecognized-chars-like', 'unrecognized chars like συγγρ'),
             array('numbers-1234', 'numbers 1234'),
             array('perevirka-ryadka', 'перевірка рядка'),
             array('bukvar-s-bukvoy-y', 'букварь с буквой ы'),
@@ -832,9 +841,11 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
             array(false, "\n\t ' \v\f"),
             array(false, "\n\t 2 \v\f"),
             array(true, '', 'UTF-8'),
-            array(true, ' ', 'UTF-8'), // no-break space
+            array(true, ' ', 'UTF-8'), // no-break space (U+00A0)
-            array(true, '   ', 'UTF-8'), // thin space
+            array(true, '           ', 'UTF-8'), // spaces U+2000 to U+200A
-            array(true, '　　', 'UTF-8'), // ideographic spaces
+            array(true, ' ', 'UTF-8'), // narrow no-break space (U+202F)
+            array(true, ' ', 'UTF-8'), // medium mathematical space (U+205F)
+            array(true, '　', 'UTF-8'), // ideographic space (U+3000)
             array(false, '　z', 'UTF-8'),
             array(false, '　1', 'UTF-8'),
         );
@@ -874,6 +885,24 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
         );
     }
 
+    public function hasLowerCaseProvider()
+    {
+        return array(
+            array(false, ''),
+            array(true, 'foobar'),
+            array(false, 'FOO BAR'),
+            array(true, 'fOO BAR'),
+            array(true, 'foO BAR'),
+            array(true, 'FOO BAr'),
+            array(true, 'Foobar'),
+            array(false, 'FÒÔBÀŘ', 'UTF-8'),
+            array(true, 'fòôbàř', 'UTF-8'),
+            array(true, 'fòôbàř2', 'UTF-8'),
+            array(true, 'Fòô bàř', 'UTF-8'),
+            array(true, 'fòôbÀŘ', 'UTF-8'),
+        );
+    }
+
     public function isSerializedProvider()
     {
         return array(
@@ -901,6 +930,24 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
         );
     }
 
+    public function hasUpperCaseProvider()
+    {
+        return array(
+            array(false, ''),
+            array(true, 'FOOBAR'),
+            array(false, 'foo bar'),
+            array(true, 'Foo bar'),
+            array(true, 'FOo bar'),
+            array(true, 'foo baR'),
+            array(true, 'fOOBAR'),
+            array(false, 'fòôbàř', 'UTF-8'),
+            array(true, 'FÒÔBÀŘ', 'UTF-8'),
+            array(true, 'FÒÔBÀŘ2', 'UTF-8'),
+            array(true, 'fÒÔ BÀŘ', 'UTF-8'),
+            array(true, 'FÒÔBàř', 'UTF-8'),
+        );
+    }
+
     public function isHexadecimalProvider()
     {
         return array(

tests/StaticStringyTest.php

@@ -133,9 +133,9 @@ class StaticStringyTestCase extends CommonTest
     /**
      * @dataProvider toAsciiProvider()
      */
-    public function testToAscii($expected, $str)
+    public function testToAscii($expected, $str, $removeUnsupported = true)
     {
-        $result = S::toAscii($str);
+        $result = S::toAscii($str, $removeUnsupported);
         $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
@@ -565,6 +565,16 @@ class StaticStringyTestCase extends CommonTest
         $this->assertEquals($expected, $result);
     }
 
+    /**
+     * @dataProvider hasLowerCaseProvider()
+     */
+    public function testHasLowerCase($expected, $str, $encoding = null)
+    {
+        $result = S::hasLowerCase($str, $encoding);
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+    }
+
     /**
      * @dataProvider isSerializedProvider()
      */
@@ -585,6 +595,16 @@ class StaticStringyTestCase extends CommonTest
         $this->assertEquals($expected, $result);
     }
 
+    /**
+     * @dataProvider hasUpperCaseProvider()
+     */
+    public function testHasUpperCase($expected, $str, $encoding = null)
+    {
+        $result = S::hasUpperCase($str, $encoding);
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+    }
+
     /**
      * @dataProvider isHexadecimalProvider()
      */

tests/StringyTest.php

@@ -300,10 +300,10 @@ class StringyTestCase extends CommonTest
     /**
      * @dataProvider toAsciiProvider()
      */
-    public function testToAscii($expected, $str)
+    public function testToAscii($expected, $str, $removeUnsupported = true)
     {
         $stringy = S::create($str);
-        $result = $stringy->toAscii();
+        $result = $stringy->toAscii($removeUnsupported);
         $this->assertStringy($result);
         $this->assertEquals($expected, $result);
         $this->assertEquals($str, $stringy);
@@ -813,6 +813,18 @@ class StringyTestCase extends CommonTest
         $this->assertEquals($str, $stringy);
     }
 
+    /**
+     * @dataProvider hasLowerCaseProvider()
+     */
+    public function testHasLowerCase($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->hasLowerCase();
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
     /**
      * @dataProvider isSerializedProvider()
      */
@@ -837,6 +849,18 @@ class StringyTestCase extends CommonTest
         $this->assertEquals($str, $stringy);
     }
 
+    /**
+     * @dataProvider hasUpperCaseProvider()
+     */
+    public function testHasUpperCase($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->hasUpperCase();
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
     /**
      * @dataProvider isHexadecimalProvider()
      */