diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..176a458
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+* text=auto
diff --git a/.scrutinizer.yml b/.scrutinizer.yml
new file mode 100644
index 0000000..5839f87
--- /dev/null
+++ b/.scrutinizer.yml
@@ -0,0 +1,9 @@
+tools:
+    php_mess_detector:
+        enabled: true
+        config:
+            rulesets: [phpmd.xml]
+    php_cpd:
+        enabled: true
+    php_pdepend:
+        enabled: true
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b93aebf..f38f2b0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,14 @@ CHANGE LOG
 ==========
 
 
+## V0.2 Alpha (25/08/2013)
+#### Major Release
+
+* Updated the providers
+* Scrutinizer updates
+* Minor tweaks
+
+
 ## V0.1 Alpha (15/08/2013)
 #### Major Release
 
diff --git a/README.md b/README.md
index f697073..cc75f8c 100644
--- a/README.md
+++ b/README.md
@@ -2,17 +2,14 @@ Laravel HTMLMin
 ===============
 
 
-[![Latest Stable Version](https://poser.pugx.org/graham-campbell/htmlmin/v/stable.png)](https://packagist.org/packages/graham-campbell/htmlmin)
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/GrahamCampbell/laravel-htmlmin/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
 [![Build Status](https://travis-ci.org/GrahamCampbell/Laravel-HTMLMin.png?branch=master)](https://travis-ci.org/GrahamCampbell/Laravel-HTMLMin)
-[![Latest Unstable Version](https://poser.pugx.org/graham-campbell/htmlmin/v/unstable.png)](https://packagist.org/packages/graham-campbell/htmlmin)
-[![Build Status](https://travis-ci.org/GrahamCampbell/Laravel-HTMLMin.png?branch=develop)](https://travis-ci.org/GrahamCampbell/Laravel-HTMLMin)
+[![Latest Version](https://poser.pugx.org/graham-campbell/htmlmin/v/stable.png)](https://packagist.org/packages/graham-campbell/htmlmin)
 [![Total Downloads](https://poser.pugx.org/graham-campbell/htmlmin/downloads.png)](https://packagist.org/packages/graham-campbell/htmlmin)
+[![Scrutinizer Quality Score](https://scrutinizer-ci.com/g/GrahamCampbell/Laravel-HTMLMin/badges/quality-score.png?s=b56aacf6a0c1b2e612c3d7dab63d212084e6b83b)](https://scrutinizer-ci.com/g/GrahamCampbell/Laravel-HTMLMin)
 [![Still Maintained](http://stillmaintained.com/GrahamCampbell/Laravel-HTMLMin.png)](http://stillmaintained.com/GrahamCampbell/Laravel-HTMLMin)
 
 
-[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/GrahamCampbell/laravel-htmlmin/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
-
-
 Copyright © [Graham Campbell](https://github.com/GrahamCampbell) 2013  
 
 
@@ -25,6 +22,7 @@ Laravel HTMLMin is a simple HTML minifier for [Laravel 4](http://laravel.com).
 
 * Laravel HTMLMin was created by, and is maintained by [Graham Campbell](https://github.com/GrahamCampbell).  
 * Laravel HTMLMin uses [Travis CI](https://travis-ci.org/GrahamCampbell/Laravel-HTMLMin) to run tests to check if it's working as it should.  
+* Laravel HTMLMin uses [Scrutinizer CI](https://scrutinizer-ci.com/g/GrahamCampbell/Laravel-HTMLMin) to run additional tests and checks.  
 * Laravel HTMLMin uses [Composer](https://getcomposer.org) to load and manage dependencies.  
 * Laravel HTMLMin provides a [change log](https://github.com/GrahamCampbell/Laravel-HTMLMin/blob/master/CHANGELOG.md), [releases](https://github.com/GrahamCampbell/Laravel-HTMLMin/releases), and a [wiki](https://github.com/GrahamCampbell/Laravel-HTMLMin/wiki).  
 * Laravel HTMLMin is licensed under the MIT, available [here](https://github.com/GrahamCampbell/Laravel-HTMLMin/blob/master/LICENSE.md).  
diff --git a/composer.json b/composer.json
index 6639398..4248f32 100644
--- a/composer.json
+++ b/composer.json
@@ -11,10 +11,10 @@
     ],
     "require": {
         "php": ">=5.3.3",
-        "illuminate/support": "4.0.*"
+        "illuminate/support": "4.0.*@stable"
     },
     "require-dev": {
-        "mockery/mockery": "dev-master",
+        "mockery/mockery": "0.8.*@stable",
         "phpunit/phpunit": "3.7.*@stable"
     },
     "autoload": {
@@ -22,10 +22,5 @@
             "GrahamCampbell\\HTMLMin": "src/"
         }
     },
-    "extra": {
-        "branch-alias": {
-            "dev-master": "0.1.x-dev"
-        }
-    },
     "minimum-stability": "dev"
 }
diff --git a/phpmd.xml b/phpmd.xml
new file mode 100644
index 0000000..2fa7b6b
--- /dev/null
+++ b/phpmd.xml
@@ -0,0 +1,719 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<ruleset name="Code Size Rules"
+        xmlns="http://pmd.sf.net/ruleset/1.0.0"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://pmd.sf.net/ruleset/1.0.0 http://pmd.sf.net/ruleset_xml_schema.xsd"
+        xsi:noNamespaceSchemaLocation="http://pmd.sf.net/ruleset_xml_schema.xsd">
+    <description>Bootstrap CMS Rules</description>
+
+    <rule name="CyclomaticComplexity"
+          since="0.1"
+          message = "The {0} {1}() has a Cyclomatic Complexity of {2}. The configured cyclomatic complexity threshold is {3}."
+          class="PHP_PMD_Rule_CyclomaticComplexity"
+          externalInfoUrl="http://phpmd.org/rules/codesize.html#cyclomaticcomplexity">
+        <description>
+            <![CDATA[
+Complexity is determined by the number of decision points in a method plus one for the
+method entry.  The decision points are 'if', 'while', 'for', and 'case labels'.  Generally,
+1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity,
+ and 11+ is very high complexity.
+            ]]>
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="reportLevel" description="The Cyclomatic Complexity reporting threshold"  value="10"/>
+            <property name="showClassesComplexity"
+                      description="Indicate if class average violation should be added to the report"
+                      value="true"/>
+            <property name="showMethodsComplexity"
+                      description="Indicate if class average violation should be added to the report"
+                      value="true"/>
+        </properties>
+        <example>
+            <![CDATA[
+// Cyclomatic Complexity = 12
+class Foo {
+1   public function example()  {
+2       if ($a == $b)  {
+3           if ($a1 == $b1) {
+                fiddle();
+4           } else if ($a2 == $b2) {
+                fiddle();
+            }  else {
+                fiddle();
+            }
+5       } else if ($c == $d) {
+6           while ($c == $d) {
+                fiddle();
+            }
+7        } else if ($e == $f) {
+8           for ($n = 0; $n < $h; $n++) {
+                fiddle();
+            }
+        } else{
+            switch ($z) {
+9               case 1:
+                    fiddle();
+                    break;
+10              case 2:
+                    fiddle();
+                    break;
+11              case 3:
+                    fiddle();
+                    break;
+12              default:
+                    fiddle();
+                    break;
+            }
+        }
+    }
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="NPathComplexity"
+          since="0.1"
+          message="The {0} {1}() has an NPath complexity of {2}. The configured NPath complexity threshold is {3}."
+          class="PHP_PMD_Rule_Design_NpathComplexity"
+          externalInfoUrl="http://phpmd.org/rules/codesize.html#npathcomplexity">
+        <description>
+The NPath complexity of a method is the number of acyclic execution paths through that method.
+A threshold of 200 is generally considered the point where measures should be taken to reduce complexity.
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="minimum" description="The npath reporting threshold" value="200"/>
+        </properties>
+        <example>
+            <![CDATA[
+class Foo {
+    function bar() {
+        // lots of complicated code
+    }
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="ExcessiveMethodLength"
+          since="0.1"
+          message="The {0} {1}() has {2} lines of code. Current threshold is set to {3}. Avoid really long methods."
+          class="PHP_PMD_Rule_Design_LongMethod"
+          externalInfoUrl="http://phpmd.org/rules/codesize.html#excessivemethodlength">
+        <description>
+Violations of this rule usually indicate that the method is doing
+too much.  Try to reduce the method size by creating helper methods and removing any copy/pasted code.
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="minimum" description="The method size reporting threshold" value="100"/>
+        </properties>
+        <example>
+            <![CDATA[
+class Foo {
+    public function doSomething() {
+        print("Hello world!" . PHP_EOL);
+        print("Hello world!" . PHP_EOL);
+        // 98 copies omitted for brevity.
+    }
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="ExcessiveClassLength"
+      since="0.1"
+          message="The class {0} has {1} lines of code. Current threshold is {2}. Avoid really long classes."
+          class="PHP_PMD_Rule_Design_LongClass"
+          externalInfoUrl="http://phpmd.org/rules/codesize.html#excessiveclasslength">
+        <description>
+Long Class files are indications that the class may be trying to
+do too much.  Try to break it down, and reduce the size to something
+manageable.
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="minimum" description="The class size reporting threshold"  value="1000"/>
+        </properties>
+        <example>
+            <![CDATA[
+class Foo {
+  public function bar() {
+    // 1000 lines of code
+  }
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="ExcessiveParameterList"
+          since="0.1"
+          message="The {0} {1} has {2} parameters. Consider to reduce parameter number under {3}."
+          class="PHP_PMD_Rule_Design_LongParameterList"
+          externalInfoUrl="http://phpmd.org/rules/codesize.html#excessiveparameterlist">
+        <description>
+Long parameter lists can indicate that a new object should be created to
+wrap the numerous parameters.  Basically, try to group the parameters together.
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="minimum" description="The parameter count reporting threshold" value="10"/>
+        </properties>
+        <example>
+            <![CDATA[
+class Foo {
+    public function addData(
+        $p0, $p1, $p2, $p3, $p4, $p5,
+        $p5, $p6, $p7, $p8, $p9, $p10) {
+    }
+}
+            ]]>
+        </example>
+
+    </rule>
+
+    <rule name="ExcessivePublicCount"
+          since="0.1"
+          message="The {0} {1} has {2} public methods and attributes. Consider to reduce the number of public items under {3}."
+          class="PHP_PMD_Rule_ExcessivePublicCount"
+          externalInfoUrl="http://phpmd.org/rules/codesize.html#excessivepubliccount">
+        <description>
+A large number of public methods and attributes declared in a class can indicate
+the class may need to be broken up as increased effort will be required to
+thoroughly test it.
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="minimum" description="The public item reporting threshold" value="30"/>
+        </properties>
+        <example>
+            <![CDATA[
+public class Foo {
+    public $value;
+    public $something;
+    public $var;
+    // [... more more public attributes ...]
+
+    public function doWork() {}
+    public function doMoreWork() {}
+    public function doWorkAgain() {}
+    // [... more more public methods ...]
+}
+    ]]>
+        </example>
+    </rule>
+
+    <rule name="TooManyFields"
+          since="0.1"
+          message="The {0} {1} has {2} fields. Consider to redesign {1} to keep the number of fields under {3}."
+          class="PHP_PMD_Rule_Design_TooManyFields"
+          externalInfoUrl="http://phpmd.org/rules/codesize.html#toomanyfields">
+        <description>
+Classes that have too many fields could be redesigned to have fewer fields,
+possibly through some nested object grouping of some of the information. For
+example, a class with city/state/zip fields could instead have one Address
+field.
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="maxfields" description="The field count reporting threshold " value="15"/>
+        </properties>
+        <example>
+            <![CDATA[
+class Person {
+   protected $one;
+   private $two;
+   private $three;
+   [... many more fields ...]
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="TooManyMethods"
+          since="0.1"
+          class="PHP_PMD_Rule_Design_TooManyMethods"
+          message="The {0} {1} has {2} methods. Consider refactoring {1} to keep number of methods under {3}."
+          externalInfoUrl="http://phpmd.org/rules/codesize.html#toomanymethods">
+        <description>
+            <![CDATA[
+A class with too many methods is probably a good suspect for refactoring, in
+order to reduce its complexity and find a way to have more fine grained objects.
+            ]]>
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="maxmethods" description="The method count reporting threshold " value="20"/>
+        </properties>
+    </rule>
+
+    <rule name="ExcessiveClassComplexity"
+          since="0.2.5"
+          class="PHP_PMD_Rule_Design_WeightedMethodCount"
+          message="The class {0} has an overall complexity of {1} which is very high. The configured complexity threshold is {2}."
+          externalInfoUrl="http://phpmd.org/rules/codesize.html#excessiveclasscomplexity">
+        <description>
+            <![CDATA[
+The WMC of a class is a good indicator of how much time and effort is required
+to modify and maintain this class. A large number of methods also means that
+this class has a greater potential impact on derived classes.
+            ]]>
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="maximum" description="The maximum WMC tolerable for a class." value="50"/>
+        </properties>
+        <example>
+            <![CDATA[
+class Foo {
+    public function bar()  {
+        if ($a == $b)  {
+            if ($a1 == $b1) {
+                fiddle();
+            } else if ($a2 == $b2) {
+                fiddle();
+            }  else {
+            }
+        }
+    }
+    public function baz()  {
+        if ($a == $b)  {
+            if ($a1 == $b1) {
+                fiddle();
+            } else if ($a2 == $b2) {
+                fiddle();
+            }  else {
+            }
+        }
+    }
+    // Several other complex methods
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="ExitExpression"
+          since="0.2"
+          message = "The {0} {1}() contains an exit expression."
+          class="PHP_PMD_Rule_Design_ExitExpression"
+          externalInfoUrl="http://phpmd.org/rules/design.html#exitexpression">
+        <description>
+            <![CDATA[
+An exit-expression within regular code is untestable and therefore it should
+be avoided. Consider to move the exit-expression into some kind of startup
+script where an error/exception code is returned to the calling environment.
+            ]]>
+        </description>
+        <priority>1</priority>
+        <properties />
+        <example>
+            <![CDATA[
+class Foo {
+    public function bar($param)  {
+        if ($param === 42) {
+            exit(23);
+        }
+    }
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="EvalExpression"
+          since="0.2"
+          message = "The {0} {1}() contains an eval expression."
+          class="PHP_PMD_Rule_Design_EvalExpression"
+          externalInfoUrl="http://phpmd.org/rules/design.html#evalexpression">
+        <description>
+            <![CDATA[
+An eval-expression is untestable, a security risk and bad practice. Therefore
+it should be avoided. Consider to replace the eval-expression with regular
+code.
+            ]]>
+        </description>
+        <priority>1</priority>
+        <properties />
+        <example>
+            <![CDATA[
+class Foo {
+    public function bar($param)  {
+        if ($param === 42) {
+            eval('$param = 23;');
+        }
+    }
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="GotoStatement"
+          since="1.1.0"
+          message="The {0} {1}() utilizes a goto statement."
+          class="PHP_PMD_Rule_Design_GotoStatement"
+          externalInfoUrl="http://phpmd.org/rules/design.html#gotostatement">
+        <description>
+            <![CDATA[
+Goto makes code harder to read and it is nearly impossible to understand the
+control flow of an application that uses this language construct. Therefore it
+should be avoided. Consider to replace Goto with regular control structures and
+separate methods/function, which are easier to read.
+            ]]>
+        </description>
+        <priority>1</priority>
+        <properties />
+        <example>
+            <![CDATA[
+class Foo {
+    public function bar($param)  {
+        A:
+        if ($param === 42) {
+            goto X;
+        }
+        Y:
+        if (time() % 42 === 23) {
+            goto Z;
+        }
+        X:
+        if (time() % 23 === 42) {
+            goto Y;
+        }
+        Z:
+        return 42;                 
+    }
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="NumberOfChildren"
+          since="0.2"
+          message = "The {0} {1} has {2} children. Consider to rebalance this class hierarchy to keep number of children under {3}."
+          class="PHP_PMD_Rule_Design_NumberOfChildren"
+          externalInfoUrl="http://phpmd.org/rules/design.html#numberofchildren">
+        <description>
+            <![CDATA[
+A class with an excessive number of children is an indicator for an unbalanced
+class hierarchy. You should consider to refactor this class hierarchy.
+            ]]>
+        </description>
+        <priority>2</priority>
+        <properties>
+            <property name="minimum" value="15" description="Maximum number of acceptable child classes." />
+        </properties>
+        <example />
+    </rule>
+
+    <rule name="DepthOfInheritance"
+          since="0.2"
+          message = "The {0} {1} has {2} parents. Consider to reduce the depth of this class hierarchy to under {3}."
+          class="PHP_PMD_Rule_Design_DepthOfInheritance"
+          externalInfoUrl="http://phpmd.org/rules/design.html#depthofinheritance">
+        <description>
+            <![CDATA[
+A class with many parents is an indicator for an unbalanced and wrong class
+hierarchy. You should consider to refactor this class hierarchy.
+            ]]>
+        </description>
+        <priority>2</priority>
+        <properties>
+            <property name="minimum" value="6" description="Maximum number of acceptable parent classes." />
+        </properties>
+        <example />
+    </rule>
+
+    <rule name="CouplingBetweenObjects"
+          since="1.1.0"
+          message="The class {0} has a coupling between objects value of {1}. Consider to reduce the number of dependencies under {2}."
+          class="PHP_PMD_Rule_Design_CouplingBetweenObjects"
+          externalInfoUrl="http://phpmd.org/rules/design.html#couplingbetweenobjects">
+        <description>
+            <![CDATA[
+A class with to many dependencies has negative impacts on several quality
+aspects of a class. This includes quality criterias like stability,
+maintainability and understandability
+            ]]>
+        </description>
+        <priority>2</priority>
+        <properties>
+            <property name="minimum" value="16" description="Maximum number of acceptable dependencies." />
+        </properties>
+        <example>
+            <![CDATA[
+class Foo {
+    /**
+     * @var \foo\bar\X
+     */
+    private $x = null;
+
+    /**
+     * @var \foo\bar\Y
+     */
+    private $y = null;
+
+    /**
+     * @var \foo\bar\Z
+     */
+    private $z = null;
+
+    public function setFoo(\Foo $foo) {}
+    public function setBar(\Bar $bar) {}
+    public function setBaz(\Baz $baz) {}
+
+    /**
+     * @return \SplObjectStorage
+     * @throws \OutOfRangeException
+     * @throws \InvalidArgumentException
+     * @throws \ErrorException
+     */
+    public function process(Iterator $it) {}
+
+    // ...
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="ShortVariable"
+          since="0.2"
+          message="Avoid variables with short names like {0}. Configured minimum length is {1}."
+          class="PHP_PMD_Rule_Naming_ShortVariable"
+          externalInfoUrl="http://phpmd.org/rules/naming.html#shortvariable">
+        <description>
+Detects when a field, local, or parameter has a very short name.
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="minimum" description="Minimum length for a variable, property or parameter name" value="3"/>
+            <property name="exceptions" description="Comma-separated list of exceptions" value="id"/>
+        </properties>
+        <example>
+            <![CDATA[
+class Something {
+    private $q = 15; // VIOLATION - Field
+    public static function main( array $as ) {  // VIOLATION - Formal
+        $r = 20 + $this->q; // VIOLATION - Local
+        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
+            $r += $this->q;
+        }
+    }
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="LongVariable"
+          since="0.2"
+          message="Avoid excessively long variable names like {0}. Keep variable name length under {1}."
+          class="PHP_PMD_Rule_Naming_LongVariable"
+          externalInfoUrl="http://phpmd.org/rules/naming.html#longvariable">
+        <description>
+Detects when a field, formal or local variable is declared with a long name.
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="maximum" description="The variable length reporting threshold" value="20"/>
+        </properties>
+        <example>
+            <![CDATA[
+class Something {
+    protected $reallyLongIntName = -3;  // VIOLATION - Field
+    public static function main( array $argumentsList[] ) { // VIOLATION - Formal
+        $otherReallyLongName = -5; // VIOLATION - Local
+        for ($interestingIntIndex = 0;  // VIOLATION - For
+             $interestingIntIndex < 10;
+             $interestingIntIndex++ ) {
+        }
+    }
+}
+]]>
+        </example>
+    </rule>
+
+    <rule name="ShortMethodName"
+          since="0.2"
+          message="Avoid using short method names like {0}::{1}(). The configured minimum method name length is {2}."
+          class="PHP_PMD_Rule_Naming_ShortMethodName"
+          externalInfoUrl="http://phpmd.org/rules/naming.html#shortmethodname">
+        <description>
+Detects when very short method names are used.
+        </description>
+        <priority>3</priority>
+        <properties>
+            <property name="minimum" description="Minimum length for a method or function name" value="3"/>
+            <property name="exceptions" description="Comma-separated list of exceptions" value="up"/>
+        </properties>
+        <example>
+            <![CDATA[
+class ShortMethod {
+    public function a( $index ) { // Violation
+    }
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="ConstructorWithNameAsEnclosingClass"
+          since="0.2"
+          message="Classes should not have a constructor method with the same name as the class"
+          class="PHP_PMD_Rule_Naming_ConstructorWithNameAsEnclosingClass"
+          externalInfoUrl="http://phpmd.org/rules/naming.html#constructorwithnameasenclosingclass">
+        <description>
+A constructor method should not have the same name as the enclosing class, consider
+to use the PHP 5 __construct method.
+        </description>
+        <priority>3</priority>
+        <example>
+            <![CDATA[
+class MyClass {
+     // this is bad because it is PHP 4 style
+    public function MyClass() {}
+    // this is good because it is a PHP 5 constructor
+    public function __construct() {}
+}
+    ]]>
+        </example>
+    </rule>
+
+    <rule name="ConstantNamingConventions"
+          since="0.2"
+          message="Constant {0} should be defined in uppercase"
+          class="PHP_PMD_Rule_Naming_ConstantNamingConventions"
+          externalInfoUrl="http://phpmd.org/rules/naming.html#constantnamingconventions">
+        <description>
+Class/Interface constant names should always be defined in uppercase.
+        </description>
+        <priority>4</priority>
+        <properties />
+        <example>
+            <![CDATA[
+class Foo {
+    const MY_NUM = 0; // ok
+    const myTest = ""; // fail
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="BooleanGetMethodName"
+          since="0.2"
+          message="The '{0}()' method which returns a boolean should be named 'is...()' or 'has...()'"
+          class="PHP_PMD_Rule_Naming_BooleanGetMethodName"
+          externalInfoUrl="http://phpmd.org/rules/naming.html#booleangetmethodname">
+        <description>
+Looks for methods named 'getX()' with 'boolean' as the return type. The convention
+is to name these methods 'isX()' or 'hasX()'.
+        </description>
+        <priority>4</priority>
+        <properties>
+            <property name="checkParameterizedMethods" value="false" description="Applies only to methods without parameter when set to true" />
+        </properties>
+        <example>
+            <![CDATA[
+class Foo {
+    /**
+     * @return boolean
+     */
+    public function getFoo() {} // bad
+    /**
+     * @return bool
+     */
+    public function isFoo(); // ok
+    /**
+     * @return boolean
+     */
+    public function getFoo($bar); // ok, unless checkParameterizedMethods=true
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="UnusedPrivateField"
+          since="0.2"
+          message="Avoid unused private fields such as '{0}'."
+          class="PHP_PMD_Rule_UnusedPrivateField"
+          externalInfoUrl="http://phpmd.org/rules/unusedcode.html#unusedprivatefield">
+        <description>
+Detects when a private field is declared and/or assigned a value, but not used.
+        </description>
+        <priority>3</priority>
+        <example>
+<![CDATA[
+class Something
+{
+    private static $FOO = 2; // Unused
+    private $i = 5; // Unused
+    private $j = 6;
+    public function addOne()
+    {
+        return $this->j++;
+    }
+}
+]]>
+        </example>
+    </rule>
+
+    <rule name="UnusedLocalVariable"
+          since="0.2"
+          message="Avoid unused local variables such as '{0}'."
+          class="PHP_PMD_Rule_UnusedLocalVariable"
+          externalInfoUrl="http://phpmd.org/rules/unusedcode.html#unusedlocalvariable">
+        <description>
+Detects when a local variable is declared and/or assigned, but not used.
+        </description>
+        <priority>3</priority>
+        <example>
+<![CDATA[
+class Foo {
+    public function doSomething()
+    {
+        $i = 5; // Unused
+    }
+}
+]]>
+        </example>
+    </rule>
+
+    <rule name="UnusedPrivateMethod"
+          since="0.2"
+          message="Avoid unused private methods such as '{0}'."
+          class="PHP_PMD_Rule_UnusedPrivateMethod"
+          externalInfoUrl="http://phpmd.org/rules/unusedcode.html#unusedprivatemethod">
+        <description>
+Unused Private Method detects when a private method is declared but is unused.
+        </description>
+        <priority>3</priority>
+        <example>
+<![CDATA[
+class Something
+{
+    private function foo() {} // unused
+}
+]]>
+        </example>
+    </rule>
+
+    <rule name="UnusedFormalParameter"
+          since="0.2"
+          message="Avoid unused parameters such as '{0}'."
+          class="PHP_PMD_Rule_UnusedFormalParameter"
+          externalInfoUrl="http://phpmd.org/rules/unusedcode.html#unusedformalparameter">
+        <description>
+Avoid passing parameters to methods or constructors and then not using those parameters.
+        </description>
+        <priority>3</priority>
+        <example>
+<![CDATA[
+class Foo
+{
+    private function bar($howdy)
+    {
+        // $howdy is not used
+    }
+}
+]]>
+        </example>
+    </rule>
+
+</ruleset>
diff --git a/src/GrahamCampbell/HTMLMin/Classes/HTMLMin.php b/src/GrahamCampbell/HTMLMin/Classes/HTMLMin.php
index 362096f..508ea19 100644
--- a/src/GrahamCampbell/HTMLMin/Classes/HTMLMin.php
+++ b/src/GrahamCampbell/HTMLMin/Classes/HTMLMin.php
@@ -5,6 +5,7 @@ class HTMLMin {
     /**
      * Get the minified html.
      *
+     * @param  string  $render
      * @return string
      */
     public static function render($render) {
diff --git a/src/GrahamCampbell/HTMLMin/HTMLMinServiceProvider.php b/src/GrahamCampbell/HTMLMin/HTMLMinServiceProvider.php
index 007b063..a0d2535 100644
--- a/src/GrahamCampbell/HTMLMin/HTMLMinServiceProvider.php
+++ b/src/GrahamCampbell/HTMLMin/HTMLMinServiceProvider.php
@@ -37,6 +37,6 @@ public function register() {
      * @return array
      */
     public function provides() {
-        return array();
+        return array('htmlmin');
     }
 }