From 488852146674b189ca715dede52e0b27a0b82825 Mon Sep 17 00:00:00 2001
From: "Daniel St. Jules" <danielst.jules@gmail.com>
Date: Sun, 28 Jul 2013 21:13:45 -0700
Subject: [PATCH] Create gh-pages branch via GitHub

---
 index.html  | 254 +++++++++++++++++++++++++++-------------------------
 params.json |   2 +-
 2 files changed, 135 insertions(+), 121 deletions(-)

diff --git a/index.html b/index.html
index 094c75a..314d9c6 100644
--- a/index.html
+++ b/index.html
@@ -31,9 +31,11 @@
         <h1>
 <a name="stringy" class="anchor" href="#stringy"><span class="octicon octicon-link"></span></a>Stringy</h1>
 
-<p>A PHP library with a variety of string manipulation functions with multibyte support. Offers both OO method chaining and a procedural-style static wrapper. Inspired by underscore.string.js.</p>
+<p>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.</p>
 
-<p>Note: The methods listed below are subject to change until we reach a 1.0.0 release.</p>
+<p><a href="https://travis-ci.org/danielstjules/Stringy"><img src="https://travis-ci.org/danielstjules/Stringy.png" alt="Build Status"></a>
+<a href="https://packagist.org/packages/danielstjules/stringy"><img src="https://poser.pugx.org/danielstjules/Stringy/downloads.png" alt="Total Downloads"></a>
+<a href="https://packagist.org/packages/danielstjules/stringy"><img src="https://poser.pugx.org/danielstjules/Stringy/v/stable.png" alt="Latest Stable Version"></a></p>
 
 <ul>
 <li><a href="#requiringloading">Requiring/Loading</a></li>
@@ -46,6 +48,7 @@
 <li><a href="#camelize">camelize</a></li>
 <li><a href="#collapsewhitespace">collapseWhitespace</a></li>
 <li><a href="#contains">contains</a></li>
+<li><a href="#count">count</a></li>
 <li><a href="#create">create</a></li>
 <li><a href="#dasherize">dasherize</a></li>
 <li><a href="#endswith">endsWith</a></li>
@@ -71,6 +74,7 @@
 <li><a href="#padright">padRight</a></li>
 <li><a href="#removeleft">removeLeft</a></li>
 <li><a href="#removeright">removeRight</a></li>
+<li><a href="#replace">replace</a></li>
 <li><a href="#reverse">reverse</a></li>
 <li><a href="#safetruncate">safeTruncate</a></li>
 <li><a href="#shuffle">shuffle</a></li>
@@ -148,12 +152,12 @@ public, and can be accessed directly if required, ie: <code>S::create('foo')-&gt
 <a name="methods" class="anchor" href="#methods"><span class="octicon octicon-link"></span></a>Methods</h2>
 
 <p>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.</p>
+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.</p>
 
 <p><em>Note: If $encoding is not given, it defaults to mb_internal_encoding().</em></p>
 
-<h5>
-<a name="at" class="anchor" href="#at"><span class="octicon octicon-link"></span></a>at</h5>
+<h4>
+<a name="at" class="anchor" href="#at"><span class="octicon octicon-link"></span></a>at</h4>
 
 <p>$stringy-&gt;at(int $index)</p>
 
@@ -165,8 +169,8 @@ method in Stringy\StaticStringy. For all others, they're found in Stringy\String
 <span class="nx">S</span><span class="o">::</span><span class="na">at</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'ř'</span>
 </pre></div>
 
-<h5>
-<a name="camelize" class="anchor" href="#camelize"><span class="octicon octicon-link"></span></a>camelize</h5>
+<h4>
+<a name="camelize" class="anchor" href="#camelize"><span class="octicon octicon-link"></span></a>camelize</h4>
 
 <p>$stringy-&gt;camelize();</p>
 
@@ -180,8 +184,8 @@ dashes and underscores, and removes spaces, dashes, underscores.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">camelize</span><span class="p">(</span><span class="s1">'Camel-Case'</span><span class="p">);</span>  <span class="c1">// 'camelCase'</span>
 </pre></div>
 
-<h5>
-<a name="collapsewhitespace" class="anchor" href="#collapsewhitespace"><span class="octicon octicon-link"></span></a>collapseWhitespace</h5>
+<h4>
+<a name="collapsewhitespace" class="anchor" href="#collapsewhitespace"><span class="octicon octicon-link"></span></a>collapseWhitespace</h4>
 
 <p>$stringy-&gt;collapseWhitespace()</p>
 
@@ -194,8 +198,8 @@ single space. This inclues tabs and newline characters.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">collapseWhitespace</span><span class="p">(</span><span class="s1">'   Ο     συγγραφέας  '</span><span class="p">);</span>  <span class="c1">// 'Ο συγγραφέας'</span>
 </pre></div>
 
-<h5>
-<a name="contains" class="anchor" href="#contains"><span class="octicon octicon-link"></span></a>contains</h5>
+<h4>
+<a name="contains" class="anchor" href="#contains"><span class="octicon octicon-link"></span></a>contains</h4>
 
 <p>$stringy-&gt;contains(string $needle)</p>
 
@@ -204,11 +208,25 @@ single space. This inclues tabs and newline characters.</p>
 <p>Returns true if $haystack contains $needle, false otherwise.</p>
 
 <div class="highlight"><pre><span class="nx">S</span><span class="o">::</span><span class="na">create</span><span class="p">(</span><span class="s1">'Ο συγγραφέας είπε'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">)</span><span class="o">-&gt;</span><span class="na">contains</span><span class="p">(</span><span class="s1">'συγγραφέας'</span><span class="p">);</span>
-<span class="nx">S</span><span class="o">::</span><span class="na">contains</span><span class="p">(</span><span class="s1">'Ο συγγραφέας είπε'</span><span class="p">,</span> <span class="s1">'συγγραφέας'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">)</span>  <span class="c1">// true</span>
+<span class="nx">S</span><span class="o">::</span><span class="na">contains</span><span class="p">(</span><span class="s1">'Ο συγγραφέας είπε'</span><span class="p">,</span> <span class="s1">'συγγραφέας'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// true</span>
 </pre></div>
 
-<h5>
-<a name="create" class="anchor" href="#create"><span class="octicon octicon-link"></span></a>create</h5>
+<h4>
+<a name="count" class="anchor" href="#count"><span class="octicon octicon-link"></span></a>count</h4>
+
+<p>$stringy-&gt;count(string $substring)</p>
+
+<p>S::count(string $str, string $substring [, string $encoding ])</p>
+
+<p>Returns the number of occurences of $substring in $str. An alias for
+mb_substr_count()</p>
+
+<div class="highlight"><pre><span class="nx">S</span><span class="o">::</span><span class="na">create</span><span class="p">(</span><span class="s1">'Ο συγγραφέας είπε'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">)</span><span class="o">-&gt;</span><span class="na">count</span><span class="p">(</span><span class="s1">'α'</span><span class="p">);</span>
+<span class="nx">S</span><span class="o">::</span><span class="na">count</span><span class="p">(</span><span class="s1">'Ο συγγραφέας είπε'</span><span class="p">,</span> <span class="s1">'α'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 2</span>
+</pre></div>
+
+<h4>
+<a name="create" class="anchor" href="#create"><span class="octicon octicon-link"></span></a>create</h4>
 
 <p>$stringy = S::create(string $str, [, $encoding ])</p>
 
@@ -219,8 +237,8 @@ mb_internal_encoding(). It then returns the instantiated object.</p>
 <div class="highlight"><pre><span class="nx">S</span><span class="o">::</span><span class="na">create</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'fòô bàř'</span>
 </pre></div>
 
-<h5>
-<a name="dasherize" class="anchor" href="#dasherize"><span class="octicon octicon-link"></span></a>dasherize</h5>
+<h4>
+<a name="dasherize" class="anchor" href="#dasherize"><span class="octicon octicon-link"></span></a>dasherize</h4>
 
 <p>$stringy-&gt;dasherize();</p>
 
@@ -235,8 +253,8 @@ of spaces as well as underscores.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">dasherize</span><span class="p">(</span><span class="s1">'TestDCase'</span><span class="p">);</span>  <span class="c1">// 'test-d-case'</span>
 </pre></div>
 
-<h5>
-<a name="endswith" class="anchor" href="#endswith"><span class="octicon octicon-link"></span></a>endsWith</h5>
+<h4>
+<a name="endswith" class="anchor" href="#endswith"><span class="octicon octicon-link"></span></a>endsWith</h4>
 
 <p>$stringy-&gt;endsWith(string $substring [, boolean $caseSensitive = true ])</p>
 
@@ -250,8 +268,8 @@ by setting $caseSensitive to false.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">endsWith</span><span class="p">(</span><span class="s1">'FÒÔ bàřs'</span><span class="p">,</span> <span class="s1">'àřs'</span><span class="p">,</span> <span class="k">true</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// true</span>
 </pre></div>
 
-<h5>
-<a name="ensureleft" class="anchor" href="#ensureleft"><span class="octicon octicon-link"></span></a>ensureLeft</h5>
+<h4>
+<a name="ensureleft" class="anchor" href="#ensureleft"><span class="octicon octicon-link"></span></a>ensureLeft</h4>
 
 <p>$stringy-&gt;ensureLeft(string $substring)</p>
 
@@ -263,8 +281,8 @@ by setting $caseSensitive to false.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">ensureLeft</span><span class="p">(</span><span class="s1">'foobar'</span><span class="p">,</span> <span class="s1">'http://'</span><span class="p">);</span>  <span class="c1">// 'http://foobar'</span>
 </pre></div>
 
-<h5>
-<a name="ensureright" class="anchor" href="#ensureright"><span class="octicon octicon-link"></span></a>ensureRight</h5>
+<h4>
+<a name="ensureright" class="anchor" href="#ensureright"><span class="octicon octicon-link"></span></a>ensureRight</h4>
 
 <p>$stringy-&gt;ensureRight(string $substring)</p>
 
@@ -276,8 +294,8 @@ by setting $caseSensitive to false.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">ensureRight</span><span class="p">(</span><span class="s1">'foobar'</span><span class="p">,</span> <span class="s1">'.com'</span><span class="p">);</span>  <span class="c1">// 'foobar.com'</span>
 </pre></div>
 
-<h5>
-<a name="first" class="anchor" href="#first"><span class="octicon octicon-link"></span></a>first</h5>
+<h4>
+<a name="first" class="anchor" href="#first"><span class="octicon octicon-link"></span></a>first</h4>
 
 <p>$stringy-&gt;first(int $n)</p>
 
@@ -289,8 +307,8 @@ by setting $caseSensitive to false.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">first</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'fòô'</span>
 </pre></div>
 
-<h5>
-<a name="humanize" class="anchor" href="#humanize"><span class="octicon octicon-link"></span></a>humanize</h5>
+<h4>
+<a name="humanize" class="anchor" href="#humanize"><span class="octicon octicon-link"></span></a>humanize</h4>
 
 <p>$stringy-&gt;humanize()</p>
 
@@ -303,8 +321,8 @@ and strips '_id'.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">humanize</span><span class="p">(</span><span class="s1">'author_id'</span><span class="p">);</span>  <span class="c1">// 'Author'</span>
 </pre></div>
 
-<h5>
-<a name="insert" class="anchor" href="#insert"><span class="octicon octicon-link"></span></a>insert</h5>
+<h4>
+<a name="insert" class="anchor" href="#insert"><span class="octicon octicon-link"></span></a>insert</h4>
 
 <p>$stringy-&gt;insert(int $index, string $substring)</p>
 
@@ -316,8 +334,8 @@ and strips '_id'.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">insert</span><span class="p">(</span><span class="s1">'fòô bà'</span><span class="p">,</span> <span class="s1">'ř'</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'fòô bàř'</span>
 </pre></div>
 
-<h5>
-<a name="isalpha" class="anchor" href="#isalpha"><span class="octicon octicon-link"></span></a>isAlpha</h5>
+<h4>
+<a name="isalpha" class="anchor" href="#isalpha"><span class="octicon octicon-link"></span></a>isAlpha</h4>
 
 <p>$stringy-&gt;isAlpha()</p>
 
@@ -329,8 +347,8 @@ and strips '_id'.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">isAlpha</span><span class="p">(</span><span class="s1">'丹尼爾'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// true</span>
 </pre></div>
 
-<h5>
-<a name="isalphanumeric" class="anchor" href="#isalphanumeric"><span class="octicon octicon-link"></span></a>isAlphanumeric</h5>
+<h4>
+<a name="isalphanumeric" class="anchor" href="#isalphanumeric"><span class="octicon octicon-link"></span></a>isAlphanumeric</h4>
 
 <p>$stringy-&gt;isAlphanumeric()</p>
 
@@ -343,8 +361,8 @@ otherwise.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">isAlphanumeric</span><span class="p">(</span><span class="s1">'دانيال1'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// true</span>
 </pre></div>
 
-<h5>
-<a name="isblank" class="anchor" href="#isblank"><span class="octicon octicon-link"></span></a>isBlank</h5>
+<h4>
+<a name="isblank" class="anchor" href="#isblank"><span class="octicon octicon-link"></span></a>isBlank</h4>
 
 <p>$stringy-&gt;isBlank()</p>
 
@@ -356,8 +374,8 @@ otherwise.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">isBlank</span><span class="p">(</span><span class="s2">"</span><span class="se">\n\t</span><span class="s2">  \v\f"</span><span class="p">);</span>  <span class="c1">// true</span>
 </pre></div>
 
-<h5>
-<a name="islowercase" class="anchor" href="#islowercase"><span class="octicon octicon-link"></span></a>isLowerCase</h5>
+<h4>
+<a name="islowercase" class="anchor" href="#islowercase"><span class="octicon octicon-link"></span></a>isLowerCase</h4>
 
 <p>$stringy-&gt;isLowerCase()</p>
 
@@ -369,8 +387,8 @@ otherwise.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">isLowerCase</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// true</span>
 </pre></div>
 
-<h5>
-<a name="isuppercase" class="anchor" href="#isuppercase"><span class="octicon octicon-link"></span></a>isUpperCase</h5>
+<h4>
+<a name="isuppercase" class="anchor" href="#isuppercase"><span class="octicon octicon-link"></span></a>isUpperCase</h4>
 
 <p>$stringy-&gt;isUpperCase()</p>
 
@@ -382,8 +400,8 @@ otherwise.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">isUpperCase</span><span class="p">(</span><span class="s1">'FÒÔBÀŘ'</span><span class="p">,,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// true</span>
 </pre></div>
 
-<h5>
-<a name="last" class="anchor" href="#last"><span class="octicon octicon-link"></span></a>last</h5>
+<h4>
+<a name="last" class="anchor" href="#last"><span class="octicon octicon-link"></span></a>last</h4>
 
 <p>$stringy-&gt;last(int $n)</p>
 
@@ -395,8 +413,8 @@ otherwise.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">last</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'bàř'</span>
 </pre></div>
 
-<h5>
-<a name="length" class="anchor" href="#length"><span class="octicon octicon-link"></span></a>length</h5>
+<h4>
+<a name="length" class="anchor" href="#length"><span class="octicon octicon-link"></span></a>length</h4>
 
 <p>$stringy-&gt;length()</p>
 
@@ -408,8 +426,8 @@ otherwise.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">length</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 7</span>
 </pre></div>
 
-<h5>
-<a name="longestcommonprefix" class="anchor" href="#longestcommonprefix"><span class="octicon octicon-link"></span></a>longestCommonPrefix</h5>
+<h4>
+<a name="longestcommonprefix" class="anchor" href="#longestcommonprefix"><span class="octicon octicon-link"></span></a>longestCommonPrefix</h4>
 
 <p>$stringy-&gt;longestCommonPrefix(string $otherStr)</p>
 
@@ -421,8 +439,8 @@ otherwise.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">longestCommonPrefix</span><span class="p">(</span><span class="s1">'fòô bar'</span><span class="p">,</span> <span class="s1">'fòr bar'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'fò'</span>
 </pre></div>
 
-<h5>
-<a name="longestcommonsuffix" class="anchor" href="#longestcommonsuffix"><span class="octicon octicon-link"></span></a>longestCommonSuffix</h5>
+<h4>
+<a name="longestcommonsuffix" class="anchor" href="#longestcommonsuffix"><span class="octicon octicon-link"></span></a>longestCommonSuffix</h4>
 
 <p>$stringy-&gt;longestCommonSuffix(string $otherStr)</p>
 
@@ -434,8 +452,8 @@ otherwise.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">longestCommonSuffix</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">'fòr bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// ' bàř'</span>
 </pre></div>
 
-<h5>
-<a name="longestcommonsubstring" class="anchor" href="#longestcommonsubstring"><span class="octicon octicon-link"></span></a>longestCommonSubstring</h5>
+<h4>
+<a name="longestcommonsubstring" class="anchor" href="#longestcommonsubstring"><span class="octicon octicon-link"></span></a>longestCommonSubstring</h4>
 
 <p>$stringy-&gt;longestCommonSubstring(string $otherStr)</p>
 
@@ -448,8 +466,8 @@ case of ties, returns that which occurs first.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">longestCommonSubstring</span><span class="p">(</span><span class="s1">'foo bar'</span><span class="p">,</span> <span class="s1">'boo far'</span><span class="p">);</span>  <span class="c1">// 'oo '</span>
 </pre></div>
 
-<h5>
-<a name="lowercasefirst" class="anchor" href="#lowercasefirst"><span class="octicon octicon-link"></span></a>lowerCaseFirst</h5>
+<h4>
+<a name="lowercasefirst" class="anchor" href="#lowercasefirst"><span class="octicon octicon-link"></span></a>lowerCaseFirst</h4>
 
 <p>$stringy-&gt;lowerCaseFirst();</p>
 
@@ -462,8 +480,8 @@ support for multibyte strings.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">lowerCaseFirst</span><span class="p">(</span><span class="s1">'Σ test'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'σ test'</span>
 </pre></div>
 
-<h5>
-<a name="pad" class="anchor" href="#pad"><span class="octicon octicon-link"></span></a>pad</h5>
+<h4>
+<a name="pad" class="anchor" href="#pad"><span class="octicon octicon-link"></span></a>pad</h4>
 
 <p>$stringy-&gt;pad(int $length [, string $padStr = ' ' [, string $padType = 'right' ]])</p>
 
@@ -479,8 +497,8 @@ isn't one of those 3 values.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">pad</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="s1">'¬ø'</span><span class="p">,</span> <span class="s1">'left'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// '¬ø¬fòô bàř'</span>
 </pre></div>
 
-<h5>
-<a name="padboth" class="anchor" href="#padboth"><span class="octicon octicon-link"></span></a>padBoth</h5>
+<h4>
+<a name="padboth" class="anchor" href="#padboth"><span class="octicon octicon-link"></span></a>padBoth</h4>
 
 <p>$stringy-&gt;padBoth(int $length [, string $padStr = ' ' ])</p>
 
@@ -493,8 +511,8 @@ string are padded. Alias for pad($str, $length, $padStr, 'both', $encoding)</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">padBoth</span><span class="p">(</span><span class="s1">'foo bar'</span><span class="p">,</span> <span class="mi">9</span><span class="p">,</span> <span class="s1">' '</span><span class="p">);</span>  <span class="c1">// ' foo bar '</span>
 </pre></div>
 
-<h5>
-<a name="padleft" class="anchor" href="#padleft"><span class="octicon octicon-link"></span></a>padLeft</h5>
+<h4>
+<a name="padleft" class="anchor" href="#padleft"><span class="octicon octicon-link"></span></a>padLeft</h4>
 
 <p>$stringy-&gt;padLeft(int $length [, string $padStr = ' ' ])</p>
 
@@ -507,8 +525,8 @@ string is padded. Alias for pad($str, $length, $padStr, 'left', $encoding)</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">padLeft</span><span class="p">(</span><span class="s1">'foo bar'</span><span class="p">,</span> <span class="mi">9</span><span class="p">,</span> <span class="s1">' '</span><span class="p">);</span>  <span class="c1">// '  foo bar'</span>
 </pre></div>
 
-<h5>
-<a name="padright" class="anchor" href="#padright"><span class="octicon octicon-link"></span></a>padRight</h5>
+<h4>
+<a name="padright" class="anchor" href="#padright"><span class="octicon octicon-link"></span></a>padRight</h4>
 
 <p>$stringy-&gt;padRight(int $length [, string $padStr = ' ' ])</p>
 
@@ -521,8 +539,8 @@ padded. Alias for pad($str, $length, $padStr, 'right', $encoding)</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">padRight</span><span class="p">(</span><span class="s1">'foo bar'</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="s1">'_*'</span><span class="p">);</span>  <span class="c1">// 'foo bar_*_'</span>
 </pre></div>
 
-<h5>
-<a name="removeleft" class="anchor" href="#removeleft"><span class="octicon octicon-link"></span></a>removeLeft</h5>
+<h4>
+<a name="removeleft" class="anchor" href="#removeleft"><span class="octicon octicon-link"></span></a>removeLeft</h4>
 
 <p>$stringy-&gt;removeLeft(string $substring)</p>
 
@@ -534,8 +552,8 @@ padded. Alias for pad($str, $length, $padStr, 'right', $encoding)</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">removeLeft</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">'fòô '</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'bàř'</span>
 </pre></div>
 
-<h5>
-<a name="removeright" class="anchor" href="#removeright"><span class="octicon octicon-link"></span></a>removeRight</h5>
+<h4>
+<a name="removeright" class="anchor" href="#removeright"><span class="octicon octicon-link"></span></a>removeRight</h4>
 
 <p>$stringy-&gt;removeRight(string $substring)</p>
 
@@ -547,8 +565,21 @@ padded. Alias for pad($str, $length, $padStr, 'right', $encoding)</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">removeRight</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">' bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'fòô'</span>
 </pre></div>
 
-<h5>
-<a name="reverse" class="anchor" href="#reverse"><span class="octicon octicon-link"></span></a>reverse</h5>
+<h4>
+<a name="replace" class="anchor" href="#replace"><span class="octicon octicon-link"></span></a>replace</h4>
+
+<p>$stringy-&gt;replace(string $search, string $replace)</p>
+
+<p>S::replace(string $str, string $search, string $replace [, string $encoding ])</p>
+
+<p>Replaces all occurrences of $search with $replace in $str.</p>
+
+<div class="highlight"><pre><span class="nx">S</span><span class="o">::</span><span class="na">create</span><span class="p">(</span><span class="s1">'fòô bàř fòô bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">)</span><span class="o">-&gt;</span><span class="na">replace</span><span class="p">(</span><span class="s1">'fòô '</span><span class="p">,</span> <span class="s1">''</span><span class="p">);</span>
+<span class="nx">S</span><span class="o">::</span><span class="na">replace</span><span class="p">(</span><span class="s1">'fòô bàř fòô bàř'</span><span class="p">,</span> <span class="s1">'fòô '</span><span class="p">,</span> <span class="s1">''</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'bàř bàř'</span>
+</pre></div>
+
+<h4>
+<a name="reverse" class="anchor" href="#reverse"><span class="octicon octicon-link"></span></a>reverse</h4>
 
 <p>$stringy-&gt;reverse()</p>
 
@@ -560,8 +591,8 @@ padded. Alias for pad($str, $length, $padStr, 'right', $encoding)</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">reverse</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'řàb ôòf'</span>
 </pre></div>
 
-<h5>
-<a name="safetruncate" class="anchor" href="#safetruncate"><span class="octicon octicon-link"></span></a>safeTruncate</h5>
+<h4>
+<a name="safetruncate" class="anchor" href="#safetruncate"><span class="octicon octicon-link"></span></a>safeTruncate</h4>
 
 <p>$stringy-&gt;safeTruncate(int $length, [, string $substring = '' ])</p>
 
@@ -576,8 +607,8 @@ exceeding the desired length.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">safeTruncate</span><span class="p">(</span><span class="s1">'What are your plans today?'</span><span class="p">,</span> <span class="mi">22</span><span class="p">,</span> <span class="s1">'...'</span><span class="p">);</span>  <span class="c1">// 'What are your plans...'</span>
 </pre></div>
 
-<h5>
-<a name="shuffle" class="anchor" href="#shuffle"><span class="octicon octicon-link"></span></a>shuffle</h5>
+<h4>
+<a name="shuffle" class="anchor" href="#shuffle"><span class="octicon octicon-link"></span></a>shuffle</h4>
 
 <p>$stringy-&gt;shuffle()</p>
 
@@ -587,11 +618,11 @@ exceeding the desired length.</p>
 in a string.</p>
 
 <div class="highlight"><pre><span class="nx">S</span><span class="o">::</span><span class="na">create</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">)</span><span class="o">-&gt;</span><span class="na">shuffle</span><span class="p">();</span>
-<span class="nx">S</span><span class="o">::</span><span class="na">shuffle</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">)</span>  <span class="c1">// 'àôřb òf'</span>
+<span class="nx">S</span><span class="o">::</span><span class="na">shuffle</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'àôřb òf'</span>
 </pre></div>
 
-<h5>
-<a name="slugify" class="anchor" href="#slugify"><span class="octicon octicon-link"></span></a>slugify</h5>
+<h4>
+<a name="slugify" class="anchor" href="#slugify"><span class="octicon octicon-link"></span></a>slugify</h4>
 
 <p>$stringy-&gt;slugify()</p>
 
@@ -603,11 +634,11 @@ non-alphanumeric and non-ASCII characters, and replacing whitespace with
 dashes. The string is also converted to lowercase.</p>
 
 <div class="highlight"><pre><span class="nx">S</span><span class="o">::</span><span class="na">create</span><span class="p">(</span><span class="s1">'Using strings like fòô bàř'</span><span class="p">)</span><span class="o">-&gt;</span><span class="na">slugify</span><span class="p">();</span>
-<span class="nx">S</span><span class="o">::</span><span class="na">slugify</span><span class="p">(</span><span class="s1">'Using strings like fòô bàř'</span><span class="p">)</span>  <span class="c1">// 'using-strings-like-foo-bar'</span>
+<span class="nx">S</span><span class="o">::</span><span class="na">slugify</span><span class="p">(</span><span class="s1">'Using strings like fòô bàř'</span><span class="p">);</span>  <span class="c1">// 'using-strings-like-foo-bar'</span>
 </pre></div>
 
-<h5>
-<a name="standardize" class="anchor" href="#standardize"><span class="octicon octicon-link"></span></a>standardize</h5>
+<h4>
+<a name="standardize" class="anchor" href="#standardize"><span class="octicon octicon-link"></span></a>standardize</h4>
 
 <p>$stringy-&gt;standardize()</p>
 
@@ -619,8 +650,8 @@ dashes. The string is also converted to lowercase.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">standardize</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">);</span>  <span class="c1">// 'foo bar'</span>
 </pre></div>
 
-<h5>
-<a name="startswith" class="anchor" href="#startswith"><span class="octicon octicon-link"></span></a>startsWith</h5>
+<h4>
+<a name="startswith" class="anchor" href="#startswith"><span class="octicon octicon-link"></span></a>startsWith</h4>
 
 <p>$stringy-&gt;startsWith(string $substring [, boolean $caseSensitive = true ])</p>
 
@@ -634,8 +665,8 @@ by setting $caseSensitive to false.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">startsWith</span><span class="p">(</span><span class="s1">'FÒÔ bàřs'</span><span class="p">,</span> <span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="k">false</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// true</span>
 </pre></div>
 
-<h5>
-<a name="substr" class="anchor" href="#substr"><span class="octicon octicon-link"></span></a>substr</h5>
+<h4>
+<a name="substr" class="anchor" href="#substr"><span class="octicon octicon-link"></span></a>substr</h4>
 
 <p>$stringy-&gt;substr(int $start [, int $length ])</p>
 
@@ -649,8 +680,8 @@ null will return the rest of the string, rather than an empty string.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">substr</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'ô b'</span>
 </pre></div>
 
-<h5>
-<a name="surround" class="anchor" href="#surround"><span class="octicon octicon-link"></span></a>surround</h5>
+<h4>
+<a name="surround" class="anchor" href="#surround"><span class="octicon octicon-link"></span></a>surround</h4>
 
 <p>$stringy-&gt;surround(string $substring)</p>
 
@@ -662,8 +693,8 @@ null will return the rest of the string, rather than an empty string.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">surround</span><span class="p">(</span><span class="s1">' ͜ '</span><span class="p">,</span> <span class="s1">'ʘ'</span><span class="p">);</span>  <span class="c1">// 'ʘ ͜ ʘ'</span>
 </pre></div>
 
-<h5>
-<a name="swapcase" class="anchor" href="#swapcase"><span class="octicon octicon-link"></span></a>swapCase</h5>
+<h4>
+<a name="swapcase" class="anchor" href="#swapcase"><span class="octicon octicon-link"></span></a>swapCase</h4>
 
 <p>$stringy-&gt;swapCase();</p>
 
@@ -675,8 +706,8 @@ null will return the rest of the string, rather than an empty string.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">swapCase</span><span class="p">(</span><span class="s1">'Ντανιλ'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'νΤΑΝΙΛ'</span>
 </pre></div>
 
-<h5>
-<a name="tidy" class="anchor" href="#tidy"><span class="octicon octicon-link"></span></a>tidy</h5>
+<h4>
+<a name="tidy" class="anchor" href="#tidy"><span class="octicon octicon-link"></span></a>tidy</h4>
 
 <p>$stringy-&gt;tidy()</p>
 
@@ -689,8 +720,8 @@ null will return the rest of the string, rather than an empty string.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">tidy</span><span class="p">(</span><span class="s1">'“I see…”'</span><span class="p">);</span>  <span class="c1">// '"I see..."'</span>
 </pre></div>
 
-<h5>
-<a name="titleize" class="anchor" href="#titleize"><span class="octicon octicon-link"></span></a>titleize</h5>
+<h4>
+<a name="titleize" class="anchor" href="#titleize"><span class="octicon octicon-link"></span></a>titleize</h4>
 
 <p>$stringy-&gt;titleize([ string $encoding ])</p>
 
@@ -707,8 +738,8 @@ capitalized.</p>
 <span class="c1">// 'I Like to Watch DVDs at Home'</span>
 </pre></div>
 
-<h5>
-<a name="tospaces" class="anchor" href="#tospaces"><span class="octicon octicon-link"></span></a>toSpaces</h5>
+<h4>
+<a name="tospaces" class="anchor" href="#tospaces"><span class="octicon octicon-link"></span></a>toSpaces</h4>
 
 <p>$stringy-&gt;toSpaces([ tabLength = 4 ])</p>
 
@@ -718,11 +749,11 @@ capitalized.</p>
 $tabLength. By default, each tab is converted to 4 consecutive spaces.</p>
 
 <div class="highlight"><pre><span class="nx">S</span><span class="o">::</span><span class="na">create</span><span class="p">(</span><span class="s1">' String speech = "Hi"'</span><span class="p">)</span><span class="o">-&gt;</span><span class="na">toSpaces</span><span class="p">();</span>
-<span class="nx">S</span><span class="o">::</span><span class="na">toSpaces</span><span class="p">(</span><span class="s1">'   String speech = "Hi"'</span><span class="p">)</span>  <span class="c1">// '    String speech = "Hi"'</span>
+<span class="nx">S</span><span class="o">::</span><span class="na">toSpaces</span><span class="p">(</span><span class="s1">'   String speech = "Hi"'</span><span class="p">);</span>  <span class="c1">// '    String speech = "Hi"'</span>
 </pre></div>
 
-<h5>
-<a name="totabs" class="anchor" href="#totabs"><span class="octicon octicon-link"></span></a>toTabs</h5>
+<h4>
+<a name="totabs" class="anchor" href="#totabs"><span class="octicon octicon-link"></span></a>toTabs</h4>
 
 <p>$stringy-&gt;toTabs([ tabLength = 4 ])</p>
 
@@ -733,11 +764,11 @@ by $tabLength, to a tab. By default, each 4 consecutive spaces are
 converted to a tab.</p>
 
 <div class="highlight"><pre><span class="nx">S</span><span class="o">::</span><span class="na">create</span><span class="p">(</span><span class="s1">'    fòô    bàř'</span><span class="p">)</span><span class="o">-&gt;</span><span class="na">toTabs</span><span class="p">();</span>
-<span class="nx">S</span><span class="o">::</span><span class="na">toTabs</span><span class="p">(</span><span class="s1">'    fòô    bàř'</span><span class="p">)</span>  <span class="c1">// '   fòô bàř'</span>
+<span class="nx">S</span><span class="o">::</span><span class="na">toTabs</span><span class="p">(</span><span class="s1">'    fòô    bàř'</span><span class="p">);</span>  <span class="c1">// '   fòô bàř'</span>
 </pre></div>
 
-<h5>
-<a name="trim" class="anchor" href="#trim"><span class="octicon octicon-link"></span></a>trim</h5>
+<h4>
+<a name="trim" class="anchor" href="#trim"><span class="octicon octicon-link"></span></a>trim</h4>
 
 <p>$stringy-&gt;trim()</p>
 
@@ -746,11 +777,11 @@ converted to a tab.</p>
 <p>Trims $str. An alias for PHP's trim() function.</p>
 
 <div class="highlight"><pre><span class="nx">S</span><span class="o">::</span><span class="na">create</span><span class="p">(</span><span class="s1">'fòô bàř'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">)</span><span class="o">-&gt;</span><span class="na">trim</span><span class="p">();</span>
-<span class="nx">S</span><span class="o">::</span><span class="na">trim</span><span class="p">(</span><span class="s1">' fòô bàř '</span><span class="p">)</span>  <span class="c1">// 'fòô bàř'</span>
+<span class="nx">S</span><span class="o">::</span><span class="na">trim</span><span class="p">(</span><span class="s1">' fòô bàř '</span><span class="p">);</span>  <span class="c1">// 'fòô bàř'</span>
 </pre></div>
 
-<h5>
-<a name="truncate" class="anchor" href="#truncate"><span class="octicon octicon-link"></span></a>truncate</h5>
+<h4>
+<a name="truncate" class="anchor" href="#truncate"><span class="octicon octicon-link"></span></a>truncate</h4>
 
 <p>$stringy-&gt;truncate(int $length, [, string $substring = '' ])</p>
 
@@ -764,8 +795,8 @@ may be appended without exceeding the desired length.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">safeTruncate</span><span class="p">(</span><span class="s1">'What are your plans today?'</span><span class="p">,</span> <span class="mi">19</span><span class="p">,</span> <span class="s1">'...'</span><span class="p">);</span>  <span class="c1">// 'What are your pl...'</span>
 </pre></div>
 
-<h5>
-<a name="underscored" class="anchor" href="#underscored"><span class="octicon octicon-link"></span></a>underscored</h5>
+<h4>
+<a name="underscored" class="anchor" href="#underscored"><span class="octicon octicon-link"></span></a>underscored</h4>
 
 <p>$stringy-&gt;underscored();</p>
 
@@ -780,8 +811,8 @@ of spaces as well as dashes.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">underscored</span><span class="p">(</span><span class="s1">'TestUCase'</span><span class="p">);</span>  <span class="c1">// 'test_u_case'</span>
 </pre></div>
 
-<h5>
-<a name="uppercamelize" class="anchor" href="#uppercamelize"><span class="octicon octicon-link"></span></a>upperCamelize</h5>
+<h4>
+<a name="uppercamelize" class="anchor" href="#uppercamelize"><span class="octicon octicon-link"></span></a>upperCamelize</h4>
 
 <p>$stringy-&gt;upperCamelize();</p>
 
@@ -795,8 +826,8 @@ spaces, dashes and underscores, and removes spaces, dashes, underscores.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">upperCamelize</span><span class="p">(</span><span class="s1">'Upper Camel-Case'</span><span class="p">);</span>  <span class="c1">// 'UpperCamelCase'</span>
 </pre></div>
 
-<h5>
-<a name="uppercasefirst" class="anchor" href="#uppercasefirst"><span class="octicon octicon-link"></span></a>upperCaseFirst</h5>
+<h4>
+<a name="uppercasefirst" class="anchor" href="#uppercasefirst"><span class="octicon octicon-link"></span></a>upperCaseFirst</h4>
 
 <p>$stringy-&gt;upperCaseFirst();</p>
 
@@ -809,26 +840,9 @@ support for multibyte strings.</p>
 <span class="nx">S</span><span class="o">::</span><span class="na">upperCaseFirst</span><span class="p">(</span><span class="s1">'σ test'</span><span class="p">,</span> <span class="s1">'UTF-8'</span><span class="p">);</span>  <span class="c1">// 'Σ test'</span>
 </pre></div>
 
-<h2>
-<a name="todo" class="anchor" href="#todo"><span class="octicon octicon-link"></span></a>TODO</h2>
-
-<p><strong>count</strong> =&gt; substr_count</p>
-
-<p><strong>wordCount</strong> =&gt; str_word_count</p>
-
-<p><strong>wordWrap</strong></p>
-
-<p><strong>excerpt</strong> ($str, $substring, $radius)</p>
-
-<p><strong>pluralize</strong> ($count, $singular, $plural = null)</p>
-
-<p><strong>toBoolean</strong></p>
-
 <h2>
 <a name="tests" class="anchor" href="#tests"><span class="octicon octicon-link"></span></a>Tests</h2>
 
-<p><a href="https://travis-ci.org/danielstjules/Stringy"><img src="https://travis-ci.org/danielstjules/Stringy.png" alt="Build Status"></a></p>
-
 <p>From the project directory, tests can be ran using <code>phpunit</code></p>
 
 <h2>
diff --git a/params.json b/params.json
index c6c0f58..dc2759f 100644
--- a/params.json
+++ b/params.json
@@ -1 +1 @@
-{"name":"Stringy","tagline":"A PHP string manipulation library with multibyte support","body":"# Stringy\r\n\r\nA PHP library with a variety of string manipulation functions with multibyte support. Offers both OO method chaining and a procedural-style static wrapper. Inspired by underscore.string.js.\r\n\r\nNote: The methods listed below are subject to change until we reach a 1.0.0 release.\r\n\r\n* [Requiring/Loading](#requiringloading)\r\n* [OO and Procedural](#oo-and-procedural)\r\n* [Methods](#methods)\r\n    * [at](#at)\r\n    * [camelize](#camelize)\r\n    * [collapseWhitespace](#collapsewhitespace)\r\n    * [contains](#contains)\r\n    * [create](#create)\r\n    * [dasherize](#dasherize)\r\n    * [endsWith](#endswith)\r\n    * [ensureLeft](#ensureleft)\r\n    * [ensureRight](#ensureright)\r\n    * [first](#first)\r\n    * [humanize](#humanize)\r\n    * [insert](#insert)\r\n    * [isAlpha](#isalpha)\r\n    * [isAlphanumeric](#isalphanumeric)\r\n    * [isBlank](#isblank)\r\n    * [isLowerCase](#islowercase)\r\n    * [isUpperCase](#isuppercase)\r\n    * [last](#last)\r\n    * [length](#length)\r\n    * [longestCommonPrefix](#longestcommonprefix)\r\n    * [longestCommonSuffix](#longestcommonsuffix)\r\n    * [longestCommonSubstring](#longestcommonsubstring)\r\n    * [lowerCaseFirst](#lowercasefirst)\r\n    * [pad](#pad)\r\n    * [padBoth](#padboth)\r\n    * [padLeft](#padleft)\r\n    * [padRight](#padright)\r\n    * [removeLeft](#removeleft)\r\n    * [removeRight](#removeright)\r\n    * [reverse](#reverse)\r\n    * [safeTruncate](#safetruncate)\r\n    * [shuffle](#shuffle)\r\n    * [slugify](#slugify)\r\n    * [standardize](#standardize)\r\n    * [startsWith](#startswith)\r\n    * [substr](#substr)\r\n    * [surround](#surround)\r\n    * [swapCase](#swapcase)\r\n    * [tidy](#tidy)\r\n    * [titleize](#titleize)\r\n    * [toSpaces](#tospaces)\r\n    * [toTabs](#totabs)\r\n    * [trim](#trim)\r\n    * [truncate](#truncate)\r\n    * [underscored](#underscored)\r\n    * [upperCamelize](#uppercamelize)\r\n    * [upperCaseFirst](#uppercasefirst)\r\n* [Tests](#tests)\r\n* [License](#license)\r\n\r\n## Requiring/Loading\r\n\r\nIf you're using Composer to manage dependencies, you can include the following in your composer.json file:\r\n\r\n    \"require\": {\r\n        \"danielstjules/stringy\": \"dev-master\"\r\n    }\r\n\r\nThen, after running `composer update` or `php composer.phar update`, you can load the class using Composer's autoloading:\r\n\r\n```php\r\nrequire 'vendor/autoload.php';\r\n```\r\n\r\nOtherwise, you can simply require the file directly:\r\n\r\n```php\r\nrequire_once 'path/to/Stringy/src/Stringy/Stringy.php';\r\n// or\r\nrequire_once 'path/to/Stringy/src/Stringy/StaticStringy.php';\r\n```\r\n\r\nAnd in either case, I'd suggest using an alias.\r\n\r\n```php\r\nuse Stringy\\Stringy as S;\r\n// or\r\nuse Stringy\\StaticStringy as S;\r\n```\r\n\r\n## OO and Procedural\r\n\r\nThe library offers both OO method chaining with `Stringy\\Stringy`, as well as\r\nprocedural-style static method calls with `Stringy\\StaticStringy`. An example\r\nof the former is the following:\r\n\r\n```php\r\nuse Stringy\\Stringy as S;\r\necho S::create(\"Fòô     Bàř\", 'UTF-8')->collapseWhitespace()->swapCase();  // 'fÒÔ bÀŘ'\r\n```\r\n\r\n`Stringy\\Stringy` contains a __toString() method, which returns the current\r\nstring when the object is used in a string context. Its $str property is also\r\npublic, and can be accessed directly if required, ie: `S::create('foo')->str  // 'foo'`\r\n\r\nUsing the static wrapper, an alternative is the following:\r\n\r\n```php\r\nuse Stringy\\StaticStringy as S;\r\n$string = S::collapseWhitespace(\"Fòô     Bàř\", 'UTF-8');\r\necho S::swapCase($string, 'UTF-8');  // 'fÒÔ bÀŘ''\r\n```\r\n\r\n## Methods\r\n\r\nIn the list below, any static method other than S::create refers to a\r\nmethod in Stringy\\StaticStringy. For all others, they're found in Stringy\\Stringy.\r\n\r\n*Note: If $encoding is not given, it defaults to mb_internal_encoding().*\r\n\r\n##### at\r\n\r\n$stringy->at(int $index)\r\n\r\nS::substr(int $index [, string $encoding ])\r\n\r\nGets the character of $str at $index, with indexes starting at 0.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->at(6);\r\nS::at('fòô bàř', 6, 'UTF-8');  // 'ř'\r\n```\r\n\r\n##### camelize\r\n\r\n$stringy->camelize();\r\n\r\nS::camelize(string $str [, string $encoding ])\r\n\r\nReturns a camelCase version of a supplied string, with multibyte support.\r\nTrims surrounding spaces, capitalizes letters following digits, spaces,\r\ndashes and underscores, and removes spaces, dashes, underscores.\r\n\r\n```php\r\nS::create('Camel-Case')->camelize();\r\nS::camelize('Camel-Case');  // 'camelCase'\r\n```\r\n\r\n##### collapseWhitespace\r\n\r\n$stringy->collapseWhitespace()\r\n\r\nS::collapseWhitespace(string $str)\r\n\r\nTrims the string and replaces consecutive whitespace characters with a\r\nsingle space. This inclues tabs and newline characters.\r\n\r\n```php\r\nS::create('   Ο     συγγραφέας  ')->collapseWhitespace();\r\nS::collapseWhitespace('   Ο     συγγραφέας  ');  // 'Ο συγγραφέας'\r\n```\r\n\r\n##### contains\r\n\r\n$stringy->contains(string $needle)\r\n\r\nS::contains(string $haystack, string $needle [, string $encoding ])\r\n\r\nReturns true if $haystack contains $needle, false otherwise.\r\n\r\n```php\r\nS::create('Ο συγγραφέας είπε', 'UTF-8')->contains('συγγραφέας');\r\nS::contains('Ο συγγραφέας είπε', 'συγγραφέας', 'UTF-8')  // true\r\n```\r\n\r\n##### create\r\n\r\n$stringy = S::create(string $str, [, $encoding ])\r\n\r\nCreates a Stringy object and assigns both str and encoding properties\r\nthe supplied values. If $encoding is not specified, it defaults to\r\nmb_internal_encoding(). It then returns the instantiated object.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8');  // 'fòô bàř'\r\n```\r\n\r\n##### dasherize\r\n\r\n$stringy->dasherize();\r\n\r\nS::dasherize(string $str [, string $encoding ])\r\n\r\nReturns a lowercase and trimmed string seperated by dashes, with\r\nmultibyte support. Dashes are inserted before uppercase characters\r\n(with the exception of the first character of the string), and in place\r\nof spaces as well as underscores.\r\n\r\n```php\r\nS::create('TestDCase')->dasherize();\r\nS::dasherize('TestDCase');  // 'test-d-case'\r\n```\r\n\r\n##### endsWith\r\n\r\n$stringy->endsWith(string $substring [, boolean $caseSensitive = true ])\r\n\r\nS::endsWith(string $str, string $substring [, boolean $caseSensitive = true [, string $encoding ]])\r\n\r\nReturns true if the string $str ends with $substring, false otherwise.\r\nBy default, the comparison is case-sensitive, but can be made insensitive\r\nby setting $caseSensitive to false.\r\n\r\n```php\r\nS::create('FÒÔ bàřs', 'UTF-8')->endsWith('àřs', true);\r\nS::endsWith('FÒÔ bàřs', 'àřs', true, 'UTF-8');  // true\r\n```\r\n\r\n##### ensureLeft\r\n\r\n$stringy->ensureLeft(string $substring)\r\n\r\nS::ensureLeft(string $substring [, string $encoding ])\r\n\r\nEnsures that $str begins with $substring.\r\n\r\n```php\r\nS::create('foobar')->ensureLeft('http://');\r\nS::ensureLeft('foobar', 'http://');  // 'http://foobar'\r\n```\r\n\r\n##### ensureRight\r\n\r\n$stringy->ensureRight(string $substring)\r\n\r\nS::ensureRight(string $substring [, string $encoding ])\r\n\r\nEnsures that $str ends with $substring.\r\n\r\n```php\r\nS::create('foobar')->ensureRight('.com');\r\nS::ensureRight('foobar', '.com');  // 'foobar.com'\r\n```\r\n\r\n##### first\r\n\r\n$stringy->first(int $n)\r\n\r\nS::first(int $n [, string $encoding ])\r\n\r\nGets the first $n characters of $str.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->first(3);\r\nS::first('fòô bàř', 3, 'UTF-8');  // 'fòô'\r\n```\r\n\r\n##### humanize\r\n\r\n$stringy->humanize()\r\n\r\nS::humanize(string $str [, string $encoding ])\r\n\r\nCapitalizes the first word of a string, replaces underscores with spaces,\r\nand strips '_id'.\r\n\r\n```php\r\nS::create('author_id')->humanize();\r\nS::humanize('author_id');  // 'Author'\r\n```\r\n\r\n##### insert\r\n\r\n$stringy->insert(int $index, string $substring)\r\n\r\nS::insert(string $str, int $index, string $substring [, string $encoding ])\r\n\r\nInserts $substring into $str at the $index provided.\r\n\r\n```php\r\nS::create('fòô bà', 'UTF-8')->insert('ř', 6);\r\nS::insert('fòô bà', 'ř', 6, 'UTF-8');  // 'fòô bàř'\r\n```\r\n\r\n##### isAlpha\r\n\r\n$stringy->isAlpha()\r\n\r\nS::isAlpha(string $str [, string $encoding ])\r\n\r\nReturns true if $str contains only alphabetic chars, false otherwise.\r\n\r\n```php\r\nS::create('丹尼爾', 'UTF-8')->isAlpha();\r\nS::isAlpha('丹尼爾', 'UTF-8');  // true\r\n```\r\n\r\n##### isAlphanumeric\r\n\r\n$stringy->isAlphanumeric()\r\n\r\nS::isAlphanumeric(string $str [, string $encoding ])\r\n\r\nReturns true if $str contains only alphabetic and numeric chars, false\r\notherwise.\r\n\r\n```php\r\nS::create('دانيال1', 'UTF-8')->isAlphanumeric();\r\nS::isAlphanumeric('دانيال1', 'UTF-8');  // true\r\n```\r\n\r\n##### isBlank\r\n\r\n$stringy->isBlank()\r\n\r\nS::isBlank(string $str [, string $encoding ])\r\n\r\nReturns true if $str contains only whitespace chars, false otherwise.\r\n\r\n```php\r\nS::create(\"\\n\\t  \\v\\f\")->isBlank();\r\nS::isBlank(\"\\n\\t  \\v\\f\");  // true\r\n```\r\n\r\n##### isLowerCase\r\n\r\n$stringy->isLowerCase()\r\n\r\nS::isLowerCase(string $str [, string $encoding ])\r\n\r\nReturns true if $str contains only lower case chars, false otherwise.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->isLowerCase();\r\nS::isLowerCase('fòô bàř', 'UTF-8');  // true\r\n```\r\n\r\n##### isUpperCase\r\n\r\n$stringy->isUpperCase()\r\n\r\nS::isUpperCase(string $str [, string $encoding ])\r\n\r\nReturns true if $str contains only upper case chars, false otherwise.\r\n\r\n```php\r\nS::create('FÒÔBÀŘ',, 'UTF-8')->isUpperCase();\r\nS::isUpperCase('FÒÔBÀŘ',, 'UTF-8');  // true\r\n```\r\n\r\n##### last\r\n\r\n$stringy->last(int $n)\r\n\r\nS::last(int $n [, string $encoding ])\r\n\r\nGets the last $n characters of $str.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->last(3);\r\nS::last('fòô bàř', 3, 'UTF-8');  // 'bàř'\r\n```\r\n\r\n##### length\r\n\r\n$stringy->length()\r\n\r\nS::length(string $str [, string $encoding ])\r\n\r\nReturns the length of $str. An alias for PHP's mb_strlen() function.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->length();\r\nS::length('fòô bàř', 'UTF-8');  // 7\r\n```\r\n\r\n##### longestCommonPrefix\r\n\r\n$stringy->longestCommonPrefix(string $otherStr)\r\n\r\nS::longestCommonPrefix(string $str, string $otherStr [, $encoding ])\r\n\r\nFinds the longest common prefix between $str and $otherStr.\r\n\r\n```php\r\nS::create('fòô bar', 'UTF-8')->longestCommonPrefix('fòr bar');\r\nS::longestCommonPrefix('fòô bar', 'fòr bar', 'UTF-8');  // 'fò'\r\n```\r\n\r\n##### longestCommonSuffix\r\n\r\n$stringy->longestCommonSuffix(string $otherStr)\r\n\r\nS::longestCommonSuffix(string $str, string $otherStr [, $encoding ])\r\n\r\nFinds the longest common suffix between $str and $otherStr.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->longestCommonSuffix('fòr bàř');\r\nS::longestCommonSuffix('fòô bàř', 'fòr bàř', 'UTF-8');  // ' bàř'\r\n```\r\n\r\n##### longestCommonSubstring\r\n\r\n$stringy->longestCommonSubstring(string $otherStr)\r\n\r\nS::longestCommonSubstring(string $str, string $otherStr [, $encoding ])\r\n\r\nFinds the longest common substring between $str and $otherStr. In the\r\ncase of ties, returns that which occurs first.\r\n\r\n```php\r\nS::create('foo bar')->longestCommonSubstring('boo far');\r\nS::longestCommonSubstring('foo bar', 'boo far');  // 'oo '\r\n```\r\n\r\n##### lowerCaseFirst\r\n\r\n$stringy->lowerCaseFirst();\r\n\r\nS::lowerCaseFirst(string $str [, string $encoding ])\r\n\r\nConverts the first character of the supplied string to lower case, with\r\nsupport for multibyte strings.\r\n\r\n```php\r\nS::create('Σ test', 'UTF-8')->lowerCaseFirst();\r\nS::lowerCaseFirst('Σ test', 'UTF-8');  // 'σ test'\r\n```\r\n\r\n##### pad\r\n\r\n$stringy->pad(int $length [, string $padStr = ' ' [, string $padType = 'right' ]])\r\n\r\nS::pad(string $str , int $length [, string $padStr = ' ' [, string $padType = 'right' [, string $encoding ]]])\r\n\r\nPads a string to a given length with another string. If length is less\r\nthan or equal to the length of $str, then no padding takes places. The\r\ndefault string used for padding is a space, and the default type (one of\r\n'left', 'right', 'both') is 'right'. Throws an exception if $padType\r\nisn't one of those 3 values.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->pad( 10, '¬ø', 'left',);\r\nS::pad('fòô bàř', 10, '¬ø', 'left', 'UTF-8');  // '¬ø¬fòô bàř'\r\n```\r\n\r\n##### padBoth\r\n\r\n$stringy->padBoth(int $length [, string $padStr = ' ' ])\r\n\r\nS::padBoth(string $str , int $length [, string $padStr = ' ' [, string $encoding ]])\r\n\r\nReturns a new string of a given length such that both sides of the string\r\nstring are padded. Alias for pad($str, $length, $padStr, 'both', $encoding)\r\n\r\n```php\r\nS::create('foo bar')->padBoth(9, ' ');\r\nS::padBoth('foo bar', 9, ' ');  // ' foo bar '\r\n```\r\n\r\n##### padLeft\r\n\r\n$stringy->padLeft(int $length [, string $padStr = ' ' ])\r\n\r\nS::padLeft(string $str , int $length [, string $padStr = ' ' [, string $encoding ]])\r\n\r\nReturns a new string of a given length such that the beginning of the\r\nstring is padded. Alias for pad($str, $length, $padStr, 'left', $encoding)\r\n\r\n```php\r\nS::create($str, $encoding)->padLeft($length, $padStr);\r\nS::padLeft('foo bar', 9, ' ');  // '  foo bar'\r\n```\r\n\r\n##### padRight\r\n\r\n$stringy->padRight(int $length [, string $padStr = ' ' ])\r\n\r\nS::padRight(string $str , int $length [, string $padStr = ' ' [, string $encoding ]])\r\n\r\nReturns a new string of a given length such that the end of the string is\r\npadded. Alias for pad($str, $length, $padStr, 'right', $encoding)\r\n\r\n```php\r\nS::create('foo bar')->padRight(10, '_*');\r\nS::padRight('foo bar', 10, '_*');  // 'foo bar_*_'\r\n```\r\n\r\n##### removeLeft\r\n\r\n$stringy->removeLeft(string $substring)\r\n\r\nS::removeLeft(string $str, string $substring [, string $encoding ])\r\n\r\nRemoves the prefix $substring if present.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->removeLeft('fòô ');\r\nS::removeLeft('fòô bàř', 'fòô ', 'UTF-8');  // 'bàř'\r\n```\r\n\r\n##### removeRight\r\n\r\n$stringy->removeRight(string $substring)\r\n\r\nS::removeRight(string $str, string $substring [, string $encoding ])\r\n\r\nRemoves the suffix $substring if present.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->removeRight(' bàř');\r\nS::removeRight('fòô bàř', ' bàř', 'UTF-8');  // 'fòô'\r\n```\r\n\r\n##### reverse\r\n\r\n$stringy->reverse()\r\n\r\nS::reverse(string $str, [, string $encoding ])\r\n\r\nReverses a string. A multibyte version of strrev.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->reverse();\r\nS::reverse('fòô bàř', 'UTF-8');  // 'řàb ôòf'\r\n```\r\n\r\n##### safeTruncate\r\n\r\n$stringy->safeTruncate(int $length, [, string $substring = '' ])\r\n\r\nS::safeTruncate(string $str, int $length, [, string $substring = '' [, string $encoding ]])\r\n\r\nTruncates the string to a given length, while ensuring that it does not\r\nchop words. If $substring is provided, and truncating occurs, the string\r\nis further truncated so that the substring may be appended without\r\nexceeding the desired length.\r\n\r\n```php\r\nS::create('What are your plans today?')->safeTruncate(22, '...');\r\nS::safeTruncate('What are your plans today?', 22, '...');  // 'What are your plans...'\r\n```\r\n\r\n##### shuffle\r\n\r\n$stringy->shuffle()\r\n\r\nS::shuffle(string $str [, string $encoding ])\r\n\r\nA multibyte str_shuffle function. It randomizes the order of characters\r\nin a string.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->shuffle();\r\nS::shuffle('fòô bàř', 'UTF-8')  // 'àôřb òf'\r\n```\r\n\r\n##### slugify\r\n\r\n$stringy->slugify()\r\n\r\nS::slugify(string $str)\r\n\r\nConverts the supplied text into an URL slug. This includes replacing\r\nnon-ASCII characters with their closest ASCII equivalents, removing\r\nnon-alphanumeric and non-ASCII characters, and replacing whitespace with\r\ndashes. The string is also converted to lowercase.\r\n\r\n```php\r\nS::create('Using strings like fòô bàř')->slugify();\r\nS::slugify('Using strings like fòô bàř')  // 'using-strings-like-foo-bar'\r\n```\r\n\r\n##### standardize\r\n\r\n$stringy->standardize()\r\n\r\nS::standardize(string $str)\r\n\r\nConverts some non-ASCII characters to their closest ASCII counterparts.\r\n\r\n```php\r\nS::create('fòô bàř')->standardize();\r\nS::standardize('fòô bàř');  // 'foo bar'\r\n```\r\n\r\n##### startsWith\r\n\r\n$stringy->startsWith(string $substring [, boolean $caseSensitive = true ])\r\n\r\nS::startsWith(string $str, string $substring [, boolean $caseSensitive = true [, string $encoding ]])\r\n\r\nReturns true if the string $str begins with $substring, false otherwise.\r\nBy default, the comparison is case-sensitive, but can be made insensitive\r\nby setting $caseSensitive to false.\r\n\r\n```php\r\nS::create('FÒÔ bàřs', 'UTF-8')->startsWith('fòô bàř', false);\r\nS::startsWith('FÒÔ bàřs', 'fòô bàř', false, 'UTF-8');  // true\r\n```\r\n\r\n##### substr\r\n\r\n$stringy->substr(int $start [, int $length ])\r\n\r\nS::substr(string $str, int $start [, int $length [, string $encoding ]])\r\n\r\nGets the substring of $str beginning at $start with the specified $length.\r\nIt differs from the mb_substr() function in that providing a $length of\r\nnull will return the rest of the string, rather than an empty string.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->substr(2, 3);\r\nS::substr('fòô bàř', 2, 3, 'UTF-8');  // 'ô b'\r\n```\r\n\r\n##### surround\r\n\r\n$stringy->surround(string $substring)\r\n\r\nS::surround(string $str, string $substring)\r\n\r\nSurrounds a string with the given substring.\r\n\r\n```php\r\nS::create(' ͜ ')->surround('ʘ');\r\nS::surround(' ͜ ', 'ʘ');  // 'ʘ ͜ ʘ'\r\n```\r\n\r\n##### swapCase\r\n\r\n$stringy->swapCase();\r\n\r\nS::swapCase(string $str [, string $encoding ])\r\n\r\nReturns a case swapped version of a string.\r\n\r\n```php\r\nS::create('Ντανιλ', 'UTF-8')->swapCase();\r\nS::swapCase('Ντανιλ', 'UTF-8');  // 'νΤΑΝΙΛ'\r\n```\r\n\r\n##### tidy\r\n\r\n$stringy->tidy()\r\n\r\nS::tidy(string $str)\r\n\r\nReplaces smart quotes, ellipsis characters, and dashes from Windows-1252\r\n(and commonly used in Word documents) with their ASCII equivalents.\r\n\r\n```php\r\nS::create('“I see…”')->tidy();\r\nS::tidy('“I see…”');  // '\"I see...\"'\r\n```\r\n\r\n##### titleize\r\n\r\n$stringy->titleize([ string $encoding ])\r\n\r\nS::titleize(string $str [, array $ignore [, string $encoding ]])\r\n\r\nCapitalizes the first letter of each word in a string, after trimming.\r\nIgnores the case of other letters, allowing for the use of acronyms.\r\nAlso accepts an array, $ignore, allowing you to list words not to be\r\ncapitalized.\r\n\r\n```php\r\n$ignore = array('at', 'by', 'for', 'in', 'of', 'on', 'out', 'to', 'the');\r\nS::create('i like to watch DVDs at home', 'UTF-8')->titleize($ignore);\r\nS::titleize('i like to watch DVDs at home', $ignore, 'UTF-8');\r\n// 'I Like to Watch DVDs at Home'\r\n```\r\n\r\n##### toSpaces\r\n\r\n$stringy->toSpaces([ tabLength = 4 ])\r\n\r\nS::toSpaces(string $str, [, int $tabLength = 4 ])\r\n\r\nConverts each tab in a string to some number of spaces, as defined by\r\n$tabLength. By default, each tab is converted to 4 consecutive spaces.\r\n\r\n```php\r\nS::create(' String speech = \"Hi\"')->toSpaces();\r\nS::toSpaces('   String speech = \"Hi\"')  // '    String speech = \"Hi\"'\r\n```\r\n\r\n##### toTabs\r\n\r\n$stringy->toTabs([ tabLength = 4 ])\r\n\r\nS::toTabs(string $str, [, int $tabLength = 4 ])\r\n\r\nConverts each occurence of some consecutive number of spaces, as defined\r\nby $tabLength, to a tab. By default, each 4 consecutive spaces are\r\nconverted to a tab.\r\n\r\n```php\r\nS::create('    fòô    bàř')->toTabs();\r\nS::toTabs('    fòô    bàř')  // '   fòô bàř'\r\n```\r\n\r\n##### trim\r\n\r\n$stringy->trim()\r\n\r\nS::trim(string $str)\r\n\r\nTrims $str. An alias for PHP's trim() function.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->trim();\r\nS::trim(' fòô bàř ')  // 'fòô bàř'\r\n```\r\n\r\n##### truncate\r\n\r\n$stringy->truncate(int $length, [, string $substring = '' ])\r\n\r\nS::truncate(string $str, int $length, [, string $substring = '' [, string $encoding ]])\r\n\r\nTruncates $str to a given length. If $substring is provided, and\r\ntruncating occurs, the string is further truncated so that the substring\r\nmay be appended without exceeding the desired length.\r\n\r\n```php\r\nS::create('What are your plans today?')->safeTruncate(19, '...');\r\nS::safeTruncate('What are your plans today?', 19, '...');  // 'What are your pl...'\r\n```\r\n\r\n##### underscored\r\n\r\n$stringy->underscored();\r\n\r\nS::underscored(string $str [, string $encoding ])\r\n\r\nReturns a lowercase and trimmed string seperated by underscores, with\r\nmultibyte support. Underscores are inserted before uppercase characters\r\n(with the exception of the first character of the string), and in place\r\nof spaces as well as dashes.\r\n\r\n```php\r\nS::create('TestUCase')->underscored();\r\nS::underscored('TestUCase');  // 'test_u_case'\r\n```\r\n\r\n##### upperCamelize\r\n\r\n$stringy->upperCamelize();\r\n\r\nS::upperCamelize(string $str [, string $encoding ])\r\n\r\nReturns an UpperCamelCase version of a supplied string, with multibyte\r\nsupport. Trims surrounding spaces, capitalizes letters following digits,\r\nspaces, dashes and underscores, and removes spaces, dashes, underscores.\r\n\r\n```php\r\nS::create('Upper Camel-Case')->upperCamelize();\r\nS::upperCamelize('Upper Camel-Case');  // 'UpperCamelCase'\r\n```\r\n\r\n##### upperCaseFirst\r\n\r\n$stringy->upperCaseFirst();\r\n\r\nS::upperCaseFirst(string $str [, string $encoding ])\r\n\r\nConverts the first character of the supplied string to upper case, with\r\nsupport for multibyte strings.\r\n\r\n```php\r\nS::create('σ test', 'UTF-8')->upperCaseFirst();\r\nS::upperCaseFirst('σ test', 'UTF-8');  // 'Σ test'\r\n```\r\n\r\n## TODO\r\n\r\n**count** => substr_count\r\n\r\n**wordCount** => str_word_count\r\n\r\n**wordWrap**\r\n\r\n**excerpt** ($str, $substring, $radius)\r\n\r\n**pluralize** ($count, $singular, $plural = null)\r\n\r\n**toBoolean**\r\n\r\n## Tests\r\n\r\n[![Build Status](https://travis-ci.org/danielstjules/Stringy.png)](https://travis-ci.org/danielstjules/Stringy)\r\n\r\nFrom the project directory, tests can be ran using `phpunit`\r\n\r\n## License\r\n\r\nReleased under the MIT License - see `LICENSE.txt` for details.\r\n","google":"","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file
+{"name":"Stringy","tagline":"A PHP string manipulation library with multibyte support","body":"# Stringy\r\n\r\nA 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.\r\n\r\n[![Build Status](https://travis-ci.org/danielstjules/Stringy.png)](https://travis-ci.org/danielstjules/Stringy)\r\n[![Total Downloads](https://poser.pugx.org/danielstjules/Stringy/downloads.png)](https://packagist.org/packages/danielstjules/stringy)\r\n[![Latest Stable Version](https://poser.pugx.org/danielstjules/Stringy/v/stable.png)](https://packagist.org/packages/danielstjules/stringy)\r\n\r\n* [Requiring/Loading](#requiringloading)\r\n* [OO and Procedural](#oo-and-procedural)\r\n* [Methods](#methods)\r\n    * [at](#at)\r\n    * [camelize](#camelize)\r\n    * [collapseWhitespace](#collapsewhitespace)\r\n    * [contains](#contains)\r\n    * [count](#count)\r\n    * [create](#create)\r\n    * [dasherize](#dasherize)\r\n    * [endsWith](#endswith)\r\n    * [ensureLeft](#ensureleft)\r\n    * [ensureRight](#ensureright)\r\n    * [first](#first)\r\n    * [humanize](#humanize)\r\n    * [insert](#insert)\r\n    * [isAlpha](#isalpha)\r\n    * [isAlphanumeric](#isalphanumeric)\r\n    * [isBlank](#isblank)\r\n    * [isLowerCase](#islowercase)\r\n    * [isUpperCase](#isuppercase)\r\n    * [last](#last)\r\n    * [length](#length)\r\n    * [longestCommonPrefix](#longestcommonprefix)\r\n    * [longestCommonSuffix](#longestcommonsuffix)\r\n    * [longestCommonSubstring](#longestcommonsubstring)\r\n    * [lowerCaseFirst](#lowercasefirst)\r\n    * [pad](#pad)\r\n    * [padBoth](#padboth)\r\n    * [padLeft](#padleft)\r\n    * [padRight](#padright)\r\n    * [removeLeft](#removeleft)\r\n    * [removeRight](#removeright)\r\n    * [replace](#replace)\r\n    * [reverse](#reverse)\r\n    * [safeTruncate](#safetruncate)\r\n    * [shuffle](#shuffle)\r\n    * [slugify](#slugify)\r\n    * [standardize](#standardize)\r\n    * [startsWith](#startswith)\r\n    * [substr](#substr)\r\n    * [surround](#surround)\r\n    * [swapCase](#swapcase)\r\n    * [tidy](#tidy)\r\n    * [titleize](#titleize)\r\n    * [toSpaces](#tospaces)\r\n    * [toTabs](#totabs)\r\n    * [trim](#trim)\r\n    * [truncate](#truncate)\r\n    * [underscored](#underscored)\r\n    * [upperCamelize](#uppercamelize)\r\n    * [upperCaseFirst](#uppercasefirst)\r\n* [Tests](#tests)\r\n* [License](#license)\r\n\r\n## Requiring/Loading\r\n\r\nIf you're using Composer to manage dependencies, you can include the following in your composer.json file:\r\n\r\n    \"require\": {\r\n        \"danielstjules/stringy\": \"dev-master\"\r\n    }\r\n\r\nThen, after running `composer update` or `php composer.phar update`, you can load the class using Composer's autoloading:\r\n\r\n```php\r\nrequire 'vendor/autoload.php';\r\n```\r\n\r\nOtherwise, you can simply require the file directly:\r\n\r\n```php\r\nrequire_once 'path/to/Stringy/src/Stringy/Stringy.php';\r\n// or\r\nrequire_once 'path/to/Stringy/src/Stringy/StaticStringy.php';\r\n```\r\n\r\nAnd in either case, I'd suggest using an alias.\r\n\r\n```php\r\nuse Stringy\\Stringy as S;\r\n// or\r\nuse Stringy\\StaticStringy as S;\r\n```\r\n\r\n## OO and Procedural\r\n\r\nThe library offers both OO method chaining with `Stringy\\Stringy`, as well as\r\nprocedural-style static method calls with `Stringy\\StaticStringy`. An example\r\nof the former is the following:\r\n\r\n```php\r\nuse Stringy\\Stringy as S;\r\necho S::create(\"Fòô     Bàř\", 'UTF-8')->collapseWhitespace()->swapCase();  // 'fÒÔ bÀŘ'\r\n```\r\n\r\n`Stringy\\Stringy` contains a __toString() method, which returns the current\r\nstring when the object is used in a string context. Its $str property is also\r\npublic, and can be accessed directly if required, ie: `S::create('foo')->str  // 'foo'`\r\n\r\nUsing the static wrapper, an alternative is the following:\r\n\r\n```php\r\nuse Stringy\\StaticStringy as S;\r\n$string = S::collapseWhitespace(\"Fòô     Bàř\", 'UTF-8');\r\necho S::swapCase($string, 'UTF-8');  // 'fÒÔ bÀŘ''\r\n```\r\n\r\n## Methods\r\n\r\nIn the list below, any static method other than S::create refers to a\r\nmethod 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.\r\n\r\n*Note: If $encoding is not given, it defaults to mb_internal_encoding().*\r\n\r\n#### at\r\n\r\n$stringy->at(int $index)\r\n\r\nS::substr(int $index [, string $encoding ])\r\n\r\nGets the character of $str at $index, with indexes starting at 0.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->at(6);\r\nS::at('fòô bàř', 6, 'UTF-8');  // 'ř'\r\n```\r\n\r\n#### camelize\r\n\r\n$stringy->camelize();\r\n\r\nS::camelize(string $str [, string $encoding ])\r\n\r\nReturns a camelCase version of a supplied string, with multibyte support.\r\nTrims surrounding spaces, capitalizes letters following digits, spaces,\r\ndashes and underscores, and removes spaces, dashes, underscores.\r\n\r\n```php\r\nS::create('Camel-Case')->camelize();\r\nS::camelize('Camel-Case');  // 'camelCase'\r\n```\r\n\r\n#### collapseWhitespace\r\n\r\n$stringy->collapseWhitespace()\r\n\r\nS::collapseWhitespace(string $str)\r\n\r\nTrims the string and replaces consecutive whitespace characters with a\r\nsingle space. This inclues tabs and newline characters.\r\n\r\n```php\r\nS::create('   Ο     συγγραφέας  ')->collapseWhitespace();\r\nS::collapseWhitespace('   Ο     συγγραφέας  ');  // 'Ο συγγραφέας'\r\n```\r\n\r\n#### contains\r\n\r\n$stringy->contains(string $needle)\r\n\r\nS::contains(string $haystack, string $needle [, string $encoding ])\r\n\r\nReturns true if $haystack contains $needle, false otherwise.\r\n\r\n```php\r\nS::create('Ο συγγραφέας είπε', 'UTF-8')->contains('συγγραφέας');\r\nS::contains('Ο συγγραφέας είπε', 'συγγραφέας', 'UTF-8');  // true\r\n```\r\n\r\n#### count\r\n\r\n$stringy->count(string $substring)\r\n\r\nS::count(string $str, string $substring [, string $encoding ])\r\n\r\nReturns the number of occurences of $substring in $str. An alias for\r\nmb_substr_count()\r\n\r\n```php\r\nS::create('Ο συγγραφέας είπε', 'UTF-8')->count('α');\r\nS::count('Ο συγγραφέας είπε', 'α', 'UTF-8');  // 2\r\n```\r\n\r\n#### create\r\n\r\n$stringy = S::create(string $str, [, $encoding ])\r\n\r\nCreates a Stringy object and assigns both str and encoding properties\r\nthe supplied values. If $encoding is not specified, it defaults to\r\nmb_internal_encoding(). It then returns the instantiated object.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8');  // 'fòô bàř'\r\n```\r\n\r\n#### dasherize\r\n\r\n$stringy->dasherize();\r\n\r\nS::dasherize(string $str [, string $encoding ])\r\n\r\nReturns a lowercase and trimmed string seperated by dashes, with\r\nmultibyte support. Dashes are inserted before uppercase characters\r\n(with the exception of the first character of the string), and in place\r\nof spaces as well as underscores.\r\n\r\n```php\r\nS::create('TestDCase')->dasherize();\r\nS::dasherize('TestDCase');  // 'test-d-case'\r\n```\r\n\r\n#### endsWith\r\n\r\n$stringy->endsWith(string $substring [, boolean $caseSensitive = true ])\r\n\r\nS::endsWith(string $str, string $substring [, boolean $caseSensitive = true [, string $encoding ]])\r\n\r\nReturns true if the string $str ends with $substring, false otherwise.\r\nBy default, the comparison is case-sensitive, but can be made insensitive\r\nby setting $caseSensitive to false.\r\n\r\n```php\r\nS::create('FÒÔ bàřs', 'UTF-8')->endsWith('àřs', true);\r\nS::endsWith('FÒÔ bàřs', 'àřs', true, 'UTF-8');  // true\r\n```\r\n\r\n#### ensureLeft\r\n\r\n$stringy->ensureLeft(string $substring)\r\n\r\nS::ensureLeft(string $substring [, string $encoding ])\r\n\r\nEnsures that $str begins with $substring.\r\n\r\n```php\r\nS::create('foobar')->ensureLeft('http://');\r\nS::ensureLeft('foobar', 'http://');  // 'http://foobar'\r\n```\r\n\r\n#### ensureRight\r\n\r\n$stringy->ensureRight(string $substring)\r\n\r\nS::ensureRight(string $substring [, string $encoding ])\r\n\r\nEnsures that $str ends with $substring.\r\n\r\n```php\r\nS::create('foobar')->ensureRight('.com');\r\nS::ensureRight('foobar', '.com');  // 'foobar.com'\r\n```\r\n\r\n#### first\r\n\r\n$stringy->first(int $n)\r\n\r\nS::first(int $n [, string $encoding ])\r\n\r\nGets the first $n characters of $str.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->first(3);\r\nS::first('fòô bàř', 3, 'UTF-8');  // 'fòô'\r\n```\r\n\r\n#### humanize\r\n\r\n$stringy->humanize()\r\n\r\nS::humanize(string $str [, string $encoding ])\r\n\r\nCapitalizes the first word of a string, replaces underscores with spaces,\r\nand strips '_id'.\r\n\r\n```php\r\nS::create('author_id')->humanize();\r\nS::humanize('author_id');  // 'Author'\r\n```\r\n\r\n#### insert\r\n\r\n$stringy->insert(int $index, string $substring)\r\n\r\nS::insert(string $str, int $index, string $substring [, string $encoding ])\r\n\r\nInserts $substring into $str at the $index provided.\r\n\r\n```php\r\nS::create('fòô bà', 'UTF-8')->insert('ř', 6);\r\nS::insert('fòô bà', 'ř', 6, 'UTF-8');  // 'fòô bàř'\r\n```\r\n\r\n#### isAlpha\r\n\r\n$stringy->isAlpha()\r\n\r\nS::isAlpha(string $str [, string $encoding ])\r\n\r\nReturns true if $str contains only alphabetic chars, false otherwise.\r\n\r\n```php\r\nS::create('丹尼爾', 'UTF-8')->isAlpha();\r\nS::isAlpha('丹尼爾', 'UTF-8');  // true\r\n```\r\n\r\n#### isAlphanumeric\r\n\r\n$stringy->isAlphanumeric()\r\n\r\nS::isAlphanumeric(string $str [, string $encoding ])\r\n\r\nReturns true if $str contains only alphabetic and numeric chars, false\r\notherwise.\r\n\r\n```php\r\nS::create('دانيال1', 'UTF-8')->isAlphanumeric();\r\nS::isAlphanumeric('دانيال1', 'UTF-8');  // true\r\n```\r\n\r\n#### isBlank\r\n\r\n$stringy->isBlank()\r\n\r\nS::isBlank(string $str [, string $encoding ])\r\n\r\nReturns true if $str contains only whitespace chars, false otherwise.\r\n\r\n```php\r\nS::create(\"\\n\\t  \\v\\f\")->isBlank();\r\nS::isBlank(\"\\n\\t  \\v\\f\");  // true\r\n```\r\n\r\n#### isLowerCase\r\n\r\n$stringy->isLowerCase()\r\n\r\nS::isLowerCase(string $str [, string $encoding ])\r\n\r\nReturns true if $str contains only lower case chars, false otherwise.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->isLowerCase();\r\nS::isLowerCase('fòô bàř', 'UTF-8');  // true\r\n```\r\n\r\n#### isUpperCase\r\n\r\n$stringy->isUpperCase()\r\n\r\nS::isUpperCase(string $str [, string $encoding ])\r\n\r\nReturns true if $str contains only upper case chars, false otherwise.\r\n\r\n```php\r\nS::create('FÒÔBÀŘ',, 'UTF-8')->isUpperCase();\r\nS::isUpperCase('FÒÔBÀŘ',, 'UTF-8');  // true\r\n```\r\n\r\n#### last\r\n\r\n$stringy->last(int $n)\r\n\r\nS::last(int $n [, string $encoding ])\r\n\r\nGets the last $n characters of $str.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->last(3);\r\nS::last('fòô bàř', 3, 'UTF-8');  // 'bàř'\r\n```\r\n\r\n#### length\r\n\r\n$stringy->length()\r\n\r\nS::length(string $str [, string $encoding ])\r\n\r\nReturns the length of $str. An alias for PHP's mb_strlen() function.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->length();\r\nS::length('fòô bàř', 'UTF-8');  // 7\r\n```\r\n\r\n#### longestCommonPrefix\r\n\r\n$stringy->longestCommonPrefix(string $otherStr)\r\n\r\nS::longestCommonPrefix(string $str, string $otherStr [, $encoding ])\r\n\r\nFinds the longest common prefix between $str and $otherStr.\r\n\r\n```php\r\nS::create('fòô bar', 'UTF-8')->longestCommonPrefix('fòr bar');\r\nS::longestCommonPrefix('fòô bar', 'fòr bar', 'UTF-8');  // 'fò'\r\n```\r\n\r\n#### longestCommonSuffix\r\n\r\n$stringy->longestCommonSuffix(string $otherStr)\r\n\r\nS::longestCommonSuffix(string $str, string $otherStr [, $encoding ])\r\n\r\nFinds the longest common suffix between $str and $otherStr.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->longestCommonSuffix('fòr bàř');\r\nS::longestCommonSuffix('fòô bàř', 'fòr bàř', 'UTF-8');  // ' bàř'\r\n```\r\n\r\n#### longestCommonSubstring\r\n\r\n$stringy->longestCommonSubstring(string $otherStr)\r\n\r\nS::longestCommonSubstring(string $str, string $otherStr [, $encoding ])\r\n\r\nFinds the longest common substring between $str and $otherStr. In the\r\ncase of ties, returns that which occurs first.\r\n\r\n```php\r\nS::create('foo bar')->longestCommonSubstring('boo far');\r\nS::longestCommonSubstring('foo bar', 'boo far');  // 'oo '\r\n```\r\n\r\n#### lowerCaseFirst\r\n\r\n$stringy->lowerCaseFirst();\r\n\r\nS::lowerCaseFirst(string $str [, string $encoding ])\r\n\r\nConverts the first character of the supplied string to lower case, with\r\nsupport for multibyte strings.\r\n\r\n```php\r\nS::create('Σ test', 'UTF-8')->lowerCaseFirst();\r\nS::lowerCaseFirst('Σ test', 'UTF-8');  // 'σ test'\r\n```\r\n\r\n#### pad\r\n\r\n$stringy->pad(int $length [, string $padStr = ' ' [, string $padType = 'right' ]])\r\n\r\nS::pad(string $str , int $length [, string $padStr = ' ' [, string $padType = 'right' [, string $encoding ]]])\r\n\r\nPads a string to a given length with another string. If length is less\r\nthan or equal to the length of $str, then no padding takes places. The\r\ndefault string used for padding is a space, and the default type (one of\r\n'left', 'right', 'both') is 'right'. Throws an exception if $padType\r\nisn't one of those 3 values.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->pad( 10, '¬ø', 'left',);\r\nS::pad('fòô bàř', 10, '¬ø', 'left', 'UTF-8');  // '¬ø¬fòô bàř'\r\n```\r\n\r\n#### padBoth\r\n\r\n$stringy->padBoth(int $length [, string $padStr = ' ' ])\r\n\r\nS::padBoth(string $str , int $length [, string $padStr = ' ' [, string $encoding ]])\r\n\r\nReturns a new string of a given length such that both sides of the string\r\nstring are padded. Alias for pad($str, $length, $padStr, 'both', $encoding)\r\n\r\n```php\r\nS::create('foo bar')->padBoth(9, ' ');\r\nS::padBoth('foo bar', 9, ' ');  // ' foo bar '\r\n```\r\n\r\n#### padLeft\r\n\r\n$stringy->padLeft(int $length [, string $padStr = ' ' ])\r\n\r\nS::padLeft(string $str , int $length [, string $padStr = ' ' [, string $encoding ]])\r\n\r\nReturns a new string of a given length such that the beginning of the\r\nstring is padded. Alias for pad($str, $length, $padStr, 'left', $encoding)\r\n\r\n```php\r\nS::create($str, $encoding)->padLeft($length, $padStr);\r\nS::padLeft('foo bar', 9, ' ');  // '  foo bar'\r\n```\r\n\r\n#### padRight\r\n\r\n$stringy->padRight(int $length [, string $padStr = ' ' ])\r\n\r\nS::padRight(string $str , int $length [, string $padStr = ' ' [, string $encoding ]])\r\n\r\nReturns a new string of a given length such that the end of the string is\r\npadded. Alias for pad($str, $length, $padStr, 'right', $encoding)\r\n\r\n```php\r\nS::create('foo bar')->padRight(10, '_*');\r\nS::padRight('foo bar', 10, '_*');  // 'foo bar_*_'\r\n```\r\n\r\n#### removeLeft\r\n\r\n$stringy->removeLeft(string $substring)\r\n\r\nS::removeLeft(string $str, string $substring [, string $encoding ])\r\n\r\nRemoves the prefix $substring if present.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->removeLeft('fòô ');\r\nS::removeLeft('fòô bàř', 'fòô ', 'UTF-8');  // 'bàř'\r\n```\r\n\r\n#### removeRight\r\n\r\n$stringy->removeRight(string $substring)\r\n\r\nS::removeRight(string $str, string $substring [, string $encoding ])\r\n\r\nRemoves the suffix $substring if present.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->removeRight(' bàř');\r\nS::removeRight('fòô bàř', ' bàř', 'UTF-8');  // 'fòô'\r\n```\r\n\r\n#### replace\r\n\r\n$stringy->replace(string $search, string $replace)\r\n\r\nS::replace(string $str, string $search, string $replace [, string $encoding ])\r\n\r\nReplaces all occurrences of $search with $replace in $str.\r\n\r\n```php\r\nS::create('fòô bàř fòô bàř', 'UTF-8')->replace('fòô ', '');\r\nS::replace('fòô bàř fòô bàř', 'fòô ', '', 'UTF-8');  // 'bàř bàř'\r\n```\r\n\r\n#### reverse\r\n\r\n$stringy->reverse()\r\n\r\nS::reverse(string $str, [, string $encoding ])\r\n\r\nReverses a string. A multibyte version of strrev.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->reverse();\r\nS::reverse('fòô bàř', 'UTF-8');  // 'řàb ôòf'\r\n```\r\n\r\n#### safeTruncate\r\n\r\n$stringy->safeTruncate(int $length, [, string $substring = '' ])\r\n\r\nS::safeTruncate(string $str, int $length, [, string $substring = '' [, string $encoding ]])\r\n\r\nTruncates the string to a given length, while ensuring that it does not\r\nchop words. If $substring is provided, and truncating occurs, the string\r\nis further truncated so that the substring may be appended without\r\nexceeding the desired length.\r\n\r\n```php\r\nS::create('What are your plans today?')->safeTruncate(22, '...');\r\nS::safeTruncate('What are your plans today?', 22, '...');  // 'What are your plans...'\r\n```\r\n\r\n#### shuffle\r\n\r\n$stringy->shuffle()\r\n\r\nS::shuffle(string $str [, string $encoding ])\r\n\r\nA multibyte str_shuffle function. It randomizes the order of characters\r\nin a string.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->shuffle();\r\nS::shuffle('fòô bàř', 'UTF-8');  // 'àôřb òf'\r\n```\r\n\r\n#### slugify\r\n\r\n$stringy->slugify()\r\n\r\nS::slugify(string $str)\r\n\r\nConverts the supplied text into an URL slug. This includes replacing\r\nnon-ASCII characters with their closest ASCII equivalents, removing\r\nnon-alphanumeric and non-ASCII characters, and replacing whitespace with\r\ndashes. The string is also converted to lowercase.\r\n\r\n```php\r\nS::create('Using strings like fòô bàř')->slugify();\r\nS::slugify('Using strings like fòô bàř');  // 'using-strings-like-foo-bar'\r\n```\r\n\r\n#### standardize\r\n\r\n$stringy->standardize()\r\n\r\nS::standardize(string $str)\r\n\r\nConverts some non-ASCII characters to their closest ASCII counterparts.\r\n\r\n```php\r\nS::create('fòô bàř')->standardize();\r\nS::standardize('fòô bàř');  // 'foo bar'\r\n```\r\n\r\n#### startsWith\r\n\r\n$stringy->startsWith(string $substring [, boolean $caseSensitive = true ])\r\n\r\nS::startsWith(string $str, string $substring [, boolean $caseSensitive = true [, string $encoding ]])\r\n\r\nReturns true if the string $str begins with $substring, false otherwise.\r\nBy default, the comparison is case-sensitive, but can be made insensitive\r\nby setting $caseSensitive to false.\r\n\r\n```php\r\nS::create('FÒÔ bàřs', 'UTF-8')->startsWith('fòô bàř', false);\r\nS::startsWith('FÒÔ bàřs', 'fòô bàř', false, 'UTF-8');  // true\r\n```\r\n\r\n#### substr\r\n\r\n$stringy->substr(int $start [, int $length ])\r\n\r\nS::substr(string $str, int $start [, int $length [, string $encoding ]])\r\n\r\nGets the substring of $str beginning at $start with the specified $length.\r\nIt differs from the mb_substr() function in that providing a $length of\r\nnull will return the rest of the string, rather than an empty string.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->substr(2, 3);\r\nS::substr('fòô bàř', 2, 3, 'UTF-8');  // 'ô b'\r\n```\r\n\r\n#### surround\r\n\r\n$stringy->surround(string $substring)\r\n\r\nS::surround(string $str, string $substring)\r\n\r\nSurrounds a string with the given substring.\r\n\r\n```php\r\nS::create(' ͜ ')->surround('ʘ');\r\nS::surround(' ͜ ', 'ʘ');  // 'ʘ ͜ ʘ'\r\n```\r\n\r\n#### swapCase\r\n\r\n$stringy->swapCase();\r\n\r\nS::swapCase(string $str [, string $encoding ])\r\n\r\nReturns a case swapped version of a string.\r\n\r\n```php\r\nS::create('Ντανιλ', 'UTF-8')->swapCase();\r\nS::swapCase('Ντανιλ', 'UTF-8');  // 'νΤΑΝΙΛ'\r\n```\r\n\r\n#### tidy\r\n\r\n$stringy->tidy()\r\n\r\nS::tidy(string $str)\r\n\r\nReplaces smart quotes, ellipsis characters, and dashes from Windows-1252\r\n(and commonly used in Word documents) with their ASCII equivalents.\r\n\r\n```php\r\nS::create('“I see…”')->tidy();\r\nS::tidy('“I see…”');  // '\"I see...\"'\r\n```\r\n\r\n#### titleize\r\n\r\n$stringy->titleize([ string $encoding ])\r\n\r\nS::titleize(string $str [, array $ignore [, string $encoding ]])\r\n\r\nCapitalizes the first letter of each word in a string, after trimming.\r\nIgnores the case of other letters, allowing for the use of acronyms.\r\nAlso accepts an array, $ignore, allowing you to list words not to be\r\ncapitalized.\r\n\r\n```php\r\n$ignore = array('at', 'by', 'for', 'in', 'of', 'on', 'out', 'to', 'the');\r\nS::create('i like to watch DVDs at home', 'UTF-8')->titleize($ignore);\r\nS::titleize('i like to watch DVDs at home', $ignore, 'UTF-8');\r\n// 'I Like to Watch DVDs at Home'\r\n```\r\n\r\n#### toSpaces\r\n\r\n$stringy->toSpaces([ tabLength = 4 ])\r\n\r\nS::toSpaces(string $str, [, int $tabLength = 4 ])\r\n\r\nConverts each tab in a string to some number of spaces, as defined by\r\n$tabLength. By default, each tab is converted to 4 consecutive spaces.\r\n\r\n```php\r\nS::create(' String speech = \"Hi\"')->toSpaces();\r\nS::toSpaces('   String speech = \"Hi\"');  // '    String speech = \"Hi\"'\r\n```\r\n\r\n#### toTabs\r\n\r\n$stringy->toTabs([ tabLength = 4 ])\r\n\r\nS::toTabs(string $str, [, int $tabLength = 4 ])\r\n\r\nConverts each occurence of some consecutive number of spaces, as defined\r\nby $tabLength, to a tab. By default, each 4 consecutive spaces are\r\nconverted to a tab.\r\n\r\n```php\r\nS::create('    fòô    bàř')->toTabs();\r\nS::toTabs('    fòô    bàř');  // '   fòô bàř'\r\n```\r\n\r\n#### trim\r\n\r\n$stringy->trim()\r\n\r\nS::trim(string $str)\r\n\r\nTrims $str. An alias for PHP's trim() function.\r\n\r\n```php\r\nS::create('fòô bàř', 'UTF-8')->trim();\r\nS::trim(' fòô bàř ');  // 'fòô bàř'\r\n```\r\n\r\n#### truncate\r\n\r\n$stringy->truncate(int $length, [, string $substring = '' ])\r\n\r\nS::truncate(string $str, int $length, [, string $substring = '' [, string $encoding ]])\r\n\r\nTruncates $str to a given length. If $substring is provided, and\r\ntruncating occurs, the string is further truncated so that the substring\r\nmay be appended without exceeding the desired length.\r\n\r\n```php\r\nS::create('What are your plans today?')->safeTruncate(19, '...');\r\nS::safeTruncate('What are your plans today?', 19, '...');  // 'What are your pl...'\r\n```\r\n\r\n#### underscored\r\n\r\n$stringy->underscored();\r\n\r\nS::underscored(string $str [, string $encoding ])\r\n\r\nReturns a lowercase and trimmed string seperated by underscores, with\r\nmultibyte support. Underscores are inserted before uppercase characters\r\n(with the exception of the first character of the string), and in place\r\nof spaces as well as dashes.\r\n\r\n```php\r\nS::create('TestUCase')->underscored();\r\nS::underscored('TestUCase');  // 'test_u_case'\r\n```\r\n\r\n#### upperCamelize\r\n\r\n$stringy->upperCamelize();\r\n\r\nS::upperCamelize(string $str [, string $encoding ])\r\n\r\nReturns an UpperCamelCase version of a supplied string, with multibyte\r\nsupport. Trims surrounding spaces, capitalizes letters following digits,\r\nspaces, dashes and underscores, and removes spaces, dashes, underscores.\r\n\r\n```php\r\nS::create('Upper Camel-Case')->upperCamelize();\r\nS::upperCamelize('Upper Camel-Case');  // 'UpperCamelCase'\r\n```\r\n\r\n#### upperCaseFirst\r\n\r\n$stringy->upperCaseFirst();\r\n\r\nS::upperCaseFirst(string $str [, string $encoding ])\r\n\r\nConverts the first character of the supplied string to upper case, with\r\nsupport for multibyte strings.\r\n\r\n```php\r\nS::create('σ test', 'UTF-8')->upperCaseFirst();\r\nS::upperCaseFirst('σ test', 'UTF-8');  // 'Σ test'\r\n```\r\n\r\n## Tests\r\n\r\nFrom the project directory, tests can be ran using `phpunit`\r\n\r\n## License\r\n\r\nReleased under the MIT License - see `LICENSE.txt` for details.\r\n","google":"","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file