1.5.1 release

Fixed "Class 'CommonTest' not found" error when running specific tests in PHPUnit by including tests directory in Composer's autoloader.

.gitignore

@@ -1 +1,3 @@
 vendor/
+composer.lock
+.DS_Store

CHANGELOG.md

@@ -1,3 +1,73 @@
+### 1.5.1 (2014-04-19)
+
+  * Fixed toAscii() failing to remove remaining non-ascii characters
+  * Updated slugify() to treat dash and underscore as delimiters by default
+  * Updated slugify() to remove leading and trailing delimiter, if present
+
+### 1.5.0 (2014-03-19)
+
+  * Made both str and encoding protected, giving property access to subclasses
+  * Added getEncoding()
+  * Fixed isJSON() giving false negatives
+  * Cleaned up and simplified: replace(), collapseWhitespace(), underscored(),
+    dasherize(), pad(), padLeft(), padRight() and padBoth()
+  * Fixed handling consecutive invalid chars in slugify()
+  * Removed conflicting hard sign transliteration in toAscii()
+
+### 1.4.0 (2014-02-12)
+
+  * Implemented the IteratorAggregate interface, added chars()
+  * Renamed count() to countSubstr()
+  * Updated count() to implement Countable interface
+  * Implemented the ArrayAccess interface with positive and negative indices
+  * Switched from PSR-0 to PSR-4 autoloading
+
+### 1.3.0 (2013-12-16)
+
+  * Additional Bulgarian support for toAscii
+  * str property made private
+  * Constructor casts first argument to string
+  * Constructor throws an InvalidArgumentException when given an array
+  * Constructor throws an InvalidArgumentException when given an object without
+    a __toString method
+
+### 1.2.2 (2013-12-04)
+
+  * Updated create function to use late static binding
+  * Added optional $replacement param to slugify
+
+### 1.2.1 (2013-10-11)
+
+  * Cleaned up tests
+  * Added homepage to composer.json
+
+### 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()
+  * Added isHexadecimal()
+  * Added constructor to Stringy\Stringy
+  * Added isSerialized()
+  * Added isJson()
+
+### 1.0.0 (2013-08-1)
+
+  * 1.0.0 release
+  * Added test coverage for Stringy::create and method chaining
+  * Added tests for returned type
+  * Fixed StaticStringy::replace(). It was returning a Stringy object instead of string
+  * Renamed standardize() to the more appropriate toAscii()
+  * Cleaned up comments and README
+
 ### 1.0.0-rc.1 (2013-07-28)
 
   * Release candidate

README.md

@@ -1,31 +1,37 @@
-# Stringy
+![Stringy](http://danielstjules.com/stringy/logo.png)
 
-A PHP library with a variety of string manipulation functions with multibyte support. Offers both OO method chaining and a procedural-style static wrapper. Compatible with PHP 5.3+. Inspired by underscore.string.js.
+A PHP library with a variety of string manipulation functions with multibyte
+support. Offers both OO method chaining and a procedural-style static wrapper.
+Compatible with PHP 5.3+. Inspired by underscore.string.js.
 
 [![Build Status](https://travis-ci.org/danielstjules/Stringy.png)](https://travis-ci.org/danielstjules/Stringy)
-[![Total Downloads](https://poser.pugx.org/danielstjules/Stringy/downloads.png)](https://packagist.org/packages/danielstjules/stringy)
-[![Latest Stable Version](https://poser.pugx.org/danielstjules/Stringy/v/stable.png)](https://packagist.org/packages/danielstjules/stringy)
 
 * [Requiring/Loading](#requiringloading)
 * [OO and Procedural](#oo-and-procedural)
+* [Implemented Interfaces](#implemented-interfaces)
 * [Methods](#methods)
     * [at](#at)
     * [camelize](#camelize)
+    * [chars](#chars)
     * [collapseWhitespace](#collapsewhitespace)
     * [contains](#contains)
-    * [count](#count)
+    * [countSubstr](#countsubstr)
     * [create](#create)
     * [dasherize](#dasherize)
     * [endsWith](#endswith)
     * [ensureLeft](#ensureleft)
     * [ensureRight](#ensureright)
     * [first](#first)
+    * [getEncoding](#getencoding)
     * [humanize](#humanize)
     * [insert](#insert)
     * [isAlpha](#isalpha)
     * [isAlphanumeric](#isalphanumeric)
     * [isBlank](#isblank)
+    * [isHexadecimal](#ishexadecimal)
+    * [isJson](#isjson)
     * [isLowerCase](#islowercase)
+    * [isSerialized](#isserialized)
     * [isUpperCase](#isuppercase)
     * [last](#last)
     * [length](#length)
@@ -37,6 +43,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)
@@ -44,32 +51,37 @@ A PHP library with a variety of string manipulation functions with multibyte sup
     * [safeTruncate](#safetruncate)
     * [shuffle](#shuffle)
     * [slugify](#slugify)
-    * [standardize](#standardize)
     * [startsWith](#startswith)
     * [substr](#substr)
     * [surround](#surround)
     * [swapCase](#swapcase)
     * [tidy](#tidy)
     * [titleize](#titleize)
+    * [toAscii](#toascii)
+    * [toLowerCase](#tolowercase)
     * [toSpaces](#tospaces)
     * [toTabs](#totabs)
+    * [toUpperCase](#touppercase)
     * [trim](#trim)
     * [truncate](#truncate)
     * [underscored](#underscored)
     * [upperCamelize](#uppercamelize)
     * [upperCaseFirst](#uppercasefirst)
+* [Links](#links)
 * [Tests](#tests)
 * [License](#license)
 
 ## Requiring/Loading
 
-If you're using Composer to manage dependencies, you can include the following in your composer.json file:
+If you're using Composer to manage dependencies, you can include the following
+in your composer.json file:
 
     "require": {
-        "danielstjules/stringy": "dev-master"
+        "danielstjules/stringy": ">=1.5.1"
     }
 
-Then, after running `composer update` or `php composer.phar update`, you can load the class using Composer's autoloading:
+Then, after running `composer update` or `php composer.phar update`, you can
+load the class using Composer's autoloading:
 
 ```php
 require 'vendor/autoload.php';
@@ -78,9 +90,9 @@ require 'vendor/autoload.php';
 Otherwise, you can simply require the file directly:
 
 ```php
-require_once 'path/to/Stringy/src/Stringy/Stringy.php';
+require_once 'path/to/Stringy/src/Stringy.php';
 // or
-require_once 'path/to/Stringy/src/Stringy/StaticStringy.php';
+require_once 'path/to/Stringy/src/StaticStringy.php';
 ```
 
 And in either case, I'd suggest using an alias.
@@ -99,35 +111,75 @@ of the former is the following:
 
 ```php
 use Stringy\Stringy as S;
-echo S::create("Fòô     Bàř", 'UTF-8')->collapseWhitespace()->swapCase();  // 'fÒÔ bÀŘ'
+echo S::create('Fòô     Bàř', 'UTF-8')->collapseWhitespace()->swapCase();  // 'fÒÔ bÀŘ'
 ```
 
-`Stringy\Stringy` contains a __toString() method, which returns the current
-string when the object is used in a string context. Its $str property is also
-public, and can be accessed directly if required, ie: `S::create('foo')->str  // 'foo'`
+`Stringy\Stringy` has a __toString() method, which returns the current string
+when the object is used in a string context, ie:
+`(string) S::create('foo')  // 'foo'`
 
 Using the static wrapper, an alternative is the following:
 
 ```php
 use Stringy\StaticStringy as S;
-$string = S::collapseWhitespace("Fòô     Bàř", 'UTF-8');
-echo S::swapCase($string, 'UTF-8');  // 'fÒÔ bÀŘ''
+$string = S::collapseWhitespace('Fòô     Bàř', 'UTF-8');
+echo S::swapCase($string, 'UTF-8');  // 'fÒÔ bÀŘ'
+```
+
+## Implemented Interfaces
+
+`Stringy\Stringy` implements the `IteratorAggregate` interface, meaning that
+`foreach` can be used with an instance of the class:
+
+``` php
+$stringy = S::create('Fòô Bàř', 'UTF-8');
+foreach ($stringy as $char) {
+    echo $char;
+}
+// 'Fòô Bàř'
+```
+
+It implements the `Countable` interface, enabling the use of `count()` to
+retrieve the number of characters in the string:
+
+``` php
+$stringy = S::create('Fòô', 'UTF-8');
+count($stringy);  // 3
+```
+
+Furthermore, the `ArrayAccess` interface has been implemented. As a result,
+`isset()` can be used to check if a character at a specific index exists. And
+since `Stringy\Stringy` is immutable, any call to `offsetSet` or `offsetUnset`
+will throw an exception. `offsetGet` has been implemented, however, and accepts
+both positive and negative indexes. Invalid indexes result in an
+`OutOfBoundsException`.
+
+``` php
+$stringy = S::create('Bàř', 'UTF-8');
+echo $stringy[2];     // 'ř'
+echo $stringy[-2];    // 'à'
+isset($stringy[-4]);  // false
+
+$stringy[3];          // OutOfBoundsException
+$stringy[2] = 'a';    // Exception
 ```
 
 ## 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 an object of type Stringy return a new object, and do not modify the original.
+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. Stringy objects are immutable.
 
-*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
 
 $stringy->at(int $index)
 
-S::substr(int $index [, string $encoding ])
+S::at(int $index [, string $encoding ])
 
-Gets the character of $str at $index, with indexes starting at 0.
+Returns the character at $index, with indexes starting at 0.
 
 ```php
 S::create('fòô bàř', 'UTF-8')->at(6);
@@ -140,23 +192,37 @@ $stringy->camelize();
 
 S::camelize(string $str [, string $encoding ])
 
-Returns a camelCase version of a supplied string, with multibyte support.
-Trims surrounding spaces, capitalizes letters following digits, spaces,
-dashes and underscores, and removes spaces, dashes, underscores.
+Returns a camelCase version of the string. Trims surrounding spaces,
+capitalizes letters following digits, spaces, dashes and underscores,
+and removes spaces, dashes, as well as underscores.
 
 ```php
 S::create('Camel-Case')->camelize();
 S::camelize('Camel-Case');  // 'camelCase'
 ```
 
+#### chars
+
+$stringy->chars();
+
+S::chars(string $str [, string $encoding ])
+
+Returns an array consisting of the characters in the string.
+
+```php
+S::create('Fòô Bàř', 'UTF-8')->chars();
+S::chars('Fòô Bàř', 'UTF-8');  // array(F', 'ò', 'ô', ' ', 'B', 'à', 'ř')
+```
+
 #### collapseWhitespace
 
 $stringy->collapseWhitespace()
 
-S::collapseWhitespace(string $str)
+S::collapseWhitespace(string $str [, string $encoding ])
 
 Trims the string and replaces consecutive whitespace characters with a
-single space. This inclues tabs and newline characters.
+single space. This includes tabs and newline characters, as well as
+multibyte whitespace such as the thin space and ideographic space.
 
 ```php
 S::create('   Ο     συγγραφέας  ')->collapseWhitespace();
@@ -165,41 +231,46 @@ 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 $haystack 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('συγγραφέας');
 S::contains('Ο συγγραφέας είπε', 'συγγραφέας', 'UTF-8');  // true
 ```
 
-#### count
+#### countSubstr
 
-$stringy->count(string $substring)
+$stringy->countSubstr(string $substring [, boolean $caseSensitive = true ])
 
-S::count(string $str, string $substring [, string $encoding ])
+S::countSubstr(string $str, string $substring [, boolean $caseSensitive = true [, string $encoding ]])
 
-Returns the number of occurences of $substring in $str. 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('α');
-S::count('Ο συγγραφέας είπε', 'α', 'UTF-8');  // 2
+S::create('Ο συγγραφέας είπε', 'UTF-8')->countSubstr('α');
+S::countSubstr('Ο συγγραφέας είπε', 'α', 'UTF-8');  // 2
 ```
 
 #### create
 
-$stringy = S::create(string $str, [, $encoding ])
+S::create(mixed $str, [, $encoding ])
 
 Creates a Stringy object and assigns both str and encoding properties
-the supplied values. If $encoding is not specified, it defaults to
-mb_internal_encoding(). It then returns the instantiated object.
+the supplied values. $str is cast to a string prior to assignment, and if
+$encoding is not specified, it defaults to mb_internal_encoding(). It
+then returns the initialized object. Throws an InvalidArgumentException
+if the first argument is an array or object without a __toString method.
 
 ```php
-S::create('fòô bàř', 'UTF-8');  // 'fòô bàř'
+$stringy = S::create('fòô bàř', 'UTF-8');  // 'fòô bàř'
 ```
 
 #### dasherize
@@ -208,10 +279,9 @@ $stringy->dasherize();
 
 S::dasherize(string $str [, string $encoding ])
 
-Returns a lowercase and trimmed string seperated by dashes, with
-multibyte support. Dashes are inserted before uppercase characters
-(with the exception of the first character of the string), and in place
-of spaces as well as underscores.
+Returns a lowercase and trimmed string separated by dashes. Dashes are
+inserted before uppercase characters (with the exception of the first
+character of the string), and in place of spaces as well as underscores.
 
 ```php
 S::create('TestDCase')->dasherize();
@@ -224,9 +294,9 @@ $stringy->endsWith(string $substring [, boolean $caseSensitive = true ])
 
 S::endsWith(string $str, string $substring [, boolean $caseSensitive = true [, string $encoding ]])
 
-Returns true if the string $str ends with $substring, false otherwise.
-By default, the comparison is case-sensitive, but can be made insensitive
-by setting $caseSensitive to false.
+Returns true if the string ends with $substring, false otherwise. By
+default, the comparison is case-sensitive, but can be made insensitive by
+setting $caseSensitive to false.
 
 ```php
 S::create('FÒÔ bàřs', 'UTF-8')->endsWith('àřs', true);
@@ -239,7 +309,7 @@ $stringy->ensureLeft(string $substring)
 
 S::ensureLeft(string $substring [, string $encoding ])
 
-Ensures that $str begins with $substring.
+Ensures that the string begins with $substring. If it doesn't, it's prepended.
 
 ```php
 S::create('foobar')->ensureLeft('http://');
@@ -252,7 +322,7 @@ $stringy->ensureRight(string $substring)
 
 S::ensureRight(string $substring [, string $encoding ])
 
-Ensures that $str ends with $substring.
+Ensures that the string begins with $substring. If it doesn't, it's appended.
 
 ```php
 S::create('foobar')->ensureRight('.com');
@@ -265,21 +335,31 @@ $stringy->first(int $n)
 
 S::first(int $n [, string $encoding ])
 
-Gets the first $n characters of $str.
+Returns the first $n characters of the string.
 
 ```php
 S::create('fòô bàř', 'UTF-8')->first(3);
 S::first('fòô bàř', 3, 'UTF-8');  // 'fòô'
 ```
 
+#### getEncoding
+
+$stringy->getEncoding()
+
+Returns the encoding used by the Stringy object.
+
+```php
+S::create('fòô bàř', 'UTF-8')->getEncoding();  // 'UTF-8'
+```
+
 #### humanize
 
 $stringy->humanize()
 
 S::humanize(string $str [, string $encoding ])
 
-Capitalizes the first word of a string, replaces underscores with spaces,
-and strips '_id'.
+Capitalizes the first word of the string, replaces underscores with
+spaces, and strips '_id'.
 
 ```php
 S::create('author_id')->humanize();
@@ -292,7 +372,7 @@ $stringy->insert(int $index, string $substring)
 
 S::insert(string $str, int $index, string $substring [, string $encoding ])
 
-Inserts $substring into $str at the $index provided.
+Inserts $substring into the string at the $index provided.
 
 ```php
 S::create('fòô bà', 'UTF-8')->insert('ř', 6);
@@ -305,7 +385,7 @@ $stringy->isAlpha()
 
 S::isAlpha(string $str [, string $encoding ])
 
-Returns true if $str contains only alphabetic chars, false otherwise.
+Returns true if the string contains only alphabetic chars, false otherwise.
 
 ```php
 S::create('丹尼爾', 'UTF-8')->isAlpha();
@@ -318,7 +398,7 @@ $stringy->isAlphanumeric()
 
 S::isAlphanumeric(string $str [, string $encoding ])
 
-Returns true if $str contains only alphabetic and numeric chars, false
+Returns true if the string contains only alphabetic and numeric chars, false
 otherwise.
 
 ```php
@@ -332,37 +412,76 @@ $stringy->isBlank()
 
 S::isBlank(string $str [, string $encoding ])
 
-Returns true if $str contains only whitespace chars, false otherwise.
+Returns true if the string contains only whitespace chars, false otherwise.
 
 ```php
 S::create("\n\t  \v\f")->isBlank();
 S::isBlank("\n\t  \v\f");  // true
 ```
 
+#### isHexadecimal
+
+$stringy->isHexadecimal()
+
+S::isHexadecimal(string $str [, string $encoding ])
+
+Returns true if the string contains only hexadecimal chars, false otherwise.
+
+```php
+S::create('A102F')->isHexadecimal();
+S::isHexadecimal('A102F');  // true
+```
+
+#### isJson
+
+$stringy->isJson()
+
+S::isJson(string $str [, string $encoding ])
+
+Returns true if the string is JSON, false otherwise.
+
+```php
+S::create('{"foo":"bar"}')->isJson();
+S::isJson('{"foo":"bar"}');  // true
+```
+
 #### isLowerCase
 
 $stringy->isLowerCase()
 
 S::isLowerCase(string $str [, string $encoding ])
 
-Returns true if $str contains only lower case chars, false otherwise.
+Returns true if the string contains only lower case chars, false otherwise.
 
 ```php
 S::create('fòô bàř', 'UTF-8')->isLowerCase();
 S::isLowerCase('fòô bàř', 'UTF-8');  // true
 ```
 
+#### isSerialized
+
+$stringy->isSerialized()
+
+S::isSerialized(string $str [, string $encoding ])
+
+Returns true if the string is serialized, false otherwise.
+
+```php
+S::create('a:1:{s:3:"foo";s:3:"bar";}', 'UTF-8')->isSerialized();
+S::isSerialized('a:1:{s:3:"foo";s:3:"bar";}', 'UTF-8');  // true
+```
+
 #### isUpperCase
 
 $stringy->isUpperCase()
 
 S::isUpperCase(string $str [, string $encoding ])
 
-Returns true if $str contains only upper case chars, false otherwise.
+Returns true if the string contains only upper case chars, false otherwise.
 
 ```php
-S::create('FÒÔBÀŘ',, 'UTF-8')->isUpperCase();
-S::isUpperCase('FÒÔBÀŘ',, 'UTF-8');  // true
+S::create('FÒÔBÀŘ', 'UTF-8')->isUpperCase();
+S::isUpperCase('FÒÔBÀŘ', 'UTF-8');  // true
 ```
 
 #### last
@@ -371,7 +490,7 @@ $stringy->last(int $n)
 
 S::last(int $n [, string $encoding ])
 
-Gets the last $n characters of $str.
+Returns the last $n characters of the string.
 
 ```php
 S::create('fòô bàř', 'UTF-8')->last(3);
@@ -384,7 +503,7 @@ $stringy->length()
 
 S::length(string $str [, string $encoding ])
 
-Returns the length of $str. An alias for PHP's mb_strlen() function.
+Returns the length of the string. An alias for PHP's mb_strlen() function.
 
 ```php
 S::create('fòô bàř', 'UTF-8')->length();
@@ -397,7 +516,7 @@ $stringy->longestCommonPrefix(string $otherStr)
 
 S::longestCommonPrefix(string $str, string $otherStr [, $encoding ])
 
-Finds the longest common prefix between $str and $otherStr.
+Returns the longest common prefix between the string and $otherStr.
 
 ```php
 S::create('fòô bar', 'UTF-8')->longestCommonPrefix('fòr bar');
@@ -410,7 +529,7 @@ $stringy->longestCommonSuffix(string $otherStr)
 
 S::longestCommonSuffix(string $str, string $otherStr [, $encoding ])
 
-Finds the longest common suffix between $str and $otherStr.
+Returns the longest common suffix between the string and $otherStr.
 
 ```php
 S::create('fòô bàř', 'UTF-8')->longestCommonSuffix('fòr bàř');
@@ -423,8 +542,8 @@ $stringy->longestCommonSubstring(string $otherStr)
 
 S::longestCommonSubstring(string $str, string $otherStr [, $encoding ])
 
-Finds the longest common substring between $str and $otherStr. In the
-case of ties, returns that which occurs first.
+Returns the longest common substring between the string and $otherStr. In the
+case of ties, it returns that which occurs first.
 
 ```php
 S::create('foo bar')->longestCommonSubstring('boo far');
@@ -437,8 +556,7 @@ $stringy->lowerCaseFirst();
 
 S::lowerCaseFirst(string $str [, string $encoding ])
 
-Converts the first character of the supplied string to lower case, with
-support for multibyte strings.
+Converts the first character of the supplied string to lower case.
 
 ```php
 S::create('Σ test', 'UTF-8')->lowerCaseFirst();
@@ -451,14 +569,14 @@ $stringy->pad(int $length [, string $padStr = ' ' [, string $padType = 'right' ]
 
 S::pad(string $str , int $length [, string $padStr = ' ' [, string $padType = 'right' [, string $encoding ]]])
 
-Pads a string to a given length with another string. If length is less
-than or equal to the length of $str, then no padding takes places. The
-default string used for padding is a space, and the default type (one of
-'left', 'right', 'both') is 'right'. Throws an exception if $padType
-isn't one of those 3 values.
+Pads the string to a given length with $padStr. If length is less than
+or equal to the length of the string, no padding takes places. The default
+string used for padding is a space, and the default type (one of 'left',
+'right', 'both') is 'right'. Throws an InvalidArgumentException if
+$padType isn't one of those 3 values.
 
 ```php
-S::create('fòô bàř', 'UTF-8')->pad( 10, '¬ø', 'left',);
+S::create('fòô bàř', 'UTF-8')->pad( 10, '¬ø', 'left');
 S::pad('fòô bàř', 10, '¬ø', 'left', 'UTF-8');  // '¬ø¬fòô bàř'
 ```
 
@@ -469,7 +587,7 @@ $stringy->padBoth(int $length [, string $padStr = ' ' ])
 S::padBoth(string $str , int $length [, string $padStr = ' ' [, string $encoding ]])
 
 Returns a new string of a given length such that both sides of the string
-string are padded. Alias for pad($str, $length, $padStr, 'both', $encoding)
+string are padded. Alias for pad() with a $padType of 'both'.
 
 ```php
 S::create('foo bar')->padBoth(9, ' ');
@@ -483,7 +601,7 @@ $stringy->padLeft(int $length [, string $padStr = ' ' ])
 S::padLeft(string $str , int $length [, string $padStr = ' ' [, string $encoding ]])
 
 Returns a new string of a given length such that the beginning of the
-string is padded. Alias for pad($str, $length, $padStr, 'left', $encoding)
+string is padded. Alias for pad() with a $padType of 'left'.
 
 ```php
 S::create($str, $encoding)->padLeft($length, $padStr);
@@ -497,20 +615,36 @@ $stringy->padRight(int $length [, string $padStr = ' ' ])
 S::padRight(string $str , int $length [, string $padStr = ' ' [, string $encoding ]])
 
 Returns a new string of a given length such that the end of the string is
-padded. Alias for pad($str, $length, $padStr, 'right', $encoding)
+padded. Alias for pad() with a $padType of 'right'.
 
 ```php
 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)
 
 S::removeLeft(string $str, string $substring [, string $encoding ])
 
-Removes the prefix $substring if present.
+Returns a new string with the prefix $substring removed, if present.
 
 ```php
 S::create('fòô bàř', 'UTF-8')->removeLeft('fòô ');
@@ -523,7 +657,7 @@ $stringy->removeRight(string $substring)
 
 S::removeRight(string $str, string $substring [, string $encoding ])
 
-Removes the suffix $substring if present.
+Returns a new string with the suffix $substring removed, if present.
 
 ```php
 S::create('fòô bàř', 'UTF-8')->removeRight(' bàř');
@@ -532,11 +666,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 ])
 
-Replaces all occurrences of $search with $replace in $str.
+Replaces all occurrences of $search in $str by $replacement.
 
 ```php
 S::create('fòô bàř fòô bàř', 'UTF-8')->replace('fòô ', '');
@@ -549,7 +683,7 @@ $stringy->reverse()
 
 S::reverse(string $str, [, string $encoding ])
 
-Reverses a string. A multibyte version of strrev.
+Returns a reversed string. A multibyte version of strrev().
 
 ```php
 S::create('fòô bàř', 'UTF-8')->reverse();
@@ -563,8 +697,8 @@ $stringy->safeTruncate(int $length, [, string $substring = '' ])
 S::safeTruncate(string $str, int $length, [, string $substring = '' [, string $encoding ]])
 
 Truncates the string to a given length, while ensuring that it does not
-chop words. If $substring is provided, and truncating occurs, the string
-is further truncated so that the substring may be appended without
+split words. If $substring is provided, and truncating occurs, the
+string is further truncated so that the substring may be appended without
 exceeding the desired length.
 
 ```php
@@ -578,8 +712,8 @@ $stringy->shuffle()
 
 S::shuffle(string $str [, string $encoding ])
 
-A multibyte str_shuffle function. It randomizes the order of characters
-in a string.
+A multibyte str_shuffle() function. It returns a string with its characters in
+random order.
 
 ```php
 S::create('fòô bàř', 'UTF-8')->shuffle();
@@ -588,40 +722,28 @@ S::shuffle('fòô bàř', 'UTF-8');  // 'àôřb òf'
 
 #### slugify
 
-$stringy->slugify()
+$stringy->slugify([ string $replacement = '-' ])
 
-S::slugify(string $str)
+S::slugify(string $str [, string $replacement = '-' ])
 
-Converts the supplied text into an URL slug. This includes replacing
-non-ASCII characters with their closest ASCII equivalents, removing
-non-alphanumeric and non-ASCII characters, and replacing whitespace with
-dashes. The string is also converted to lowercase.
+Converts the string into an URL slug. This includes replacing non-ASCII
+characters with their closest ASCII equivalents, removing remaining
+non-ASCII and non-alphanumeric characters, and replacing whitespace with
+$replacement. The replacement defaults to a single dash, and the string
+is also converted to lowercase.
 
 ```php
 S::create('Using strings like fòô bàř')->slugify();
 S::slugify('Using strings like fòô bàř');  // 'using-strings-like-foo-bar'
 ```
 
-#### standardize
-
-$stringy->standardize()
-
-S::standardize(string $str)
-
-Converts some non-ASCII characters to their closest ASCII counterparts.
-
-```php
-S::create('fòô bàř')->standardize();
-S::standardize('fòô bàř');  // 'foo bar'
-```
-
 #### startsWith
 
 $stringy->startsWith(string $substring [, boolean $caseSensitive = true ])
 
 S::startsWith(string $str, string $substring [, boolean $caseSensitive = true [, string $encoding ]])
 
-Returns true if the string $str begins with $substring, false otherwise.
+Returns true if the string begins with $substring, false otherwise.
 By default, the comparison is case-sensitive, but can be made insensitive
 by setting $caseSensitive to false.
 
@@ -636,7 +758,7 @@ $stringy->substr(int $start [, int $length ])
 
 S::substr(string $str, int $start [, int $length [, string $encoding ]])
 
-Gets the substring of $str beginning at $start with the specified $length.
+Returns the substring beginning at $start with the specified $length.
 It differs from the mb_substr() function in that providing a $length of
 null will return the rest of the string, rather than an empty string.
 
@@ -664,7 +786,7 @@ $stringy->swapCase();
 
 S::swapCase(string $str [, string $encoding ])
 
-Returns a case swapped version of a string.
+Returns a case swapped version of the string.
 
 ```php
 S::create('Ντανιλ', 'UTF-8')->swapCase();
@@ -677,8 +799,8 @@ $stringy->tidy()
 
 S::tidy(string $str)
 
-Replaces smart quotes, ellipsis characters, and dashes from Windows-1252
-(and commonly used in Word documents) with their ASCII equivalents.
+Returns a string with smart quotes, ellipsis characters, and dashes from
+Windows-1252 (commonly used in Word documents) replaced by their ASCII equivalents.
 
 ```php
 S::create('“I see…”')->tidy();
@@ -691,10 +813,9 @@ $stringy->titleize([ string $encoding ])
 
 S::titleize(string $str [, array $ignore [, string $encoding ]])
 
-Capitalizes the first letter of each word in a string, after trimming.
-Ignores the case of other letters, allowing for the use of acronyms.
-Also accepts an array, $ignore, allowing you to list words not to be
-capitalized.
+Returns a trimmed string with the first letter of each word capitalized.
+Ignores the case of other letters, preserving any acronyms. Also accepts
+an array, $ignore, allowing you to list words not to be capitalized.
 
 ```php
 $ignore = array('at', 'by', 'for', 'in', 'of', 'on', 'out', 'to', 'the');
@@ -703,13 +824,41 @@ S::titleize('i like to watch DVDs at home', $ignore, 'UTF-8');
 // 'I Like to Watch DVDs at Home'
 ```
 
+#### toAscii
+
+$stringy->toAscii()
+
+S::toAscii(string $str)
+
+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.
+
+```php
+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 ])
 
 S::toSpaces(string $str, [, int $tabLength = 4 ])
 
-Converts each tab in a string to some number of spaces, as defined by
+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.
 
 ```php
@@ -723,7 +872,7 @@ $stringy->toTabs([ tabLength = 4 ])
 
 S::toTabs(string $str, [, int $tabLength = 4 ])
 
-Converts each occurence of some consecutive number of spaces, as defined
+Converts each occurrence of some consecutive number of spaces, as defined
 by $tabLength, to a tab. By default, each 4 consecutive spaces are
 converted to a tab.
 
@@ -732,13 +881,27 @@ 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()
 
 S::trim(string $str)
 
-Trims $str. An alias for PHP's trim() function.
+Returns the trimmed string. An alias for PHP's trim() function.
 
 ```php
 S::create('fòô bàř', 'UTF-8')->trim();
@@ -751,13 +914,13 @@ $stringy->truncate(int $length, [, string $substring = '' ])
 
 S::truncate(string $str, int $length, [, string $substring = '' [, string $encoding ]])
 
-Truncates $str to a given length. If $substring is provided, and
+Truncates the string to a given length. If $substring is provided, and
 truncating occurs, the string is further truncated so that the substring
 may be appended without exceeding the desired length.
 
 ```php
-S::create('What are your plans today?')->safeTruncate(19, '...');
-S::safeTruncate('What are your plans today?', 19, '...');  // 'What are your pl...'
+S::create('What are your plans today?')->truncate(19, '...');
+S::truncate('What are your plans today?', 19, '...');  // 'What are your pl...'
 ```
 
 #### underscored
@@ -766,10 +929,9 @@ $stringy->underscored();
 
 S::underscored(string $str [, string $encoding ])
 
-Returns a lowercase and trimmed string seperated by underscores, with
-multibyte support. Underscores are inserted before uppercase characters
-(with the exception of the first character of the string), and in place
-of spaces as well as dashes.
+Returns a lowercase and trimmed string separated by underscores.
+Underscores are inserted before uppercase characters (with the exception
+of the first character of the string), and in place of spaces as well as dashes.
 
 ```php
 S::create('TestUCase')->underscored();
@@ -782,9 +944,9 @@ $stringy->upperCamelize();
 
 S::upperCamelize(string $str [, string $encoding ])
 
-Returns an UpperCamelCase version of a supplied string, with multibyte
-support. Trims surrounding spaces, capitalizes letters following digits,
-spaces, dashes and underscores, and removes spaces, dashes, underscores.
+Returns an UpperCamelCase version of the supplied string. It trims
+surrounding spaces, capitalizes letters following digits, spaces, dashes
+and underscores, and removes spaces, dashes, underscores.
 
 ```php
 S::create('Upper Camel-Case')->upperCamelize();
@@ -797,14 +959,20 @@ $stringy->upperCaseFirst();
 
 S::upperCaseFirst(string $str [, string $encoding ])
 
-Converts the first character of the supplied string to upper case, with
-support for multibyte strings.
+Converts the first character of the supplied string to upper case.
 
 ```php
 S::create('σ test', 'UTF-8')->upperCaseFirst();
 S::upperCaseFirst('σ test', 'UTF-8');  // 'Σ test'
 ```
 
+## Links
+
+The following is a list of libraries that extend Stringy:
+
+ * [SliceableStringy](https://github.com/danielstjules/SliceableStringy):
+Python-like string slices in PHP
+
 ## Tests
 
 From the project directory, tests can be ran using `phpunit`

composer.json

@@ -5,6 +5,7 @@
         "multibyte", "string", "manipulation", "utility", "methods", "utf-8",
         "helpers", "utils", "utf"
     ],
+    "homepage": "https://github.com/danielstjules/Stringy",
     "license": "MIT",
     "authors": [
         {
@@ -16,7 +17,15 @@
     "require": {
         "php": ">=5.3.0"
     },
+    "require-dev": {
+        "phpunit/phpunit": "4.0.*"
+    },
+    "support": {
+        "issues": "https://github.com/danielstjules/Stringy/issues",
+        "source": "https://github.com/danielstjules/Stringy"
+    },
     "autoload": {
-        "psr-0": { "Stringy": "src/" }
+        "psr-4": { "Stringy\\": "src/" },
+        "classmap": [ "tests" ]
     }
 }

phpunit.xml.dist

@@ -5,7 +5,7 @@
          syntaxCheck="false">
     <testsuites>
         <testsuite name="Stringy">
-            <directory>tests/Stringy</directory>
+            <directory>tests</directory>
         </testsuite>
     </testsuites>
 </phpunit>

src/StaticStringy.php

@@ -0,0 +1,792 @@
+<?php
+
+namespace Stringy;
+
+class StaticStringy
+{
+    /**
+     * Returns an array consisting of the characters in the string.
+     *
+     * @param  string $str      String for which to return the chars
+     * @param  string $encoding The character encoding
+     * @return array  An array of string chars
+     */
+    public static function chars($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->chars();
+    }
+
+    /**
+     * Converts the first character of the supplied string to upper case.
+     *
+     * @param  string $str      String to modify
+     * @param  string $encoding The character encoding
+     * @return string String with the first character being upper case
+     */
+    public static function upperCaseFirst($str, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->upperCaseFirst();
+    }
+
+    /**
+     * Converts the first character of the supplied string to lower case.
+     *
+     * @param  string $str      String to modify
+     * @param  string $encoding The character encoding
+     * @return string String with the first character being lower case
+     */
+    public static function lowerCaseFirst($str, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->lowerCaseFirst();
+    }
+
+    /**
+     * Returns a camelCase version of the string. Trims surrounding spaces,
+     * capitalizes letters following digits, spaces, dashes and underscores,
+     * and removes spaces, dashes, as well as underscores.
+     *
+     * @param  string $str      String to convert to camelCase
+     * @param  string $encoding The character encoding
+     * @return string String in camelCase
+     */
+    public static function camelize($str, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->camelize();
+    }
+
+    /**
+     * Returns an UpperCamelCase version of the supplied string. It trims
+     * surrounding spaces, capitalizes letters following digits, spaces, dashes
+     * and underscores, and removes spaces, dashes, underscores.
+     *
+     * @param  string $str      String to convert to UpperCamelCase
+     * @param  string $encoding The character encoding
+     * @return string String in UpperCamelCase
+     */
+    public static function upperCamelize($str, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->upperCamelize();
+    }
+
+    /**
+     * Returns a lowercase and trimmed string separated by dashes. Dashes are
+     * inserted before uppercase characters (with the exception of the first
+     * character of the string), and in place of spaces as well as underscores.
+     *
+     * @param  string $str      String to convert
+     * @param  string $encoding The character encoding
+     * @return string Dasherized string
+     */
+    public static function dasherize($str, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->dasherize();
+    }
+
+    /**
+     * Returns a lowercase and trimmed string separated by underscores.
+     * Underscores are inserted before uppercase characters (with the exception
+     * of the first character of the string), and in place of spaces as well as
+     * dashes.
+     *
+     * @param  string  $str      String to convert
+     * @param  string  $encoding The character encoding
+     * @return string  Underscored string
+     */
+    public static function underscored($str, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->underscored();
+    }
+
+    /**
+     * Returns a case swapped version of the string.
+     *
+     * @param  string $str      String to swap case
+     * @param  string $encoding The character encoding
+     * @return string String with each character's case swapped
+     */
+    public static function swapCase($str, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->swapCase();
+    }
+
+    /**
+     * Returns a trimmed string with the first letter of each word capitalized.
+     * Ignores the case of other letters, preserving any acronyms. Also accepts
+     * an array, $ignore, allowing you to list words not to be capitalized.
+     *
+     * @param  string $str      String to titleize
+     * @param  string $encoding The character encoding
+     * @param  array  $ignore   An array of words not to capitalize
+     * @return string Titleized string
+     */
+    public static function titleize($str, $ignore = null, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->titleize($ignore);
+    }
+
+    /**
+     * Capitalizes the first word of the string, replaces underscores with
+     * spaces, and strips '_id'.
+     *
+     * @param  string $str      String to humanize
+     * @param  string $encoding The character encoding
+     * @return string A humanized string
+     */
+    public static function humanize($str, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->humanize();
+    }
+
+    /**
+     * Returns a string with smart quotes, ellipsis characters, and dashes from
+     * Windows-1252 (commonly used in Word documents) replaced by their ASCII
+     * equivalents.
+     *
+     * @param  string $str String to remove special chars
+     * @return string String with those characters removed
+     */
+    public static function tidy($str)
+    {
+        return (string) Stringy::create($str)->tidy();
+    }
+
+    /**
+     * Trims the string and replaces consecutive whitespace characters with a
+     * single space. This includes tabs and newline characters, as well as
+     * multibyte whitespace such as the thin space and ideographic space.
+     *
+     * @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)
+    {
+        return (string) Stringy::create($str, $encoding)->collapseWhitespace();
+    }
+
+    /**
+     * 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.
+     *
+     * @param  string $str A string with non-ASCII characters
+     * @return string A string containing only ASCII characters
+     */
+    public static function toAscii($str)
+    {
+        return (string) Stringy::create($str)->toAscii();
+    }
+
+    /**
+     * Pads the string to a given length with $padStr. If length is less than
+     * or equal to the length of the string, no padding takes places. The
+     * default string used for padding is a space, and the default type (one of
+     * 'left', 'right', 'both') is 'right'. Throws an InvalidArgumentException
+     * if $padType isn't one of those 3 values.
+     *
+     * @param  string $str      String to pad
+     * @param  int    $length   Desired string length after padding
+     * @param  string $padStr   String used to pad, defaults to space
+     * @param  string $padType  One of 'left', 'right', 'both'
+     * @param  string $encoding The character encoding
+     * @return string The padded string
+     * @throws \InvalidArgumentException If $padType isn't one of 'right',
+     *         'left' or 'both'
+     */
+    public static function pad($str, $length, $padStr = ' ', $padType = 'right',
+                               $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->pad($length, $padStr, $padType);
+    }
+
+    /**
+     * Returns a new string of a given length such that the beginning of the
+     * string is padded. Alias for pad() with a $padType of 'left'.
+     *
+     * @param  string $str      String to pad
+     * @param  int    $length   Desired string length after padding
+     * @param  string $padStr   String used to pad, defaults to space
+     * @param  string $encoding The character encoding
+     * @return string The padded string
+     */
+    public static function padLeft($str, $length, $padStr = ' ', $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->padLeft($length, $padStr);
+    }
+
+    /**
+     * Returns a new string of a given length such that the end of the string
+     * is padded. Alias for pad() with a $padType of 'right'.
+     *
+     * @param  string $str      String to pad
+     * @param  int    $length   Desired string length after padding
+     * @param  string $padStr   String used to pad, defaults to space
+     * @param  string $encoding The character encoding
+     * @return string The padded string
+     */
+    public static function padRight($str, $length, $padStr = ' ', $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->padRight($length, $padStr);
+    }
+
+    /**
+     * Returns a new string of a given length such that both sides of the
+     * string are padded. Alias for pad() with a $padType of 'both'.
+     *
+     * @param  string $str      String to pad
+     * @param  int    $length   Desired string length after padding
+     * @param  string $padStr   String used to pad, defaults to space
+     * @param  string $encoding The character encoding
+     * @return string The padded string
+     */
+    public static function padBoth($str, $length, $padStr = ' ', $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->padBoth($length, $padStr);
+    }
+
+    /**
+     * Returns true if the string begins with $substring, false otherwise. By
+     * default, the comparison is case-sensitive, but can be made insensitive
+     * by setting $caseSensitive to false.
+     *
+     * @param  string $str           String to check the start of
+     * @param  string $substring     The 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 $str starts with $substring
+     */
+    public static function startsWith($str, $substring, $caseSensitive = true,
+                                      $encoding = null)
+    {
+        return Stringy::create($str, $encoding)
+            ->startsWith($substring, $caseSensitive);
+    }
+
+    /**
+     * Returns true if the string ends with $substring, false otherwise. By
+     * default, the comparison is case-sensitive, but can be made insensitive
+     * by setting $caseSensitive to false.
+     *
+     * @param  string $str           String to check the end of
+     * @param  string $substring     The 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 $str ends with $substring
+     */
+    public static function endsWith($str, $substring, $caseSensitive = true,
+                                    $encoding = null)
+    {
+        return Stringy::create($str, $encoding)
+            ->endsWith($substring, $caseSensitive);
+    }
+
+    /**
+     * Converts each tab in the string to some number of spaces, as defined by
+     * $tabLength. By default, each tab is converted to 4 consecutive spaces.
+     *
+     * @param  string $str       String to convert tabs to spaces
+     * @param  int    $tabLength Number of spaces to replace each tab with
+     * @return string String with tabs switched to spaces
+     */
+    public static function toSpaces($str, $tabLength = 4)
+    {
+        return (string) Stringy::create($str)->toSpaces($tabLength);
+    }
+
+    /**
+     * Converts each occurrence of some consecutive number of spaces, as
+     * defined by $tabLength, to a tab. By default, each 4 consecutive spaces
+     * are converted to a tab.
+     *
+     * @param  string $str       String to convert spaces to tabs
+     * @param  int    $tabLength Number of spaces to replace with a tab
+     * @return string String with spaces switched to tabs
+     */
+    public static function toTabs($str, $tabLength = 4)
+    {
+        return (string) Stringy::create($str)->toTabs($tabLength);
+    }
+
+    /**
+     * 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 (string) Stringy::create($str, $encoding)->toLowerCase();
+    }
+
+    /**
+     * 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 (string) Stringy::create($str, $encoding)->toUpperCase();
+    }
+
+    /**
+     * Converts the string into an URL slug. This includes replacing non-ASCII
+     * characters with their closest ASCII equivalents, removing remaining
+     * non-ASCII and non-alphanumeric characters, and replacing whitespace with
+     * $replacement. The replacement defaults to a single dash, and the string
+     * is also converted to lowercase.
+     *
+     * @param  string $str         Text to transform into an URL slug
+     * @param  string $replacement The string used to replace whitespace
+     * @return string The corresponding URL slug
+     */
+    public static function slugify($str, $replacement = '-')
+    {
+        return (string) Stringy::create($str)->slugify($replacement);
+    }
+
+    /**
+     * 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  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, $caseSensitive = true,
+                                    $encoding = null)
+    {
+        return Stringy::create($haystack, $encoding)
+            ->contains($needle, $caseSensitive);
+    }
+
+    /**
+     * Surrounds a string with the given substring.
+     *
+     * @param  string $str       The string to surround
+     * @param  string $substring The substring to add to both sides
+     * @return string The string with the substring prepended and appended
+     */
+    public static function surround($str, $substring)
+    {
+        return (string) Stringy::create($str)->surround($substring);
+    }
+
+    /**
+     * Inserts $substring into the string at the $index provided.
+     *
+     * @param  string $str       String to insert into
+     * @param  string $substring String to be inserted
+     * @param  int    $index     The index at which to insert the substring
+     * @param  string $encoding  The character encoding
+     * @return string The resulting string after the insertion
+     */
+    public static function insert($str, $substring, $index, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->insert($substring, $index);
+    }
+
+    /**
+     * Truncates the string to a given length. If $substring is provided, and
+     * truncating occurs, the string is further truncated so that the substring
+     * may be appended without exceeding the desired length.
+     *
+     * @param  string $str       String to truncate
+     * @param  int    $length    Desired length of the truncated string
+     * @param  string $substring The substring to append if it can fit
+     * @param  string $encoding  The character encoding
+     * @return string The resulting string after truncating
+     */
+    public static function truncate($str, $length, $substring = '',
+                                    $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->truncate($length, $substring);
+    }
+
+    /**
+     * Truncates the string to a given length, while ensuring that it does not
+     * split words. If $substring is provided, and truncating occurs, the
+     * string is further truncated so that the substring may be appended without
+     * exceeding the desired length.
+     *
+     * @param  string $str       String to truncate
+     * @param  int    $length    Desired length of the truncated string
+     * @param  string $substring The substring to append if it can fit
+     * @param  string $encoding  The character encoding
+     * @return string The resulting string after truncating
+     */
+    public static function safeTruncate($str, $length, $substring = '',
+                                    $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->safeTruncate($length, $substring);
+    }
+
+    /**
+     * Returns a reversed string. A multibyte version of strrev().
+     *
+     * @param  string $str      String to reverse
+     * @param  string $encoding The character encoding
+     * @return string The reversed string
+     */
+    public static function reverse($str, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->reverse();
+    }
+
+    /**
+     * A multibyte str_shuffle() function. It returns a string with its
+     * characters in random order.
+     *
+     * @param  string $str      String to shuffle
+     * @param  string $encoding The character encoding
+     * @return string The shuffled string
+     */
+    public static function shuffle($str, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->shuffle();
+    }
+
+    /**
+     * Returns the trimmed string. An alias for PHP's trim() function.
+     *
+     * @param  string $str String to trim
+     * @return string Trimmed $str
+     */
+    public static function trim($str)
+    {
+        return trim($str);
+    }
+
+    /**
+     * Returns the longest common prefix between the string and $otherStr.
+     *
+     * @param  string $str      First string for comparison
+     * @param  string $otherStr Second string for comparison
+     * @param  string $encoding The character encoding
+     * @return string The longest common prefix
+     */
+    public static function longestCommonPrefix($str, $otherStr, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->longestCommonPrefix($otherStr);
+    }
+
+    /**
+     * Returns the longest common suffix between the string and $otherStr.
+     *
+     * @param  string $str      First string for comparison
+     * @param  string $otherStr Second string for comparison
+     * @param  string $encoding The character encoding
+     * @return string The longest common suffix
+     */
+    public static function longestCommonSuffix($str, $otherStr, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->longestCommonSuffix($otherStr);
+    }
+
+    /**
+     * Returns the longest common substring between the string and $otherStr.
+     * In the case of ties, it returns that which occurs first.
+     *
+     * @param  string $str      First string for comparison
+     * @param  string $otherStr Second string for comparison
+     * @param  string $encoding The character encoding
+     * @return string The longest common substring
+     */
+    public static function longestCommonSubstring($str, $otherStr,
+                                                  $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->longestCommonSubstring($otherStr);
+    }
+
+    /**
+     * Returns the length of the string. An alias for PHP's mb_strlen() function.
+     *
+     * @param  string $str      The string to get the length of
+     * @param  string $encoding The character encoding
+     * @return int    The number of characters in $str given the encoding
+     */
+    public static function length($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->length();
+    }
+
+    /**
+     * Returns the substring beginning at $start with the specified $length.
+     * It differs from the mb_substr() function in that providing a $length of
+     * null will return the rest of the string, rather than an empty string.
+     *
+     * @param  string $str      The string to get the length of
+     * @param  int    $start    Position of the first character to use
+     * @param  int    $length   Maximum number of characters used
+     * @param  string $encoding The character encoding
+     * @return string The substring of $str
+     */
+    public static function substr($str, $start, $length = null, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->substr($start, $length);
+    }
+
+    /**
+     * Returns the character at $index, with indexes starting at 0.
+     *
+     * @param  string $str      The string from which to get the char
+     * @param  int    $index    Position of the character
+     * @param  string $encoding The character encoding
+     * @return string The character at $index
+     */
+    public static function at($str, $index, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->at($index);
+    }
+
+    /**
+     * Returns the first $n characters of the string.
+     *
+     * @param  string $str      The string from which to get the substring
+     * @param  int    $n        Number of chars to retrieve from the start
+     * @param  string $encoding The character encoding
+     * @return string The first $n characters
+     */
+    public static function first($str, $n, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->first($n);
+    }
+
+    /**
+     * Returns the last $n characters of the string.
+     *
+     * @param  string $str      The string from which to get the substring
+     * @param  int    $n        Number of chars to retrieve from the end
+     * @param  string $encoding The character encoding
+     * @return string The last $n characters
+     */
+    public static function last($str, $n, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->last($n);
+    }
+
+    /**
+     * Ensures that the string begins with $substring. If it doesn't, it's
+     * prepended.
+     *
+     * @param  string $str       The string to modify
+     * @param  string $substring The substring to add if not present
+     * @param  string $encoding  The character encoding
+     * @return string The string prefixed by the $substring
+     */
+    public static function ensureLeft($str, $substring, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->ensureLeft($substring);
+    }
+
+    /**
+     * Ensures that the string begins with $substring. If it doesn't, it's
+     * appended.
+     *
+     * @param  string $str       The string to modify
+     * @param  string $substring The substring to add if not present
+     * @param  string $encoding  The character encoding
+     * @return string The string suffixed by the $substring
+     */
+    public static function ensureRight($str, $substring, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->ensureRight($substring);
+    }
+
+    /**
+     * Returns a new string with the prefix $substring removed, if present.
+     *
+     * @param  string $str       String from which to remove the prefix
+     * @param  string $substring The prefix to remove
+     * @param  string $encoding  The character encoding
+     * @return string The string without the prefix $substring
+     */
+    public static function removeLeft($str, $substring, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->removeLeft($substring);
+    }
+
+    /**
+     * Returns a new string with the suffix $substring removed, if present.
+     *
+     * @param  string $str       String from which to remove the suffix
+     * @param  string $substring The suffix to remove
+     * @param  string $encoding  The character encoding
+     * @return string The string without the suffix $substring
+     */
+    public static function removeRight($str, $substring, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)->removeRight($substring);
+    }
+
+    /**
+     * Returns true if the string contains only alphabetic chars, false
+     * otherwise.
+     *
+     * @param  string $str      String to check
+     * @param  string $encoding The character encoding
+     * @return bool   Whether or not $str contains only alphabetic chars
+     */
+    public static function isAlpha($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->isAlpha();
+    }
+
+    /**
+     * Returns true if the string contains only alphabetic and numeric chars,
+     * false otherwise.
+     *
+     * @param  string $str      String to check
+     * @param  string $encoding The character encoding
+     * @return bool   Whether or not $str contains only alphanumeric chars
+     */
+    public static function isAlphanumeric($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->isAlphanumeric();
+    }
+
+    /**
+     * Returns true if the string contains only whitespace chars, false
+     * otherwise.
+     *
+     * @param  string $str      String to check
+     * @param  string $encoding The character encoding
+     * @return bool   Whether or not $str contains only whitespace characters
+     */
+    public static function isBlank($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->isBlank();
+    }
+
+    /**
+     * Returns true if the string is JSON, false otherwise.
+     *
+     * @param  string $str      String to check
+     * @param  string $encoding The character encoding
+     * @return bool   Whether or not $str is JSON
+     */
+    public static function isJson($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->isJson();
+    }
+
+    /**
+     * Returns true if the string contains only lower case chars, false
+     * otherwise.
+     *
+     * @param  string $str      String to check
+     * @param  string $encoding The character encoding
+     * @return bool   Whether or not $str contains only lower case characters
+     */
+    public static function isLowerCase($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->isLowerCase();
+    }
+
+    /**
+     * Returns true if the string is serialized, false otherwise.
+     *
+     * @param  string $str      String to check
+     * @param  string $encoding The character encoding
+     * @return bool   Whether or not $str is serialized
+     */
+    public static function isSerialized($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->isSerialized();
+    }
+
+    /**
+     * Returns true if the string contains only upper case chars, false
+     * otherwise.
+     *
+     * @param  string $str      String to check
+     * @param  string $encoding The character encoding
+     * @return bool   Whether or not $str contains only upper case characters
+     */
+    public static function isUpperCase($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->isUpperCase();
+    }
+
+    /**
+     * Returns true if the string contains only hexadecimal chars, false
+     * otherwise.
+     *
+     * @param  string $str      String to check
+     * @param  string $encoding The character encoding
+     * @return bool   Whether or not $str contains only hexadecimal characters
+     */
+    public static function isHexadecimal($str, $encoding = null)
+    {
+        return Stringy::create($str, $encoding)->isHexadecimal();
+    }
+
+    /**
+     * Returns the number of occurrences of $substring in the given string.
+     * By default, the comparison is case-sensitive, but can be made insensitive
+     * by setting $caseSensitive to false.
+     *
+     * @param  string $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 countSubstr($str, $substring, $caseSensitive = true,
+                                       $encoding = null)
+    {
+        return Stringy::create($str, $encoding)
+            ->countSubstr($substring, $caseSensitive);
+    }
+
+    /**
+     * 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 $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, $replacement, $encoding = null)
+    {
+        return (string) Stringy::create($str, $encoding)
+            ->replace($search,$replacement);
+    }
+
+    /**
+     * 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 (string) Stringy::create($str, $encoding)
+            ->regexReplace($pattern, $replacement, $options, $encoding);
+    }
+}

src/Stringy/StaticStringy.php

@@ -1,673 +0,0 @@
-<?php
-
-namespace Stringy;
-
-class StaticStringy
-{
-    /**
-     * Converts the first character of the supplied string to upper case.
-     *
-     * @param   string  $str       String to modify
-     * @param   string  $encoding  The character encoding
-     * @return  string  String with the first character being upper case
-     */
-    public static function upperCaseFirst($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->upperCaseFirst()->str;
-    }
-
-    /**
-     * Converts the first character of the supplied string to lower case.
-     *
-     * @param   string  $str       String to modify
-     * @param   string  $encoding  The character encoding
-     * @return  string  String with the first character being lower case
-     */
-    public static function lowerCaseFirst($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->lowerCaseFirst()->str;
-    }
-
-    /**
-     * Returns a camelCase version of a supplied string. Trims surrounding
-     * spaces, capitalizes letters following digits, spaces, dashes and
-     * underscores, and removes spaces, dashes, underscores.
-     *
-     * @param   string  $str       String to convert to camelCase
-     * @param   string  $encoding  The character encoding
-     * @return  string  String in camelCase
-     */
-    public static function camelize($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->camelize()->str;
-    }
-
-    /**
-     * Returns an UpperCamelCase version of a supplied string. Trims surrounding
-     * spaces, capitalizes letters following digits, spaces, dashes and
-     * underscores, and removes spaces, dashes, underscores.
-     *
-     * @param   string  $str       String to convert to UpperCamelCase
-     * @param   string  $encoding  The character encoding
-     * @return  string  String in UpperCamelCase
-     */
-    public static function upperCamelize($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->upperCamelize()->str;
-    }
-
-    /**
-     * Returns a lowercase and trimmed string seperated by dashes. Dashes are
-     * inserted before uppercase characters (with the exception of the first
-     * character of the string), and in place of spaces as well as underscores.
-     *
-     * @param   string  $str       String to convert
-     * @param   string  $encoding  The character encoding
-     * @return  string  Dasherized string
-     */
-    public static function dasherize($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->dasherize()->str;
-    }
-
-    /**
-     * Returns a lowercase and trimmed string seperated by underscores.
-     * Underscores are inserted before uppercase characters (with the exception
-     * of the first character of the string), and in place of spaces as well as
-     * dashes.
-     *
-     * @param   string  $str       String to convert
-     * @param   string  $encoding  The character encoding
-     * @return  string  Underscored string
-     */
-    public static function underscored($str, $encoding = null)
-    {
-        return $result = Stringy::create($str, $encoding)->underscored()->str;
-    }
-
-    /**
-     * Returns a case swapped version of a string.
-     *
-     * @param   string  $str       String to swap case
-     * @param   string  $encoding  The character encoding
-     * @return  string  String with each character's case swapped
-     */
-    public static function swapCase($str, $encoding = null)
-    {
-        return $result = Stringy::create($str, $encoding)->swapCase()->str;
-    }
-
-    /**
-     * Capitalizes the first letter of each word in a string, after trimming.
-     * Ignores the case of other letters, allowing for the use of acronyms.
-     * Also accepts an array, $ignore, allowing you to list words not to be
-     * capitalized.
-     *
-     * @param   string  $str       String to titleize
-     * @param   string  $encoding  The character encoding
-     * @param   array   $ignore    An array of words not to capitalize
-     * @return  string  Titleized string
-     */
-    public static function titleize($str, $ignore = null, $encoding = null)
-    {
-        return $result = Stringy::create($str, $encoding)->titleize($ignore)->str;
-    }
-
-    /**
-     * Capitalizes the first word of a string, replaces underscores with spaces,
-     * and strips '_id'.
-     *
-     * @param   string  $str       String to humanize
-     * @param   string  $encoding  The character encoding
-     * @return  string  A humanized string
-     */
-    public static function humanize($str, $encoding = null)
-    {
-        return $result = Stringy::create($str, $encoding)->humanize()->str;
-    }
-
-    /**
-     * Replaces smart quotes, ellipsis characters, and dashes from Windows-1252
-     * (and commonly used in Word documents) with their ASCII 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)
-    {
-        return $result = Stringy::create($str)->tidy()->str;
-    }
-
-    /**
-     * Trims the string and replaces consecutive whitespace characters with a
-     * single space. This inclues tabs and newline characters.
-     *
-     * @param   string  $str  The string to cleanup whitespace
-     * @return  string  The trimmed string with condensed whitespace
-     */
-    public static function collapseWhitespace($str)
-    {
-        return $result = Stringy::create($str)->collapseWhitespace()->str;
-    }
-
-    /**
-     * Converts some non-ASCII characters to their closest ASCII counterparts.
-     *
-     * @param   string  $str  A string with non-ASCII characters
-     * @return  string  The string after the replacements
-     */
-    public static function standardize($str)
-    {
-        return $result = Stringy::create($str)->standardize()->str;
-    }
-
-    /**
-     * Pads a string to a given length with another string. If length is less
-     * than or equal to the length of $str, then no padding takes places. The
-     * default string used for padding is a space, and the default type (one of
-     * 'left', 'right', 'both') is 'right'. Throws an exception if $padType
-     * isn't one of those 3 values.
-     *
-     * @param   string  $str       String to pad
-     * @param   int     $length    Desired string length after padding
-     * @param   string  $padStr    String used to pad, defaults to space
-     * @param   string  $padType   One of 'left', 'right', 'both'
-     * @param   string  $encoding  The character encoding
-     * @return  string  The padded string
-     * @throws  InvalidArgumentException If $padType isn't one of 'right',
-     *          'left' or 'both'
-     */
-    public static function pad($str, $length, $padStr = ' ', $padType = 'right',
-                               $encoding = null)
-    {
-        return $result = Stringy::create($str, $encoding)
-                                ->pad($length, $padStr, $padType)->str;
-    }
-
-    /**
-     * Returns a new string of a given length such that the beginning of the
-     * string is padded. Alias for pad($str, $length, $padStr, 'left', $encoding)
-     *
-     * @param   string  $str       String to pad
-     * @param   int     $length    Desired string length after padding
-     * @param   string  $padStr    String used to pad, defaults to space
-     * @param   string  $encoding  The character encoding
-     * @return  string  The padded string
-     */
-    public static function padLeft($str, $length, $padStr = ' ', $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->padLeft($length, $padStr)->str;
-    }
-
-    /**
-     * Returns a new string of a given length such that the end of the string is
-     * padded. Alias for pad($str, $length, $padStr, 'right', $encoding)
-     *
-     * @param   string  $str       String to pad
-     * @param   int     $length    Desired string length after padding
-     * @param   string  $padStr    String used to pad, defaults to space
-     * @param   string  $encoding  The character encoding
-     * @return  string  The padded string
-     */
-    public static function padRight($str, $length, $padStr = ' ', $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->padRight($length, $padStr)->str;
-    }
-
-    /**
-     * Returns a new string of a given length such that both sides of the string
-     * string are padded. Alias for pad($str, $length, $padStr, 'both', $encoding)
-     *
-     * @param   string  $str       String to pad
-     * @param   int     $length    Desired string length after padding
-     * @param   string  $padStr    String used to pad, defaults to space
-     * @param   string  $encoding  The character encoding
-     * @return  string  The padded string
-     */
-    public static function padBoth($str, $length, $padStr = ' ', $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->padBoth($length, $padStr)->str;
-    }
-
-    /**
-     * Returns true if the string $str begins with $substring, false otherwise.
-     * By default, the comparison is case-sensitive, but can be made insensitive
-     * by setting $caseSensitive to false.
-     *
-     * @param   string  $str            String to check the start of
-     * @param   string  $substring      The substring to look for
-     * @param   bool    $caseSensitive  Whether or not to enfore case-sensitivity
-     * @param   string  $encoding       The character encoding
-     * @return  bool    Whether or not $str starts with $substring
-     */
-    public static function startsWith($str, $substring, $caseSensitive = true,
-                                      $encoding = null)
-    {
-        return Stringy::create($str, $encoding)
-                      ->startsWith($substring, $caseSensitive);
-    }
-
-    /**
-     * Returns true if the string $str ends with $substring, false otherwise.
-     * By default, the comparison is case-sensitive, but can be made insensitive
-     * by setting $caseSensitive to false.
-     *
-     * @param   string  $str            String to check the end of
-     * @param   string  $substring      The substring to look for
-     * @param   bool    $caseSensitive  Whether or not to enfore case-sensitivity
-     * @param   string  $encoding       The character encoding
-     * @return  bool    Whether or not $str ends with $substring
-     */
-    public static function endsWith($str, $substring, $caseSensitive = true,
-                                    $encoding = null)
-    {
-        return Stringy::create($str, $encoding)
-                      ->endsWith($substring, $caseSensitive);
-    }
-
-    /**
-     * Converts each tab in a string to some number of spaces, as defined by
-     * $tabLength. By default, each tab is converted to 4 consecutive spaces.
-     *
-     * @param   string  $str        String to convert tabs to spaces
-     * @param   int     $tabLength  Number of spaces to replace each tab with
-     * @return  string  String with tabs switched to spaces
-     */
-    public static function toSpaces($str, $tabLength = 4)
-    {
-        return Stringy::create($str)->toSpaces($tabLength)->str;
-    }
-
-    /**
-     * Converts each occurence of some consecutive number of spaces, as defined
-     * by $tabLength, to a tab. By default, each 4 consecutive spaces are
-     * converted to a tab.
-     *
-     * @param   string  $str        String to convert spaces to tabs
-     * @param   int     $tabLength  Number of spaces to replace with a tab
-     * @return  string  String with spaces switched to tabs
-     */
-    public static function toTabs($str, $tabLength = 4)
-    {
-        return Stringy::create($str)->toTabs($tabLength)->str;
-    }
-
-    /**
-     * Converts the supplied text into an URL slug. This includes replacing
-     * non-ASCII characters with their closest ASCII equivalents, removing
-     * non-alphanumeric and non-ASCII characters, and replacing whitespace with
-     * dashes. The string is also converted to lowercase.
-     *
-     * @param   string  $str  Text to transform into an URL slug
-     * @return  string  The corresponding URL slug
-     */
-    public static function slugify($str)
-    {
-        return Stringy::create($str)->slugify()->str;
-    }
-
-    /**
-     * Returns true if $haystack contains $needle, false otherwise.
-     *
-     * @param   string  $haystack  String being checked
-     * @param   string  $needle    Substring to look for
-     * @param   string  $encoding  The character encoding
-     * @return  bool    Whether or not $haystack contains $needle
-     */
-    public static function contains($haystack, $needle, $encoding = null)
-    {
-        return Stringy::create($haystack, $encoding)->contains($needle);
-    }
-
-    /**
-     * Surrounds a string with the given substring.
-     *
-     * @param   string  $str        The string to surround
-     * @param   string  $substring  The substring to add to both sides
-     * @return  string  The string with the substring prepended and appended
-     */
-    public static function surround($str, $substring)
-    {
-        return Stringy::create($str)->surround($substring)->str;
-    }
-
-    /**
-     * Inserts $substring into $str at the $index provided.
-     *
-     * @param   string  $str        String to insert into
-     * @param   string  $substring  String to be inserted
-     * @param   int     $index      The index at which to insert the substring
-     * @param   string  $encoding   The character encoding
-     * @return  string  The resulting string after the insertion
-     */
-    public static function insert($str, $substring, $index, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->insert($substring, $index)->str;
-    }
-
-    /**
-     * Truncates $str to a given length. If $substring is provided, and
-     * truncating occurs, the string is further truncated so that the substring
-     * may be appended without exceeding the desired length.
-     *
-     * @param   string  $str          String to truncate
-     * @param   int     $length       Desired length of the truncated string
-     * @param   string  $substring    The substring to append if it can fit
-     * @param   string  $encoding     The character encoding
-     * @return  string  The resulting string after truncating
-     */
-    public static function truncate($str, $length, $substring = '',
-                                    $encoding = null)
-    {
-        return Stringy::create($str, $encoding)
-                      ->truncate($length, $substring)->str;
-    }
-
-    /**
-     * Truncates the string to a given length, while ensuring that it does not
-     * chop words. If $substring is provided, and truncating occurs, the string
-     * is further truncated so that the substring may be appended without
-     * exceeding the desired length.
-     *
-     * @param   string  $str          String to truncate
-     * @param   int     $length       Desired length of the truncated string
-     * @param   string  $substring    The substring to append if it can fit
-     * @param   string  $encoding     The character encoding
-     * @return  string  The resulting string after truncating
-     */
-    public static function safeTruncate($str, $length, $substring = '',
-                                    $encoding = null)
-    {
-        return Stringy::create($str, $encoding)
-                      ->safeTruncate($length, $substring)->str;
-    }
-
-    /**
-     * Reverses a string. A multibyte version of strrev.
-     *
-     * @param   string  $str        String to reverse
-     * @param   string  $encoding   The character encoding
-     * @return  string  The reversed string
-     */
-    public static function reverse($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->reverse()->str;
-    }
-
-    /**
-     * A multibyte str_shuffle function. It randomizes the order of characters
-     * in a string.
-     *
-     * @param   string  $str       String to shuffle
-     * @param   string  $encoding  The character encoding
-     * @return  string  The shuffled string
-     */
-    public static function shuffle($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->shuffle()->str;
-    }
-
-    /**
-     * Trims $str. An alias for PHP's trim() function.
-     *
-     * @param   string  $str  String to trim
-     * @return  string  Trimmed $str
-     */
-    public static function trim($str)
-    {
-        return trim($str);
-    }
-
-    /**
-     * Finds the longest common prefix between $str and $otherStr.
-     *
-     * @param   string  $str       First string for comparison
-     * @param   string  $otherStr  Second string for comparison
-     * @param   string  $encoding  The character encoding
-     * @return  string  The longest common prefix
-     */
-    public static function longestCommonPrefix($str, $otherStr, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)
-                      ->longestCommonPrefix($otherStr)->str;
-    }
-
-    /**
-     * Finds the longest common suffix between $str and $otherStr.
-     *
-     * @param   string  $str       First string for comparison
-     * @param   string  $otherStr  Second string for comparison
-     * @param   string  $encoding  The character encoding
-     * @return  string  The longest common suffix
-     */
-    public static function longestCommonSuffix($str, $otherStr, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)
-                      ->longestCommonSuffix($otherStr)->str;
-    }
-
-    /**
-     * Finds the longest common substring between $str and $otherStr. In the
-     * case of ties, returns that which occurs first.
-     *
-     * @param   string  $str       First string for comparison
-     * @param   string  $otherStr  Second string for comparison
-     * @param   string  $encoding  The character encoding
-     * @return  string  The longest common substring
-     */
-    public static function longestCommonSubstring($str, $otherStr,
-                                                  $encoding = null)
-    {
-        return Stringy::create($str, $encoding)
-                      ->longestCommonSubstring($otherStr)->str;
-    }
-
-    /**
-     * Returns the length of $str. An alias for PHP's mb_strlen() function.
-     *
-     * @param   string  $str       The string to get the length of
-     * @param   string  $encoding  The character encoding
-     * @return  int     The number of characters in $str given the encoding
-     */
-    public static function length($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->length();
-    }
-
-    /**
-     * Gets the substring of $str beginning at $start with the specified $length.
-     * It differs from the mb_substr() function in that providing a $length of
-     * null will return the rest of the string, rather than an empty string.
-     *
-     * @param   string  $str     The string to get the length of
-     * @param   int     $start   Position of the first character to use from str
-     * @param   int     $length  Maximum number of characters used
-     * @param   string  $encoding  The character encoding
-     * @return  string  The substring of $str
-     */
-    public static function substr($str, $start, $length = null, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->substr($start, $length)->str;
-    }
-
-    /**
-     * Gets the character of $str at $index, with indexes starting at 0.
-     *
-     * @param   string   $str       The string from which to get the char
-     * @param   int      $index     Position of the character
-     * @param   string   $encoding  The character encoding
-     * @return  string   The character at $index
-     */
-    public static function at($str, $index, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->at($index)->str;
-    }
-
-    /**
-     * Gets the first $n characters of $str.
-     *
-     * @param   string   $str       The string from which to get the substring
-     * @param   int      $n         Number of chars to retrieve from the start
-     * @param   string   $encoding  The character encoding
-     * @return  string   The first $n characters
-     */
-    public static function first($str, $n, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->first($n)->str;
-    }
-
-    /**
-     * Gets the last $n characters of $str.
-     *
-     * @param   string   $str       The string from which to get the substring
-     * @param   int      $n         Number of chars to retrieve from the end
-     * @param   string   $encoding  The character encoding
-     * @return  string   The last $n characters
-     */
-    public static function last($str, $n, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->last($n)->str;
-    }
-
-    /**
-     * Ensures that $str begins with $substring.
-     *
-     * @param   string   $str        The string to modify
-     * @param   string   $substring  The substring to add if not present
-     * @param   string   $encoding   The character encoding
-     * @return  string   The string prefixed by the $substring
-     */
-    public static function ensureLeft($str, $substring, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->ensureLeft($substring)->str;
-    }
-
-    /**
-     * Ensures that $str ends with $substring.
-     *
-     * @param   string   $str        The string to modify
-     * @param   string   $substring  The substring to add if not present
-     * @param   string   $encoding   The character encoding
-     * @return  string   The string suffixed by the $substring
-     */
-    public static function ensureRight($str, $substring, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->ensureRight($substring)->str;
-    }
-
-    /**
-     * Removes the prefix $substring if present.
-     *
-     * @param   string   $str        String from which to remove the prefix
-     * @param   string   $substring  The prefix to remove
-     * @param   string   $encoding   The character encoding
-     * @return  string   The string without the prefix $substring
-     */
-    public static function removeLeft($str, $substring, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->removeLeft($substring)->str;
-    }
-
-    /**
-     * Removes the suffix $substring if present.
-     *
-     * @param   string   $str        String from which to remove the suffix
-     * @param   string   $substring  The suffix to remove
-     * @param   string   $encoding   The character encoding
-     * @return  string   The string without the suffix $substring
-     */
-    public static function removeRight($str, $substring, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->removeRight($substring)->str;
-    }
-
-    /**
-     * Returns true if $str contains only alphabetic chars, false otherwise.
-     *
-     * @param   string   $str       String to check
-     * @param   string   $encoding  The character encoding
-     * @return  bool     Whether or not $str contains only alphabetic chars
-     */
-    public static function isAlpha($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->isAlpha();
-    }
-
-    /**
-     * Returns true if $str contains only alphabetic and numeric chars, false
-     * otherwise.
-     *
-     * @param   string   $str       String to check
-     * @param   string   $encoding  The character encoding
-     * @return  bool     Whether or not $str contains only alphanumeric chars
-     */
-    public static function isAlphanumeric($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->isAlphanumeric();
-    }
-
-    /**
-     * Returns true if $str contains only whitespace chars, false otherwise.
-     *
-     * @param   string   $str       String to check
-     * @param   string   $encoding  The character encoding
-     * @return  bool     Whether or not $str contains only whitespace characters
-     */
-    public static function isBlank($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->isBlank();
-    }
-
-    /**
-     * Returns true if $str contains only lower case chars, false otherwise.
-     *
-     * @param   string   $str       String to check
-     * @param   string   $encoding  The character encoding
-     * @return  bool     Whether or not $str contains only lower case characters
-     */
-    public static function isLowerCase($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->isLowerCase();
-    }
-
-    /**
-     * Returns true if $str contains only upper case chars, false otherwise.
-     *
-     * @param   string   $str       String to check
-     * @param   string   $encoding  The character encoding
-     * @return  bool     Whether or not $str contains only upper case characters
-     */
-    public static function isUpperCase($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->isUpperCase();
-    }
-
-    /**
-     * Returns the number of occurences of $substring in $str. An alias for
-     * mb_substr_count()
-     *
-     * @param   string   $str        The haystack to search through
-     * @param   string   $substring  The substring to search for
-     * @param   string   $encoding   The character encoding
-     * @return  int      The number of $substring occurences
-     */
-    public static function count($str, $substring, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->count($substring);
-    }
-
-    /**
-     * Replaces all occurrences of $search with $replace in $str.
-     *
-     * @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
-     * @return  string   The resulting string after the replacements
-     */
-    public static function replace($str, $search, $replace, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->replace($search, $replace);
-    }
-}

tests/CommonTest.php

@@ -1,36 +1,41 @@
 <?php
 
-class CommonTest extends PHPUnit_Framework_TestCase
+abstract class CommonTest extends PHPUnit_Framework_TestCase
 {
-    public function stringsForUpperCaseFirst()
+    public function charsProvider()
     {
-        $testData = array(
+        return array(
+            array(array(), ''),
+            array(array('T', 'e', 's', 't'), 'Test'),
+            array(array('F', 'ò', 'ô', ' ', 'B', 'à', 'ř'), 'Fòô Bàř', 'UTF-8')
+        );
+    }
+
+    public function upperCaseFirstProvider()
+    {
+        return array(
             array('Test', 'Test'),
             array('Test', 'test'),
             array('1a', '1a'),
             array('Σ test', 'σ test', 'UTF-8'),
             array(' σ test', ' σ test', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForLowerCaseFirst()
+    public function lowerCaseFirstProvider()
     {
-        $testData = array(
+        return array(
             array('test', 'Test'),
             array('test', 'test'),
             array('1a', '1a'),
             array('σ test', 'Σ test', 'UTF-8'),
             array(' Σ test', ' Σ test', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForCamelize()
+    public function camelizeProvider()
     {
-        $testData = array(
+        return array(
             array('camelCase', 'CamelCase'),
             array('camelCase', 'Camel-Case'),
             array('camelCase', 'camel case'),
@@ -45,13 +50,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('στανιλCase', 'Στανιλ case', 'UTF-8'),
             array('σamelCase', 'σamel  Case', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForUpperCamelize()
+    public function upperCamelizeProvider()
     {
-        $testData = array(
+        return array(
             array('CamelCase', 'camelCase'),
             array('CamelCase', 'Camel-Case'),
             array('CamelCase', 'camel case'),
@@ -66,13 +69,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('ΣτανιλCase', 'στανιλ case', 'UTF-8'),
             array('ΣamelCase', 'Σamel  Case', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForDasherize()
+    public function dasherizeProvider()
     {
-        $testData = array(
+        return array(
             array('test-case', 'testCase'),
             array('test-case', 'Test-Case'),
             array('test-case', 'test case'),
@@ -89,13 +90,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('στανιλ-case', 'Στανιλ case', 'UTF-8'),
             array('σash-case', 'Σash  Case', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForUnderscored()
+    public function underscoredProvider()
     {
-        $testData = array(
+        return array(
             array('test_case', 'testCase'),
             array('test_case', 'Test-Case'),
             array('test_case', 'test case'),
@@ -112,89 +111,81 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('στανιλ_case', 'Στανιλ case', 'UTF-8'),
             array('σash_case', 'Σash  Case', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForSwapCase()
+    public function swapCaseProvider()
     {
-        $testData = array(
+        return array(
             array('TESTcASE', 'testCase'),
             array('tEST-cASE', 'Test-Case'),
             array(' - σASH  cASE', ' - Σash  Case', 'UTF-8'),
             array('νΤΑΝΙΛ', 'Ντανιλ', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForTitleize()
+    public function titleizeProvider()
     {
         $ignore = array('at', 'by', 'for', 'in', 'of', 'on', 'out', 'to', 'the');
 
-        $testData = array(
+        return array(
             array('Testing The Method', 'testing the method'),
             array('Testing the Method', 'testing the method', $ignore, 'UTF-8'),
             array('I Like to Watch DVDs at Home', 'i like to watch DVDs at home',
                 $ignore, 'UTF-8'),
             array('Θα Ήθελα Να Φύγει', '  Θα ήθελα να φύγει  ', null, 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForHumanize()
+    public function humanizeProvider()
     {
-        $testData = array(
+        return array(
             array('Author', 'author_id'),
             array('Test user', ' _test_user_'),
             array('Συγγραφέας', ' συγγραφέας_id ', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForTidy()
+    public function tidyProvider()
     {
-        $testData = array(
+        return array(
             array('"I see..."', '“I see…”'),
             array("'This too'", "‘This too’"),
             array('test-dash', 'test—dash'),
             array('Ο συγγραφέας είπε...', 'Ο συγγραφέας είπε…')
         );
-
-        return $testData;
     }
 
-    public function stringsForCollapseWhitespace()
+    public function collapseWhitespaceProvider()
     {
-        $testData = array(
+        return array(
             array('foo bar', '  foo   bar  '),
             array('test string', 'test string'),
             array('Ο συγγραφέας', '   Ο     συγγραφέας  '),
             array('123', ' 123 '),
+            array('1 2 3', '　　1　　2　　3　　', 'UTF-8'), // ideographic spaces
+            array('', '   ', 'UTF-8'), // thin space and space
             array('', ' '),
             array('', ''),
         );
-
-        return $testData;
     }
 
-    public function stringsForStandardize()
+    public function toAsciiProvider()
     {
-        $testData = array(
+        return array(
             array('foo bar', 'fòô bàř'),
             array(' TEST ', ' ŤÉŚŢ '),
-            array('φ = z = 3', 'φ = ź = 3')
+            array(' = z = 3', 'φ = ź = 3'),
+            array('perevirka', 'перевірка'),
+            array('lysaya gora', 'лысая гора'),
+            array('shchuka', 'щука'),
+            array('', '漢字')
         );
-
-        return $testData;
     }
 
-    public function stringsForPad()
+    public function padProvider()
     {
-        $testData = array(
-            // $length <= $str
+        return array(
+            // length <= str
             array('foo bar', 'foo bar', -1),
             array('foo bar', 'foo bar', 7),
             array('fòô bàř', 'fòô bàř', 7, ' ', 'right', 'UTF-8'),
@@ -202,75 +193,66 @@ class CommonTest extends PHPUnit_Framework_TestCase
             // right
             array('foo bar  ', 'foo bar', 9),
             array('foo bar_*', 'foo bar', 9, '_*', 'right'),
-            array('foo bar_*_', 'foo bar', 10, '_*', 'right'),
-            array('fòô bàř  ', 'fòô bàř', 9, ' ', 'right', 'UTF-8'),
-            array('fòô bàř¬ø', 'fòô bàř', 9, '¬ø', 'right', 'UTF-8'),
             array('fòô bàř¬ø¬', 'fòô bàř', 10, '¬ø', 'right', 'UTF-8'),
-            array('fòô bàř¬ø¬ø', 'fòô bàř', 11, '¬ø', 'right', 'UTF-8'),
 
             // left
             array('  foo bar', 'foo bar', 9, ' ', 'left'),
             array('_*foo bar', 'foo bar', 9, '_*', 'left'),
-            array('_*_foo bar', 'foo bar', 10, '_*', 'left'),
-            array('  fòô bàř', 'fòô bàř', 9, ' ', 'left', 'UTF-8'),
-            array('¬øfòô bàř', 'fòô bàř', 9, '¬ø', 'left', 'UTF-8'),
             array('¬ø¬fòô bàř', 'fòô bàř', 10, '¬ø', 'left', 'UTF-8'),
-            array('¬ø¬øfòô bàř', 'fòô bàř', 11, '¬ø', 'left', 'UTF-8'),
 
             // both
             array('foo bar ', 'foo bar', 8, ' ', 'both'),
-            array(' foo bar ', 'foo bar', 9, ' ', 'both'),
-            array('fòô bàř ', 'fòô bàř', 8, ' ', 'both', 'UTF-8'),
-            array(' fòô bàř ', 'fòô bàř', 9, ' ', 'both', 'UTF-8'),
-            array('fòô bàř¬', 'fòô bàř', 8, '¬ø', 'both', 'UTF-8'),
-            array('¬fòô bàř¬', 'fòô bàř', 9, '¬ø', 'both', 'UTF-8'),
             array('¬fòô bàř¬ø', 'fòô bàř', 10, '¬ø', 'both', 'UTF-8'),
-            array('¬øfòô bàř¬ø', 'fòô bàř', 11, '¬ø', 'both', 'UTF-8'),
-            array('¬fòô bàř¬ø', 'fòô bàř', 10, '¬øÿ', 'both', 'UTF-8'),
-            array('¬øfòô bàř¬ø', 'fòô bàř', 11, '¬øÿ', 'both', 'UTF-8'),
             array('¬øfòô bàř¬øÿ', 'fòô bàř', 12, '¬øÿ', 'both', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForPadLeft()
+    public function padLeftProvider()
     {
-        $testData = array(
+        return array(
             array('  foo bar', 'foo bar', 9),
+            array('_*foo bar', 'foo bar', 9, '_*'),
             array('_*_foo bar', 'foo bar', 10, '_*'),
+            array('  fòô bàř', 'fòô bàř', 9, ' ', 'UTF-8'),
+            array('¬øfòô bàř', 'fòô bàř', 9, '¬ø', 'UTF-8'),
+            array('¬ø¬fòô bàř', 'fòô bàř', 10, '¬ø', 'UTF-8'),
             array('¬ø¬øfòô bàř', 'fòô bàř', 11, '¬ø', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForPadRight()
+    public function padRightProvider()
     {
-        $testData = array(
+        return array(
             array('foo bar  ', 'foo bar', 9),
+            array('foo bar_*', 'foo bar', 9, '_*'),
             array('foo bar_*_', 'foo bar', 10, '_*'),
+            array('fòô bàř  ', 'fòô bàř', 9, ' ', 'UTF-8'),
+            array('fòô bàř¬ø', 'fòô bàř', 9, '¬ø', 'UTF-8'),
+            array('fòô bàř¬ø¬', 'fòô bàř', 10, '¬ø', 'UTF-8'),
             array('fòô bàř¬ø¬ø', 'fòô bàř', 11, '¬ø', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForPadBoth()
+    public function padBothProvider()
     {
-        $testData = array(
+        return array(
             array('foo bar ', 'foo bar', 8),
             array(' foo bar ', 'foo bar', 9, ' '),
+            array('fòô bàř ', 'fòô bàř', 8, ' ', 'UTF-8'),
+            array(' fòô bàř ', 'fòô bàř', 9, ' ', 'UTF-8'),
+            array('fòô bàř¬', 'fòô bàř', 8, '¬ø', 'UTF-8'),
+            array('¬fòô bàř¬', 'fòô bàř', 9, '¬ø', 'UTF-8'),
+            array('¬fòô bàř¬ø', 'fòô bàř', 10, '¬ø', 'UTF-8'),
+            array('¬øfòô bàř¬ø', 'fòô bàř', 11, '¬ø', 'UTF-8'),
             array('¬fòô bàř¬ø', 'fòô bàř', 10, '¬øÿ', 'UTF-8'),
+            array('¬øfòô bàř¬ø', 'fòô bàř', 11, '¬øÿ', 'UTF-8'),
             array('¬øfòô bàř¬øÿ', 'fòô bàř', 12, '¬øÿ', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForStartsWith()
+    public function startsWithProvider()
     {
-        $testData = array(
+        return array(
             array(true, 'foo bars', 'foo bar'),
             array(true, 'FOO bars', 'foo bar', false),
             array(true, 'FOO bars', 'foo BAR', false),
@@ -283,13 +265,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array(false, 'FÒÔ bàřs', 'fòô bàř', true, 'UTF-8'),
             array(false, 'fòô bàřs', 'fòô BÀŘ', true, 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForEndsWith()
+    public function endsWithProvider()
     {
-        $testData = array(
+        return array(
             array(true, 'foo bars', 'o bars'),
             array(true, 'FOO bars', 'o bars', false),
             array(true, 'FOO bars', 'o BARs', false),
@@ -302,13 +282,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array(false, 'FÒÔ bàřs', 'fòô bàřs', true, 'UTF-8'),
             array(false, 'fòô bàřs', 'fòô BÀŘS', true, 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForToSpaces()
+    public function toSpacesProvider()
     {
-        $testData = array(
+        return array(
             array('    foo    bar    ', '	foo	bar	'),
             array('     foo     bar     ', '	foo	bar	', 5),
             array('    foo  bar  ', '		foo	bar	', 2),
@@ -316,72 +294,104 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array("    foo\n    bar", "	foo\n	bar"),
             array("    fòô\n    bàř", "	fòô\n	bàř")
         );
-
-        return $testData;
     }
 
-    public function stringsForToTabs()
+    public function toTabsProvider()
     {
-        $testData = array(
+        return array(
             array('	foo	bar	', '    foo    bar    '),
             array('	foo	bar	', '     foo     bar     ', 5),
             array('		foo	bar	', '    foo  bar  ', 2),
             array("	foo\n	bar", "    foo\n    bar"),
             array("	fòô\n	bàř", "    fòô\n    bàř")
         );
-
-        return $testData;
     }
 
-    public function stringsForSlugify()
+    public function toLowerCaseProvider()
     {
-        $testData = array(
+        return 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'),
+        );
+    }
+
+    public function toUpperCaseProvider()
+    {
+        return 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'),
+        );
+    }
+
+    public function slugifyProvider()
+    {
+        return array(
             array('foo-bar', ' foo  bar '),
+            array('foo-bar', 'foo -.-"-...bar'),
+            array('another-foo-bar', 'another..& foo -.-"-...bar'),
             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('numbers-1234', 'numbers 1234'),
+            array('perevirka-ryadka', 'перевірка рядка'),
+            array('bukvar-s-bukvoy-y', 'букварь с буквой ы'),
+            array('podekhal-k-podezdu-moego-doma', 'подъехал к подъезду моего дома'),
+            array('foo:bar:baz', 'Foo bar baz', ':'),
+            array('a_string_with_underscores', 'A_string with_underscores', '_'),
+            array('a_string_with_dashes', 'A string-with-dashes', '_'),
+            array('a\string\with\dashes', 'A string-with-dashes', '\\'),
+            array('an_odd_string', '--   An odd__   string-_', '_')
         );
-
-        return $testData;
     }
 
-    public function stringsForContains()
+    public function containsProvider()
     {
-        $testData = array(
+        return array(
             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;
     }
 
-    public function stringsForSurround()
+    public function surroundProvider()
     {
-        $testData = array(
+        return array(
             array('__foobar__', 'foobar', '__'),
             array('test', 'test', ''),
             array('**', '', '*'),
             array('¬fòô bàř¬', 'fòô bàř', '¬'),
             array('ßå∆˚ test ßå∆˚', ' test ', 'ßå∆˚')
         );
-
-        return $testData;
     }
 
-    public function stringsForInsert()
+    public function insertProvider()
     {
-        $testData = array(
+        return array(
             array('foo bar', 'oo bar', 'f', 0),
             array('foo bar', 'f bar', 'oo', 1),
             array('f bar', 'f bar', 'oo', 20),
@@ -390,13 +400,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('fòô bàř', 'f bàř', 'òô', 1, 'UTF-8'),
             array('fòô bàř', 'fòô bà', 'ř', 6, 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForTruncate()
+    public function truncateProvider()
     {
-        $testData = array(
+        return array(
             array('Test foo bar', 'Test foo bar', 12),
             array('Test foo ba', 'Test foo bar', 11),
             array('Test foo', 'Test foo bar', 8),
@@ -420,13 +428,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('Teϰϰ', 'Test fòô bàř', 4, 'ϰϰ', 'UTF-8'),
             array('What are your pl...', 'What are your plans today?', 19, '...')
         );
-
-        return $testData;
     }
 
-    public function stringsForSafeTruncate()
+    public function safeTruncateProvider()
     {
-        $testData = array(
+        return array(
             array('Test foo bar', 'Test foo bar', 12),
             array('Test foo', 'Test foo bar', 11),
             array('Test foo', 'Test foo bar', 8),
@@ -450,37 +456,31 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('ϰϰ', 'Test fòô bàř', 4, 'ϰϰ', 'UTF-8'),
             array('What are your plans...', 'What are your plans today?', 22, '...')
         );
-
-        return $testData;
     }
 
-    public function stringsForReverse()
+    public function reverseProvider()
     {
-        $testData = array(
+        return array(
             array('', ''),
             array('raboof', 'foobar'),
             array('řàbôòf', 'fòôbàř', 'UTF-8'),
             array('řàb ôòf', 'fòô bàř', 'UTF-8'),
             array('∂∆ ˚åß', 'ßå˚ ∆∂', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForShuffle()
+    public function shuffleProvider()
     {
-        $testData = array(
+        return array(
             array('foo bar'),
             array('∂∆ ˚åß', 'UTF-8'),
             array('å´¥©¨ˆßå˚ ∆∂˙©å∑¥øœ¬', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForTrim()
+    public function trimProvider()
     {
-        $testData = array(
+        return array(
             array('foo   bar', '  foo   bar  '),
             array('foo bar', ' foo bar'),
             array('foo bar', 'foo bar '),
@@ -490,13 +490,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('fòô bàř', 'fòô bàř '),
             array('fòô bàř', "\n\t fòô bàř \n\t")
         );
-
-        return $testData;
     }
 
-    public function stringsForLongestCommonPrefix()
+    public function longestCommonPrefixProvider()
     {
-        $testData = array(
+        return array(
             array('foo', 'foobar', 'foo bar'),
             array('foo bar', 'foo bar', 'foo bar'),
             array('f', 'foo bar', 'far boo'),
@@ -508,13 +506,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('', 'toy car', 'fòô bar', 'UTF-8'),
             array('', 'fòô bar', '', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForLongestCommonSuffix()
+    public function longestCommonSuffixProvider()
     {
-        $testData = array(
+        return array(
             array('bar', 'foobar', 'foo bar'),
             array('foo bar', 'foo bar', 'foo bar'),
             array('ar', 'foo bar', 'boo far'),
@@ -526,13 +522,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('', 'toy car', 'fòô bàř', 'UTF-8'),
             array('', 'fòô bàř', '', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForLongestCommonSubstring()
+    public function longestCommonSubstringProvider()
     {
-        $testData = array(
+        return array(
             array('foo', 'foobar', 'foo bar'),
             array('foo bar', 'foo bar', 'foo bar'),
             array('oo ', 'foo bar', 'boo far'),
@@ -544,25 +538,21 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array(' ', 'toy car', 'fòô bàř', 'UTF-8'),
             array('', 'fòô bàř', '', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForLength()
+    public function lengthProvider()
     {
-        $testData = array(
+        return array(
             array(11, '  foo bar  '),
             array(1, 'f'),
             array(0, ''),
             array(7, 'fòô bàř', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForSubstr()
+    public function substrProvider()
     {
-        $testData = array(
+        return array(
             array('foo bar', 'foo bar', 0),
             array('bar', 'foo bar', 4),
             array('bar', 'foo bar', 4, null),
@@ -573,13 +563,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('ô b', 'fòô bàř', 2, 3, 'UTF-8'),
             array('', 'fòô bàř', 4, 0, 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForAt()
+    public function atProvider()
     {
-        $testData = array(
+        return array(
             array('f', 'foo bar', 0),
             array('o', 'foo bar', 1),
             array('r', 'foo bar', 6),
@@ -589,13 +577,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('ř', 'fòô bàř', 6, 'UTF-8'),
             array('', 'fòô bàř', 7, 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForFirst()
+    public function firstProvider()
     {
-        $testData = array(
+        return array(
             array('', 'foo bar', -5),
             array('', 'foo bar', 0),
             array('f', 'foo bar', 1),
@@ -609,13 +595,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('fòô bàř', 'fòô bàř', 7, 'UTF-8'),
             array('fòô bàř', 'fòô bàř', 8, 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForLast()
+    public function lastProvider()
     {
-        $testData = array(
+        return array(
             array('', 'foo bar', -5),
             array('', 'foo bar', 0),
             array('r', 'foo bar', 1),
@@ -629,13 +613,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('fòô bàř', 'fòô bàř', 7, 'UTF-8'),
             array('fòô bàř', 'fòô bàř', 8, 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForEnsureLeft()
+    public function ensureLeftProvider()
     {
-        $testData = array(
+        return array(
             array('foobar', 'foobar', 'f'),
             array('foobar', 'foobar', 'foo'),
             array('foo/foobar', 'foobar', 'foo/'),
@@ -647,13 +629,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('http://fòôbàř', 'fòôbàř', 'http://', 'UTF-8'),
             array('http://fòôbàř', 'http://fòôbàř', 'http://', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForEnsureRight()
+    public function ensureRightProvider()
     {
-        $testData = array(
+        return array(
             array('foobar', 'foobar', 'r'),
             array('foobar', 'foobar', 'bar'),
             array('foobar/bar', 'foobar', '/bar'),
@@ -665,13 +645,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('fòôbàř.com/', 'fòôbàř', '.com/', 'UTF-8'),
             array('fòôbàř.com/', 'fòôbàř.com/', '.com/', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForRemoveLeft()
+    public function removeLeftProvider()
     {
-        $testData = array(
+        return array(
             array('foo bar', 'foo bar', ''),
             array('oo bar', 'foo bar', 'f'),
             array('bar', 'foo bar', 'foo '),
@@ -683,13 +661,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('fòô bàř', 'fòô bàř', 'òô', 'UTF-8'),
             array('fòô bàř', 'fòô bàř', 'òô bàř', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForRemoveRight()
+    public function removeRightProvider()
     {
-        $testData = array(
+        return array(
             array('foo bar', 'foo bar', ''),
             array('foo ba', 'foo bar', 'r'),
             array('foo', 'foo bar', ' bar'),
@@ -701,13 +677,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array('fòô bàř', 'fòô bàř', 'bà', 'UTF-8'),
             array('fòô bàř', 'fòô bàř', 'fòô bà', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForIsAlpha()
+    public function isAlphaProvider()
     {
-        $testData = array(
+        return array(
             array(true, ''),
             array(true, 'foobar'),
             array(false, 'foo bar'),
@@ -719,13 +693,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array(false, 'ҠѨњ¨ˆфгШ', 'UTF-8'),
             array(true, '丹尼爾', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForIsAlphanumeric()
+    public function isAlphanumericProvider()
     {
-        $testData = array(
+        return array(
             array(true, ''),
             array(true, 'foobar1'),
             array(false, 'foo bar'),
@@ -740,13 +712,11 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array(true, 'دانيال1', 'UTF-8'),
             array(false, 'دانيال1 ', 'UTF-8')
         );
-
-        return $testData;
     }
 
-    public function stringsForIsBlank()
+    public function isBlankProvider()
     {
-        $testData = array(
+        return array(
             array(true, ''),
             array(true, ' '),
             array(true, "\n\t "),
@@ -760,13 +730,31 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array(false, '　z', 'UTF-8'),
             array(false, '　1', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForIsLowerCase()
+    public function isJsonProvider()
     {
-        $testData = array(
+        return array(
+            array(true, ''),
+            array(true, '123'),
+            array(true, '{"foo": "bar"}'),
+            array(false, '{"foo":"bar",}'),
+            array(false, '{"foo"}'),
+            array(true, '["foo"]'),
+            array(false, '{"foo": "bar"]'),
+            array(true, '123', 'UTF-8'),
+            array(true, '{"fòô": "bàř"}', 'UTF-8'),
+            array(false, '{"fòô":"bàř",}', 'UTF-8'),
+            array(false, '{"fòô"}', 'UTF-8'),
+            array(false, '["fòô": "bàř"]', 'UTF-8'),
+            array(true, '["fòô"]', 'UTF-8'),
+            array(false, '{"fòô": "bàř"]', 'UTF-8'),
+        );
+    }
+
+    public function isLowerCaseProvider()
+    {
+        return array(
             array(true, ''),
             array(true, 'foobar'),
             array(false, 'foo bar'),
@@ -776,13 +764,24 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array(false, 'fòô bàř', 'UTF-8'),
             array(false, 'fòôbÀŘ', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForIsUpperCase()
+    public function isSerializedProvider()
     {
-        $testData = array(
+        return array(
+            array(false, ''),
+            array(true, 'a:1:{s:3:"foo";s:3:"bar";}'),
+            array(false, 'a:1:{s:3:"foo";s:3:"bar"}'),
+            array(true, serialize(array('foo' => 'bar'))),
+            array(true, 'a:1:{s:5:"fòô";s:5:"bàř";}', 'UTF-8'),
+            array(false, 'a:1:{s:5:"fòô";s:5:"bàř"}', 'UTF-8'),
+            array(true, serialize(array('fòô' => 'bár')), 'UTF-8'),
+        );
+    }
+
+    public function isUpperCaseProvider()
+    {
+        return array(
             array(true, ''),
             array(true, 'FOOBAR'),
             array(false, 'FOO BAR'),
@@ -792,13 +791,30 @@ class CommonTest extends PHPUnit_Framework_TestCase
             array(false, 'FÒÔ BÀŘ', 'UTF-8'),
             array(false, 'FÒÔBàř', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    public function stringsForCount()
+    public function isHexadecimalProvider()
     {
-        $testData = array(
+        return array(
+            array(true, ''),
+            array(true, 'abcdef'),
+            array(true, 'ABCDEF'),
+            array(true, '0123456789'),
+            array(true, '0123456789AbCdEf'),
+            array(false, '0123456789x'),
+            array(false, 'ABCDEFx'),
+            array(true, 'abcdef', 'UTF-8'),
+            array(true, 'ABCDEF', 'UTF-8'),
+            array(true, '0123456789', 'UTF-8'),
+            array(true, '0123456789AbCdEf', 'UTF-8'),
+            array(false, '0123456789x', 'UTF-8'),
+            array(false, 'ABCDEFx', 'UTF-8'),
+        );
+    }
+
+    public function countSubstrProvider()
+    {
+        return array(
             array(0, '', 'foo'),
             array(0, 'foo', 'bar'),
             array(1, 'foo bar', 'foo'),
@@ -806,35 +822,50 @@ 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;
     }
 
-    public function stringsForReplace()
+    public function replaceProvider()
     {
-        $testData = array(
+        return array(
             array('', '', '', ''),
             array('foo', '', '', 'foo'),
+            array('foo', '\s', '\s', 'foo'),
             array('foo bar', 'foo bar', '', ''),
+            array('foo bar', 'foo bar', 'f(o)o', '\1'),
+            array('\1 bar', 'foo bar', 'foo', '\1'),
             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'),
             array('bàř bàř', 'fòô bàř fòô bàř', 'fòô ', '', 'UTF-8'),
         );
-
-        return $testData;
     }
 
-    // A test is required so as not to throw an error
-    // This is a lot cleaner than using PHPUnit's mocks to spy
-    public function test() {
-        $this->assertTrue(true);
+    public function regexReplaceProvider()
+    {
+        return array(
+            array('', '', '', ''),
+            array('bar', 'foo', 'f[o]+', 'bar'),
+            array('o bar', 'foo bar', 'f(o)o', '\1'),
+            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')
+        );
     }
 }

tests/StaticStringyTest.php

@@ -1,457 +1,598 @@
 <?php
 
-$base = realpath(dirname(__FILE__) . '/../..');
-require("$base/src/Stringy/StaticStringy.php");
+require __DIR__ . '/../src/StaticStringy.php';
 
 use Stringy\StaticStringy as S;
 
 class StaticStringyTestCase extends CommonTest
 {
     /**
-     * @dataProvider stringsForUpperCaseFirst
+     * @dataProvider charsProvider()
+     */
+    public function testChars($expected, $str, $encoding = null)
+    {
+        $result = S::chars($str, $encoding);
+        $this->assertInternalType('array', $result);
+        foreach ($result as $char) {
+            $this->assertInternalType('string', $char);
+        }
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider upperCaseFirstProvider()
      */
     public function testUpperCaseFirst($expected, $str, $encoding = null)
     {
         $result = S::upperCaseFirst($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForLowerCaseFirst
+     * @dataProvider lowerCaseFirstProvider()
      */
     public function testLowerCaseFirst($expected, $str, $encoding = null)
     {
         $result = S::lowerCaseFirst($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForCamelize
+     * @dataProvider camelizeProvider()
      */
     public function testCamelize($expected, $str, $encoding = null)
     {
         $result = S::camelize($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForUpperCamelize
+     * @dataProvider upperCamelizeProvider()
      */
     public function testUpperCamelize($expected, $str, $encoding = null)
     {
         $result = S::upperCamelize($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForDasherize
+     * @dataProvider dasherizeProvider()
      */
     public function testDasherize($expected, $str, $encoding = null)
     {
         $result = S::dasherize($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForUnderscored
+     * @dataProvider underscoredProvider()
      */
     public function testUnderscored($expected, $str, $encoding = null)
     {
         $result = S::underscored($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForSwapCase
+     * @dataProvider swapCaseProvider()
      */
     public function testSwapCase($expected, $str, $encoding = null)
     {
         $result = S::swapCase($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForTitleize
+     * @dataProvider titleizeProvider()
      */
     public function testTitleize($expected, $str, $ignore = null,
                                  $encoding = null)
     {
         $result = S::titleize($str, $ignore, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForHumanize
+     * @dataProvider humanizeProvider()
      */
     public function testHumanize($expected, $str, $encoding = null)
     {
         $result = S::humanize($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForTidy
+     * @dataProvider tidyProvider()
      */
     public function testTidy($expected, $str)
     {
         $result = S::tidy($str);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForCollapseWhitespace
+     * @dataProvider collapseWhitespaceProvider()
      */
-    public function testCollapseWhitespace($expected, $str)
+    public function testCollapseWhitespace($expected, $str, $encoding = null)
     {
-        $result = S::collapseWhitespace($str);
+        $result = S::collapseWhitespace($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForStandardize
+     * @dataProvider toAsciiProvider()
      */
-    public function testStandardize($expected, $str)
+    public function testToAscii($expected, $str)
     {
-        $result = S::standardize($str);
+        $result = S::toAscii($str);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForPad
+     * @dataProvider padProvider()
      */
     public function testPad($expected, $str, $length, $padStr = ' ',
                             $padType = 'right', $encoding = null)
     {
         $result = S::pad($str, $length, $padStr, $padType, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForPadLeft
+     * @expectedException \InvalidArgumentException
+     */
+    public function testPadException()
+    {
+        $result = S::pad('string', 5, 'foo', 'bar');
+    }
+
+    /**
+     * @dataProvider padLeftProvider()
      */
     public function testPadLeft($expected, $str, $length, $padStr = ' ',
                                 $encoding = null)
     {
         $result = S::padLeft($str, $length, $padStr, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForPadRight
+     * @dataProvider padRightProvider()
      */
     public function testPadRight($expected, $str, $length, $padStr = ' ',
                                  $encoding = null)
     {
         $result = S::padRight($str, $length, $padStr, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForPadBoth
+     * @dataProvider padBothProvider()
      */
     public function testPadBoth($expected, $str, $length, $padStr = ' ',
                                 $encoding = null)
     {
         $result = S::padBoth($str, $length, $padStr, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForStartsWith
+     * @dataProvider startsWithProvider()
      */
     public function testStartsWith($expected, $str, $substring,
-                                $caseSensitive = true, $encoding = null)
+                                   $caseSensitive = true, $encoding = null)
     {
         $result = S::startsWith($str, $substring, $caseSensitive, $encoding);
+        $this->assertInternalType('boolean', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForEndsWith
+     * @dataProvider endsWithProvider()
      */
     public function testEndsWith($expected, $str, $substring,
-                                $caseSensitive = true, $encoding = null)
+                                 $caseSensitive = true, $encoding = null)
     {
         $result = S::endsWith($str, $substring, $caseSensitive, $encoding);
+        $this->assertInternalType('boolean', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForToSpaces
+     * @dataProvider toSpacesProvider()
      */
     public function testToSpaces($expected, $str, $tabLength = 4)
     {
         $result = S::toSpaces($str, $tabLength);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForToTabs
+     * @dataProvider toTabsProvider()
      */
     public function testToTabs($expected, $str, $tabLength = 4)
     {
         $result = S::toTabs($str, $tabLength);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForSlugify
+     * @dataProvider toLowerCaseProvider()
      */
-    public function testSlugify($expected, $str)
+    public function testToLowerCase($expected, $str, $encoding = null)
     {
-        $result = S::slugify($str);
+        $result = S::toLowerCase($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForContains
+     * @dataProvider toUpperCaseProvider()
      */
-    public function testContains($expected, $haystack, $needle, $encoding = null)
+    public function testToUpperCase($expected, $str, $encoding = null)
     {
-        $result = S::contains($haystack, $needle, $encoding);
+        $result = S::toUpperCase($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForSurround
+     * @dataProvider slugifyProvider()
+     */
+    public function testSlugify($expected, $str, $replacement = '-')
+    {
+        $result = S::slugify($str, $replacement);
+        $this->assertInternalType('string', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider containsProvider()
+     */
+    public function testContains($expected, $haystack, $needle,
+                                 $caseSensitive = true, $encoding = null)
+    {
+        $result = S::contains($haystack, $needle, $caseSensitive, $encoding);
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider surroundProvider()
      */
     public function testSurround($expected, $str, $substring)
     {
         $result = S::surround($str, $substring);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForInsert
+     * @dataProvider insertProvider()
      */
     public function testInsert($expected, $str, $substring, $index,
                                $encoding = null)
     {
         $result = S::insert($str, $substring, $index, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForTruncate
+     * @dataProvider truncateProvider()
      */
     public function testTruncate($expected, $str, $length, $substring = '',
                                  $encoding = null)
     {
         $result = S::truncate($str, $length, $substring, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForSafeTruncate
+     * @dataProvider safeTruncateProvider()
      */
     public function testSafeTruncate($expected, $str, $length, $substring = '',
                                      $encoding = null)
     {
         $result = S::safeTruncate($str, $length, $substring, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForReverse
+     * @dataProvider reverseProvider()
      */
     public function testReverse($expected, $str, $encoding = null)
     {
         $result = S::reverse($str, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForShuffle
+     * @dataProvider shuffleProvider()
      */
     public function testShuffle($str, $encoding = null)
     {
-        // We'll just make sure that the chars are present before/after shuffle
         $result = S::shuffle($str, $encoding);
-        $this->assertEquals(count_chars($str), count_chars($result));
+        $encoding = $encoding ?: mb_internal_encoding();
+
+        $this->assertInternalType('string', $result);
+        $this->assertEquals(mb_strlen($str, $encoding),
+            mb_strlen($result, $encoding));
+
+        // We'll make sure that the chars are present after shuffle
+        for ($i = 0; $i < mb_strlen($str, $encoding); $i++) {
+            $char = mb_substr($str, $i, 1, $encoding);
+            $countBefore = mb_substr_count($str, $char, $encoding);
+            $countAfter = mb_substr_count($result, $char, $encoding);
+            $this->assertEquals($countBefore, $countAfter);
+        }
     }
 
     /**
-     * @dataProvider stringsForTrim
+     * @dataProvider trimProvider()
      */
     public function testTrim($expected, $str)
     {
         $result = S::trim($str);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForLongestCommonPrefix
+     * @dataProvider longestCommonPrefixProvider()
      */
     public function testLongestCommonPrefix($expected, $str, $otherStr,
                                             $encoding = null)
     {
         $result = S::longestCommonPrefix($str, $otherStr, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForLongestCommonSuffix
+     * @dataProvider longestCommonSuffixProvider()
      */
     public function testLongestCommonSuffix($expected, $str, $otherStr,
                                             $encoding = null)
     {
         $result = S::longestCommonSuffix($str, $otherStr, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForLongestCommonSubstring
+     * @dataProvider longestCommonSubstringProvider()
      */
     public function testLongestCommonSubstring($expected, $str, $otherStr,
                                                $encoding = null)
     {
         $result = S::longestCommonSubstring($str, $otherStr, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForLength
+     * @dataProvider lengthProvider()
      */
     public function testLength($expected, $str, $encoding = null)
     {
         $result = S::length($str, $encoding);
         $this->assertEquals($expected, $result);
+        $this->assertInternalType('int', $result);
     }
 
     /**
-     * @dataProvider stringsForSubstr
+     * @dataProvider substrProvider()
      */
     public function testSubstr($expected, $str, $start, $length = null,
                                $encoding = null)
     {
         $result = S::substr($str, $start, $length, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForAt
+     * @dataProvider atProvider()
      */
     public function testAt($expected, $str, $index, $encoding = null)
     {
         $result = S::at($str, $index, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForFirst
+     * @dataProvider firstProvider()
      */
     public function testFirst($expected, $str, $n, $encoding = null)
     {
         $result = S::first($str, $n, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForLast
+     * @dataProvider lastProvider()
      */
     public function testLast($expected, $str, $n, $encoding = null)
     {
         $result = S::last($str, $n, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForEnsureLeft
+     * @dataProvider ensureLeftProvider()
      */
     public function testEnsureLeft($expected, $str, $substring, $encoding = null)
     {
         $result = S::ensureLeft($str, $substring, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForEnsureRight
+     * @dataProvider ensureRightProvider()
      */
     public function testEnsureRight($expected, $str, $substring, $encoding = null)
     {
         $result = S::ensureRight($str, $substring, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForRemoveLeft
+     * @dataProvider removeLeftProvider()
      */
     public function testRemoveLeft($expected, $str, $substring, $encoding = null)
     {
         $result = S::removeLeft($str, $substring, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForRemoveRight
+     * @dataProvider removeRightProvider()
      */
     public function testRemoveRight($expected, $str, $substring, $encoding = null)
     {
         $result = S::removeRight($str, $substring, $encoding);
+        $this->assertInternalType('string', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForIsAlpha
+     * @dataProvider isAlphaProvider()
      */
     public function testIsAlpha($expected, $str, $encoding = null)
     {
         $result = S::isAlpha($str, $encoding);
+        $this->assertInternalType('boolean', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForIsAlphanumeric
+     * @dataProvider isAlphanumericProvider()
      */
     public function testIsAlphanumeric($expected, $str, $encoding = null)
     {
         $result = S::isAlphanumeric($str, $encoding);
+        $this->assertInternalType('boolean', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForIsBlank
+     * @dataProvider isBlankProvider()
      */
     public function testIsBlank($expected, $str, $encoding = null)
     {
         $result = S::isBlank($str, $encoding);
+        $this->assertInternalType('boolean', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForIsLowerCase
+     * @dataProvider isJsonProvider()
+     */
+    public function testIsJson($expected, $str, $encoding = null)
+    {
+        $result = S::isJson($str, $encoding);
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider isLowerCaseProvider()
      */
     public function testIsLowerCase($expected, $str, $encoding = null)
     {
         $result = S::isLowerCase($str, $encoding);
+        $this->assertInternalType('boolean', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForIsUpperCase
+     * @dataProvider isSerializedProvider()
+     */
+    public function testIsSerialized($expected, $str, $encoding = null)
+    {
+        $result = S::isSerialized($str, $encoding);
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider isUpperCaseProvider()
      */
     public function testIsUpperCase($expected, $str, $encoding = null)
     {
         $result = S::isUpperCase($str, $encoding);
+        $this->assertInternalType('boolean', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForCount
+     * @dataProvider isHexadecimalProvider()
      */
-    public function testCount($expected, $str, $substring, $encoding = null)
+    public function testIsHexadecimal($expected, $str, $encoding = null)
     {
-        $result = S::count($str, $substring, $encoding);
+        $result = S::isHexadecimal($str, $encoding);
+        $this->assertInternalType('boolean', $result);
         $this->assertEquals($expected, $result);
     }
 
     /**
-     * @dataProvider stringsForReplace
+     * @dataProvider countSubstrProvider()
      */
-    public function testReplace($expected, $str, $search, $replace,
+    public function testCountSubstr($expected, $str, $substring,
+                                    $caseSensitive = true, $encoding = null)
+    {
+        $result = S::countSubstr($str, $substring, $caseSensitive, $encoding);
+        $this->assertInternalType('int', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider replaceProvider()
+     */
+    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 regexReplaceProvider()
+     */
+    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

@@ -1,527 +0,0 @@
-<?php
-
-$base = realpath(dirname(__FILE__) . '/../..');
-require("$base/src/Stringy/Stringy.php");
-
-use Stringy\Stringy as S;
-
-class StringyTestCase extends CommonTest
-{
-    /**
-     * @dataProvider stringsForUpperCaseFirst
-     */
-    public function testUpperCaseFirst($expected, $str, $encoding = null)
-    {
-        $result = S::create($str, $encoding)->upperCaseFirst();
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider stringsForLowerCaseFirst
-     */
-    public function testLowerCaseFirst($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->lowerCaseFirst();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForCamelize
-     */
-    public function testCamelize($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->camelize();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForUpperCamelize
-     */
-    public function testUpperCamelize($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->upperCamelize();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForDasherize
-     */
-    public function testDasherize($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->dasherize();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForUnderscored
-     */
-    public function testUnderscored($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->underscored();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForSwapCase
-     */
-    public function testSwapCase($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->swapCase();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForTitleize
-     */
-    public function testTitleize($expected, $str, $ignore = null,
-                                 $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->titleize($ignore);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForHumanize
-     */
-    public function testHumanize($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->humanize();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForTidy
-     */
-    public function testTidy($expected, $str)
-    {
-        $stringy = S::create($str);
-        $result = $stringy->tidy();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForCollapseWhitespace
-     */
-    public function testCollapseWhitespace($expected, $str)
-    {
-        $stringy = S::create($str);
-        $result = $stringy->collapseWhitespace();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForStandardize
-     */
-    public function testStandardize($expected, $str)
-    {
-        $stringy = S::create($str);
-        $result = $stringy->standardize();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForPad
-     */
-    public function testPad($expected, $str, $length, $padStr = ' ',
-                            $padType = 'right', $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->pad($length, $padStr, $padType);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForPadLeft
-     */
-    public function testPadLeft($expected, $str, $length, $padStr = ' ',
-                                $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->padLeft($length, $padStr);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForPadRight
-     */
-    public function testPadRight($expected, $str, $length, $padStr = ' ',
-                                 $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->padRight($length, $padStr);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForPadBoth
-     */
-    public function testPadBoth($expected, $str, $length, $padStr = ' ',
-                                $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->padBoth($length, $padStr);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForStartsWith
-     */
-    public function testStartsWith($expected, $str, $substring,
-                                $caseSensitive = true, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->startsWith($substring, $caseSensitive);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForEndsWith
-     */
-    public function testEndsWith($expected, $str, $substring,
-                                $caseSensitive = true, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->endsWith($substring, $caseSensitive);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForToSpaces
-     */
-    public function testToSpaces($expected, $str, $tabLength = 4)
-    {
-        $stringy = S::create($str);
-        $result = $stringy->toSpaces($tabLength);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForToTabs
-     */
-    public function testToTabs($expected, $str, $tabLength = 4)
-    {
-        $stringy = S::create($str);
-        $result = $stringy->toTabs($tabLength);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForSlugify
-     */
-    public function testSlugify($expected, $str)
-    {
-        $stringy = S::create($str);
-        $result = $stringy->slugify();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForContains
-     */
-    public function testContains($expected, $haystack, $needle, $encoding = null)
-    {
-        $stringy = S::create($haystack, $encoding);
-        $result = $stringy->contains($needle);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($haystack, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForSurround
-     */
-    public function testSurround($expected, $str, $substring)
-    {
-        $stringy = S::create($str);
-        $result = $stringy->surround($substring);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForInsert
-     */
-    public function testInsert($expected, $str, $substring, $index,
-                               $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->insert($substring, $index);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForTruncate
-     */
-    public function testTruncate($expected, $str, $length, $substring = '',
-                                 $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->truncate($length, $substring);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForReverse
-     */
-    public function testReverse($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->reverse();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForShuffle
-     */
-    public function testShuffle($str, $encoding = null)
-    {
-        // We'll just make sure that the chars are present before/after shuffle
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->shuffle();
-        $this->assertEquals(count_chars($str), count_chars($result));
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForTrim
-     */
-    public function testTrim($expected, $str)
-    {
-        $stringy = S::create($str);
-        $result = $stringy->trim();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForLongestCommonPrefix
-     */
-    public function testLongestCommonPrefix($expected, $str, $otherStr,
-                                            $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->longestCommonPrefix($otherStr);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForLongestCommonSubstring
-     */
-    public function testLongestCommonSubstring($expected, $str, $otherStr,
-                                               $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->longestCommonSubstring($otherStr);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForLength
-     */
-    public function testLength($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->length();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForSubstr
-     */
-    public function testSubstr($expected, $str, $start, $length = null,
-                               $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->substr($start, $length);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForAt
-     */
-    public function testAt($expected, $str, $index, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->at($index);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForFirst
-     */
-    public function testFirst($expected, $str, $n, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->first($n);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForLast
-     */
-    public function testLast($expected, $str, $n, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->last($n);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForEnsureLeft
-     */
-    public function testEnsureLeft($expected, $str, $substring, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->ensureLeft($substring);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForEnsureRight
-     */
-    public function testEnsureRight($expected, $str, $substring, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->ensureRight($substring);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForRemoveLeft
-     */
-    public function testRemoveLeft($expected, $str, $substring, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->removeLeft($substring);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForRemoveRight
-     */
-    public function testRemoveRight($expected, $str, $substring, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->removeRight($substring);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForIsAlpha
-     */
-    public function testIsAlpha($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->isAlpha();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForIsAlphanumeric
-     */
-    public function testIsAlphanumeric($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->isAlphanumeric();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForIsBlank
-     */
-    public function testIsBlank($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->isBlank();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForIsLowerCase
-     */
-    public function testIsLowerCase($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->isLowerCase();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForIsUpperCase
-     */
-    public function testIsUpperCase($expected, $str, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->isUpperCase();
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForCount
-     */
-    public function testCount($expected, $str, $substring, $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->count($substring);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-
-    /**
-     * @dataProvider stringsForReplace
-     */
-    public function testReplace($expected, $str, $search, $replace,
-                                $encoding = null)
-    {
-        $stringy = S::create($str, $encoding);
-        $result = $stringy->replace($search, $replace);
-        $this->assertEquals($expected, $result);
-        $this->assertEquals($str, $stringy);
-    }
-}

tests/StringyTest.php

@@ -0,0 +1,826 @@
+<?php
+
+require __DIR__ . '/../src/Stringy.php';
+
+use Stringy\Stringy as S;
+
+class StringyTestCase extends CommonTest
+{
+    public function testConstruct()
+    {
+        $stringy = new S('foo bar', 'UTF-8');
+        $this->assertInstanceOf('Stringy\Stringy', $stringy);
+        $this->assertEquals('foo bar', (string) $stringy);
+        $this->assertEquals('UTF-8', $stringy->getEncoding());
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testConstructWithArray()
+    {
+        (string) new S(array());
+        $this->fail('Expecting exception when the constructor is passed an array');
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testMissingToString()
+    {
+        (string) new S(new stdClass());
+        $this->fail('Expecting exception when the constructor is passed an ' .
+                    'object without a __toString method');
+    }
+
+    /**
+     * @dataProvider toStringProvider()
+     */
+    public function testToString($expected, $str)
+    {
+        $this->assertEquals($expected, (string) new S($str));
+    }
+
+    public function toStringProvider()
+    {
+        return array(
+            array('', null),
+            array('', false),
+            array('1', true),
+            array('-9', -9),
+            array('1.18', 1.18),
+            array(' string  ', ' string  ')
+        );
+    }
+
+    public function testCreate()
+    {
+        $stringy = S::create('foo bar', 'UTF-8');
+        $this->assertInstanceOf('Stringy\Stringy', $stringy);
+        $this->assertEquals('foo bar', (string) $stringy);
+        $this->assertEquals('UTF-8', $stringy->getEncoding());
+    }
+
+    public function testChaining()
+    {
+        $stringy = S::create("Fòô     Bàř", 'UTF-8');
+        $this->assertInstanceOf('Stringy\Stringy', $stringy);
+        $result = $stringy->collapseWhitespace()->swapCase()->upperCaseFirst();
+        $this->assertEquals('FÒÔ bÀŘ', $result);
+    }
+
+    public function testCount()
+    {
+        $stringy = S::create('Fòô', 'UTF-8');
+        $this->assertEquals(3, $stringy->count());
+        $this->assertEquals(3, count($stringy));
+    }
+
+    public function testGetIterator()
+    {
+        $stringy = S::create('Fòô Bàř', 'UTF-8');
+
+        $valResult = array();
+        foreach ($stringy as $char) {
+            $valResult[] = $char;
+        }
+
+        $keyValResult = array();
+        foreach ($stringy as $pos => $char) {
+            $keyValResult[$pos] = $char;
+        }
+
+        $this->assertEquals(array('F', 'ò', 'ô', ' ', 'B', 'à', 'ř'), $valResult);
+        $this->assertEquals(array('F', 'ò', 'ô', ' ', 'B', 'à', 'ř'), $keyValResult);
+    }
+
+    /**
+     * @dataProvider offsetExistsProvider()
+     */
+    public function testOffsetExists($expected, $offset)
+    {
+        $stringy = S::create('fòô', 'UTF-8');
+        $this->assertEquals($expected, $stringy->offsetExists($offset));
+        $this->assertEquals($expected, isset($stringy[$offset]));
+    }
+
+    public function offsetExistsProvider()
+    {
+        return array(
+            array(true, 0),
+            array(true, 2),
+            array(false, 3),
+            array(true, -1),
+            array(true, -3),
+            array(false, -4)
+        );
+    }
+
+    public function testOffsetGet()
+    {
+        $stringy = S::create('fòô', 'UTF-8');
+
+        $this->assertEquals('f', $stringy->offsetGet(0));
+        $this->assertEquals('ô', $stringy->offsetGet(2));
+
+        $this->assertEquals('ô', $stringy[2]);
+    }
+
+    /**
+     * @expectedException \OutOfBoundsException
+     */
+    public function testOffsetGetOutOfBounds()
+    {
+        $stringy = S::create('fòô', 'UTF-8');
+        $test = $stringy[3];
+    }
+
+    /**
+     * @expectedException \Exception
+     */
+    public function testOffsetSet()
+    {
+        $stringy = S::create('fòô', 'UTF-8');
+        $stringy[1] = 'invalid';
+    }
+
+    /**
+     * @expectedException \Exception
+     */
+    public function testOffsetUnset()
+    {
+        $stringy = S::create('fòô', 'UTF-8');
+        unset($stringy[1]);
+    }
+
+    /**
+     * @dataProvider charsProvider()
+     */
+    public function testChars($expected, $str, $encoding = null)
+    {
+        $result = S::create($str, $encoding)->chars();
+        $this->assertInternalType('array', $result);
+        foreach ($result as $char) {
+            $this->assertInternalType('string', $char);
+        }
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider upperCaseFirstProvider()
+     */
+    public function testUpperCaseFirst($expected, $str, $encoding = null)
+    {
+        $result = S::create($str, $encoding)->upperCaseFirst();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @dataProvider lowerCaseFirstProvider()
+     */
+    public function testLowerCaseFirst($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->lowerCaseFirst();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider camelizeProvider()
+     */
+    public function testCamelize($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->camelize();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider upperCamelizeProvider()
+     */
+    public function testUpperCamelize($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->upperCamelize();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider dasherizeProvider()
+     */
+    public function testDasherize($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->dasherize();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider underscoredProvider()
+     */
+    public function testUnderscored($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->underscored();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider swapCaseProvider()
+     */
+    public function testSwapCase($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->swapCase();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider titleizeProvider()
+     */
+    public function testTitleize($expected, $str, $ignore = null,
+                                 $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->titleize($ignore);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider humanizeProvider()
+     */
+    public function testHumanize($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->humanize();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider tidyProvider()
+     */
+    public function testTidy($expected, $str)
+    {
+        $stringy = S::create($str);
+        $result = $stringy->tidy();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider collapseWhitespaceProvider()
+     */
+    public function testCollapseWhitespace($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->collapseWhitespace();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider toAsciiProvider()
+     */
+    public function testToAscii($expected, $str)
+    {
+        $stringy = S::create($str);
+        $result = $stringy->toAscii();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider padProvider()
+     */
+    public function testPad($expected, $str, $length, $padStr = ' ',
+                            $padType = 'right', $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->pad($length, $padStr, $padType);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testPadException()
+    {
+        $stringy = S::create('foo');
+        $result = $stringy->pad(5, 'foo', 'bar');
+    }
+
+    /**
+     * @dataProvider padLeftProvider()
+     */
+    public function testPadLeft($expected, $str, $length, $padStr = ' ',
+                                $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->padLeft($length, $padStr);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider padRightProvider()
+     */
+    public function testPadRight($expected, $str, $length, $padStr = ' ',
+                                 $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->padRight($length, $padStr);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider padBothProvider()
+     */
+    public function testPadBoth($expected, $str, $length, $padStr = ' ',
+                                $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->padBoth($length, $padStr);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider startsWithProvider()
+     */
+    public function testStartsWith($expected, $str, $substring,
+                                   $caseSensitive = true, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->startsWith($substring, $caseSensitive);
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider endsWithProvider()
+     */
+    public function testEndsWith($expected, $str, $substring,
+                                 $caseSensitive = true, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->endsWith($substring, $caseSensitive);
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider toSpacesProvider()
+     */
+    public function testToSpaces($expected, $str, $tabLength = 4)
+    {
+        $stringy = S::create($str);
+        $result = $stringy->toSpaces($tabLength);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider toTabsProvider()
+     */
+    public function testToTabs($expected, $str, $tabLength = 4)
+    {
+        $stringy = S::create($str);
+        $result = $stringy->toTabs($tabLength);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider toLowerCaseProvider()
+     */
+    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 toUpperCaseProvider()
+     */
+    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 slugifyProvider()
+     */
+    public function testSlugify($expected, $str, $replacement = '-')
+    {
+        $stringy = S::create($str);
+        $result = $stringy->slugify($replacement);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider containsProvider()
+     */
+    public function testContains($expected, $haystack, $needle,
+                                 $caseSensitive = true, $encoding = null)
+    {
+        $stringy = S::create($haystack, $encoding);
+        $result = $stringy->contains($needle, $caseSensitive);
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($haystack, $stringy);
+    }
+
+    /**
+     * @dataProvider surroundProvider()
+     */
+    public function testSurround($expected, $str, $substring)
+    {
+        $stringy = S::create($str);
+        $result = $stringy->surround($substring);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider insertProvider()
+     */
+    public function testInsert($expected, $str, $substring, $index,
+                               $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->insert($substring, $index);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider truncateProvider()
+     */
+    public function testTruncate($expected, $str, $length, $substring = '',
+                                 $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->truncate($length, $substring);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider reverseProvider()
+     */
+    public function testReverse($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->reverse();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider shuffleProvider()
+     */
+    public function testShuffle($str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $encoding = $encoding ?: mb_internal_encoding();
+        $result = $stringy->shuffle();
+
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($str, $stringy);
+        $this->assertEquals(mb_strlen($str, $encoding),
+            mb_strlen($result, $encoding));
+
+        // We'll make sure that the chars are present after shuffle
+        for ($i = 0; $i < mb_strlen($str, $encoding); $i++) {
+            $char = mb_substr($str, $i, 1, $encoding);
+            $countBefore = mb_substr_count($str, $char, $encoding);
+            $countAfter = mb_substr_count($result, $char, $encoding);
+            $this->assertEquals($countBefore, $countAfter);
+        }
+    }
+
+    /**
+     * @dataProvider trimProvider()
+     */
+    public function testTrim($expected, $str)
+    {
+        $stringy = S::create($str);
+        $result = $stringy->trim();
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider longestCommonPrefixProvider()
+     */
+    public function testLongestCommonPrefix($expected, $str, $otherStr,
+                                            $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->longestCommonPrefix($otherStr);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider longestCommonSubstringProvider()
+     */
+    public function testLongestCommonSubstring($expected, $str, $otherStr,
+                                               $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->longestCommonSubstring($otherStr);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider lengthProvider()
+     */
+    public function testLength($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->length();
+        $this->assertInternalType('int', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider substrProvider()
+     */
+    public function testSubstr($expected, $str, $start, $length = null,
+                               $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->substr($start, $length);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider atProvider()
+     */
+    public function testAt($expected, $str, $index, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->at($index);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider firstProvider()
+     */
+    public function testFirst($expected, $str, $n, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->first($n);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider lastProvider()
+     */
+    public function testLast($expected, $str, $n, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->last($n);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider ensureLeftProvider()
+     */
+    public function testEnsureLeft($expected, $str, $substring, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->ensureLeft($substring);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider ensureRightProvider()
+     */
+    public function testEnsureRight($expected, $str, $substring, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->ensureRight($substring);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider removeLeftProvider()
+     */
+    public function testRemoveLeft($expected, $str, $substring, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->removeLeft($substring);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider removeRightProvider()
+     */
+    public function testRemoveRight($expected, $str, $substring, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->removeRight($substring);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider isAlphaProvider()
+     */
+    public function testIsAlpha($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->isAlpha();
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider isAlphanumericProvider()
+     */
+    public function testIsAlphanumeric($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->isAlphanumeric();
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider isBlankProvider()
+     */
+    public function testIsBlank($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->isBlank();
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider isJsonProvider()
+     */
+    public function testIsJson($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->isJson();
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider isLowerCaseProvider()
+     */
+    public function testIsLowerCase($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->isLowerCase();
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider isSerializedProvider()
+     */
+    public function testIsSerialized($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->isSerialized();
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider isUpperCaseProvider()
+     */
+    public function testIsUpperCase($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->isUpperCase();
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider isHexadecimalProvider()
+     */
+    public function testIsHexadecimal($expected, $str, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->isHexadecimal();
+        $this->assertInternalType('boolean', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider countSubstrProvider()
+     */
+    public function testCountSubstr($expected, $str, $substring,
+                                    $caseSensitive = true, $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->countSubstr($substring, $caseSensitive);
+        $this->assertInternalType('int', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider replaceProvider()
+     */
+    public function testReplace($expected, $str, $search, $replacement,
+                                $encoding = null)
+    {
+        $stringy = S::create($str, $encoding);
+        $result = $stringy->replace($search, $replacement);
+        $this->assertInstanceOf('Stringy\Stringy', $result);
+        $this->assertEquals($expected, $result);
+        $this->assertEquals($str, $stringy);
+    }
+
+    /**
+     * @dataProvider regexReplaceProvider()
+     */
+    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);
+    }
+}