1.10.0

Adding the option to trim the string with others characters, not only with the default characters provided by php. Also added the option to define the function which will be used to trim the string, if it's normal trim, left trim or right trim

CHANGELOG.md

@@ -1,3 +1,22 @@
+### 1.10.0 (2015-07-22)
+
+ * Added trimLeft, trimRight
+ * Added support for unicode whitespace to trim
+ * Added delimit
+ * Added indexOf and indexOfLast
+ * Added htmlEncode and htmlDecode
+ * Added "Ç" in toAscii()
+
+### 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

@@ -21,12 +21,19 @@ PHP 5.3+ and HHVM. Inspired by underscore.string.js.
     * [countSubstr](#countsubstr)
     * [create](#create)
     * [dasherize](#dasherize)
+    * [delimit](#delimit)
     * [endsWith](#endswith)
     * [ensureLeft](#ensureleft)
     * [ensureRight](#ensureright)
     * [first](#first)
     * [getEncoding](#getencoding)
+    * [hasLowerCase](#haslowercase)
+    * [hasUpperCase](#hasuppercase)
+    * [htmlDecode](#htmldecode)
+    * [htmlEncode](#htmlencode)
     * [humanize](#humanize)
+    * [indexOf](#indexof)
+    * [indexOfLast](#indexoflast)
     * [insert](#insert)
     * [isAlpha](#isalpha)
     * [isAlphanumeric](#isalphanumeric)
@@ -67,6 +74,8 @@ PHP 5.3+ and HHVM. Inspired by underscore.string.js.
     * [toTitleCase](#totitlecase)
     * [toUpperCase](#touppercase)
     * [trim](#trim)
+    * [trimLeft](#trimLeft)
+    * [trimRight](#trimRight)
     * [truncate](#truncate)
     * [underscored](#underscored)
     * [upperCamelize](#uppercamelize)
@@ -83,7 +92,7 @@ in your composer.json file:
 ```json
 {
     "require": {
-        "danielstjules/stringy": "~1.8"
+        "danielstjules/stringy": "~1.10"
     }
 }
 ```
@@ -314,7 +323,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
@@ -341,6 +350,22 @@ S::create('TestDCase')->dasherize();
 S::dasherize('TestDCase');  // 'test-d-case'
 ```
 
+#### delimit
+
+$stringy->delimit($delimiter);
+
+S::delimit(string $str [, string $delimiter, string $encoding ])
+
+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.
+
+```php
+S::create('TestDCase')->delimit('>>');
+S::delimit('TestCase', '>>');  // 'test>>case'
+```
+
 #### endsWith
 
 $stringy->endsWith(string $substring [, boolean $caseSensitive = true ])
@@ -405,6 +430,58 @@ 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
+```
+
+#### htmlDecode
+
+$stringy->htmlDecode()
+
+S::htmlDecode(string $str [, int $flags, string $encoding ])
+
+Convert all HTML entities to their applicable characters.
+
+```php
+S::create('&')->htmlDecode();
+S::htmlDecode('&');  // '&'
+```
+
+#### htmlEncode
+
+$stringy->htmlEncode()
+
+S::htmlEncode(string $str [, int $flags, string $encoding ])
+
+Convert all applicable characters to HTML entities.
+
+```php
+S::create('&')->htmlEncode();
+S::htmlEncode('&');  // '&'
+```
+
 #### humanize
 
 $stringy->humanize()
@@ -419,6 +496,36 @@ S::create('author_id')->humanize();
 S::humanize('author_id');  // 'Author'
 ```
 
+#### indexOf
+
+$stringy->indexOf(string $needle [, $offset = 0 ]);
+
+S::indexOf(string $haystack , string $needle [, $offset = 0 [, $encoding = null ]])
+
+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.
+
+```php
+S::create('string', 'UTF-8')->indexOf('ing');
+S::indexOf('string', 'ing');  // 3
+```
+
+#### indexOfLast
+
+$stringy->indexOfLast(string $needle [, $offset = 0 ]);
+
+S::indexOfLast(string $haystack , string $needle [, $offset = 0 [, $encoding = null ]])
+
+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.
+
+```php
+S::create('string', 'UTF-8')->indexOfLast('ing');
+S::indexOfLast('string string', 'ing');  // 10
+```
+
 #### insert
 
 $stringy->insert(int $index, string $substring)
@@ -734,7 +841,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 +852,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 +988,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 +1017,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 +1031,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
@@ -963,22 +1071,54 @@ S::toUpperCase('fòô bàř', 'UTF-8');  // 'FÒÔ BÀŘ'
 
 #### trim
 
-$stringy->trim()
+$stringy->trim([, string $chars])
 
-S::trim(string $str)
+S::trim(string $str [, string $chars [, string $encoding ]])
 
-Returns the trimmed string. An alias for PHP's trim() function.
+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.
 
 ```php
-S::create('fòô bàř', 'UTF-8')->trim();
-S::trim(' fòô bàř ');  // 'fòô bàř'
+S::create('  fòô bàř  ', 'UTF-8')->trim();
+S::trim('  fòô bàř  ');  // 'fòô bàř'
+```
+
+#### trimLeft
+
+$stringy->trimLeft([, string $chars])
+
+S::trimLeft(string $str [, string $chars [, string $encoding ]])
+
+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.
+
+```php
+S::create('  fòô bàř  ', 'UTF-8')->trimLeft();
+S::trimLeft('  fòô bàř  ');  // 'fòô bàř  '
+```
+
+#### trimRight
+
+$stringy->trimRight([, string $chars])
+
+S::trimRight(string $str [, string $chars [, string $encoding ]])
+
+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.
+
+```php
+S::create('  fòô bàř  ', 'UTF-8')->trimRight();
+S::trimRight('  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
@@ -1038,6 +1178,8 @@ The following is a list of libraries that extend Stringy:
 
  * [SliceableStringy](https://github.com/danielstjules/SliceableStringy):
 Python-like string slices in PHP
+ * [SubStringy](https://github.com/TCB13/SubStringy):
+Advanced substring methods
 
 ## Tests
 

src/StaticStringy.php

@@ -97,6 +97,22 @@ class StaticStringy
         return (string) Stringy::create($str, $encoding)->underscored();
     }
 
+    /**
+     * 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  $str       String to convert
+     * @param  string  $delimiter Sequence used to separate parts of the string
+     * @param  string  $encoding  The character encoding
+     * @return string  String with delimiter
+     */
+    public static function delimit($str, $delimiter, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->delimit($delimiter);
+    }
+
     /**
      * Returns a case swapped version of the string.
      *
@@ -166,14 +182,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);
     }
 
     /**
@@ -418,6 +437,40 @@ class StaticStringy
             ->containsAll($needles, $caseSensitive);
     }
 
+    /**
+     * 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   $haystack String to 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 static function indexOf($haystack, $needle, $offset = 0,
+                                   $encoding = null)
+    {
+        return Stringy::create($haystack, $encoding)
+            ->indexOf($needle, $offset);
+    }
+
+    /**
+     * 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.
+     *
+     * @param  string   $haystack String to search
+     * @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 static function indexOfLast($haystack, $needle, $offset = 0,
+                                       $encoding = null)
+    {
+        return Stringy::create($haystack, $encoding)
+            ->indexOfLast($needle, $offset);
+    }
+
     /**
      * Surrounds a string with the given substring.
      *
@@ -508,14 +561,48 @@ class StaticStringy
     }
 
     /**
-     * Returns the trimmed string. An alias for PHP's trim() function.
+     * 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 $str String to trim
+     * @param  string $str      String to trim
+     * @param  string $chars    Optional string of characters to strip
+     * @param  string $encoding The character encoding
      * @return string Trimmed $str
      */
-    public static function trim($str)
+    public static function trim($str, $chars = null, $encoding = null)
     {
-        return trim($str);
+        return (string) Stringy::create($str, $encoding)->trim($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 $str      String to trim
+     * @param  string $chars    Optional string of characters to strip
+     * @param  string $encoding The character encoding
+     * @return string Trimmed $str
+     */
+    public static function trimLeft($str, $chars = null, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->trimLeft($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 $str      String to trim
+     * @param  string $chars    Optional string of characters to strip
+     * @param  string $encoding The character encoding
+     * @return string Trimmed $str
+     */
+    public static function trimRight($str, $chars = null, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->trimRight($chars);
     }
 
     /**
@@ -683,6 +770,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 +928,7 @@ class StaticStringy
     public static function replace($str, $search, $replacement, $encoding = null)
     {
         return (string) Stringy::create($str, $encoding)
-            ->replace($search,$replacement);
+            ->replace($search, $replacement);
     }
 
     /**
@@ -837,4 +950,30 @@ class StaticStringy
         return (string) Stringy::create($str, $encoding)
             ->regexReplace($pattern, $replacement, $options, $encoding);
     }
+
+    /**
+     * Convert all applicable characters to HTML entities.
+     *
+     * @param  string   $str   The string to encode.
+     * @param  int|null $flags See http://php.net/manual/en/function.htmlentities.php
+     * @param  string   $encoding    The character encoding
+     * @return Stringy  Object with the resulting $str after being html encoded.
+     */
+    public static function htmlEncode($str, $flags = ENT_COMPAT, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->htmlEncode($flags);
+    }
+
+    /**
+     * Convert all HTML entities to their applicable characters.
+     *
+     * @param  string   $str   The string to decode.
+     * @param  int|null $flags See http://php.net/manual/en/function.html-entity-decode.php
+     * @param  string   $encoding    The character encoding
+     * @return Stringy  Object with the resulting $str after being html decoded.
+     */
+    public static function htmlDecode($str, $flags = ENT_COMPAT, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->htmlDecode($flags);
+    }
 }

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->delimit('-');
     }
 
     /**
@@ -290,24 +290,27 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
      */
     public function underscored()
     {
-        return $this->applyDelimeter('_');
+        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 Stringy Object with a delimited $str
      */
-    protected function applyDelimeter($delimiter)
+    public function delimit($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('[-_\s]+', $delimiter, $str);
+        $str = mb_ereg_replace('\B([A-Z])', '-\1', $this->trim());
         $str = mb_strtolower($str, $this->encoding);
+        $str = mb_ereg_replace('[-_\s]+', $delimiter, $str);
 
         mb_regex_encoding($regexEncoding);
 
@@ -354,7 +357,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 +422,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('à', 'á', 'â', 'ä', 'ã', 'ā', 'ą', 'ă', 'å', 'α',
-                            'ά', 'ἀ', 'ἁ', 'ἂ', 'ἃ', 'ἄ', 'ἅ', 'ἆ', 'ἇ', 'ᾀ',
-                            'ᾁ', 'ᾂ', 'ᾃ', 'ᾄ', 'ᾅ', 'ᾆ', 'ᾇ', 'ὰ', 'ά', 'ᾰ',
-                            'ᾱ', 'ᾲ', 'ᾳ', 'ᾴ', 'ᾶ', 'ᾷ', 'а'),
-            'b'    => array('б', 'β'),
+
+        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 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('è', 'é', 'ê', 'ë', 'ē', 'ę', 'ě', 'ĕ', 'ė', 'ε',
-                            'έ', 'ἐ', 'ἑ', 'ἒ', 'ἓ', 'ἔ', 'ἕ', 'ὲ', 'έ', 'е',
-                            'ё', 'э', 'є'),
-            '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('ü', 'ù', 'ú', 'û', 'ū', 'ů', 'ű', 'ŭ', 'ũ', 'ų',
-                            'µ', 'у'),
+                            'д', 'δ', 'د', 'ض'),
+            '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('ź', 'ž', 'ż', 'з'),
+            'w'    => array('ŵ', 'ω', 'ώ'),
+            'x'    => 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('Á', 'Â', 'Ä', 'Ã', 'Å', 'Ā', 'Ą', 'Ă', 'Α', 'Ά',
-                            'Ἀ', 'Ἁ', 'Ἂ', 'Ἃ', 'Ἄ', 'Ἅ', 'Ἆ', 'Ἇ', 'ᾈ', 'ᾉ',
-                            'ᾊ', 'ᾋ', 'ᾌ', 'ᾍ', 'ᾎ', 'ᾏ', 'Ᾰ', 'Ᾱ', 'Ὰ', 'Ά',
-                            'ᾼ', 'А'),
-            '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('Ù', 'Ú', 'Û', 'Ü', 'Ū', 'Ů', 'Ű', 'Ŭ', 'Ũ', 'Ų',
-                            'У'),
+            '(c)'  => array('©'),
+            'A'    => array('Á', 'À', 'Ả', 'Ã', 'Ạ', 'Ă', 'Ắ', 'Ằ', 'Ẳ', 'Ẵ',
+                            'Ặ', 'Â', 'Ấ', 'Ầ', 'Ẩ', 'Ẫ', 'Ậ', 'Ä', 'Å', 'Ā',
+                            'Ą', 'Α', 'Ά', 'Ἀ', 'Ἁ', 'Ἂ', 'Ἃ', 'Ἄ', 'Ἅ', 'Ἆ',
+                            'Ἇ', 'ᾈ', 'ᾉ', 'ᾊ', 'ᾋ', 'ᾌ', 'ᾍ', 'ᾎ', 'ᾏ', 'Ᾰ',
+                            'Ᾱ', 'Ὰ', 'Ά', 'ᾼ', 'А'),
+            'B'    => array('Б', 'Β'),
+            'C'    => array('Ç','Ć', 'Č', 'Ĉ', 'Ċ'),
+            'D'    => array('Ď', 'Ð', 'Đ', 'Ɖ', 'Ɗ', 'Ƌ', 'ᴅ', 'ᴆ', 'Д', 'Δ'),
+            'E'    => array('É', 'È', 'Ẻ', 'Ẽ', 'Ẹ', 'Ê', 'Ế', 'Ề', 'Ể', 'Ễ',
+                            'Ệ', 'Ë', 'Ē', 'Ę', 'Ě', 'Ĕ', 'Ė', 'Ε', 'Έ', 'Ἐ',
+                            'Ἑ', 'Ἒ', 'Ἓ', 'Ἔ', 'Ἕ', 'Έ', 'Ὲ', 'Е', 'Ё', 'Э',
+                            'Є', 'Ə'),
+            'F'    => array('Ф', 'Φ'),
+            'G'    => array('Ğ', 'Ġ', 'Ģ', 'Г', 'Ґ', 'Γ'),
+            'H'    => 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('Ź', 'Ž', 'Ż', 'З'),
+            'W'    => 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",
-                            "\xE3\x80\x80"),
+            ' '    => array("\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"),
         );
-
-        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 +675,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,
-            $right, $stringy->encoding);
+        $rightPadding = mb_substr(str_repeat($padStr, ceil($right / $length)),
+            0, $right, $stringy->encoding);
 
         $stringy->str = $leftPadding . $stringy->str . $rightPadding;
 
@@ -755,13 +812,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()->delimit($replacement)
                        ->removeLeft($replacement)->removeRight($replacement);
     }
 
@@ -833,11 +890,42 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
         return true;
     }
 
+    /**
+     * 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.
+     *
+     * @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);
+    }
+
     /**
      * 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)
     {
@@ -969,13 +1057,48 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
     }
 
     /**
-     * Returns the trimmed string. An alias for PHP's trim() function.
+     * 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 Stringy Object with a trimmed $str
      */
-    public function trim()
+    public function trim($chars = null)
     {
-        return static::create(trim($this->str), $this->encoding);
+        $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 Stringy 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 Stringy Object with a trimmed $str
+     */
+    public function trimRight($chars = null)
+    {
+        $chars = ($chars) ? preg_quote($chars) : '[:space:]';
+
+        return $this->regexReplace("[$chars]+\$", '');
     }
 
     /**
@@ -1052,7 +1175,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 +1365,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.
@@ -1383,4 +1529,30 @@ class Stringy implements \Countable, \IteratorAggregate, \ArrayAccess
 
         return static::create($str, $this->encoding);
     }
+
+    /**
+     * Convert all applicable characters to HTML entities.
+     *
+     * @param  int|null $flags See http://php.net/manual/en/function.htmlentities.php
+     * @return Stringy  Object with the resulting $str after being html encoded.
+     */
+    public function htmlEncode($flags = ENT_COMPAT)
+    {
+        $str = htmlentities($this->str, $flags, $this->encoding);
+
+        return static::create($str, $this->encoding);
+    }
+
+    /**
+     * Convert all HTML entities to their applicable characters.
+     *
+     * @param  int|null $flags See http://php.net/manual/en/function.html-entity-decode.php
+     * @return Stringy  Object with the resulting $str after being html decoded.
+     */
+    public function htmlDecode($flags = ENT_COMPAT)
+    {
+        $str = html_entity_decode($this->str, $flags, $this->encoding);
+
+        return static::create($str, $this->encoding);
+    }
 }

tests/CommonTest.php

@@ -14,6 +14,26 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
         $this->assertInstanceOf('Stringy\Stringy', $actual);
     }
 
+    public function indexOfProvider()
+    {
+        return array(
+            array(2, 'This is the string', 'is'),
+            array(2, 'This is the string', 'is', 0, 'UTF-8'),
+            array(false, 'This is the string', 'not-found', 0, 'UTF-8'),
+            array(32, 'This is the string... and there is another thing', 'is', 10, 'UTF-8'),
+        );
+    }
+
+    public function indexOfLastProvider()
+    {
+        return array(
+            array(5, 'This is the string', 'is'),
+            array(5, 'This is the string', 'is', 0, 'UTF-8'),
+            array(false, 'This is the string', 'not-found', 0, 'UTF-8'),
+            array(32, 'This is the string... and there is another thing', 'is', 0, 'UTF-8'),
+        );
+    }
+
     public function charsProvider()
     {
         return array(
@@ -125,6 +145,26 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
         );
     }
 
+    public function delimitProvider()
+    {
+        return array(
+            array('test*case', 'testCase', '*'),
+            array('test&case', 'Test-Case', '&'),
+            array('test#case', 'test case', '#'),
+            array('test**case', 'test -case', '**'),
+            array('~!~test~!~case', '-test - case', '~!~'),
+            array('test*case', 'test_case', '*'),
+            array('test%c%test', '  test c test', '%'),
+            array('test+u+case', 'TestUCase', '+'),
+            array('test=c=c=test', 'TestCCTest', '='),
+            array('string#>with1number', 'string_with1number', '#>'),
+            array('1test2case', '1test2case', '*'),
+            array('test ύα σase', 'test Σase', ' ύα ', 'UTF-8',),
+            array('στανιλαcase', 'Στανιλ case', 'α', 'UTF-8',),
+            array('σashΘcase', 'Σash  Case', 'Θ', 'UTF-8')
+        );
+    }
+
     public function swapCaseProvider()
     {
         return array(
@@ -174,9 +214,12 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
             array('test string', 'test string'),
             array('Ο συγγραφέας', '   Ο     συγγραφέας  '),
             array('123', ' 123 '),
-            array('', ' ', 'UTF-8'), // no-break space
-            array('1 2 3', '　　1　　2　　3　　', 'UTF-8'), // ideographic spaces
-            array('', '   ', 'UTF-8'), // thin space and space
+            array('', ' ', 'UTF-8'), // no-break space (U+00A0)
+            array('', '           ', 'UTF-8'), // spaces U+2000 to U+200A
+            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 +230,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('  1  2  3  ', '　　1　　2　　3　　'), // ideographic spaces
-            array('   ', '   '), // thin space and space
+            array('xin chao the gioi', 'xin chào thế giới'),
+            array('XIN CHAO THE GIOI', 'XIN CHÀO THẾ GIỚI'),
+            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 +415,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', 'букварь с буквой ы'),
@@ -591,7 +640,49 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
             array('fòô   bàř', '  fòô   bàř  '),
             array('fòô bàř', ' fòô bàř'),
             array('fòô bàř', 'fòô bàř '),
-            array('fòô bàř', "\n\t fòô bàř \n\t")
+            array(' foo bar ', "\n\t foo bar \n\t", "\n\t"),
+            array('fòô bàř', "\n\t fòô bàř \n\t", null, 'UTF-8'),
+            array('fòô', ' fòô ', null, 'UTF-8'), // narrow no-break space (U+202F)
+            array('fòô', '  fòô  ', null, 'UTF-8'), // medium mathematical space (U+205F)
+            array('fòô', '           fòô', null, 'UTF-8') // spaces U+2000 to U+200A
+        );
+    }
+
+    public function trimLeftProvider()
+    {
+        return array(
+            array('foo   bar  ', '  foo   bar  '),
+            array('foo bar', ' foo bar'),
+            array('foo bar ', 'foo bar '),
+            array("foo bar \n\t", "\n\t foo bar \n\t"),
+            array('fòô   bàř  ', '  fòô   bàř  '),
+            array('fòô bàř', ' fòô bàř'),
+            array('fòô bàř ', 'fòô bàř '),
+            array('foo bar', '--foo bar', '-'),
+            array('fòô bàř', 'òòfòô bàř', 'ò', 'UTF-8'),
+            array("fòô bàř \n\t", "\n\t fòô bàř \n\t", null, 'UTF-8'),
+            array('fòô ', ' fòô ', null, 'UTF-8'), // narrow no-break space (U+202F)
+            array('fòô  ', '  fòô  ', null, 'UTF-8'), // medium mathematical space (U+205F)
+            array('fòô', '           fòô', null, 'UTF-8') // spaces U+2000 to U+200A
+        );
+    }
+
+    public function trimRightProvider()
+    {
+        return array(
+            array('  foo   bar', '  foo   bar  '),
+            array('foo bar', 'foo bar '),
+            array(' foo bar', ' foo bar'),
+            array("\n\t foo bar", "\n\t foo bar \n\t"),
+            array('  fòô   bàř', '  fòô   bàř  '),
+            array('fòô bàř', 'fòô bàř '),
+            array(' fòô bàř', ' fòô bàř'),
+            array('foo bar', 'foo bar--', '-'),
+            array('fòô bàř', 'fòô bàřòò', 'ò', 'UTF-8'),
+            array("\n\t fòô bàř", "\n\t fòô bàř \n\t", null, 'UTF-8'),
+            array(' fòô', ' fòô ', null, 'UTF-8'), // narrow no-break space (U+202F)
+            array('  fòô', '  fòô  ', null, 'UTF-8'), // medium mathematical space (U+205F)
+            array('fòô', 'fòô           ', null, 'UTF-8') // spaces U+2000 to U+200A
         );
     }
 
@@ -832,9 +923,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'), // thin space
-            array(true, '　　', 'UTF-8'), // ideographic spaces
+            array(true, ' ', 'UTF-8'), // no-break space (U+00A0)
+            array(true, '           ', 'UTF-8'), // spaces U+2000 to U+200A
+            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 +967,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 +1012,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(
@@ -976,4 +1105,26 @@ abstract class CommonTest extends PHPUnit_Framework_TestCase
             array('fòô', 'bàř', '[[:alpha:]]{3}', 'fòô', 'msr', 'UTF-8')
         );
     }
+
+    public function htmlEncodeProvider()
+    {
+        return array(
+            array('&', '&'),
+            array('"', '"'),
+            array(''', "'", ENT_QUOTES),
+            array('&lt;', '<'),
+            array('&gt;', '>'),
+        );
+    }
+
+    public function htmlDecodeProvider()
+    {
+        return array(
+            array('&', '&amp;'),
+            array('"', '&quot;'),
+            array("'", '&#039;', ENT_QUOTES),
+            array('<', '&lt;'),
+            array('>', '&gt;'),
+        );
+    }
 }

tests/StaticStringyTest.php

@@ -6,6 +6,24 @@ use Stringy\StaticStringy as S;
 
 class StaticStringyTestCase extends CommonTest
 {
+	/**
+     * @dataProvider indexOfProvider()
+     */
+    public function testIndexOf($expected, $str, $subStr, $offset = 0, $encoding = null)
+    {
+        $result = S::indexOf($str, $subStr, $offset, $encoding);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider indexOfLastProvider()
+     */
+    public function testIndexOfLast($expected, $str, $subStr, $offset = 0, $encoding = null)
+    {
+        $result = S::indexOfLast($str, $subStr, $offset, $encoding);
+        $this->assertEquals($expected, $result);
+    }
+
     /**
      * @dataProvider charsProvider()
      */
@@ -133,9 +151,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);
     }
@@ -384,9 +402,31 @@ class StaticStringyTestCase extends CommonTest
     /**
      * @dataProvider trimProvider()
      */
-    public function testTrim($expected, $str)
+    public function testTrim($expected, $str, $chars = null, $encoding = null)
     {
-        $result = S::trim($str);
+        $result = S::trim($str, $chars, $encoding);
+        $this->assertInternalType('string', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider trimLeftProvider()
+     */
+    public function testTrimLeft($expected, $str, $chars = null,
+                                 $encoding = null)
+    {
+        $result = S::trimLeft($str, $chars, $encoding);
+        $this->assertInternalType('string', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider trimRightProvider()
+     */
+    public function testTrimRight($expected, $str, $chars = null,
+                                  $encoding = null)
+    {
+        $result = S::trimRight($str, $chars, $encoding);
         $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
@@ -565,6 +605,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 +635,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()
      */
@@ -627,4 +687,24 @@ class StaticStringyTestCase extends CommonTest
         $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
+
+    /**
+     * @dataProvider htmlEncodeProvider()
+     */
+    public function testHtmlEncode($expected, $str, $flags = ENT_COMPAT, $encoding = null)
+    {
+        $result = S::htmlEncode($str, $flags, $encoding);
+        $this->assertInternalType('string', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider htmlDecodeProvider()
+     */
+    public function testHtmlDecode($expected, $str, $flags = ENT_COMPAT, $encoding = null)
+    {
+        $result = S::htmlDecode($str, $flags, $encoding);
+        $this->assertInternalType('string', $result);
+        $this->assertEquals($expected, $result);
+    }
 }

tests/StringyTest.php

@@ -153,6 +153,24 @@ class StringyTestCase extends CommonTest
         unset($stringy[1]);
     }
 
+    /**
+     * @dataProvider indexOfProvider()
+     */
+    public function testIndexOf($expected, $str, $subStr, $offset = 0, $encoding = null)
+    {
+        $result = S::create($str, $encoding)->indexOf($subStr, $offset);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider indexOfLastProvider()
+     */
+    public function testIndexOfLast($expected, $str, $subStr, $offset = 0, $encoding = null)
+    {
+        $result = S::create($str, $encoding)->indexOfLast($subStr, $offset);
+        $this->assertEquals($expected, $result);
+    }
+
     /**
      * @dataProvider charsProvider()
      */
@@ -236,6 +254,18 @@ class StringyTestCase extends CommonTest
         $this->assertEquals($str, $stringy);
     }
 
+    /**
+     * @dataProvider delimitProvider()
+     */
+    public function testDelimit($expected, $str, $delimiter, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->delimit($delimiter);
+        $this->assertStringy($result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
     /**
      * @dataProvider swapCaseProvider()
      */
@@ -300,10 +330,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);
@@ -596,10 +626,36 @@ class StringyTestCase extends CommonTest
     /**
      * @dataProvider trimProvider()
      */
-    public function testTrim($expected, $str)
+    public function testTrim($expected, $str, $chars = null, $encoding = null)
     {
-        $stringy = S::create($str);
-        $result = $stringy->trim();
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->trim($chars);
+        $this->assertStringy($result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider trimLeftProvider()
+     */
+    public function testTrimLeft($expected, $str, $chars = null,
+                                 $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->trimLeft($chars);
+        $this->assertStringy($result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider trimRightProvider()
+     */
+    public function testTrimRight($expected, $str, $chars = null,
+                                  $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->trimRight($chars);
         $this->assertStringy($result);
         $this->assertEquals($expected, $result);
         $this->assertEquals($str, $stringy);
@@ -813,6 +869,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 +905,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()
      */
@@ -887,4 +967,28 @@ class StringyTestCase extends CommonTest
         $this->assertEquals($expected, $result);
         $this->assertEquals($str, $stringy);
     }
+
+    /**
+     * @dataProvider htmlEncodeProvider()
+     */
+    public function testHtmlEncode($expected, $str, $flags = ENT_COMPAT, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->htmlEncode($flags);
+        $this->assertStringy($result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider htmlDecodeProvider()
+     */
+    public function testHtmlDecode($expected, $str, $flags = ENT_COMPAT, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->htmlDecode($flags);
+        $this->assertStringy($result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
 }