2.4.0

Before this, calling safeTruncate with a string without spaces and a truncate length less than the string length would return an empty string.

.editorconfig

@@ -0,0 +1,16 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.yml]
+indent_style = space
+indent_size = 2

.gitattributes

@@ -0,0 +1,8 @@
+* text=auto
+
+.editorconfig export-ignore
+.gitattributes export-ignore
+.gitignore export-ignore
+.travis.yml export-ignore
+phpunit.xml.dist export-ignore
+tests export-ignore

.travis.yml

@@ -1,7 +1,43 @@
 language: php
+
 php:
-  - 5.6
-  - 5.5
-  - 5.4
-  - 5.3
   - hhvm
+
+# This triggers builds to run on the new TravisCI infrastructure.
+# See: http://docs.travis-ci.com/user/workers/container-based-infrastructure/
+sudo: false
+
+matrix:
+  fast_finish: true
+  include:
+    - php: 5.3
+      env: polyfill='true'
+    - php: 5.3
+      env: polyfill='false'
+    - php: 5.4
+      env: polyfill='true'
+    - php: 5.4
+      env: polyfill='false'
+    - php: 5.5
+      env: polyfill='true'
+    - php: 5.5
+      env: polyfill='false'
+    - php: 5.6
+      env: polyfill='true'
+    - php: 5.6
+      env: polyfill='false'
+    - php: 7.0
+      env: polyfill='true'
+    - php: 7.0
+      env: polyfill='false'
+
+install: travis_retry composer install --no-interaction --prefer-source
+
+before_script:
+  - travis_retry composer self-update
+  - travis_retry composer install --no-interaction --prefer-source
+  - if [[ $polyfill = 'false' ]]; then travis_retry composer remove symfony/polyfill-mbstring; fi
+
+script:
+  - vendor/bin/phpunit
+

CHANGELOG.md

@@ -1,3 +1,56 @@
+### 2.4.0 (2017-03-02)
+
+* Add startsWithAny
+* Add endsWithAny
+* Add stripWhitespace
+* Fix error handling for unsupported encodings
+* Change private methods to protected for extending class
+* Fix safeTruncate for strings without spaces
+* Additional char support in toAscii, e.g. full width chars and wide
+  non-breaking space
+
+### 2.3.2 (2016-05-02)
+
+* Improve support without mbstring
+
+### 2.3.1 (2016-03-21)
+
+* Always use root namespace for mbstring functions
+
+### 2.3.0 (2016-03-19)
+
+* Add Persian characters in Stringy::charsArray()
+* Use symfony/polyfill-mbstring to avoid dependency on ext-mbstring
+
+### 2.2.0 (2015-12-20)
+
+* isJSON now returns false for empty strings
+* Update for German umlaut transformation
+* Use reflection to generate method list for StaticStringy
+* Added isBase64 method
+* Improved toAscii char coverage
+
+### 2.1.0 (2015-09-02)
+
+* Added simplified StaticStringy class
+* str in Stringy::create and constructor is now optional
+
+### 2.0.0 (2015-07-29)
+
+ * Removed StaticStringy class
+ * Added append, prepend, toBoolean, repeat, between, slice, split, and lines
+ * camelize/upperCamelize now strip leading dashes and underscores
+ * titleize converts to lowercase, thus no longer preserving acronyms
+
+### 1.10.0 (2015-07-22)
+
+ * Added trimLeft, trimRight
+ * Added support for unicode whitespace to trim
+ * Added delimit
+ * Added indexOf and indexOfLast
+ * Added htmlEncode and htmlDecode
+ * Added "Ç" in toAscii()
+
 ### 1.9.0 (2015-02-09)
 
  * Added hasUpperCase and hasLowerCase

composer.json

@@ -16,7 +16,7 @@
     ],
     "require": {
         "php": ">=5.3.0",
-        "ext-mbstring": "*"
+        "symfony/polyfill-mbstring": "~1.1"
     },
     "require-dev": {
         "phpunit/phpunit": "~4.0"

phpunit.xml.dist

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<phpunit processIsolation="false"
+<phpunit bootstrap="vendor/autoload.php"
+         processIsolation="false"
          stopOnFailure="false"
          syntaxCheck="false">
     <testsuites>
         <testsuite name="Stringy">
-            <file>tests/CommonTest.php</file>
             <file>tests/StringyTest.php</file>
             <file>tests/StaticStringyTest.php</file>
             <file phpVersion="5.6.0">tests/CreateTest.php</file>

src/StaticStringy.php

@@ -2,868 +2,147 @@
 
 namespace Stringy;
 
+use BadMethodCallException;
+use ReflectionClass;
+use ReflectionMethod;
+
+/**
+ * Class StaticStringy
+ *
+ * @method static string append(string $str, string $stringAppend, string $encoding = null)
+ * @method static string at(string $str, int $index, string $encoding = null)
+ * @method static string between(string $str, string $start, string $end, int $offset = 0, string $encoding = null)
+ * @method static string camelize(string $str, string $encoding = null)
+ * @method static string chars(string $str, string $encoding = null)
+ * @method static string collapseWhitespace(string $str, string $encoding = null)
+ * @method static bool contains(string $str, string $needle, bool $caseSensitive = true, string $encoding = null)
+ * @method static bool containsAll(string $str, string $needle, bool $caseSensitive = true, string $encoding = null)
+ * @method static bool containsAny(string $str, string $needle, bool $caseSensitive = true, string $encoding = null)
+ * @method static int count(string $str, string $encoding = null)
+ * @method static int countSubstr(string $str, string $substring, bool $caseSensitive = true, string $encoding = null)
+ * @method static string dasherize(string $str, string $encoding = null)
+ * @method static string delimit(string $str, string $delimiter, string $encoding = null)
+ * @method static bool endsWith(string $str, string $substring, bool $caseSensitive = true, string $encoding = null)
+ * @method static string ensureLeft(string $str, string $substring, string $encoding = null)
+ * @method static string ensureRight(string $str, string $substring, string $encoding = null)
+ * @method static string first(string $str, int $n, string $encoding = null)
+ * @method static bool hasLowerCase(string $str, string $encoding = null)
+ * @method static bool hasUpperCase(string $str, string $encoding = null)
+ * @method static string htmlDecode(string $str, int $flags = ENT_COMPAT, string $encoding = null)
+ * @method static string htmlEncode(string $str, int $flags = ENT_COMPAT, string $encoding = null)
+ * @method static string humanize(string $str, string $encoding = null)
+ * @method static int indexOf(string $str, string $needle, int $offset = 0, string $encoding = null)
+ * @method static int indexOfLast(string $str, string $needle, int $offset = 0, string $encoding = null)
+ * @method static string insert(string $str, string $substring, int $index = 0, string $encoding = null)
+ * @method static bool isAlpha(string $str, string $encoding = null)
+ * @method static bool isAlphanumeric(string $str, string $encoding = null)
+ * @method static bool isBase64(string $str, string $encoding = null)
+ * @method static bool isBlank(string $str, string $encoding = null)
+ * @method static bool isHexadecimal(string $str, string $encoding = null)
+ * @method static bool isJson(string $str, string $encoding = null)
+ * @method static bool isLowerCase(string $str, string $encoding = null)
+ * @method static bool isSerialized(string $str, string $encoding = null)
+ * @method static bool isUpperCase(string $str, string $encoding = null)
+ * @method static string last(string $str, string $encoding = null)
+ * @method static int length(string $str, string $encoding = null)
+ * @method static Stringy[] lines(string $str, string $encoding = null)
+ * @method static string longestCommonPrefix(string $str, string $otherStr, string $encoding = null)
+ * @method static string longestCommonSuffix(string $str, string $otherStr, string $encoding = null)
+ * @method static string longestCommonSubstring(string $str, string $otherStr, string $encoding = null)
+ * @method static string lowerCaseFirst(string $str, string $encoding = null)
+ * @method static string pad(string $str, int $length, string $padStr = ' ', string $padType = 'right', string $encoding = null)
+ * @method static string padBoth(string $str, int $length, string $padStr = ' ', string $encoding = null)
+ * @method static string padLeft(string $str, int $length, string $padStr = ' ', string $encoding = null)
+ * @method static string padRight(string $str, int $length, string $padStr = ' ', string $encoding = null)
+ * @method static string prepend(string $str, string $string, string $encoding = null)
+ * @method static string regexReplace(string $str, string $pattern, string $replacement, string $options = 'msr', string $encoding = null)
+ * @method static string removeLeft(string $str, string $substring, string $encoding = null)
+ * @method static string removeRight(string $str, string $substring, string $encoding = null)
+ * @method static string repeat(string $str, int $multiplier, string $encoding = null)
+ * @method static string replace(string $str, string $search, string $replacement, string $encoding = null)
+ * @method static string reverse(string $str, string $encoding = null)
+ * @method static string safeTruncate(string $str, int $length, string $substring = '', string $encoding = null)
+ * @method static string shuffle(string $str, string $encoding = null)
+ * @method static string slugify(string $str, string $replacement = '-', string $encoding = null)
+ * @method static bool startsWith(string $str, string $substring, bool $caseSensitive = true, string $encoding = null)
+ * @method static string slice(string $str, int $start, int $end = null, string $encoding = null)
+ * @method static string split(string $str, string $pattern, int $limit = null, string $encoding = null)
+ * @method static string substr(string $str, int $start, int $length = null, string $encoding = null)
+ * @method static string surround(string $str, string $substring, string $encoding = null)
+ * @method static string swapCase(string $str, string $encoding = null)
+ * @method static string tidy(string $str, string $encoding = null)
+ * @method static string titleize(string $str, string $encoding = null)
+ * @method static string toAscii(string $str, bool $removeUnsupported = true, string $encoding = null)
+ * @method static bool toBoolean(string $str, string $encoding = null)
+ * @method static string toLowerCase(string $str, string $encoding = null)
+ * @method static string toSpaces(string $str, int $tabLength = 4, string $encoding = null)
+ * @method static string toTabs(string $str, int $tabLength = 4, string $encoding = null)
+ * @method static string toTitleCase(string $str, string $encoding = null)
+ * @method static string toUpperCase(string $str, string $encoding = null)
+ * @method static string trim(string $str, string $chars = null, string $encoding = null)
+ * @method static string trimLeft(string $str, string $chars = null, string $encoding = null)
+ * @method static string trimRight(string $str, string $chars = null, string $encoding = null)
+ * @method static string truncate(string $str, int $length, string $substring = '', string $encoding = null)
+ * @method static string underscored(string $str, string $encoding = null)
+ * @method static string upperCamelize(string $str, string $encoding = null)
+ * @method static string upperCaseFirst(string $str, string $encoding = null)
+ */
 class StaticStringy
 {
     /**
-     * Returns an array consisting of the characters in the string.
+     * A mapping of method names to the numbers of arguments it accepts. Each
+     * should be two more than the equivalent Stringy method. Necessary as
+     * static methods place the optional $encoding as the last parameter.
      *
-     * @param  string $str      String for which to return the chars
-     * @param  string $encoding The character encoding
-     * @return array  An array of string chars
+     * @var string[]
      */
-    public static function chars($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->chars();
-    }
+    protected static $methodArgs = null;
 
     /**
-     * Converts the first character of the supplied string to upper case.
+     * Creates an instance of Stringy and invokes the given method with the
+     * rest of the passed arguments. The optional encoding is expected to be
+     * the last argument. For example, the following:
+     * StaticStringy::slice('fòôbàř', 0, 3, 'UTF-8'); translates to
+     * Stringy::create('fòôbàř', 'UTF-8')->slice(0, 3);
+     * The result is not cast, so the return value may be of type Stringy,
+     * integer, boolean, etc.
      *
-     * @param  string $str      String to modify
-     * @param  string $encoding The character encoding
-     * @return string String with the first character being upper case
+     * @param string  $name
+     * @param mixed[] $arguments
+     *
+     * @return Stringy
+     *
+     * @throws \BadMethodCallException
      */
-    public static function upperCaseFirst($str, $encoding = null)
+    public static function __callStatic($name, $arguments)
     {
-        return (string) Stringy::create($str, $encoding)->upperCaseFirst();
-    }
+        if (!static::$methodArgs) {
+            $stringyClass = new ReflectionClass('Stringy\Stringy');
+            $methods = $stringyClass->getMethods(ReflectionMethod::IS_PUBLIC);
 
-    /**
-     * 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();
-    }
+            foreach ($methods as $method) {
+                $params = $method->getNumberOfParameters() + 2;
+                static::$methodArgs[$method->name] = $params;
+            }
+        }
 
-    /**
-     * 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();
-    }
+        if (!isset(static::$methodArgs[$name])) {
+            throw new BadMethodCallException($name . ' is not a valid method');
+        }
 
-    /**
-     * 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();
-    }
+        $numArgs = count($arguments);
+        $str = ($numArgs) ? $arguments[0] : '';
 
-    /**
-     * 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();
-    }
+        if ($numArgs === static::$methodArgs[$name]) {
+            $args = array_slice($arguments, 1, -1);
+            $encoding = $arguments[$numArgs - 1];
+        } else {
+            $args = array_slice($arguments, 1);
+            $encoding = null;
+        }
 
-    /**
-     * 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();
-    }
+        $stringy = Stringy::create($str, $encoding);
 
-    /**
-     * 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
-     * unless instructed otherwise.
-     *
-     * @param  string $str               A string with non-ASCII characters
-     * @param  bool   $removeUnsupported Whether or not to remove the
-     *                                   unsupported characters
-     * @return string A string containing only ASCII characters
-     */
-    public static function toAscii($str, $removeUnsupported = true)
-    {
-        return (string) Stringy::create($str)->toAscii($removeUnsupported);
-    }
-
-    /**
-     * 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 the first character of each word in the string to uppercase.
-     *
-     * @param  string $str      String to convert case
-     * @param  string $encoding The character encoding
-     * @return string The title-cased string
-     */
-    public static function toTitleCase($str, $encoding = null)
-    {
-        return (string) Stringy::create($str, $encoding)->toTitleCase();
-    }
-
-    /**
-     * 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);
-    }
-
-    /**
-     * Returns true if the string contains any $needles, false otherwise. By
-     * default, the comparison is case-sensitive, but can be made insensitive
-     * by setting $caseSensitive to false.
-     *
-     * @param  string $haystack      String being checked
-     * @param  array  $needles       Substrings 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 any $needles
-     */
-    public static function containsAny($haystack, $needles,
-                                       $caseSensitive = true, $encoding = null)
-    {
-        return Stringy::create($haystack, $encoding)
-            ->containsAny($needles, $caseSensitive);
-    }
-
-    /**
-     * Returns true if the string contains all $needles, false otherwise. By
-     * default, the comparison is case-sensitive, but can be made insensitive
-     * by setting $caseSensitive to false.
-     *
-     * @param  string $haystack      String being checked
-     * @param  array  $needles       Substrings 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 all $needles
-     */
-    public static function containsAll($haystack, $needles,
-                                       $caseSensitive = true, $encoding = null)
-    {
-        return Stringy::create($haystack, $encoding)
-            ->containsAll($needles, $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 a lower case char, false
-     * otherwise.
-     *
-     * @param  string $str      String to check
-     * @param  string $encoding The character encoding
-     * @return bool   Whether or not $str contains a lower case character.
-     */
-    public static function hasLowerCase($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->hasLowerCase();
-    }
-
-    /**
-     * Returns true if the string contains an upper case char, false
-     * otherwise.
-     *
-     * @param  string $str      String to check
-     * @param  string $encoding The character encoding
-     * @return bool   Whether or not $str contains an upper case character.
-     */
-    public static function hasUpperCase($str, $encoding = null)
-    {
-        return Stringy::create($str, $encoding)->hasUpperCase();
-    }
-
-    /**
-     * Returns true if the string contains only alphabetic chars, false
-     * otherwise.
-     *
-     * @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);
+        return call_user_func_array(array($stringy, $name), $args);
     }
 }

tests/CreateTest.php

@@ -1,7 +1,5 @@
 <?php
 
-require __DIR__ . '/../src/Create.php';
-
 use function Stringy\create as s;
 
 class CreateTestCase extends PHPUnit_Framework_TestCase

tests/StaticStringyTest.php

@@ -1,650 +1,60 @@
 <?php
 
-require __DIR__ . '/../src/StaticStringy.php';
-
 use Stringy\StaticStringy as S;
 
-class StaticStringyTestCase extends CommonTest
+class StaticStringyTestCase extends PHPUnit_Framework_TestCase
 {
     /**
-     * @dataProvider charsProvider()
+     * @expectedException BadMethodCallException
      */
-    public function testChars($expected, $str, $encoding = null)
+    public function testBadMethodCall()
     {
-        $result = S::chars($str, $encoding);
-        $this->assertInternalType('array', $result);
-        foreach ($result as $char) {
-            $this->assertInternalType('string', $char);
+        $result = S::invalidMethod('foo');
+    }
+
+    public function testEmptyArgsInvocation()
+    {
+        $result = S::toLowerCase();
+        $this->assertEquals('', (string) $result);
+    }
+
+    public function testInvocation()
+    {
+        $result = S::toLowerCase('FOOBAR');
+        $this->assertEquals('foobar', (string) $result);
+    }
+
+    public function testPartialArgsInvocation()
+    {
+        $result = S::slice('foobar', 0, 3);
+        $this->assertEquals('foo', (string) $result);
+    }
+
+    public function testFullArgsInvocation()
+    {
+        $result = S::slice('fòôbàř', 0, 3, 'UTF-8');
+        $this->assertEquals('fòô', (string) $result);
+    }
+
+    /**
+     * Use reflection to ensure that all argument numbers are correct. Each
+     * static method should accept 2 more arguments than their Stringy
+     * equivalent.
+     */
+    public function testArgumentNumbers()
+    {
+        $staticStringyClass = new ReflectionClass('Stringy\StaticStringy');
+        $stringyClass = new ReflectionClass('Stringy\Stringy');
+
+        // getStaticPropertyValue can't access protected properties
+        $properties = $staticStringyClass->getStaticProperties();
+
+        foreach ($properties['methodArgs'] as $method => $expected) {
+            $num = $stringyClass->getMethod($method)
+                ->getNumberOfParameters() + 2;
+
+            $this->assertEquals($expected, $num,
+                'Invalid num args for ' . $method);
         }
-        $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 lowerCaseFirstProvider()
-     */
-    public function testLowerCaseFirst($expected, $str, $encoding = null)
-    {
-        $result = S::lowerCaseFirst($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider camelizeProvider()
-     */
-    public function testCamelize($expected, $str, $encoding = null)
-    {
-        $result = S::camelize($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider upperCamelizeProvider()
-     */
-    public function testUpperCamelize($expected, $str, $encoding = null)
-    {
-        $result = S::upperCamelize($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider dasherizeProvider()
-     */
-    public function testDasherize($expected, $str, $encoding = null)
-    {
-        $result = S::dasherize($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider underscoredProvider()
-     */
-    public function testUnderscored($expected, $str, $encoding = null)
-    {
-        $result = S::underscored($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider swapCaseProvider()
-     */
-    public function testSwapCase($expected, $str, $encoding = null)
-    {
-        $result = S::swapCase($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @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 humanizeProvider()
-     */
-    public function testHumanize($expected, $str, $encoding = null)
-    {
-        $result = S::humanize($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider tidyProvider()
-     */
-    public function testTidy($expected, $str)
-    {
-        $result = S::tidy($str);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider collapseWhitespaceProvider()
-     */
-    public function testCollapseWhitespace($expected, $str, $encoding = null)
-    {
-        $result = S::collapseWhitespace($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toAsciiProvider()
-     */
-    public function testToAscii($expected, $str, $removeUnsupported = true)
-    {
-        $result = S::toAscii($str, $removeUnsupported);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @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);
-    }
-
-    /**
-     * @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 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 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 startsWithProvider()
-     */
-    public function testStartsWith($expected, $str, $substring,
-                                   $caseSensitive = true, $encoding = null)
-    {
-        $result = S::startsWith($str, $substring, $caseSensitive, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider endsWithProvider()
-     */
-    public function testEndsWith($expected, $str, $substring,
-                                 $caseSensitive = true, $encoding = null)
-    {
-        $result = S::endsWith($str, $substring, $caseSensitive, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toSpacesProvider()
-     */
-    public function testToSpaces($expected, $str, $tabLength = 4)
-    {
-        $result = S::toSpaces($str, $tabLength);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toTabsProvider()
-     */
-    public function testToTabs($expected, $str, $tabLength = 4)
-    {
-        $result = S::toTabs($str, $tabLength);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toLowerCaseProvider()
-     */
-    public function testToLowerCase($expected, $str, $encoding = null)
-    {
-        $result = S::toLowerCase($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toTitleCaseProvider()
-     */
-    public function testToTitleCase($expected, $str, $encoding = null)
-    {
-        $result = S::toTitleCase($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toUpperCaseProvider()
-     */
-    public function testToUpperCase($expected, $str, $encoding = null)
-    {
-        $result = S::toUpperCase($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @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 containsAnyProvider()
-     */
-    public function testcontainsAny($expected, $haystack, $needles,
-                                    $caseSensitive = true, $encoding = null)
-    {
-        $result = S::containsAny($haystack, $needles, $caseSensitive, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider containsAllProvider()
-     */
-    public function testContainsAll($expected, $haystack, $needles,
-                                    $caseSensitive = true, $encoding = null)
-    {
-        $result = S::containsAll($haystack, $needles, $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 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 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 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 reverseProvider()
-     */
-    public function testReverse($expected, $str, $encoding = null)
-    {
-        $result = S::reverse($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider shuffleProvider()
-     */
-    public function testShuffle($str, $encoding = null)
-    {
-        $result = S::shuffle($str, $encoding);
-        $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 trimProvider()
-     */
-    public function testTrim($expected, $str)
-    {
-        $result = S::trim($str);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @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 longestCommonSuffixProvider()
-     */
-    public function testLongestCommonSuffix($expected, $str, $otherStr,
-                                            $encoding = null)
-    {
-        $result = S::longestCommonSuffix($str, $otherStr, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @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 lengthProvider()
-     */
-    public function testLength($expected, $str, $encoding = null)
-    {
-        $result = S::length($str, $encoding);
-        $this->assertEquals($expected, $result);
-        $this->assertInternalType('int', $result);
-    }
-
-    /**
-     * @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 atProvider()
-     */
-    public function testAt($expected, $str, $index, $encoding = null)
-    {
-        $result = S::at($str, $index, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @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 lastProvider()
-     */
-    public function testLast($expected, $str, $n, $encoding = null)
-    {
-        $result = S::last($str, $n, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @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 ensureRightProvider()
-     */
-    public function testEnsureRight($expected, $str, $substring, $encoding = null)
-    {
-        $result = S::ensureRight($str, $substring, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @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 removeRightProvider()
-     */
-    public function testRemoveRight($expected, $str, $substring, $encoding = null)
-    {
-        $result = S::removeRight($str, $substring, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isAlphaProvider()
-     */
-    public function testIsAlpha($expected, $str, $encoding = null)
-    {
-        $result = S::isAlpha($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isAlphanumericProvider()
-     */
-    public function testIsAlphanumeric($expected, $str, $encoding = null)
-    {
-        $result = S::isAlphanumeric($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isBlankProvider()
-     */
-    public function testIsBlank($expected, $str, $encoding = null)
-    {
-        $result = S::isBlank($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @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 hasLowerCaseProvider()
-     */
-    public function testHasLowerCase($expected, $str, $encoding = null)
-    {
-        $result = S::hasLowerCase($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @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 hasUpperCaseProvider()
-     */
-    public function testHasUpperCase($expected, $str, $encoding = null)
-    {
-        $result = S::hasUpperCase($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isHexadecimalProvider()
-     */
-    public function testIsHexadecimal($expected, $str, $encoding = null)
-    {
-        $result = S::isHexadecimal($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider countSubstrProvider()
-     */
-    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, $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);
     }
 }