Updated changelog for 1.2.0

Closes Issue 13: Fixed typo in PHPDoc

CHANGELOG.md

@@ -1,3 +1,13 @@
+### 1.2.0 (2013-09-15)
+
+  * Fixed pad's use of InvalidArgumentException
+  * Fixed replace(). It now correctly treats regex special chars as normal chars
+  * Added additional Cyrillic letters to toAscii
+  * Added $caseSensitive to contains() and count()
+  * Added toLowerCase()
+  * Added toUpperCase()
+  * Added regexReplace()
+
 ### 1.1.0 (2013-08-31)
 
   * Fix for collapseWhitespace()

README.md

@@ -38,6 +38,7 @@ A PHP library with a variety of string manipulation functions with multibyte sup
     * [padBoth](#padboth)
     * [padLeft](#padleft)
     * [padRight](#padright)
+    * [regexReplace](#regexreplace)
     * [removeLeft](#removeleft)
     * [removeRight](#removeright)
     * [replace](#replace)
@@ -52,8 +53,10 @@ A PHP library with a variety of string manipulation functions with multibyte sup
     * [tidy](#tidy)
     * [titleize](#titleize)
     * [toAscii](#toascii)
+    * [toLowerCase](#tolowercase)
     * [toSpaces](#tospaces)
     * [toTabs](#totabs)
+    * [toUpperCase](#touppercase)
     * [trim](#trim)
     * [truncate](#truncate)
     * [underscored](#underscored)
@@ -118,9 +121,9 @@ echo S::swapCase($string, 'UTF-8');  // 'fÒÔ bÀŘ'
 ## Methods
 
 In the list below, any static method other than S::create refers to a
-method in Stringy\StaticStringy. For all others, they're found in Stringy\Stringy. Furthermore, all methods that return a Stringy object or string do not modify the original.
+method in `Stringy\StaticStringy`. For all others, they're found in `Stringy\Stringy`. Furthermore, all methods that return a Stringy object or string do not modify the original.
 
-*Note: If $encoding is not given, it defaults to mb_internal_encoding().*
+*Note: If `$encoding` is not given, it defaults to `mb_internal_encoding()`.*
 
 #### at
 
@@ -167,11 +170,13 @@ S::collapseWhitespace('   Ο     συγγραφέας  ');  // 'Ο συγγρα
 
 #### contains
 
-$stringy->contains(string $needle)
+$stringy->contains(string $needle [, boolean $caseSensitive = true ])
 
-S::contains(string $haystack, string $needle [, string $encoding ])
+S::contains(string $haystack, string $needle [, boolean $caseSensitive = true [, string $encoding ]])
 
-Returns true if the string contains $needle, false otherwise.
+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.
 
 ```php
 S::create('Ο συγγραφέας είπε', 'UTF-8')->contains('συγγραφέας');
@@ -180,12 +185,13 @@ S::contains('Ο συγγραφέας είπε', 'συγγραφέας', 'UTF-8')
 
 #### count
 
-$stringy->count(string $substring)
+$stringy->count(string $substring [, boolean $caseSensitive = true ])
 
-S::count(string $str, string $substring [, string $encoding ])
+S::count(string $str, string $substring [, boolean $caseSensitive = true [, string $encoding ]])
 
-Returns the number of occurrences of $substring in the given string. An alias for
-mb_substr_count()
+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.
 
 ```php
 S::create('Ο συγγραφέας είπε', 'UTF-8')->count('α');
@@ -543,6 +549,22 @@ S::create('foo bar')->padRight(10, '_*');
 S::padRight('foo bar', 10, '_*');  // 'foo bar_*_'
 ```
 
+#### regexReplace
+
+$stringy->regexReplace(string $pattern, string $replacement [, string $options = 'msr'])
+
+S::regexReplace(string $str, string $pattern, string $replacement [, string $options = 'msr' [, string $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.4+. This is due to a lack of support
+in the bundled version of Oniguruma in PHP 5.3.
+
+```php
+S::create('fòô ', 'UTF-8')->regexReplace('f[òô]+\s', 'bàř', 'msr');
+S::regexReplace('fòô ', 'f[òô]+\s', 'bàř', 'msr', 'UTF-8');  // 'bàř'
+```
+
 #### removeLeft
 
 $stringy->removeLeft(string $substring)
@@ -571,11 +593,11 @@ S::removeRight('fòô bàř', ' bàř', 'UTF-8');  // 'fòô'
 
 #### replace
 
-$stringy->replace(string $search, string $replace)
+$stringy->replace(string $search, string $replacement)
 
-S::replace(string $str, string $search, string $replace [, string $encoding ])
+S::replace(string $str, string $search, string $replacement [, string $encoding ])
 
-Returns a string with all occurrences of $search replaced with $replace.
+Replaces all occurrences of $search in $str by $replacement.
 
 ```php
 S::create('fòô bàř fòô bàř', 'UTF-8')->replace('fòô ', '');
@@ -742,6 +764,20 @@ S::create('fòô bàř')->toAscii();
 S::toAscii('fòô bàř');  // 'foo bar'
 ```
 
+#### toLowerCase
+
+$stringy->toLowerCase()
+
+S::toLowerCase(string $str [, string $encoding ])
+
+Converts all characters in the string to lowercase. An alias for PHP's
+mb_strtolower().
+
+```php
+S::create('FÒÔ BÀŘ', 'UTF-8')->toLowerCase();
+S::toLowerCase('FÒÔ BÀŘ', 'UTF-8');  // 'fòô bàř'
+```
+
 #### toSpaces
 
 $stringy->toSpaces([ tabLength = 4 ])
@@ -771,6 +807,20 @@ S::create('    fòô    bàř')->toTabs();
 S::toTabs('    fòô    bàř');  // '   fòô bàř'
 ```
 
+#### toUpperCase
+
+$stringy->toUpperCase()
+
+S::toUpperCase(string $str [, string $encoding ])
+
+Converts all characters in the string to uppercase. An alias for PHP's
+mb_strtoupper().
+
+```php
+S::create('fòô bàř', 'UTF-8')->toUpperCase();
+S::toUpperCase('fòô bàř', 'UTF-8');  // 'FÒÔ BÀŘ'
+```
+
 #### trim
 
 $stringy->trim()

src/Stringy/StaticStringy.php

@@ -132,7 +132,6 @@ class StaticStringy
      * equivalents.
      *
      * @param   string  $str       String to remove special chars
-     * @param   string  $encoding  The character encoding
      * @return  string  String with those characters removed
      */
     public static function tidy($str)
@@ -145,7 +144,8 @@ class StaticStringy
      * single space. This includes tabs and newline characters, as well as
      * multibyte whitespace such as the thin space and ideographic space.
      *
-     * @param   string  $str  The string to cleanup whitespace
+     * @param   string  $str       The string to cleanup whitespace
+     * @param   string  $encoding  The character encoding
      * @return  string  The trimmed string with condensed whitespace
      */
     public static function collapseWhitespace($str, $encoding = null)
@@ -296,6 +296,32 @@ class StaticStringy
         return Stringy::create($str)->toTabs($tabLength)->str;
     }
 
+    /**
+     * Converts all characters in the string to lowercase. An alias for PHP's
+     * mb_strtolower().
+     *
+     * @param   string  $str       String to convert case
+     * @param   string  $encoding  The character encoding
+     * @return  string  The lowercase string
+     */
+    public static function toLowerCase($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->toLowerCase()->str;
+    }
+
+    /**
+     * Converts all characters in the string to uppercase. An alias for PHP's
+     * mb_strtoupper().
+     *
+     * @param   string  $str       String to convert case
+     * @param   string  $encoding  The character encoding
+     * @return  string  The uppercase string
+     */
+    public static function toUpperCase($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->toUpperCase()->str;
+    }
+
     /**
      * Converts the string into an URL slug. This includes replacing non-ASCII
      * characters with their closest ASCII equivalents, removing non-alphanumeric
@@ -311,16 +337,20 @@ class StaticStringy
     }
 
     /**
-     * Returns true if the string contains $needle, false otherwise.
+     * 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  $haystack  String being checked
-     * @param   string  $needle    Substring to look for
-     * @param   string  $encoding  The character encoding
+     * @param   string  $haystack       String being checked
+     * @param   string  $needle         Substring to look for
+     * @param   bool    $caseSensitive  Whether or not to enforce case-sensitivity
+     * @param   string  $encoding       The character encoding
      * @return  bool    Whether or not $haystack contains $needle
      */
-    public static function contains($haystack, $needle, $encoding = null)
+    public static function contains($haystack, $needle, $caseSensitive = true,
+                                    $encoding = null)
     {
-        return Stringy::create($haystack, $encoding)->contains($needle);
+        return Stringy::create($haystack, $encoding)->contains($needle, $caseSensitive);
     }
 
     /**
@@ -686,29 +716,52 @@ class StaticStringy
 
     /**
      * Returns the number of occurrences of $substring in the given string.
-     * An alias for mb_substr_count()
+     * By default, the comparison is case-sensitive, but can be made insensitive
+     * by setting $caseSensitive to false.
      *
-     * @param   string   $str        The string to search through
-     * @param   string   $substring  The substring to search for
-     * @param   string   $encoding   The character encoding
+     * @param   string   $str            The string to search through
+     * @param   string   $substring      The substring to search for
+     * @param   bool     $caseSensitive  Whether or not to enforce case-sensitivity
+     * @param   string   $encoding       The character encoding
      * @return  int      The number of $substring occurrences
      */
-    public static function count($str, $substring, $encoding = null)
+    public static function count($str, $substring, $caseSensitive = true,
+                                 $encoding = null)
     {
-        return Stringy::create($str, $encoding)->count($substring);
+        return Stringy::create($str, $encoding)->count($substring, $caseSensitive);
     }
 
     /**
-     * Returns a string with all occurrences of $search replaced with $replace.
+     * Replaces all occurrences of $search in $str by $replacement.
      *
-     * @param   string   $str       The haystack to search through
-     * @param   string   $search    The needle to search for
-     * @param   string   $replace   The string to replace with
-     * @param   string   $encoding  The character encoding
+     * @param   string   $str           The haystack to search through
+     * @param   string   $search        The needle to search for
+     * @param   string   $replacement   The string to replace with
+     * @param   string   $encoding      The character encoding
      * @return  string   The resulting string after the replacements
      */
-    public static function replace($str, $search, $replace, $encoding = null)
+    public static function replace($str, $search, $replacement, $encoding = null)
     {
-        return Stringy::create($str, $encoding)->replace($search, $replace)->str;
+        return Stringy::create($str, $encoding)->replace($search, $replacement)->str;
+    }
+
+    /**
+     * 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.4+. This is due to a lack of support
+     * in the bundled version of Oniguruma in PHP 5.3.
+     *
+     * @param   string   $str          The haystack to search through
+     * @param   string   $pattern      The regular expression pattern
+     * @param   string   $replacement  The string to replace with
+     * @param   string   $options      Matching conditions to be used
+     * @param   string   $encoding     The character encoding
+     * @return  string   The resulting string after the replacements
+     */
+    public static function regexReplace($str, $pattern, $replacement,
+                                        $options = 'msr', $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->regexReplace($pattern,
+            $replacement, $options, $encoding)->str;
     }
 }

src/Stringy/Stringy.php

@@ -284,55 +284,81 @@ class Stringy
     {
         $stringy = self::create($this->str, $this->encoding);
         $charsArray = array(
-            'a'  => array('à', 'á', 'â', 'ã', 'ā', 'ą', 'ă', 'å', 'α', 'ά', 'ἀ',
-                          'ἁ', 'ἂ', 'ἃ', 'ἄ', 'ἅ', 'ἆ', 'ἇ', 'ᾀ', 'ᾁ', 'ᾂ', 'ᾃ',
-                          'ᾄ', 'ᾅ', 'ᾆ', 'ᾇ', 'ὰ', 'ά', 'ᾰ', 'ᾱ', 'ᾲ', 'ᾳ', 'ᾴ',
-                          'ᾶ', 'ᾷ'),
-            'b'  => array('б', 'β'),
-            'c'  => array('ç', 'ć', 'č', 'ĉ', 'ċ'),
-            'd'  => array('ď', 'ð', 'đ', 'ƌ', 'ȡ', 'ɖ', 'ɗ', 'ᵭ', 'ᶁ', 'ᶑ'),
-            'e'  => array('è', 'é', 'ê', 'ë', 'ē', 'ę', 'ě', 'ĕ', 'ė', 'ε', 'έ',
-                          'ἐ', 'ἑ', 'ἒ', 'ἓ', 'ἔ', 'ἕ', 'ὲ', 'έ', 'е', 'ё', 'э'),
-            'g'  => array('ĝ', 'ğ', 'ġ', 'ģ'),
-            'h'  => array('ĥ', 'ħ'),
-            'i'  => array('ì', 'í', 'î', 'ï', 'ī', 'ĩ', 'ĭ', 'į', 'ı', 'ι', 'ί',
-                          'ϊ', 'ΐ', 'ἰ', 'ἱ', 'ἲ', 'ἳ', 'ἴ', 'ἵ', 'ἶ', 'ἷ', 'ὶ',
-                          'ί', 'ῐ', 'ῑ', 'ῒ', 'ΐ', 'ῖ', 'ῗ'),
-            'j'  => array('ĵ'),
-            'k'  => array('ķ', 'ĸ'),
-            'l'  => array('ł', 'ľ', 'ĺ', 'ļ', 'ŀ'),
-            'n'  => array('ñ', 'ń', 'ň', 'ņ', 'ʼn', 'ŋ', 'ν'),
-            'o'  => array('ò', 'ó', 'ô', 'õ', 'ø', 'ō', 'ő', 'ŏ', 'ο', 'ό', 'ὀ',
-                          'ὁ', 'ὂ', 'ὃ', 'ὄ', 'ὅ', 'ὸ', 'ό', 'ö'),
-            'r'  => array('ŕ', 'ř', 'ŗ'),
-            's'  => array('ś', 'š', 'ş'),
-            't'  => array('ť', 'ţ'),
-            'u'  => array('ü', 'ù', 'ú', 'û', 'ū', 'ů', 'ű', 'ŭ', 'ũ', 'ų', 'µ'),
-            'w'  => array('ŵ'),
-            'y'  => array('ÿ', 'ý', 'ŷ'),
-            'z'  => array('ź', 'ž', 'ż'),
-            'oe' => array('œ'),
-            'A'  => array('Á', 'Â', 'Ã', 'Å', 'Ā', 'Ą', 'Ă', 'Α', 'Ά', 'Ἀ', 'Ἁ',
-                         'Ἂ', 'Ἃ', 'Ἄ', 'Ἅ', 'Ἆ', 'Ἇ', 'ᾈ', 'ᾉ', 'ᾊ', 'ᾋ', 'ᾌ',
-                         'ᾍ', 'ᾎ', 'ᾏ', 'Ᾰ', 'Ᾱ', 'Ὰ', 'Ά', 'ᾼ'),
-            'B'  => array('Б'),
-            'C'  => array('Ć', 'Č', 'Ĉ', 'Ċ'),
-            'D'  => array('Ď', 'Ð', 'Đ', 'Ɖ', 'Ɗ', 'Ƌ', 'ᴅ', 'ᴆ'),
-            'E'  => array('É', 'Ê', 'Ë', 'Ē', 'Ę', 'Ě', 'Ĕ', 'Ė', 'Ε', 'Έ', 'Ἐ',
-                          'Ἑ', 'Ἒ', 'Ἓ', 'Ἔ', 'Ἕ', 'Έ', 'Ὲ', 'Е', 'Ё', 'Э'),
-            'G'  => array('Ğ', 'Ġ', 'Ģ'),
-            'I'  => array('Í', 'Î', 'Ï', 'Ī', 'Ĩ', 'Ĭ', 'Į', 'İ', 'Ι', 'Ί', 'Ϊ',
-                          'Ἰ', 'Ἱ', 'Ἳ', 'Ἴ', 'Ἵ', 'Ἶ', 'Ἷ', 'Ῐ', 'Ῑ', 'Ὶ', 'Ί'),
-            'L'  => array('Ĺ', 'Ł'),
-            'N'  => array('Ń', 'Ñ', 'Ň', 'Ņ', 'Ŋ',),
-            'O'  => array('Ó', 'Ô', 'Õ', 'Ø', 'Ō', 'Ő', 'Ŏ', 'Ο', 'Ό', 'Ὀ', 'Ὁ',
-                          'Ὂ', 'Ὃ', 'Ὄ', 'Ὅ', 'Ὸ', 'Ό'),
-            'R'  => array('Ř', 'Ŕ'),
-            'S'  => array('Ş', 'Ŝ', 'Ș', 'Š', 'Ś'),
-            'T'  => array('Ť', 'Ţ', 'Ŧ', 'Ț'),
-            'U'  => array('Ù', 'Ú', 'Û', 'Ū', 'Ů', 'Ű', 'Ŭ', 'Ũ', 'Ų'),
-            'Y'  => array('Ý', 'Ÿ', 'Ῠ', 'Ῡ', 'Ὺ', 'Ύ'),
-            'Z'  => array('Ź', 'Ž', 'Ż')
+            'a'    => array('à', 'á', 'â', 'ã', 'ā', 'ą', 'ă', 'å', 'α', 'ά', 'ἀ',
+                            'ἁ', 'ἂ', 'ἃ', 'ἄ', 'ἅ', 'ἆ', 'ἇ', 'ᾀ', 'ᾁ', 'ᾂ', 'ᾃ',
+                            'ᾄ', 'ᾅ', 'ᾆ', 'ᾇ', 'ὰ', 'ά', 'ᾰ', 'ᾱ', 'ᾲ', 'ᾳ', 'ᾴ',
+                            'ᾶ', 'ᾷ', 'а'),
+            'b'    => array('б', 'β'),
+            'c'    => array('ç', 'ć', 'č', 'ĉ', 'ċ'),
+            'd'    => array('ď', 'ð', 'đ', 'ƌ', 'ȡ', 'ɖ', 'ɗ', 'ᵭ', 'ᶁ', 'ᶑ', 'д'),
+            'e'    => array('è', 'é', 'ê', 'ë', 'ē', 'ę', 'ě', 'ĕ', 'ė', 'ε', 'έ',
+                            'ἐ', 'ἑ', 'ἒ', 'ἓ', 'ἔ', 'ἕ', 'ὲ', 'έ', 'е', 'ё', 'э', 'є'),
+            'f'    => array('ф'),
+            'g'    => array('ĝ', 'ğ', 'ġ', 'ģ', 'г', 'ґ'),
+            'h'    => array('ĥ', 'ħ'),
+            'i'    => array('ì', 'í', 'î', 'ï', 'ī', 'ĩ', 'ĭ', 'į', 'ı', 'ι', 'ί',
+                            'ϊ', 'ΐ', 'ἰ', 'ἱ', 'ἲ', 'ἳ', 'ἴ', 'ἵ', 'ἶ', 'ἷ', 'ὶ',
+                            'ί', 'ῐ', 'ῑ', 'ῒ', 'ΐ', 'ῖ', 'ῗ', 'і', 'ї', 'и'),
+            'j'    => array('ĵ'),
+            'k'    => array('ķ', 'ĸ', 'к'),
+            'l'    => array('ł', 'ľ', 'ĺ', 'ļ', 'ŀ', 'л'),
+            'm'    => array('м'),
+            'n'    => array('ñ', 'ń', 'ň', 'ņ', 'ʼn', 'ŋ', 'ν', 'н'),
+            'o'    => array('ò', 'ó', 'ô', 'õ', 'ø', 'ō', 'ő', 'ŏ', 'ο', 'ό', 'ὀ',
+                            'ὁ', 'ὂ', 'ὃ', 'ὄ', 'ὅ', 'ὸ', 'ό', 'ö', 'о'),
+            'p'    => array('п'),
+            'r'    => array('ŕ', 'ř', 'ŗ', 'р'),
+            's'    => array('ś', 'š', 'ş', 'с'),
+            't'    => array('ť', 'ţ', 'т'),
+            'u'    => array('ü', 'ù', 'ú', 'û', 'ū', 'ů', 'ű', 'ŭ', 'ũ', 'ų', 'µ', 'у'),
+            'v'    => array('в'),
+            'w'    => array('ŵ'),
+            'y'    => array('ÿ', 'ý', 'ŷ', 'й', 'ы'),
+            'z'    => array('ź', 'ž', 'ż', 'з'),
+            'ch'   => array('ч'),
+            'kh'   => array('х'),
+            'oe'   => array('œ'),
+            'sh'   => array('ш'),
+            'shch' => array('щ'),
+            'ts'   => array('ц'),
+            'ya'   => array('я'),
+            'yu'   => array('ю'),
+            'zh'   => array('ж'),
+            'A'    => array('Á', 'Â', 'Ã', 'Å', 'Ā', 'Ą', 'Ă', 'Α', 'Ά', 'Ἀ', 'Ἁ',
+                            'Ἂ', 'Ἃ', 'Ἄ', 'Ἅ', 'Ἆ', 'Ἇ', 'ᾈ', 'ᾉ', 'ᾊ', 'ᾋ', 'ᾌ',
+                            'ᾍ', 'ᾎ', 'ᾏ', 'Ᾰ', 'Ᾱ', 'Ὰ', 'Ά', 'ᾼ', 'А'),
+            'B'    => array('Б'),
+            'C'    => array('Ć', 'Č', 'Ĉ', 'Ċ'),
+            'D'    => array('Ď', 'Ð', 'Đ', 'Ɖ', 'Ɗ', 'Ƌ', 'ᴅ', 'ᴆ', 'Д'),
+            'E'    => array('É', 'Ê', 'Ë', 'Ē', 'Ę', 'Ě', 'Ĕ', 'Ė', 'Ε', 'Έ', 'Ἐ',
+                            'Ἑ', 'Ἒ', 'Ἓ', 'Ἔ', 'Ἕ', 'Έ', 'Ὲ', 'Е', 'Ё', 'Э', 'Є'),
+            'F'    => array('Ф'),
+            'G'    => array('Ğ', 'Ġ', 'Ģ', 'Г', 'Ґ'),
+            'I'    => array('Í', 'Î', 'Ï', 'Ī', 'Ĩ', 'Ĭ', 'Į', 'İ', 'Ι', 'Ί', 'Ϊ',
+                            'Ἰ', 'Ἱ', 'Ἳ', 'Ἴ', 'Ἵ', 'Ἶ', 'Ἷ', 'Ῐ', 'Ῑ', 'Ὶ', 'Ί',
+                            'И', 'І', 'Ї'),
+            'K'    => array('К'),
+            'L'    => array('Ĺ', 'Ł', 'Л'),
+            'M'    => array('М'),
+            'N'    => array('Ń', 'Ñ', 'Ň', 'Ņ', 'Ŋ', 'Н'),
+            'O'    => array('Ó', 'Ô', 'Õ', 'Ø', 'Ō', 'Ő', 'Ŏ', 'Ο', 'Ό', 'Ὀ', 'Ὁ',
+                            'Ὂ', 'Ὃ', 'Ὄ', 'Ὅ', 'Ὸ', 'Ό', 'О'),
+            'P'    => array('П'),
+            'R'    => array('Ř', 'Ŕ', 'Р'),
+            'S'    => array('Ş', 'Ŝ', 'Ș', 'Š', 'Ś', 'С'),
+            'T'    => array('Ť', 'Ţ', 'Ŧ', 'Ț', 'Т'),
+            'U'    => array('Ù', 'Ú', 'Û', 'Ū', 'Ů', 'Ű', 'Ŭ', 'Ũ', 'Ų', 'У'),
+            'V'    => array('В'),
+            'Y'    => array('Ý', 'Ÿ', 'Ῠ', 'Ῡ', 'Ὺ', 'Ύ', 'Ы', 'Й'),
+            'Z'    => array('Ź', 'Ž', 'Ż', 'З'),
+            'CH'   => array('Ч'),
+            'KH'   => array('Х'),
+            'SH'   => array('Ш'),
+            'SHCH' => array('Щ'),
+            'TS'   => array('Ц'),
+            'YA'   => array('Я'),
+            'YU'   => array('Ю'),
+            'ZH'   => array('Ж')
         );
 
         foreach ($charsArray as $key => $value) {
@@ -359,7 +385,7 @@ class Stringy
     public function pad($length, $padStr = ' ', $padType = 'right')
     {
         if (!in_array($padType, array('left', 'right', 'both'))) {
-            throw new InvalidArgumentException('Pad expects $padType ' .
+            throw new \InvalidArgumentException('Pad expects $padType ' .
                 "to be one of 'left', 'right' or 'both'");
         }
 
@@ -418,9 +444,9 @@ class Stringy
      * 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  string  Object with a right padded $str
+     * @param   int      $length  Desired string length after padding
+     * @param   string   $padStr  String used to pad, defaults to space
+     * @return  Stringy  Object with a right padded $str
      */
     public function padRight($length, $padStr = ' ')
     {
@@ -522,6 +548,32 @@ class Stringy
         return $stringy;
     }
 
+    /**
+     * Converts all characters in the string to lowercase. An alias for PHP's
+     * mb_strtolower().
+     *
+     * @return  Stringy  Object with all characters of $str being lowercase
+     */
+    public function toLowerCase()
+    {
+        $str = mb_strtolower($this->str, $this->encoding);
+
+        return self::create($str, $this->encoding);
+    }
+
+    /**
+     * Converts all characters in the string to uppercase. An alias for PHP's
+     * mb_strtoupper().
+     *
+     * @return  Stringy  Object with all characters of $str being uppercase
+     */
+    public function toUpperCase()
+    {
+        $str = mb_strtoupper($this->str, $this->encoding);
+
+        return self::create($str, $this->encoding);
+    }
+
     /**
      * Converts the string into an URL slug. This includes replacing non-ASCII
      * characters with their closest ASCII equivalents, removing non-alphanumeric
@@ -542,17 +594,20 @@ class Stringy
     }
 
     /**
-     * Returns true if the string contains $needle, false otherwise.
+     * 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   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)
+    public function contains($needle, $caseSensitive = true)
     {
-        if (mb_strpos($this->str, $needle, 0, $this->encoding) !== false)
-            return true;
-
-        return false;
+        if ($caseSensitive)
+            return (mb_strpos($this->str, $needle, 0, $this->encoding) !== false);
+        else
+            return (mb_stripos($this->str, $needle, 0, $this->encoding) !== false);
     }
 
     /**
@@ -639,7 +694,7 @@ class Stringy
 
         // If the last word was truncated
         if (mb_strpos($stringy->str, ' ', $length - 1, $stringy->encoding) != $length) {
-            // Find pos of the last occurence of a space, and get everything up until
+            // Find pos of the last occurrence of a space, and get everything up until
             $lastPos = mb_strrpos($truncated, ' ', 0, $stringy->encoding);
             $truncated = mb_substr($truncated, 0, $lastPos, $stringy->encoding);
         }
@@ -947,7 +1002,7 @@ class Stringy
     /**
      * Returns true if $str matches the supplied pattern, false otherwise.
      *
-     * @param   string  Regex pattern to match against
+     * @param   string  $pattern  Regex pattern to match against
      * @return  bool    Whether or not $str matches the pattern
      */
     private function matchesPattern($pattern)
@@ -1049,37 +1104,66 @@ class Stringy
 
     /**
      * Returns the number of occurrences of $substring in the given string.
-     * An alias for mb_substr_count()
+     * 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   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 count($substring)
+    public function count($substring, $caseSensitive = true)
     {
+        if (!$caseSensitive) {
+            $str = mb_strtoupper($this->str, $this->encoding);
+            $substring = mb_strtoupper($substring, $this->encoding);
+
+            return mb_substr_count($str, $substring, $this->encoding);
+        }
+
         return mb_substr_count($this->str, $substring, $this->encoding);
     }
 
     /**
-     * Returns a string with all occurrences of $search replaced with $replace.
+     * Replaces all occurrences of $search in $str by $replacement.
      *
-     * @param   string   $search   The needle to search for
-     * @param   string   $replace  The string to replace with
+     * @param   string   $search       The needle to search for
+     * @param   string   $replacement  The string to replace with
      * @return  Stringy  Object with the resulting $str after the replacements
      */
-    public function replace($search, $replace)
+    public function replace($search, $replacement)
     {
-        $stringy = self::create($this->str, $this->encoding);
-
         $regexEncoding = mb_regex_encoding();
-        mb_regex_encoding($stringy->encoding);
+        mb_regex_encoding($this->encoding);
 
-        // Don't want the args accidentally being parsed as regex
-        $quotedSearch = preg_quote($search);
-        $quotedReplace = preg_quote($replace);
+        // Don't want the args being parsed as regex
+        $search = preg_quote($search);
+        $replacement = preg_quote($replacement);
 
-        $stringy->str = mb_ereg_replace($search, $replace, $stringy->str);
+        $str = mb_ereg_replace($search, $replacement, $this->str);
         mb_regex_encoding($regexEncoding);
 
-        return $stringy;
+        return self::create($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.4+. This is due to a lack of support
+     * in the bundled version of Oniguruma in PHP 5.3.
+     *
+     * @param   string   $pattern      The regular expression pattern
+     * @param   string   $replacement  The string to replace with
+     * @param   string   $options      Matching conditions to be used
+     * @return  Stringy  Object with the resulting $str after the replacements
+     */
+    public function regexReplace($pattern, $replacement, $options = 'msr')
+    {
+        $regexEncoding = mb_regex_encoding();
+        mb_regex_encoding($this->encoding);
+
+        $str = mb_ereg_replace($pattern, $replacement, $this->str, $options);
+        mb_regex_encoding($regexEncoding);
+
+        return self::create($str, $this->encoding);
     }
 }

tests/Stringy/CommonTest.php

@@ -187,7 +187,10 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
         $testData = array(
             array('foo bar', 'fòô bàř'),
             array(' TEST ', ' ŤÉŚŢ '),
-            array('φ = z = 3', 'φ = ź = 3')
+            array('φ = z = 3', 'φ = ź = 3'),
+            array('perevirka', 'перевірка'),
+            array('lysaya gora', 'лысая гора'),
+            array('shchuka', 'щука')
         );
 
         return $testData;
@@ -335,6 +338,32 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
         return $testData;
     }
 
+    public function stringsForToLowerCase()
+    {
+        $testData = array(
+            array('foo bar', 'FOO BAR'),
+            array(' foo_bar ', ' FOO_bar '),
+            array('fòô bàř', 'FÒÔ BÀŘ', 'UTF-8'),
+            array(' fòô_bàř ', ' FÒÔ_bàř ', 'UTF-8'),
+            array('αυτοκίνητο', 'ΑΥΤΟΚΊΝΗΤΟ', 'UTF-8'),
+        );
+
+        return $testData;
+    }
+
+    public function stringsForToUpperCase()
+    {
+        $testData = array(
+            array('FOO BAR', 'foo bar'),
+            array(' FOO_BAR ', ' FOO_bar '),
+            array('FÒÔ BÀŘ', 'fòô bàř', 'UTF-8'),
+            array(' FÒÔ_BÀŘ ', ' FÒÔ_bàř ', 'UTF-8'),
+            array('ΑΥΤΟΚΊΝΗΤΟ', 'αυτοκίνητο', 'UTF-8'),
+        );
+
+        return $testData;
+    }
+
     public function stringsForSlugify()
     {
         $testData = array(
@@ -343,7 +372,9 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
             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('numbers-1234', 'numbers 1234'),
+            array('perevirka-ryadka', 'перевірка рядка'),
+            array('bukvar-s-bukvoy-y', 'букварь с буквой ы')
         );
 
         return $testData;
@@ -355,14 +386,24 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
             array(true, 'This string contains foo bar', 'foo bar'),
             array(true, '12398!@(*%!@# @!%#*&^%',  ' @!%#*&^%'),
             array(true, 'Ο συγγραφέας είπε', 'συγγραφέας', 'UTF-8'),
-            array(true, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', 'å´¥©', 'UTF-8'),
-            array(true, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', 'å˚ ∆', 'UTF-8'),
-            array(true, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', 'øœ¬', 'UTF-8'),
+            array(true, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', 'å´¥©', true, 'UTF-8'),
+            array(true, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', 'å˚ ∆', true, 'UTF-8'),
+            array(true, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', 'øœ¬', true, 'UTF-8'),
             array(false, 'This string contains foo bar', 'Foo bar'),
             array(false, 'This string contains foo bar', 'foobar'),
             array(false, 'This string contains foo bar', 'foo bar '),
-            array(false, 'Ο συγγραφέας είπε', '  συγγραφέας ', 'UTF-8'),
-            array(false, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', ' ßå˚', 'UTF-8')
+            array(false, 'Ο συγγραφέας είπε', '  συγγραφέας ', true, 'UTF-8'),
+            array(false, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', ' ßå˚', true, 'UTF-8'),
+            array(true, 'This string contains foo bar', 'Foo bar', false),
+            array(true, '12398!@(*%!@# @!%#*&^%',  ' @!%#*&^%', false),
+            array(true, 'Ο συγγραφέας είπε', 'ΣΥΓΓΡΑΦΈΑΣ', false, 'UTF-8'),
+            array(true, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', 'Å´¥©', false, 'UTF-8'),
+            array(true, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', 'Å˚ ∆', false, 'UTF-8'),
+            array(true, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', 'ØŒ¬', false, 'UTF-8'),
+            array(false, 'This string contains foo bar', 'foobar', false),
+            array(false, 'This string contains foo bar', 'foo bar ', false),
+            array(false, 'Ο συγγραφέας είπε', '  συγγραφέας ', false, 'UTF-8'),
+            array(false, 'å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', ' ßÅ˚', false, 'UTF-8')
         );
 
         return $testData;
@@ -866,7 +907,14 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
             array(0, '', 'fòô', 'UTF-8'),
             array(0, 'fòô', 'bàř', 'UTF-8'),
             array(1, 'fòô bàř', 'fòô', 'UTF-8'),
-            array(2, 'fôòô bàř', 'ô', 'UTF-8')
+            array(2, 'fôòô bàř', 'ô', 'UTF-8'),
+            array(0, 'fÔÒÔ bàř', 'ô', 'UTF-8'),
+            array(0, 'foo', 'BAR', false),
+            array(1, 'foo bar', 'FOo', false),
+            array(2, 'foo bar', 'O', false),
+            array(1, 'fòô bàř', 'fÒÔ', false, 'UTF-8'),
+            array(2, 'fôòô bàř', 'Ô', false, 'UTF-8'),
+            array(2, 'συγγραφέας', 'Σ', false, 'UTF-8')
         );
 
         return $testData;
@@ -877,12 +925,14 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
         $testData = array(
             array('', '', '', ''),
             array('foo', '', '', 'foo'),
+            array('foo', '\s', '\s', 'foo'),
             array('foo bar', 'foo bar', '', ''),
             array('bar', 'foo bar', 'foo ', ''),
             array('far bar', 'foo bar', 'foo', 'far'),
             array('bar bar', 'foo bar foo bar', 'foo ', ''),
             array('', '', '', '', 'UTF-8'),
             array('fòô', '', '', 'fòô', 'UTF-8'),
+            array('fòô', '\s', '\s', 'fòô', 'UTF-8'),
             array('fòô bàř', 'fòô bàř', '', '', 'UTF-8'),
             array('bàř', 'fòô bàř', 'fòô ', '', 'UTF-8'),
             array('far bàř', 'fòô bàř', 'fòô', 'far', 'UTF-8'),
@@ -891,4 +941,19 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
 
         return $testData;
     }
+
+    public function stringsForRegexReplace()
+    {
+        $testData = array(
+            array('', '', '', ''),
+            array('bar', 'foo', 'f[o]+', 'bar'),
+            array('bar', 'foo bar', 'f[O]+\s', '', 'i'),
+            array('foo', 'bar', '[[:alpha:]]{3}', 'foo'),
+            array('', '', '', '', 'msr', 'UTF-8'),
+            array('bàř', 'fòô ', 'f[òô]+\s', 'bàř', 'msr', 'UTF-8'),
+            array('fòô', 'bàř', '[[:alpha:]]{3}', 'fòô', 'msr', 'UTF-8')
+        );
+
+        return $testData;
+    }
 }

tests/Stringy/StaticStringyTest.php

@@ -139,6 +139,14 @@ class StaticStringyTestCase extends CommonTest
         $this->assertEquals($expected, $result);
     }
 
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testPadException()
+    {
+        $result = S::pad('string', 5, 'foo', 'bar');
+    }
+
     /**
      * @dataProvider stringsForPadLeft
      */
@@ -214,6 +222,26 @@ class StaticStringyTestCase extends CommonTest
         $this->assertEquals($expected, $result);
     }
 
+    /**
+     * @dataProvider stringsForToLowerCase
+     */
+    public function testToLowerCase($expected, $str, $encoding = null)
+    {
+        $result = S::toLowerCase($str, $encoding);
+        $this->assertInternalType('string', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider stringsForToUpperCase
+     */
+    public function testToUpperCase($expected, $str, $encoding = null)
+    {
+        $result = S::toUpperCase($str, $encoding);
+        $this->assertInternalType('string', $result);
+        $this->assertEquals($expected, $result);
+    }
+
     /**
      * @dataProvider stringsForSlugify
      */
@@ -227,9 +255,10 @@ class StaticStringyTestCase extends CommonTest
     /**
      * @dataProvider stringsForContains
      */
-    public function testContains($expected, $haystack, $needle, $encoding = null)
+    public function testContains($expected, $haystack, $needle,
+                                 $caseSensitive = true, $encoding = null)
     {
-        $result = S::contains($haystack, $needle, $encoding);
+        $result = S::contains($haystack, $needle, $caseSensitive, $encoding);
         $this->assertInternalType('boolean', $result);
         $this->assertEquals($expected, $result);
     }
@@ -525,9 +554,10 @@ class StaticStringyTestCase extends CommonTest
     /**
      * @dataProvider stringsForCount
      */
-    public function testCount($expected, $str, $substring, $encoding = null)
+    public function testCount($expected, $str, $substring, $caseSensitive = true,
+                              $encoding = null)
     {
-        $result = S::count($str, $substring, $encoding);
+        $result = S::count($str, $substring, $caseSensitive, $encoding);
         $this->assertInternalType('int', $result);
         $this->assertEquals($expected, $result);
     }
@@ -535,10 +565,21 @@ class StaticStringyTestCase extends CommonTest
     /**
      * @dataProvider stringsForReplace
      */
-    public function testReplace($expected, $str, $search, $replace,
+    public function testReplace($expected, $str, $search, $replacement,
                                 $encoding = null)
     {
-        $result = S::replace($str, $search, $replace, $encoding);
+        $result = S::replace($str, $search, $replacement, $encoding);
+        $this->assertInternalType('string', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider stringsForRegexReplace
+     */
+    public function testRegexReplace($expected, $str, $pattern, $replacement,
+                                     $options = 'msr', $encoding = null)
+    {
+        $result = S::regexReplace($str, $pattern, $replacement, $options, $encoding);
         $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }

tests/Stringy/StringyTest.php

@@ -187,6 +187,15 @@ class StringyTestCase extends CommonTest
         $this->assertEquals($str, $stringy);
     }
 
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testPadException()
+    {
+        $stringy = S::create('foo');
+        $result = $stringy->pad(5, 'foo', 'bar');
+    }
+
     /**
      * @dataProvider stringsForPadLeft
      */
@@ -276,6 +285,30 @@ class StringyTestCase extends CommonTest
         $this->assertEquals($str, $stringy);
     }
 
+    /**
+     * @dataProvider stringsForToLowerCase
+     */
+    public function testToLowerCase($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->toLowerCase();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider stringsForToUpperCase
+     */
+    public function testToUpperCase($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->toUpperCase();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
     /**
      * @dataProvider stringsForSlugify
      */
@@ -291,10 +324,11 @@ class StringyTestCase extends CommonTest
     /**
      * @dataProvider stringsForContains
      */
-    public function testContains($expected, $haystack, $needle, $encoding = null)
+    public function testContains($expected, $haystack, $needle,
+                                 $caseSensitive = true, $encoding = null)
     {
         $stringy = S::create($haystack, $encoding);
-        $result = $stringy->contains($needle);
+        $result = $stringy->contains($needle, $caseSensitive);
         $this->assertInternalType('boolean', $result);
         $this->assertEquals($expected, $result);
         $this->assertEquals($haystack, $stringy);
@@ -619,10 +653,11 @@ class StringyTestCase extends CommonTest
     /**
      * @dataProvider stringsForCount
      */
-    public function testCount($expected, $str, $substring, $encoding = null)
+    public function testCount($expected, $str, $substring, $caseSensitive = true,
+                              $encoding = null)
     {
         $stringy = S::create($str, $encoding);
-        $result = $stringy->count($substring);
+        $result = $stringy->count($substring, $caseSensitive);
         $this->assertInternalType('int', $result);
         $this->assertEquals($expected, $result);
         $this->assertEquals($str, $stringy);
@@ -631,11 +666,24 @@ class StringyTestCase extends CommonTest
     /**
      * @dataProvider stringsForReplace
      */
-    public function testReplace($expected, $str, $search, $replace,
+    public function testReplace($expected, $str, $search, $replacement,
                                 $encoding = null)
     {
         $stringy = S::create($str, $encoding);
-        $result = $stringy->replace($search, $replace);
+        $result = $stringy->replace($search, $replacement);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider stringsForRegexReplace
+     */
+    public function testregexReplace($expected, $str, $pattern, $replacement,
+                                     $options = 'msr', $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->regexReplace($pattern, $replacement, $options);
         $this->assertInstanceOf('Stringy\Stringy', $result);
         $this->assertEquals($expected, $result);
         $this->assertEquals($str, $stringy);