Initial Commit

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Classes/DuplicateClassNameSniff.php

@@ -0,0 +1,97 @@
+<?php
+/**
+ * Reports errors if the same class or interface name is used in multiple files.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Reports errors if the same class or interface name is used in multiple files.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Classes_DuplicateClassNameSniff implements PHP_CodeSniffer_MultiFileSniff
+{
+
+
+    /**
+     * Called once per script run to allow for processing of this sniff.
+     *
+     * @param array(PHP_CodeSniffer_File) $files The PHP_CodeSniffer files processed
+     *                                           during the script run.
+     *
+     * @return void
+     */
+    public function process(array $files)
+    {
+        $foundClasses = array();
+
+        foreach ($files as $phpcsFile) {
+            $tokens = $phpcsFile->getTokens();
+
+            $namespace = '';
+            $stackPtr  = $phpcsFile->findNext(array(T_CLASS, T_INTERFACE, T_NAMESPACE), 0);
+            while ($stackPtr !== false) {
+                // Keep track of what namespace we are in.
+                if ($tokens[$stackPtr]['code'] === T_NAMESPACE) {
+                    $nsEnd = $phpcsFile->findNext(
+                        array(T_NS_SEPARATOR, T_STRING, T_WHITESPACE),
+                        ($stackPtr + 1),
+                        null,
+                        true
+                    );
+
+                    $namespace = trim($phpcsFile->getTokensAsString(($stackPtr + 1), ($nsEnd - $stackPtr - 1)));
+                    $stackPtr  = $nsEnd;
+                } else {
+                    $nameToken = $phpcsFile->findNext(T_STRING, $stackPtr);
+                    $name      = $tokens[$nameToken]['content'];
+                    if ($namespace !== '') {
+                        $name = $namespace.'\\'.$name;
+                    }
+
+                    $compareName = strtolower($name);
+                    if (isset($foundClasses[$compareName]) === true) {
+                        $type  = strtolower($tokens[$stackPtr]['content']);
+                        $file  = $foundClasses[$compareName]['file'];
+                        $line  = $foundClasses[$compareName]['line'];
+                        $error = 'Duplicate %s name "%s" found; first defined in %s on line %s';
+                        $data  = array(
+                                  $type,
+                                  $name,
+                                  $file,
+                                  $line,
+                                 );
+                        $phpcsFile->addWarning($error, $stackPtr, 'Found', $data);
+                    } else {
+                        $foundClasses[$compareName] = array(
+                                                            'file' => $phpcsFile->getFilename(),
+                                                            'line' => $tokens[$stackPtr]['line'],
+                                                           );
+                    }
+                }
+
+                $stackPtr = $phpcsFile->findNext(array(T_CLASS, T_INTERFACE, T_NAMESPACE), ($stackPtr + 1));
+            }//end while
+
+        }//end foreach
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/CodeAnalysis/EmptyStatementSniff.php

@@ -0,0 +1,128 @@
+<?php
+/**
+ * This file is part of the CodeAnalysis addon for PHP_CodeSniffer.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * This sniff class detected empty statement.
+ *
+ * This sniff implements the common algorithm for empty statement body detection.
+ * A body is considered as empty if it is completely empty or it only contains
+ * whitespace characters and|or comments.
+ *
+ * <code>
+ * stmt {
+ *   // foo
+ * }
+ * stmt (conditions) {
+ *   // foo
+ * }
+ * </code>
+ *
+ * Statements covered by this sniff are <b>catch</b>, <b>do</b>, <b>else</b>,
+ * <b>elsif</b>, <b>for</b>, <b>foreach<b>, <b>if</b>, <b>switch</b>, <b>try</b>
+ * and <b>while</b>.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_CodeAnalysis_EmptyStatementSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * List of block tokens that this sniff covers.
+     *
+     * The key of this hash identifies the required token while the boolean
+     * value says mark an error or mark a warning.
+     *
+     * @var array
+     */
+    protected $checkedTokens = array(
+                                T_CATCH   => true,
+                                T_DO      => false,
+                                T_ELSE    => false,
+                                T_ELSEIF  => false,
+                                T_FOR     => false,
+                                T_FOREACH => false,
+                                T_IF      => false,
+                                T_SWITCH  => false,
+                                T_TRY     => false,
+                                T_WHILE   => false,
+                               );
+
+
+    /**
+     * Registers the tokens that this sniff wants to listen for.
+     *
+     * @return array(integer)
+     */
+    public function register()
+    {
+        return array_keys($this->checkedTokens);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+        $token  = $tokens[$stackPtr];
+
+        // Skip for-statements without body.
+        if (isset($token['scope_opener']) === false) {
+            return;
+        }
+
+        $next = ++$token['scope_opener'];
+        $end  = --$token['scope_closer'];
+
+        $emptyBody = true;
+        for (; $next <= $end; ++$next) {
+            if (in_array($tokens[$next]['code'], PHP_CodeSniffer_Tokens::$emptyTokens) === false) {
+                $emptyBody = false;
+                break;
+            }
+        }
+
+        if ($emptyBody === true) {
+            // Get token identifier.
+            $name  = $phpcsFile->getTokensAsString($stackPtr, 1);
+            $error = 'Empty %s statement detected';
+            $data  = array(strtoupper($name));
+            if ($this->checkedTokens[$token['code']] === true) {
+                $phpcsFile->addError($error, $stackPtr, 'NotAllowed', $data);
+            } else {
+                $phpcsFile->addWarning($error, $stackPtr, 'NotAllowedWarning', $data);
+            }
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/CodeAnalysis/ForLoopShouldBeWhileLoopSniff.php

@@ -0,0 +1,100 @@
+<?php
+/**
+ * This file is part of the CodeAnalysis addon for PHP_CodeSniffer.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Detects for-loops that can be simplified to a while-loop.
+ *
+ * This rule is based on the PMD rule catalog. Detects for-loops that can be
+ * simplified as a while-loop.
+ *
+ * <code>
+ * class Foo
+ * {
+ *     public function bar($x)
+ *     {
+ *         for (;true;) true; // No Init or Update part, may as well be: while (true)
+ *     }
+ * }
+ * </code>
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_CodeAnalysis_ForLoopShouldBeWhileLoopSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Registers the tokens that this sniff wants to listen for.
+     *
+     * @return array(integer)
+     */
+    public function register()
+    {
+        return array(T_FOR);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+        $token  = $tokens[$stackPtr];
+
+        // Skip invalid statement.
+        if (isset($token['parenthesis_opener']) === false) {
+            return;
+        }
+
+        $next = ++$token['parenthesis_opener'];
+        $end  = --$token['parenthesis_closer'];
+
+        $parts = array(0, 0, 0);
+        $index = 0;
+
+        for (; $next <= $end; ++$next) {
+            $code = $tokens[$next]['code'];
+            if ($code === T_SEMICOLON) {
+                ++$index;
+            } else if (in_array($code, PHP_CodeSniffer_Tokens::$emptyTokens) === false) {
+                ++$parts[$index];
+            }
+        }
+
+        if ($parts[0] === 0 && $parts[2] === 0 && $parts[1] > 0) {
+            $error = 'This FOR loop can be simplified to a WHILE loop';
+            $phpcsFile->addWarning($error, $stackPtr, 'CanSimplify');
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/CodeAnalysis/ForLoopWithTestFunctionCallSniff.php

@@ -0,0 +1,113 @@
+<?php
+/**
+ * This file is part of the CodeAnalysis addon for PHP_CodeSniffer.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Detects for-loops that use a function call in the test expression.
+ *
+ * This rule is based on the PMD rule catalog. Detects for-loops that use a
+ * function call in the test expression.
+ *
+ * <code>
+ * class Foo
+ * {
+ *     public function bar($x)
+ *     {
+ *         $a = array(1, 2, 3, 4);
+ *         for ($i = 0; $i < count($a); $i++) {
+ *              $a[$i] *= $i;
+ *         }
+ *     }
+ * }
+ * </code>
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_CodeAnalysis_ForLoopWithTestFunctionCallSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Registers the tokens that this sniff wants to listen for.
+     *
+     * @return array(integer)
+     */
+    public function register()
+    {
+        return array(T_FOR);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+        $token  = $tokens[$stackPtr];
+
+        // Skip invalid statement.
+        if (isset($token['parenthesis_opener']) === false) {
+            return;
+        }
+
+        $next = ++$token['parenthesis_opener'];
+        $end  = --$token['parenthesis_closer'];
+
+        $position = 0;
+
+        for (; $next <= $end; ++$next) {
+            $code = $tokens[$next]['code'];
+            if ($code === T_SEMICOLON) {
+                ++$position;
+            }
+
+            if ($position < 1) {
+                continue;
+            } else if ($position > 1) {
+                break;
+            } else if ($code !== T_VARIABLE && $code !== T_STRING) {
+                continue;
+            }
+
+            // Find next non empty token, if it is a open curly brace we have a
+            // function call.
+            $index = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($next + 1), null, true);
+
+            if ($tokens[$index]['code'] === T_OPEN_PARENTHESIS) {
+                $error = 'Avoid function calls in a FOR loop test part';
+                $phpcsFile->addWarning($error, $stackPtr, 'NotAllowed');
+                break;
+            }
+        }//end for
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/CodeAnalysis/JumbledIncrementerSniff.php

@@ -0,0 +1,148 @@
+<?php
+/**
+ * This file is part of the CodeAnalysis addon for PHP_CodeSniffer.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Detects incrementer jumbling in for loops.
+ * 
+ * This rule is based on the PMD rule catalog. The jumbling incrementer sniff
+ * detects the usage of one and the same incrementer into an outer and an inner
+ * loop. Even it is intended this is confusing code.
+ *
+ * <code>
+ * class Foo
+ * {
+ *     public function bar($x)
+ *     {
+ *         for ($i = 0; $i < 10; $i++)
+ *         {
+ *             for ($k = 0; $k < 20; $i++)
+ *             {
+ *                 echo 'Hello';
+ *             }
+ *         }
+ *     }
+ * }
+ * </code>
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_CodeAnalysis_JumbledIncrementerSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Registers the tokens that this sniff wants to listen for.
+     *
+     * @return array(integer)
+     */
+    public function register()
+    {
+        return array(T_FOR);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+        $token  = $tokens[$stackPtr];
+
+        // Skip for-loop without body.
+        if (isset($token['scope_opener']) === false) {
+            return;
+        }
+
+        // Find incrementors for outer loop.
+        $outer = $this->findIncrementers($tokens, $token);
+
+        // Skip if empty.
+        if (count($outer) === 0) {
+            return;
+        }
+
+        // Find nested for loops.
+        $start = ++$token['scope_opener'];
+        $end   = --$token['scope_closer'];
+
+        for (; $start <= $end; ++$start) {
+            if ($tokens[$start]['code'] !== T_FOR) {
+                continue;
+            }
+
+            $inner = $this->findIncrementers($tokens, $tokens[$start]);
+            $diff  = array_intersect($outer, $inner);
+
+            if (count($diff) !== 0) {
+                $error = 'Loop incrementor (%s) jumbling with inner loop';
+                $data  = array(join(', ', $diff));
+                $phpcsFile->addWarning($error, $stackPtr, 'Found', $data);
+            }
+        }
+
+    }//end process()
+
+
+    /**
+     * Get all used variables in the incrementer part of a for statement.
+     *
+     * @param array(integer=>array) $tokens Array with all code sniffer tokens.
+     * @param array(string=>mixed)  $token  Current for loop token
+     * 
+     * @return array(string) List of all found incrementer variables.
+     */
+    protected function findIncrementers(array $tokens, array $token)
+    {
+        // Skip invalid statement.
+        if (isset($token['parenthesis_opener']) === false) {
+            return array();
+        }
+
+        $start = ++$token['parenthesis_opener'];
+        $end   = --$token['parenthesis_closer'];
+
+        $incrementers = array();
+        $semicolons   = 0;
+        for ($next = $start; $next <= $end; ++$next) {
+            $code = $tokens[$next]['code'];
+            if ($code === T_SEMICOLON) {
+                ++$semicolons;
+            } else if ($semicolons === 2 && $code === T_VARIABLE) {
+                $incrementers[] = $tokens[$next]['content'];
+            }
+        }
+
+        return $incrementers;
+
+    }//end findIncrementers()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/CodeAnalysis/UnconditionalIfStatementSniff.php

@@ -0,0 +1,106 @@
+<?php
+/**
+ * This file is part of the CodeAnalysis addon for PHP_CodeSniffer.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Detects unconditional if- and elseif-statements.
+ * 
+ * This rule is based on the PMD rule catalog. The Unconditional If Statment
+ * sniff detects statement conditions that are only set to one of the constant
+ * values <b>true</b> or <b>false</b>
+ *
+ * <code>
+ * class Foo
+ * {
+ *     public function close()
+ *     {
+ *         if (true)
+ *         {
+ *             // ...
+ *         }
+ *     }
+ * }
+ * </code>
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_CodeAnalysis_UnconditionalIfStatementSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Registers the tokens that this sniff wants to listen for.
+     *
+     * @return array(integer)
+     */
+    public function register()
+    {
+        return array(
+                T_IF,
+                T_ELSEIF,
+               );
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+        $token  = $tokens[$stackPtr];
+
+        // Skip for-loop without body.
+        if (isset($token['parenthesis_opener']) === false) {
+            return;
+        }
+
+        $next = ++$token['parenthesis_opener'];
+        $end  = --$token['parenthesis_closer'];
+
+        $goodCondition = false;
+        for (; $next <= $end; ++$next) {
+            $code = $tokens[$next]['code'];
+
+            if (in_array($code, PHP_CodeSniffer_Tokens::$emptyTokens) === true) {
+                continue;
+            } else if ($code !== T_TRUE && $code !== T_FALSE) {
+                $goodCondition = true;
+            }
+        }
+
+        if ($goodCondition === false) {
+            $error = 'Avoid IF statements that are always true or false';
+            $phpcsFile->addWarning($error, $stackPtr, 'Found');
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/CodeAnalysis/UnnecessaryFinalModifierSniff.php

@@ -0,0 +1,98 @@
+<?php
+/**
+ * This file is part of the CodeAnalysis addon for PHP_CodeSniffer.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Detects unnecessary final modifiers inside of final classes.
+ *
+ * This rule is based on the PMD rule catalog. The Unnecessary Final Modifier
+ * sniff detects the use of the final modifier inside of a final class which
+ * is unnecessary.
+ *
+ * <code>
+ * final class Foo
+ * {
+ *     public final function bar()
+ *     {
+ *     }
+ * }
+ * </code>
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_CodeAnalysis_UnnecessaryFinalModifierSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Registers the tokens that this sniff wants to listen for.
+     *
+     * @return array(integer)
+     */
+    public function register()
+    {
+        return array(T_CLASS);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+        $token  = $tokens[$stackPtr];
+
+        // Skip for-statements without body.
+        if (isset($token['scope_opener']) === false) {
+            return;
+        }
+
+        // Fetch previous token.
+        $prev = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr - 1), null, true);
+
+        // Skip for non final class.
+        if ($prev === false || $tokens[$prev]['code'] !== T_FINAL) {
+            return;
+        }
+
+        $next = ++$token['scope_opener'];
+        $end  = --$token['scope_closer'];
+
+        for (; $next <= $end; ++$next) {
+            if ($tokens[$next]['code'] === T_FINAL) {
+                $error = 'Unnecessary FINAL modifier in FINAL class';
+                $phpcsFile->addWarning($error, $next, 'Found');
+            }
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/CodeAnalysis/UnusedFunctionParameterSniff.php

@@ -0,0 +1,150 @@
+<?php
+/**
+ * This file is part of the CodeAnalysis addon for PHP_CodeSniffer.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Checks the for unused function parameters.
+ *
+ * This sniff checks that all function parameters are used in the function body.
+ * One exception is made for empty function bodies or function bodies that only
+ * contain comments. This could be usefull for the classes that implement an
+ * interface that defines multiple methods but the implementation only needs some
+ * of them.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_CodeAnalysis_UnusedFunctionParameterSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_FUNCTION);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+        $token  = $tokens[$stackPtr];
+
+        // Skip broken function declarations.
+        if (isset($token['scope_opener']) === false || isset($token['parenthesis_opener']) === false) {
+            return;
+        }
+
+        $params = array();
+        foreach ($phpcsFile->getMethodParameters($stackPtr) as $param) {
+            $params[$param['name']] = $stackPtr;
+        }
+
+        $next = ++$token['scope_opener'];
+        $end  = --$token['scope_closer'];
+
+        $emptyBody = true;
+
+        for (; $next <= $end; ++$next) {
+            $token = $tokens[$next];
+            $code  = $token['code'];
+
+            // Ingorable tokens.
+            if (in_array($code, PHP_CodeSniffer_Tokens::$emptyTokens) === true) {
+                continue;
+            } else if ($code === T_THROW && $emptyBody === true) {
+                // Throw statement and an empty body indicate an interface method.
+                return;
+            } else if ($code === T_RETURN && $emptyBody === true) {
+                // Return statement and an empty body indicate an interface method.
+                $tmp = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($next + 1), null, true);
+                if ($tmp === false) {
+                    return;
+                }
+
+                // There is a return.
+                if ($tokens[$tmp]['code'] === T_SEMICOLON) {
+                    return;
+                }
+
+                $tmp = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($tmp + 1), null, true);
+
+                // There is a return <token>.
+                if ($tmp !== false && $tokens[$tmp]['code'] === T_SEMICOLON) {
+                     return;
+                }
+            }//end if
+
+            $emptyBody = false;
+
+            if ($code === T_VARIABLE && isset($params[$token['content']]) === true) {
+                unset($params[$token['content']]);
+            } else if ($code === T_DOUBLE_QUOTED_STRING || $code === T_HEREDOC) {
+                // Tokenize strings that can contain variables.
+                // Make sure the string is re-joined if it occurs over multiple lines.
+                $string = $token['content'];
+                for ($i = ($next + 1); $i <= $end; $i++) {
+                    if ($tokens[$i]['code'] === $code) {
+                        $string .= $tokens[$i]['content'];
+                        $next++;
+                    }
+                }
+
+                $strTokens = token_get_all(sprintf('<?php %s;?>', $string));
+
+                foreach ($strTokens as $tok) {
+                    if (is_array($tok) === false || $tok[0] !== T_VARIABLE ) {
+                        continue;
+                    }
+
+                    if (isset($params[$tok[1]]) === true) {
+                        unset($params[$tok[1]]);
+                    }
+                }
+            }//end if
+        }//end for
+
+        if ($emptyBody === false && count($params) > 0) {
+            foreach ($params as $paramName => $position) {
+                $error = 'The method parameter %s is never used';
+                $data  = array($paramName);
+                $phpcsFile->addWarning($error, $position, 'Found', $data);
+            }
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/CodeAnalysis/UselessOverridingMethodSniff.php

@@ -0,0 +1,180 @@
+<?php
+/**
+ * This file is part of the CodeAnalysis addon for PHP_CodeSniffer.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Detects unnecessary overriden methods that simply call their parent.
+ *
+ * This rule is based on the PMD rule catalog. The Useless Overriding Method
+ * sniff detects the use of methods that only call their parent classes's method
+ * with the same name and arguments. These methods are not required.
+ *
+ * <code>
+ * class FooBar {
+ *   public function __construct($a, $b) {
+ *     parent::__construct($a, $b);
+ *   }
+ * }
+ * </code>
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Manuel Pichler <mapi@manuel-pichler.de>
+ * @copyright 2007-2008 Manuel Pichler. All rights reserved.
+ * @license   http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_CodeAnalysis_UselessOverridingMethodSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Registers the tokens that this sniff wants to listen for.
+     *
+     * @return array(integer)
+     */
+    public function register()
+    {
+        return array(T_FUNCTION);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+        $token  = $tokens[$stackPtr];
+
+        // Skip function without body.
+        if (isset($token['scope_opener']) === false) {
+            return;
+        }
+
+        // Get function name.
+        $methodName = $phpcsFile->getDeclarationName($stackPtr);
+
+        // Get all parameters from method signature.
+        $signature = array();
+        foreach ($phpcsFile->getMethodParameters($stackPtr) as $param) {
+            $signature[] = $param['name'];
+        }
+
+        $next = ++$token['scope_opener'];
+        $end  = --$token['scope_closer'];
+
+        for (; $next <= $end; ++$next) {
+            $code = $tokens[$next]['code'];
+
+            if (in_array($code, PHP_CodeSniffer_Tokens::$emptyTokens) === true) {
+                continue;
+            } else if ($code === T_RETURN) {
+                continue;
+            }
+
+            break;
+        }
+
+        // Any token except 'parent' indicates correct code.
+        if ($tokens[$next]['code'] !== T_PARENT) {
+            return;
+        }
+
+        // Find next non empty token index, should be double colon.
+        $next = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($next + 1), null, true);
+
+        // Skip for invalid code.
+        if ($next === false || $tokens[$next]['code'] !== T_DOUBLE_COLON) {
+            return;
+        }
+
+        // Find next non empty token index, should be the function name.
+        $next = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($next + 1), null, true);
+
+        // Skip for invalid code or other method.
+        if ($next === false || $tokens[$next]['content'] !== $methodName) {
+            return;
+        }
+
+        // Find next non empty token index, should be the open parenthesis.
+        $next = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($next + 1), null, true);
+
+        // Skip for invalid code.
+        if ($next === false || $tokens[$next]['code'] !== T_OPEN_PARENTHESIS) {
+            return;
+        }
+
+        $validParameterTypes = array(
+                                T_VARIABLE,
+                                T_LNUMBER,
+                                T_CONSTANT_ENCAPSED_STRING,
+                               );
+
+        $parameters       = array('');
+        $parenthesisCount = 1;
+        $count            = count($tokens);
+        for (++$next; $next < $count; ++$next) {
+            $code = $tokens[$next]['code'];
+
+            if ($code === T_OPEN_PARENTHESIS) {
+                ++$parenthesisCount;
+            } else if ($code === T_CLOSE_PARENTHESIS) {
+                --$parenthesisCount;
+            } else if ($parenthesisCount === 1 && $code === T_COMMA) {
+                $parameters[] = '';
+            } else if (in_array($code, PHP_CodeSniffer_Tokens::$emptyTokens) === false) {
+                $parameters[(count($parameters) - 1)] .= $tokens[$next]['content'];
+            }
+
+            if ($parenthesisCount === 0) {
+                break;
+            }
+        }//end for
+
+        $next = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($next + 1), null, true);
+        if ($next === false || $tokens[$next]['code'] !== T_SEMICOLON) {
+            return;
+        }
+
+        // Check rest of the scope.
+        for (++$next; $next <= $end; ++$next) {
+            $code = $tokens[$next]['code'];
+            // Skip for any other content.
+            if (in_array($code, PHP_CodeSniffer_Tokens::$emptyTokens) === false) {
+                return;
+            }
+        }
+
+        $parameters = array_map('trim', $parameters);
+        $parameters = array_filter($parameters);
+
+        if (count($parameters) === count($signature) && $parameters === $signature) {
+            $phpcsFile->addWarning('Useless method overriding detected', $stackPtr, 'Found');
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Commenting/TodoSniff.php

@@ -0,0 +1,90 @@
+<?php
+/**
+ * Generic_Sniffs_Commenting_TodoSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Commenting_TodoSniff.
+ *
+ * Warns about TODO comments.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Commenting_TodoSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A list of tokenizers this sniff supports.
+     *
+     * @var array
+     */
+    public $supportedTokenizers = array(
+                                   'PHP',
+                                   'JS',
+                                  );
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return PHP_CodeSniffer_Tokens::$commentTokens;
+
+    }//end register()
+
+
+    /**
+     * Processes this sniff, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        $content = $tokens[$stackPtr]['content'];
+        $matches = Array();
+        if (preg_match('|[^a-z]+todo[^a-z]+(.*)|i', $content, $matches) !== 0) {
+            // Clear whitespace and some common characters not required at
+            // the end of a to-do message to make the warning more informative.
+            $type        = 'CommentFound';
+            $todoMessage = trim($matches[1]);
+            $todoMessage = trim($todoMessage, '[]().');
+            $error       = 'Comment refers to a TODO task';
+            $data        = array($todoMessage);
+            if ($todoMessage !== '') {
+                $type   = 'TaskFound';
+                $error .= ' "%s"';
+            }
+
+            $phpcsFile->addWarning($error, $stackPtr, $type, $data);
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/ControlStructures/InlineControlStructureSniff.php

@@ -0,0 +1,120 @@
+<?php
+/**
+ * Generic_Sniffs_ControlStructures_InlineControlStructureSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_ControlStructures_InlineControlStructureSniff.
+ *
+ * Verifies that inline control statements are not present.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_ControlStructures_InlineControlStructureSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A list of tokenizers this sniff supports.
+     *
+     * @var array
+     */
+    public $supportedTokenizers = array(
+                                   'PHP',
+                                   'JS',
+                                  );
+
+    /**
+     * If true, an error will be thrown; otherwise a warning.
+     *
+     * @var bool
+     */
+    public $error = true;
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(
+                T_IF,
+                T_ELSE,
+                T_FOREACH,
+                T_WHILE,
+                T_DO,
+                T_SWITCH,
+                T_FOR,
+               );
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in the
+     *                                        stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        if (isset($tokens[$stackPtr]['scope_opener']) === false) {
+            // Ignore the ELSE in ELSE IF. We'll process the IF part later.
+            if (($tokens[$stackPtr]['code'] === T_ELSE) && ($tokens[($stackPtr + 2)]['code'] === T_IF)) {
+                return;
+            }
+
+            if ($tokens[$stackPtr]['code'] === T_WHILE) {
+                // This could be from a DO WHILE, which doesn't have an opening brace.
+                $lastContent = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);
+                if ($tokens[$lastContent]['code'] === T_CLOSE_CURLY_BRACKET) {
+                    $brace = $tokens[$lastContent];
+                    if (isset($brace['scope_condition']) === true) {
+                        $condition = $tokens[$brace['scope_condition']];
+                        if ($condition['code'] === T_DO) {
+                            return;
+                        }
+                    }
+                }
+            }
+
+            // This is a control structure without an opening brace,
+            // so it is an inline statement.
+            if ($this->error === true) {
+                $phpcsFile->addError('Inline control structures are not allowed', $stackPtr, 'NotAllowed');
+            } else {
+                $phpcsFile->addWarning('Inline control structures are discouraged', $stackPtr, 'Discouraged');
+            }
+
+            return;
+        }//end if
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Debug/ClosureLinterSniff.php

@@ -0,0 +1,139 @@
+<?php
+/**
+ * Generic_Sniffs_Debug_ClosureLinterSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Debug_ClosureLinterSniff.
+ *
+ * Runs gjslint on the file.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Debug_ClosureLinterSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A list of error codes that should show errors.
+     *
+     * All other error codes will show warnings.
+     *
+     * @var int
+     */
+    public $errorCodes = array();
+
+    /**
+     * A list of error codes to ignore.
+     *
+     * @var int
+     */
+    public $ignoreCodes = array();
+
+    /**
+     * A list of tokenizers this sniff supports.
+     *
+     * @var array
+     */
+    public $supportedTokenizers = array('JS');
+
+
+    /**
+     * Returns the token types that this sniff is interested in.
+     *
+     * @return array(int)
+     */
+    public function register()
+    {
+        return array(T_OPEN_TAG);
+
+    }//end register()
+
+
+    /**
+     * Processes the tokens that this sniff is interested in.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file where the token was found.
+     * @param int                  $stackPtr  The position in the stack where
+     *                                        the token was found.
+     *
+     * @return void
+     * @throws PHP_CodeSniffer_Exception If jslint.js could not be run
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $fileName = $phpcsFile->getFilename();
+
+        $lintPath = PHP_CodeSniffer::getConfigData('gjslint_path');
+        if ($lintPath === null) {
+            return;
+        }
+
+        $cmd = "$lintPath --nosummary --notime --unix_mode \"$fileName\"";
+        $msg = exec($cmd, $output, $retval);
+
+        if (is_array($output) === false) {
+            return;
+        }
+
+        $tokens = $phpcsFile->getTokens();
+
+        foreach ($output as $finding) {
+            $matches    = array();
+            $numMatches = preg_match('/^(.*):([0-9]+):\(([0-9]+)\)(.*)$/', $finding, $matches);
+            if ($numMatches === 0) {
+                continue;
+            }
+
+            // Skip error codes we are ignoring.
+            $code = $matches[3];
+            if (in_array($code, $this->ignoreCodes) === true) {
+                continue;
+            }
+
+            $line  = (int) $matches[2];
+            $error = trim($matches[4]);
+
+            // Find the token at the start of the line.
+            $lineToken = null;
+            foreach ($tokens as $ptr => $info) {
+                if ($info['line'] === $line) {
+                    $lineToken = $ptr;
+                    break;
+                }
+            }
+
+            if ($lineToken !== null) {
+                $message = 'gjslint says: (%s) %s';
+                $data    = array(
+                            $code,
+                            $error,
+                           );
+                if (in_array($code, $this->errorCodes) === true) {
+                    $phpcsFile->addError($message, $lineToken, 'ExternalToolError', $data);
+                } else {
+                    $phpcsFile->addWarning($message, $lineToken, 'ExternalTool', $data);
+                }
+            }
+        }//end foreach
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Debug/JSHintSniff.php

@@ -0,0 +1,109 @@
+<?php
+/**
+ * Generic_Sniffs_Debug_JSHintSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Alexander Wei<65> <aweisswa@gmx.de>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Debug_JSHintSniff.
+ *
+ * Runs jshint.js on the file.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Alexander Wei<65> <aweisswa@gmx.de>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Debug_JSHintSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A list of tokenizers this sniff supports.
+     *
+     * @var array
+     */
+    public $supportedTokenizers = array('JS');
+
+
+    /**
+     * Returns the token types that this sniff is interested in.
+     *
+     * @return array(int)
+     */
+    public function register()
+    {
+        return array(T_OPEN_TAG);
+
+    }//end register()
+
+
+    /**
+     * Processes the tokens that this sniff is interested in.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file where the token was found.
+     * @param int                  $stackPtr  The position in the stack where
+     *                                        the token was found.
+     *
+     * @return void
+     * @throws PHP_CodeSniffer_Exception If jshint.js could not be run
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $fileName = $phpcsFile->getFilename();
+
+        $rhinoPath  = PHP_CodeSniffer::getConfigData('rhino_path');
+        $jshintPath = PHP_CodeSniffer::getConfigData('jshint_path');
+        if ($rhinoPath === null || $jshintPath === null) {
+            return;
+        }
+
+        $cmd = "$rhinoPath \"$jshintPath\" \"$fileName\"";
+        $msg = exec($cmd, $output, $retval);
+
+        if (is_array($output) === true) {
+            $tokens = $phpcsFile->getTokens();
+
+            foreach ($output as $finding) {
+                $matches    = array();
+                $numMatches = preg_match('/^(.+)\(.+:([0-9]+).*:[0-9]+\)$/', $finding, $matches);
+                if ($numMatches === 0) {
+                    continue;
+                }
+
+                $line    = (int) $matches[2];
+                $message = 'jshint says: '.trim($matches[1]);
+
+                // Find the token at the start of the line.
+                $lineToken = null;
+                foreach ($tokens as $ptr => $info) {
+                    if ($info['line'] === $line) {
+                        $lineToken = $ptr;
+                        break;
+                    }
+                }
+
+                if ($lineToken !== null) {
+                    $phpcsFile->addWarning($message, $lineToken, 'ExternalTool');
+                }
+            }//end foreach
+        }//end if
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Files/ByteOrderMarkSniff.php

@@ -0,0 +1,93 @@
+<?php
+/**
+ * Generic_Sniffs_Files_ByteOrderMarkSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Files_ByteOrderMarkSniff.
+ *
+ * A simple sniff for detecting BOMs that may corrupt application work.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Piotr Karas <office@mediaself.pl>
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2010-2011 mediaSELF Sp. z o.o.
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ * @see       http://en.wikipedia.org/wiki/Byte_order_mark
+ */
+class Generic_Sniffs_Files_ByteOrderMarkSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * List of supported BOM definitions.
+     *
+     * Use encoding names as keys and hex BOM representations as values.
+     *
+     * @var array
+     */
+    public $bomDefinitions = array(
+                              'UTF-8'       => 'efbbbf',
+                              'UTF-16 (BE)' => 'feff',
+                              'UTF-16 (LE)' => 'fffe',
+                             );
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_INLINE_HTML);
+
+    }//end register()
+
+
+    /**
+     * Processes this sniff, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in
+     *                                        the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process( PHP_CodeSniffer_File $phpcsFile, $stackPtr )
+    {
+        // The BOM will be the very first token in the file.
+        if ($stackPtr !== 0) {
+            return;
+        }
+
+        $tokens = $phpcsFile->getTokens();
+
+        foreach ($this->bomDefinitions as $bomName => $expectedBomHex) {
+            $bomByteLength = (strlen($expectedBomHex) / 2);
+            $htmlBomHex    = bin2hex(substr($tokens[$stackPtr]['content'], 0, $bomByteLength));
+            if ($htmlBomHex === $expectedBomHex) {
+                $errorData = array($bomName);
+                $error     = 'File contains %s byte order mark, which may corrupt your application';
+                $phpcsFile->addError($error, $stackPtr, 'Found', $errorData);
+                break;
+            }
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Files/LineEndingsSniff.php

@@ -0,0 +1,103 @@
+<?php
+/**
+ * Generic_Sniffs_Files_LineEndingsSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Files_LineEndingsSniff.
+ *
+ * Checks that end of line characters are correct.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Files_LineEndingsSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A list of tokenizers this sniff supports.
+     *
+     * @var array
+     */
+    public $supportedTokenizers = array(
+                                   'PHP',
+                                   'JS',
+                                   'CSS',
+                                  );
+
+    /**
+     * The valid EOL character.
+     *
+     * @var string
+     */
+    public $eolChar = '\n';
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_OPEN_TAG);
+
+    }//end register()
+
+
+    /**
+     * Processes this sniff, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in
+     *                                        the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        // We are only interested if this is the first open tag.
+        if ($stackPtr !== 0) {
+            if ($phpcsFile->findPrevious(T_OPEN_TAG, ($stackPtr - 1)) !== false) {
+                return;
+            }
+        }
+
+        $found = $phpcsFile->eolChar;
+        $found = str_replace("\n", '\n', $found);
+        $found = str_replace("\r", '\r', $found);
+
+        if ($found !== $this->eolChar) {
+            $error    = 'End of line character is invalid; expected "%s" but found "%s"';
+            $expected = $this->eolChar;
+            $expected = str_replace("\n", '\n', $expected);
+            $expected = str_replace("\r", '\r', $expected);
+            $data     = array(
+                         $expected,
+                         $found,
+                        );
+            $phpcsFile->addError($error, $stackPtr, 'InvalidEOLChar', $data);
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Files/LineLengthSniff.php

@@ -0,0 +1,161 @@
+<?php
+/**
+ * Generic_Sniffs_Files_LineLengthSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Files_LineLengthSniff.
+ *
+ * Checks all lines in the file, and throws warnings if they are over 80
+ * characters in length and errors if they are over 100. Both these
+ * figures can be changed by extending this sniff in your own standard.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Files_LineLengthSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * The limit that the length of a line should not exceed.
+     *
+     * @var int
+     */
+    public $lineLimit = 80;
+
+    /**
+     * The limit that the length of a line must not exceed.
+     *
+     * Set to zero (0) to disable.
+     *
+     * @var int
+     */
+    public $absoluteLineLimit = 100;
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_OPEN_TAG);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in
+     *                                        the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // Make sure this is the first open tag.
+        $previousOpenTag = $phpcsFile->findPrevious(T_OPEN_TAG, ($stackPtr - 1));
+        if ($previousOpenTag !== false) {
+            return;
+        }
+
+        $tokenCount         = 0;
+        $currentLineContent = '';
+        $currentLine        = 1;
+
+        $trim = (strlen($phpcsFile->eolChar) * -1);
+        for (; $tokenCount < $phpcsFile->numTokens; $tokenCount++) {
+            if ($tokens[$tokenCount]['line'] === $currentLine) {
+                $currentLineContent .= $tokens[$tokenCount]['content'];
+            } else {
+                $currentLineContent = substr($currentLineContent, 0, $trim);
+                $this->checkLineLength($phpcsFile, ($tokenCount - 1), $currentLineContent);
+                $currentLineContent = $tokens[$tokenCount]['content'];
+                $currentLine++;
+            }
+        }
+
+        $currentLineContent = substr($currentLineContent, 0, $trim);
+        $this->checkLineLength($phpcsFile, ($tokenCount - 1), $currentLineContent);
+
+    }//end process()
+
+
+    /**
+     * Checks if a line is too long.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile   The file being scanned.
+     * @param int                  $stackPtr    The token at the end of the line.
+     * @param string               $lineContent The content of the line.
+     *
+     * @return void
+     */
+    protected function checkLineLength(PHP_CodeSniffer_File $phpcsFile, $stackPtr, $lineContent)
+    {
+        // If the content is a CVS or SVN id in a version tag, or it is
+        // a license tag with a name and URL, there is nothing the
+        // developer can do to shorten the line, so don't throw errors.
+        if (preg_match('|@version[^\$]+\$Id|', $lineContent) !== 0) {
+            return;
+        }
+
+        if (preg_match('|@license|', $lineContent) !== 0) {
+            return;
+        }
+
+        if (PHP_CODESNIFFER_ENCODING !== 'iso-8859-1') {
+            // Not using the detault encoding, so take a bit more care.
+            $lineLength = iconv_strlen($lineContent, PHP_CODESNIFFER_ENCODING);
+            if ($lineLength === false) {
+                // String contained invalid characters, so revert to default.
+                $lineLength = strlen($lineContent);
+            }
+        } else {
+            $lineLength = strlen($lineContent);
+        }
+
+        if ($this->absoluteLineLimit > 0
+            && $lineLength > $this->absoluteLineLimit
+        ) {
+            $data = array(
+                     $this->absoluteLineLimit,
+                     $lineLength,
+                    );
+
+            $error = 'Line exceeds maximum limit of %s characters; contains %s characters';
+            $phpcsFile->addError($error, $stackPtr, 'MaxExceeded', $data);
+        } else if ($lineLength > $this->lineLimit) {
+            $data = array(
+                     $this->lineLimit,
+                     $lineLength,
+                    );
+
+            $warning = 'Line exceeds %s characters; contains %s characters';
+            $phpcsFile->addWarning($warning, $stackPtr, 'TooLong', $data);
+        }
+    }//end checkLineLength()
+
+
+}//end class
+

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Formatting/DisallowMultipleStatementsSniff.php

@@ -0,0 +1,88 @@
+<?php
+/**
+ * Generic_Sniffs_Formatting_DisallowMultipleStatementsSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Formatting_DisallowMultipleStatementsSniff.
+ *
+ * Ensures each statement is on a line by itself.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Formatting_DisallowMultipleStatementsSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_SEMICOLON);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in
+     *                                        the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        $prev = $phpcsFile->findPrevious(T_SEMICOLON, ($stackPtr - 1));
+        if ($prev === false) {
+            return;
+        }
+
+        // Ignore multiple statements in a FOR condition.
+        if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
+            foreach ($tokens[$stackPtr]['nested_parenthesis'] as $bracket) {
+                if (isset($tokens[$bracket]['parenthesis_owner']) === false) {
+                    // Probably a closure sitting inside a function call.
+                    continue;
+                }
+
+                $owner = $tokens[$bracket]['parenthesis_owner'];
+                if ($tokens[$owner]['code'] === T_FOR) {
+                    return;
+                }
+            }
+        }
+
+        if ($tokens[$prev]['line'] === $tokens[$stackPtr]['line']) {
+            $error = 'Each PHP statement must be on a line by itself';
+            $phpcsFile->addError($error, $stackPtr, 'SameLine');
+            return;
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Formatting/MultipleStatementAlignmentSniff.php

@@ -0,0 +1,304 @@
+<?php
+/**
+ * Generic_Sniffs_Formatting_MultipleStatementAlignmentSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Formatting_MultipleStatementAlignmentSniff.
+ *
+ * Checks alignment of assignments. If there are multiple adjacent assignments,
+ * it will check that the equals signs of each assignment are aligned. It will
+ * display a warning to advise that the signs should be aligned.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Formatting_MultipleStatementAlignmentSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A list of tokenizers this sniff supports.
+     *
+     * @var array
+     */
+    public $supportedTokenizers = array(
+                                   'PHP',
+                                   'JS',
+                                  );
+
+    /**
+     * If true, an error will be thrown; otherwise a warning.
+     *
+     * @var bool
+     */
+    public $error = false;
+
+    /**
+     * The maximum amount of padding before the alignment is ignored.
+     *
+     * If the amount of padding required to align this assignment with the
+     * surrounding assignments exceeds this number, the assignment will be
+     * ignored and no errors or warnings will be thrown.
+     *
+     * @var int
+     */
+    public $maxPadding = 1000;
+
+    /**
+     * If true, multi-line assignments are not checked.
+     *
+     * @var int
+     */
+    public $ignoreMultiLine = false;
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return PHP_CodeSniffer_Tokens::$assignmentTokens;
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // Ignore assignments used in a condition, like an IF or FOR.
+        if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) {
+            foreach ($tokens[$stackPtr]['nested_parenthesis'] as $start => $end) {
+                if (isset($tokens[$start]['parenthesis_owner']) === true) {
+                    return;
+                }
+            }
+        }
+
+        /*
+            By this stage, it is known that there is an assignment on this line.
+            We only want to process the block once we reach the last assignment,
+            so we need to determine if there are more to follow.
+        */
+
+        // The assignment may span over multiple lines, so look for the
+        // end of the assignment so we can check assignment blocks correctly.
+        $lineEnd = $phpcsFile->findNext(T_SEMICOLON, ($stackPtr + 1));
+
+        $nextAssign = $phpcsFile->findNext(
+            PHP_CodeSniffer_Tokens::$assignmentTokens,
+            ($lineEnd + 1)
+        );
+
+        if ($nextAssign !== false) {
+            $isAssign = true;
+            if ($tokens[$nextAssign]['line'] === ($tokens[$lineEnd]['line'] + 1)) {
+                // Assignment may be in the same block as this one. Just make sure
+                // it is not used in a condition, like an IF or FOR.
+                if (isset($tokens[$nextAssign]['nested_parenthesis']) === true) {
+                    foreach ($tokens[$nextAssign]['nested_parenthesis'] as $start => $end) {
+                        if (isset($tokens[$start]['parenthesis_owner']) === true) {
+                            // Not an assignment.
+                            $isAssign = false;
+                            break;
+                        }
+                    }
+                }
+
+                if ($isAssign === true) {
+                    return;
+                }
+            }
+        }
+
+        // Getting here means that this is the last in a block of statements.
+        $assignments    = array();
+        $assignments[]  = $stackPtr;
+        $prevAssignment = $stackPtr;
+        $lastLine       = $tokens[$stackPtr]['line'];
+
+        while (($prevAssignment = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$assignmentTokens, ($prevAssignment - 1))) !== false) {
+
+            // We are not interested in double arrows as they assign values inside
+            // arrays and loops and do not use the same indentation rules.
+            if ($tokens[$prevAssignment]['code'] === T_DOUBLE_ARROW) {
+                continue;
+            }
+
+            // The assignment's end token must be on the line directly
+            // above the current one to be in the same assignment block.
+            $lineEnd = $phpcsFile->findNext(T_SEMICOLON, ($prevAssignment + 1));
+
+            // And the end token must actually belong to this assignment.
+            $nextOpener = $phpcsFile->findNext(
+                PHP_CodeSniffer_Tokens::$scopeOpeners,
+                ($prevAssignment + 1)
+            );
+
+            if ($nextOpener !== false && $nextOpener < $lineEnd) {
+                break;
+            }
+
+            if ($tokens[$lineEnd]['line'] !== ($lastLine - 1)) {
+                break;
+            }
+
+            // Make sure it is not assigned inside a condition (eg. IF, FOR).
+            if (isset($tokens[$prevAssignment]['nested_parenthesis']) === true) {
+                foreach ($tokens[$prevAssignment]['nested_parenthesis'] as $start => $end) {
+                    if (isset($tokens[$start]['parenthesis_owner']) === true) {
+                        break(2);
+                    }
+                }
+            }
+
+            $assignments[] = $prevAssignment;
+            $lastLine      = $tokens[$prevAssignment]['line'];
+        }//end while
+
+        $assignmentData      = array();
+        $maxAssignmentLength = 0;
+        $maxVariableLength   = 0;
+
+        foreach ($assignments as $assignment) {
+            $prev = $phpcsFile->findPrevious(
+                PHP_CodeSniffer_Tokens::$emptyTokens,
+                ($assignment - 1),
+                null,
+                true
+            );
+
+            $endColumn = $tokens[($prev + 1)]['column'];
+
+            if ($maxVariableLength < $endColumn) {
+                $maxVariableLength = $endColumn;
+            }
+
+            if ($maxAssignmentLength < strlen($tokens[$assignment]['content'])) {
+                $maxAssignmentLength = strlen($tokens[$assignment]['content']);
+            }
+
+            $assignmentData[$assignment]
+                = array(
+                   'variable_length'   => $endColumn,
+                   'assignment_length' => strlen($tokens[$assignment]['content']),
+                  );
+        }//end foreach
+
+        foreach ($assignmentData as $assignment => $data) {
+            if ($data['assignment_length'] === $maxAssignmentLength) {
+                if ($data['variable_length'] === $maxVariableLength) {
+                    // The assignment is the longest possible, so the column that
+                    // everything has to align to is based on it.
+                    $column = ($maxVariableLength + 1);
+                    break;
+                } else {
+                    // The assignment token is the longest out of all of the
+                    // assignments, but the variable name is not, so the column
+                    // the start at can go back more to cover the space
+                    // between the variable name and the assigment operator.
+                    $column = ($maxVariableLength - ($maxAssignmentLength - 1) + 1);
+                }
+            }
+        }
+
+        // Determine the actual position that each equals sign should be in.
+        foreach ($assignments as $assignment) {
+            // Actual column takes into account the length of the assignment operator.
+            $actualColumn = ($column + $maxAssignmentLength - strlen($tokens[$assignment]['content']));
+            if ($tokens[$assignment]['column'] !== $actualColumn) {
+                $prev = $phpcsFile->findPrevious(
+                    PHP_CodeSniffer_Tokens::$emptyTokens,
+                    ($assignment - 1),
+                    null,
+                    true
+                );
+
+                $expected = ($actualColumn - $tokens[($prev + 1)]['column']);
+
+                if ($tokens[$assignment]['line'] !== $tokens[$prev]['line']) {
+                    // Instead of working out how many spaces there are
+                    // across new lines, the error message becomes more
+                    // generic below.
+                    $found = null;
+                } else {
+                    $found = ($tokens[$assignment]['column'] - $tokens[($prev + 1)]['column']);
+                }
+
+                // If the expected number of spaces for alignment exceeds the
+                // maxPadding rule, we just check for a single space as no
+                // alignment is required.
+                if ($expected > $this->maxPadding) {
+                    if ($found === 1) {
+                        continue;
+                    } else {
+                        $expected = 1;
+                    }
+                }
+
+                // Skip multi-line assignments if required.
+                if ($found === null && $this->ignoreMultiLine === true) {
+                    continue;
+                }
+
+                $expected .= ($expected === 1) ? ' space' : ' spaces';
+                if ($found === null) {
+                    $found = 'a new line';
+                } else {
+                    $found .= ($found === 1) ? ' space' : ' spaces';
+                }
+
+                if (count($assignments) === 1) {
+                    $type  = 'Incorrect';
+                    $error = 'Equals sign not aligned correctly; expected %s but found %s';
+                } else {
+                    $type  = 'NotSame';
+                    $error = 'Equals sign not aligned with surrounding assignments; expected %s but found %s';
+                }
+
+                $errorData = array(
+                              $expected,
+                              $found,
+                             );
+
+                if ($this->error === true) {
+                    $phpcsFile->addError($error, $assignment, $type, $errorData);
+                } else {
+                    $phpcsFile->addWarning($error, $assignment, $type.'Warning', $errorData);
+                }
+            }//end if
+        }//end foreach
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Formatting/NoSpaceAfterCastSniff.php

@@ -0,0 +1,69 @@
+<?php
+/**
+ * Generic_Sniffs_Formatting_NoSpaceAfterCastSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Formatting_NoSpaceAfterCastSniff.
+ *
+ * Ensures there is no space after cast tokens.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Formatting_NoSpaceAfterCastSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return PHP_CodeSniffer_Tokens::$castTokens;
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in
+     *                                        the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) {
+            $error = 'A cast statement must not be followed by a space';
+            $phpcsFile->addError($error, $stackPtr, 'SpaceFound');
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Formatting/SpaceAfterCastSniff.php

@@ -0,0 +1,75 @@
+<?php
+/**
+ * Generic_Sniffs_Formatting_SpaceAfterCastSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Formatting_SpaceAfterCastSniff.
+ *
+ * Ensures there is a single space after cast tokens.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Formatting_SpaceAfterCastSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return PHP_CodeSniffer_Tokens::$castTokens;
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in
+     *                                        the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) {
+            $error = 'A cast statement must be followed by a single space';
+            $phpcsFile->addError($error, $stackPtr, 'NoSpace');
+            return;
+        }
+
+        if ($tokens[($stackPtr + 1)]['content'] !== ' ') {
+            $error = 'A cast statement must be followed by a single space';
+            $phpcsFile->addError($error, $stackPtr, 'TooMuchSpace');
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Functions/CallTimePassByReferenceSniff.php

@@ -0,0 +1,148 @@
+<?php
+/**
+ * Generic_Sniffs_Functions_CallTimePassByReferenceSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Florian Grandel <jerico.dev@gmail.com>
+ * @copyright 2009 Florian Grandel
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Functions_CallTimePassByReferenceSniff.
+ *
+ * Ensures that variables are not passed by reference when calling a function.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Florian Grandel <jerico.dev@gmail.com>
+ * @copyright 2009 Florian Grandel
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Functions_CallTimePassByReferenceSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_STRING);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // Skip tokens that are the names of functions or classes
+        // within their definitions. For example: function myFunction...
+        // "myFunction" is T_STRING but we should skip because it is not a
+        // function or method *call*.
+        $functionName = $stackPtr;
+        $findTokens   = array_merge(
+            PHP_CodeSniffer_Tokens::$emptyTokens,
+            array(T_BITWISE_AND)
+        );
+
+        $functionKeyword = $phpcsFile->findPrevious(
+            $findTokens,
+            ($stackPtr - 1),
+            null,
+            true
+        );
+
+        if ($tokens[$functionKeyword]['code'] === T_FUNCTION
+            || $tokens[$functionKeyword]['code'] === T_CLASS
+        ) {
+            return;
+        }
+
+        // If the next non-whitespace token after the function or method call
+        // is not an opening parenthesis then it cant really be a *call*.
+        $openBracket = $phpcsFile->findNext(
+            PHP_CodeSniffer_Tokens::$emptyTokens,
+            ($functionName + 1),
+            null,
+            true
+        );
+
+        if ($tokens[$openBracket]['code'] !== T_OPEN_PARENTHESIS) {
+            return;
+        }
+
+        $closeBracket = $tokens[$openBracket]['parenthesis_closer'];
+
+        $nextSeparator = $openBracket;
+        while (($nextSeparator = $phpcsFile->findNext(T_VARIABLE, ($nextSeparator + 1), $closeBracket)) !== false) {
+            // Make sure the variable belongs directly to this function call
+            // and is not inside a nested function call or array.
+            $brackets    = $tokens[$nextSeparator]['nested_parenthesis'];
+            $lastBracket = array_pop($brackets);
+            if ($lastBracket !== $closeBracket) {
+                continue;
+            }
+
+            // Checking this: $value = my_function(...[*]$arg...).
+            $tokenBefore = $phpcsFile->findPrevious(
+                PHP_CodeSniffer_Tokens::$emptyTokens,
+                ($nextSeparator - 1),
+                null,
+                true
+            );
+
+            if ($tokens[$tokenBefore]['code'] === T_BITWISE_AND) {
+                // Checking this: $value = my_function(...[*]&$arg...).
+                $tokenBefore = $phpcsFile->findPrevious(
+                    PHP_CodeSniffer_Tokens::$emptyTokens,
+                    ($tokenBefore - 1),
+                    null,
+                    true
+                );
+
+                // We have to exclude all uses of T_BITWISE_AND that are not
+                // references. We use a blacklist approach as we prefer false
+                // positives to not identifiying a pass-by-reference call at all.
+                // The blacklist may not yet be complete.
+                switch ($tokens[$tokenBefore]['code']) {
+                case T_VARIABLE:
+                case T_CLOSE_PARENTHESIS:
+                    // In these cases T_BITWISE_AND represents
+                    // the bitwise and operator.
+                    continue;
+                    break;
+
+                default:
+                    // T_BITWISE_AND represents a pass-by-reference.
+                    $error = 'Call-time pass-by-reference calls are prohibited';
+                    $phpcsFile->addError($error, $tokenBefore, 'NotAllowed');
+                    break;
+                }
+            }//end if
+        }//end while
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Functions/FunctionCallArgumentSpacingSniff.php

@@ -0,0 +1,136 @@
+<?php
+/**
+ * Generic_Sniffs_Functions_FunctionCallArgumentSpacingSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Functions_FunctionCallArgumentSpacingSniff.
+ *
+ * Checks that calls to methods and functions are spaced correctly.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Functions_FunctionCallArgumentSpacingSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_STRING);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in the
+     *                                        stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // Skip tokens that are the names of functions or classes
+        // within their definitions. For example:
+        // function myFunction...
+        // "myFunction" is T_STRING but we should skip because it is not a
+        // function or method *call*.
+        $functionName    = $stackPtr;
+        $ignoreTokens    = PHP_CodeSniffer_Tokens::$emptyTokens;
+        $ignoreTokens[]  = T_BITWISE_AND;
+        $functionKeyword = $phpcsFile->findPrevious($ignoreTokens, ($stackPtr - 1), null, true);
+        if ($tokens[$functionKeyword]['code'] === T_FUNCTION || $tokens[$functionKeyword]['code'] === T_CLASS) {
+            return;
+        }
+
+        // If the next non-whitespace token after the function or method call
+        // is not an opening parenthesis then it cant really be a *call*.
+        $openBracket = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($functionName + 1), null, true);
+        if ($tokens[$openBracket]['code'] !== T_OPEN_PARENTHESIS) {
+            return;
+        }
+
+        $closeBracket = $tokens[$openBracket]['parenthesis_closer'];
+
+        $nextSeperator = $openBracket;
+        while (($nextSeperator = $phpcsFile->findNext(array(T_COMMA, T_VARIABLE), ($nextSeperator + 1), $closeBracket)) !== false) {
+            // Make sure the comma or variable belongs directly to this function call,
+            // and is not inside a nested function call or array.
+            $brackets    = $tokens[$nextSeperator]['nested_parenthesis'];
+            $lastBracket = array_pop($brackets);
+            if ($lastBracket !== $closeBracket) {
+                continue;
+            }
+
+            if ($tokens[$nextSeperator]['code'] === T_COMMA) {
+                if ($tokens[($nextSeperator - 1)]['code'] === T_WHITESPACE) {
+                    $error = 'Space found before comma in function call';
+                    $phpcsFile->addError($error, $stackPtr, 'SpaceBeforeComma');
+                }
+
+                if ($tokens[($nextSeperator + 1)]['code'] !== T_WHITESPACE) {
+                    $error = 'No space found after comma in function call';
+                    $phpcsFile->addError($error, $stackPtr, 'NoSpaceAfterComma');
+                } else {
+                    // If there is a newline in the space, then the must be formatting
+                    // each argument on a newline, which is valid, so ignore it.
+                    if (strpos($tokens[($nextSeperator + 1)]['content'], $phpcsFile->eolChar) === false) {
+                        $space = strlen($tokens[($nextSeperator + 1)]['content']);
+                        if ($space > 1) {
+                            $error = 'Expected 1 space after comma in function call; %s found';
+                            $data  = array($space);
+                            $phpcsFile->addError($error, $stackPtr, 'TooMuchSpaceAfterComma', $data);
+                        }
+                    }
+                }
+            } else {
+                // Token is a variable.
+                $nextToken = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($nextSeperator + 1), $closeBracket, true);
+                if ($nextToken !== false) {
+                    if ($tokens[$nextToken]['code'] === T_EQUAL) {
+                        if (($tokens[($nextToken - 1)]['code']) !== T_WHITESPACE) {
+                            $error = 'Expected 1 space before = sign of default value';
+                            $phpcsFile->addError($error, $stackPtr, 'NoSpaceBeforeEquals');
+                        }
+
+                        if ($tokens[($nextToken + 1)]['code'] !== T_WHITESPACE) {
+                            $error = 'Expected 1 space after = sign of default value';
+                            $phpcsFile->addError($error, $stackPtr, 'NoSpaceAfterEquals');
+                        }
+                    }
+                }
+            }//end if
+        }//end while
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Functions/OpeningFunctionBraceBsdAllmanSniff.php

@@ -0,0 +1,121 @@
+<?php
+/**
+ * Generic_Sniffs_Methods_OpeningMethodBraceBsdAllmanSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Functions_OpeningFunctionBraceBsdAllmanSniff.
+ *
+ * Checks that the opening brace of a function is on the line after the
+ * function declaration.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Functions_OpeningFunctionBraceBsdAllmanSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Registers the tokens that this sniff wants to listen for.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        return array(T_FUNCTION);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in the
+     *                                        stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        if (isset($tokens[$stackPtr]['scope_opener']) === false) {
+            return;
+        }
+
+        $openingBrace = $tokens[$stackPtr]['scope_opener'];
+
+        // The end of the function occurs at the end of the argument list. Its
+        // like this because some people like to break long function declarations
+        // over multiple lines.
+        $functionLine = $tokens[$tokens[$stackPtr]['parenthesis_closer']]['line'];
+        $braceLine    = $tokens[$openingBrace]['line'];
+
+        $lineDifference = ($braceLine - $functionLine);
+
+        if ($lineDifference === 0) {
+            $error = 'Opening brace should be on a new line';
+            $phpcsFile->addError($error, $openingBrace, 'BraceOnSameLine');
+            return;
+        }
+
+        if ($lineDifference > 1) {
+            $error = 'Opening brace should be on the line after the declaration; found %s blank line(s)';
+            $data  = array(($lineDifference - 1));
+            $phpcsFile->addError($error, $openingBrace, 'BraceSpacing', $data);
+            return;
+        }
+
+        // We need to actually find the first piece of content on this line,
+        // as if this is a method with tokens before it (public, static etc)
+        // or an if with an else before it, then we need to start the scope
+        // checking from there, rather than the current token.
+        $lineStart = $stackPtr;
+        while (($lineStart = $phpcsFile->findPrevious(array(T_WHITESPACE), ($lineStart - 1), null, false)) !== false) {
+            if (strpos($tokens[$lineStart]['content'], $phpcsFile->eolChar) !== false) {
+                break;
+            }
+        }
+
+        // We found a new line, now go forward and find the first non-whitespace
+        // token.
+        $lineStart = $phpcsFile->findNext(array(T_WHITESPACE), $lineStart, null, true);
+
+        // The opening brace is on the correct line, now it needs to be
+        // checked to be correctly indented.
+        $startColumn = $tokens[$lineStart]['column'];
+        $braceIndent = $tokens[$openingBrace]['column'];
+
+        if ($braceIndent !== $startColumn) {
+            $error = 'Opening brace indented incorrectly; expected %s spaces, found %s';
+            $data  = array(
+                      ($startColumn - 1),
+                      ($braceIndent - 1),
+                     );
+            $phpcsFile->addError($error, $openingBrace, 'BraceIndent', $data);
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Functions/OpeningFunctionBraceKernighanRitchieSniff.php

@@ -0,0 +1,109 @@
+<?php
+/**
+ * Generic_Sniffs_Functions_OpeningFunctionBraceKernighanRitchieSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Functions_OpeningFunctionBraceKernighanRitchieSniff.
+ *
+ * Checks that the opening brace of a function is on the same line
+ * as the function declaration.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Functions_OpeningFunctionBraceKernighanRitchieSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Registers the tokens that this sniff wants to listen for.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        return array(T_FUNCTION);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in the
+     *                                        stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        if (isset($tokens[$stackPtr]['scope_opener']) === false) {
+            return;
+        }
+
+        $openingBrace = $tokens[$stackPtr]['scope_opener'];
+
+        // The end of the function occurs at the end of the argument list. Its
+        // like this because some people like to break long function declarations
+        // over multiple lines.
+        $functionLine = $tokens[$tokens[$stackPtr]['parenthesis_closer']]['line'];
+        $braceLine    = $tokens[$openingBrace]['line'];
+
+        $lineDifference = ($braceLine - $functionLine);
+
+        if ($lineDifference > 0) {
+            $error = 'Opening brace should be on the same line as the declaration';
+            $phpcsFile->addError($error, $openingBrace, 'BraceOnNewLine');
+            return;
+        }
+
+        // Checks that the closing parenthesis and the opening brace are
+        // separated by a whitespace character.
+        $closerColumn = $tokens[$tokens[$stackPtr]['parenthesis_closer']]['column'];
+        $braceColumn  = $tokens[$openingBrace]['column'];
+
+        $columnDifference = ($braceColumn - $closerColumn);
+
+        if ($columnDifference !== 2) {
+            $error = 'Expected 1 space between the closing parenthesis and the opening brace; found %s';
+            $data  = array(($columnDifference - 1));
+            $phpcsFile->addError($error, $openingBrace, 'SpaceBeforeBrace', $data);
+            return;
+        }
+
+        // Check that a tab was not used instead of a space.
+        $spaceTokenPtr = ($tokens[$stackPtr]['parenthesis_closer'] + 1);
+        $spaceContent  = $tokens[$spaceTokenPtr]['content'];
+        if ($spaceContent !== ' ') {
+            $error = 'Expected a single space character between closing parenthesis and opening brace; found %s';
+            $data  = array($spaceContent);
+            $phpcsFile->addError($error, $openingBrace, 'SpaceBeforeBrace', $data);
+            return;
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Metrics/CyclomaticComplexitySniff.php

@@ -0,0 +1,131 @@
+<?php
+/**
+ * Checks the cyclomatic complexity (McCabe) for functions.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Checks the cyclomatic complexity (McCabe) for functions.
+ *
+ * The cyclomatic complexity (also called McCabe code metrics)
+ * indicates the complexity within a function by counting
+ * the different paths the function includes.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Johann-Peter Hartmann <hartmann@mayflower.de>
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2007 Mayflower GmbH
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Metrics_CyclomaticComplexitySniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A complexity higher than this value will throw a warning.
+     *
+     * @var int
+     */
+    public $complexity = 10;
+
+    /**
+     * A complexity higer than this value will throw an error.
+     *
+     * @var int
+     */
+    public $absoluteComplexity = 20;
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_FUNCTION);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $this->currentFile = $phpcsFile;
+
+        $tokens = $phpcsFile->getTokens();
+
+        // Ignore abstract methods.
+        if (isset($tokens[$stackPtr]['scope_opener']) === false) {
+            return;
+        }
+
+        // Detect start and end of this function definition.
+        $start = $tokens[$stackPtr]['scope_opener'];
+        $end   = $tokens[$stackPtr]['scope_closer'];
+
+        // Predicate nodes for PHP.
+        $find = array(
+                 'T_CASE',
+                 'T_DEFAULT',
+                 'T_CATCH',
+                 'T_IF',
+                 'T_FOR',
+                 'T_FOREACH',
+                 'T_WHILE',
+                 'T_DO',
+                 'T_ELSEIF',
+                );
+
+        $complexity = 1;
+
+        // Iterate from start to end and count predicate nodes.
+        for ($i = ($start + 1); $i < $end; $i++) {
+            if (in_array($tokens[$i]['type'], $find) === true) {
+                $complexity++;
+            }
+        }
+
+        if ($complexity > $this->absoluteComplexity) {
+            $error = 'Function\'s cyclomatic complexity (%s) exceeds allowed maximum of %s';
+            $data  = array(
+                      $complexity,
+                      $this->absoluteComplexity,
+                     );
+            $phpcsFile->addError($error, $stackPtr, 'MaxExceeded', $data);
+        } else if ($complexity > $this->complexity) {
+            $warning = 'Function\'s cyclomatic complexity (%s) exceeds %s; consider refactoring the function';
+            $data    = array(
+                        $complexity,
+                        $this->complexity,
+                       );
+            $phpcsFile->addWarning($warning, $stackPtr, 'TooHigh', $data);
+        }
+
+        return;
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Metrics/NestingLevelSniff.php

@@ -0,0 +1,114 @@
+<?php
+/**
+ * Checks the nesting level for methods.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Checks the nesting level for methods.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Johann-Peter Hartmann <hartmann@mayflower.de>
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2007 Mayflower GmbH
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Metrics_NestingLevelSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A nesting level than this value will throw a warning.
+     *
+     * @var int
+     */
+    public $nestingLevel = 5;
+
+    /**
+     * A nesting level than this value will throw an error.
+     *
+     * @var int
+     */
+    public $absoluteNestingLevel = 10;
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_FUNCTION);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // Ignore abstract methods.
+        if (isset($tokens[$stackPtr]['scope_opener']) === false) {
+            return;
+        }
+
+        // Detect start and end of this function definition.
+        $start = $tokens[$stackPtr]['scope_opener'];
+        $end   = $tokens[$stackPtr]['scope_closer'];
+
+        $nestingLevel = 0;
+
+        // Find the maximum nesting level of any token in the function.
+        for ($i = ($start + 1); $i < $end; $i++) {
+            $level = $tokens[$i]['level'];
+            if ($nestingLevel < $level) {
+                $nestingLevel = $level;
+            }
+        }
+
+        // We subtract the nesting level of the function itself.
+        $nestingLevel = ($nestingLevel - $tokens[$stackPtr]['level'] - 1);
+
+        if ($nestingLevel > $this->absoluteNestingLevel) {
+            $error = 'Function\'s nesting level (%s) exceeds allowed maximum of %s';
+            $data  = array(
+                      $nestingLevel,
+                      $this->absoluteNestingLevel,
+                     );
+            $phpcsFile->addError($error, $stackPtr, 'MaxExceeded', $data);
+        } else if ($nestingLevel > $this->nestingLevel) {
+            $warning = 'Function\'s nesting level (%s) exceeds %s; consider refactoring the function';
+            $data    = array(
+                        $nestingLevel,
+                        $this->nestingLevel,
+                       );
+            $phpcsFile->addWarning($warning, $stackPtr, 'TooHigh', $data);
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/NamingConventions/ConstructorNameSniff.php

@@ -0,0 +1,101 @@
+<?php
+/**
+ * Generic_Sniffs_NamingConventions_ConstructorNameSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Leif Wickland <lwickland@rightnow.com>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+if (class_exists('PHP_CodeSniffer_Standards_AbstractScopeSniff', true) === false) {
+    $error = 'Class PHP_CodeSniffer_Standards_AbstractScopeSniff not found';
+    throw new PHP_CodeSniffer_Exception($error);
+}
+
+/**
+ * Generic_Sniffs_NamingConventions_ConstructorNameSniff.
+ *
+ * Favor PHP 5 constructor syntax, which uses "function __construct()".
+ * Avoid PHP 4 constructor syntax, which uses "function ClassName()".
+ *
+ * @category PHP
+ * @package  PHP_CodeSniffer
+ * @author   Leif Wickland <lwickland@rightnow.com>
+ * @license  http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version  Release: 1.3.3
+ * @link     http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_NamingConventions_ConstructorNameSniff extends PHP_CodeSniffer_Standards_AbstractScopeSniff
+{
+
+
+    /**
+     * Constructs the test with the tokens it wishes to listen for.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        parent::__construct(array(T_CLASS, T_INTERFACE), array(T_FUNCTION), true);
+
+    }//end __construct()
+
+
+    /**
+     * Processes this test when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The current file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     * @param int                  $currScope A pointer to the start of the scope.
+     *
+     * @return void
+     */
+    protected function processTokenWithinScope(
+        PHP_CodeSniffer_File $phpcsFile,
+        $stackPtr,
+        $currScope
+    ) {
+        $className  = $phpcsFile->getDeclarationName($currScope);
+        $methodName = $phpcsFile->getDeclarationName($stackPtr);
+
+        if (strcasecmp($methodName, $className) === 0) {
+            $error = 'PHP4 style constructors are not allowed; use "__construct()" instead';
+            $phpcsFile->addError($error, $stackPtr, 'OldStyle');
+        } else if (strcasecmp($methodName, '__construct') !== 0) {
+            // Not a constructor.
+            return;
+        }
+
+        $tokens = $phpcsFile->getTokens();
+
+        $parentClassName = $phpcsFile->findExtendedClassName($currScope);
+        if ($parentClassName === false) {
+            return;
+        }
+
+        $endFunctionIndex = $tokens[$stackPtr]['scope_closer'];
+        $startIndex       = $stackPtr;
+        while ($doubleColonIndex = $phpcsFile->findNext(array(T_DOUBLE_COLON), $startIndex, $endFunctionIndex)) {
+            if ($tokens[($doubleColonIndex + 1)]['code'] === T_STRING
+                && $tokens[($doubleColonIndex + 1)]['content'] === $parentClassName
+            ) {
+                $error = 'PHP4 style calls to parent constructors are not allowed; use "parent::__construct()" instead';
+                $phpcsFile->addError($error, ($doubleColonIndex + 1), 'OldStyleCall');
+            }
+
+            $startIndex = ($doubleColonIndex + 1);
+        }
+
+    }//end processTokenWithinScope()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/NamingConventions/UpperCaseConstantNameSniff.php

@@ -0,0 +1,198 @@
+<?php
+/**
+ * Generic_Sniffs_NamingConventions_UpperCaseConstantNameSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_NamingConventions_UpperCaseConstantNameSniff.
+ *
+ * Ensures that constant names are all uppercase.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_NamingConventions_UpperCaseConstantNameSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_STRING);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in the
+     *                                        stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens    = $phpcsFile->getTokens();
+        $constName = $tokens[$stackPtr]['content'];
+
+        // If this token is in a heredoc, ignore it.
+        if ($phpcsFile->hasCondition($stackPtr, T_START_HEREDOC) === true) {
+            return;
+        }
+
+        // Special case for PHPUnit.
+        if ($constName === 'PHPUnit_MAIN_METHOD') {
+            return;
+        }
+
+        // If the next non-whitespace token after this token
+        // is not an opening parenthesis then it is not a function call.
+        $openBracket = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true);
+        if ($tokens[$openBracket]['code'] !== T_OPEN_PARENTHESIS) {
+            $functionKeyword = $phpcsFile->findPrevious(array(T_WHITESPACE, T_COMMA, T_COMMENT, T_STRING, T_NS_SEPARATOR), ($stackPtr - 1), null, true);
+
+            $declarations = array(
+                             T_FUNCTION,
+                             T_CLASS,
+                             T_INTERFACE,
+                             T_IMPLEMENTS,
+                             T_EXTENDS,
+                             T_INSTANCEOF,
+                             T_NEW,
+                             T_NAMESPACE,
+                             T_USE,
+                             T_AS,
+                            );
+
+            if (in_array($tokens[$functionKeyword]['code'], $declarations) === true) {
+                // This is just a declaration; no constants here.
+                return;
+            }
+
+            if ($tokens[$functionKeyword]['code'] === T_CONST) {
+                // This is a class constant.
+                if (strtoupper($constName) !== $constName) {
+                    $error = 'Class constants must be uppercase; expected %s but found %s';
+                    $data  = array(
+                              strtoupper($constName),
+                              $constName,
+                             );
+                    $phpcsFile->addError($error, $stackPtr, 'ClassConstantNotUpperCase', $data);
+                }
+
+                return;
+            }
+
+            // Is this a class name?
+            $nextPtr = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true);
+            if ($tokens[$nextPtr]['code'] === T_DOUBLE_COLON) {
+                return;
+            }
+
+            // Is this a namespace name?
+            if ($tokens[$nextPtr]['code'] === T_NS_SEPARATOR) {
+                return;
+            }
+
+            // Is this a type hint?
+            if ($tokens[$nextPtr]['code'] === T_VARIABLE
+                || $phpcsFile->isReference($nextPtr) === true
+            ) {
+                return;
+            }
+
+            // Is this a member var name?
+            $prevPtr = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);
+            if ($tokens[$prevPtr]['code'] === T_OBJECT_OPERATOR) {
+                return;
+            }
+
+            // Is this a namespace name?
+            if ($tokens[$prevPtr]['code'] === T_NS_SEPARATOR) {
+                return;
+            }
+
+            // Is this an instance of declare()
+            $prevPtr = $phpcsFile->findPrevious(array(T_WHITESPACE, T_OPEN_PARENTHESIS), ($stackPtr - 1), null, true);
+            if ($tokens[$prevPtr]['code'] === T_DECLARE) {
+                return;
+            }
+
+            // This is a real constant.
+            if (strtoupper($constName) !== $constName) {
+                $error = 'Constants must be uppercase; expected %s but found %s';
+                $data  = array(
+                          strtoupper($constName),
+                          $constName,
+                         );
+                $phpcsFile->addError($error, $stackPtr, 'ConstantNotUpperCase', $data);
+            }
+
+        } else if (strtolower($constName) === 'define' || strtolower($constName) === 'constant') {
+
+            /*
+                This may be a "define" or "constant" function call.
+            */
+
+            // Make sure this is not a method call.
+            $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);
+            if ($tokens[$prev]['code'] === T_OBJECT_OPERATOR
+                || $tokens[$prev]['code'] === T_DOUBLE_COLON
+            ) {
+                return;
+            }
+
+            // The next non-whitespace token must be the constant name.
+            $constPtr = $phpcsFile->findNext(T_WHITESPACE, ($openBracket + 1), null, true);
+            if ($tokens[$constPtr]['code'] !== T_CONSTANT_ENCAPSED_STRING) {
+                return;
+            }
+
+            $constName = $tokens[$constPtr]['content'];
+
+            // Check for constants like self::CONSTANT.
+            $prefix   = '';
+            $splitPos = strpos($constName, '::');
+            if ($splitPos !== false) {
+                $prefix    = substr($constName, 0, ($splitPos + 2));
+                $constName = substr($constName, ($splitPos + 2));
+            }
+
+            if (strtoupper($constName) !== $constName) {
+                $error = 'Constants must be uppercase; expected %s but found %s';
+                $data  = array(
+                          $prefix.strtoupper($constName),
+                          $prefix.$constName,
+                         );
+                $phpcsFile->addError($error, $stackPtr, 'ConstantNotUpperCase', $data);
+            }
+        }//end if
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/PHP/DeprecatedFunctionsSniff.php

@@ -0,0 +1,94 @@
+<?php
+/**
+ * Generic_Sniffs_PHP_DeprecatedFunctionsSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_PHP_DeprecatedFunctionsSniff.
+ *
+ * Discourages the use of deprecated functions that are kept in PHP for
+ * compatibility with older versions.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Sebastian Bergmann <sb@sebastian-bergmann.de>
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_PHP_DeprecatedFunctionsSniff extends Generic_Sniffs_PHP_ForbiddenFunctionsSniff
+{
+
+    /**
+     * A list of forbidden functions with their alternatives.
+     *
+     * The value is NULL if no alternative exists. IE, the
+     * function should just not be used.
+     *
+     * @var array(string => string|null)
+     */
+    protected $forbiddenFunctions = array();
+
+
+    /**
+     * Constructor.
+     *
+     * Uses the Reflection API to get a list of deprecated functions.
+     */
+    public function __construct()
+    {
+        $functions = get_defined_functions();
+
+        foreach ($functions['internal'] as $functionName) {
+            $function = new ReflectionFunction($functionName);
+
+            if ($function->isDeprecated() === true) {
+                $this->forbiddenFunctions[$functionName] = null;
+            }
+        }
+
+    }//end __construct()
+
+
+    /**
+     * Generates the error or wanrning for this sniff.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the forbidden function
+     *                                        in the token array.
+     * @param string               $function  The name of the forbidden function.
+     * @param string               $pattern   The pattern used for the match.
+     *
+     * @return void
+     */
+    protected function addError($phpcsFile, $stackPtr, $function, $pattern=null)
+    {
+        $data  = array($function);
+        $error = 'Function %s() has been deprecated';
+        $type  = 'Deprecated';
+
+        if ($this->error === true) {
+            $phpcsFile->addError($error, $stackPtr, $type, $data);
+        } else {
+            $phpcsFile->addWarning($error, $stackPtr, $type, $data);
+        }
+
+    }//end addError()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/PHP/DisallowShortOpenTagSniff.php

@@ -0,0 +1,85 @@
+<?php
+/**
+ * Generic_Sniffs_PHP_DisallowShortOpenTagSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_PHP_DisallowShortOpenTagSniff.
+ *
+ * Makes sure that shorthand PHP open tags are not used.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_PHP_DisallowShortOpenTagSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(
+                T_OPEN_TAG,
+                T_OPEN_TAG_WITH_ECHO,
+               );
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens  = $phpcsFile->getTokens();
+        $openTag = $tokens[$stackPtr];
+
+        if ($openTag['content'] === '<?') {
+            $error = 'Short PHP opening tag used; expected "<?php" but found "%s"';
+            $data  = array($openTag['content']);
+            $phpcsFile->addError($error, $stackPtr, 'Found', $data);
+        }
+
+        if ($openTag['code'] === T_OPEN_TAG_WITH_ECHO) {
+            $nextVar = $tokens[$phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr + 1), null, true)];
+            $error   = 'Short PHP opening tag used with echo; expected "<?php echo %s ..." but found "%s %s ..."';
+            $data = array(
+                     $nextVar['content'],
+                     $openTag['content'],
+                     $nextVar['content'],
+                    );
+            $phpcsFile->addError($error, $stackPtr, 'EchoFound', $data);
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/PHP/ForbiddenFunctionsSniff.php

@@ -0,0 +1,191 @@
+<?php
+/**
+ * Generic_Sniffs_PHP_ForbiddenFunctionsSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_PHP_ForbiddenFunctionsSniff.
+ *
+ * Discourages the use of alias functions that are kept in PHP for compatibility
+ * with older versions. Can be used to forbid the use of any function.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_PHP_ForbiddenFunctionsSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A list of forbidden functions with their alternatives.
+     *
+     * The value is NULL if no alternative exists. IE, the
+     * function should just not be used.
+     *
+     * @var array(string => string|null)
+     */
+    protected $forbiddenFunctions = array(
+                                     'sizeof' => 'count',
+                                     'delete' => 'unset',
+                                    );
+
+    /**
+     * A cache of forbidden function names, for faster lookups.
+     *
+     * @var array(string)
+     */
+    protected $forbiddenFunctionNames = array();
+
+    /**
+     * If true, forbidden functions will be considered regular expressions.
+     *
+     * @var bool
+     */
+    protected $patternMatch = false;
+
+    /**
+     * If true, an error will be thrown; otherwise a warning.
+     *
+     * @var bool
+     */
+    public $error = true;
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        // Everyone has had a chance to figure out what forbidden functions
+        // they want to check for, so now we can cache out the list.
+        $this->forbiddenFunctionNames = array_keys($this->forbiddenFunctions);
+
+        if ($this->patternMatch === true) {
+            foreach ($this->forbiddenFunctionNames as $i => $name) {
+                $this->forbiddenFunctionNames[$i] = '/'.$name.'/i';
+            }
+        }
+
+        return array(T_STRING);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in
+     *                                        the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        $ignore = array(
+                   T_DOUBLE_COLON,
+                   T_OBJECT_OPERATOR,
+                   T_FUNCTION,
+                   T_CONST,
+                  );
+
+        $prevToken = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);
+        if (in_array($tokens[$prevToken]['code'], $ignore) === true) {
+            // Not a call to a PHP function.
+            return;
+        }
+
+        $function = strtolower($tokens[$stackPtr]['content']);
+        $pattern  = null;
+
+        if ($this->patternMatch === true) {
+            $count   = 0;
+            $pattern = preg_replace(
+                $this->forbiddenFunctionNames,
+                $this->forbiddenFunctionNames,
+                $function,
+                1,
+                $count
+            );
+
+            if ($count === 0) {
+                return;
+            }
+
+            // Remove the pattern delimiters and modifier.
+            $pattern = substr($pattern, 1, -2);
+        } else {
+            if (in_array($function, $this->forbiddenFunctionNames) === false) {
+                return;
+            }
+        }
+
+        $this->addError($phpcsFile, $stackPtr, $function, $pattern);
+
+    }//end process()
+
+
+    /**
+     * Generates the error or wanrning for this sniff.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the forbidden function
+     *                                        in the token array.
+     * @param string               $function  The name of the forbidden function.
+     * @param string               $pattern   The pattern used for the match.
+     *
+     * @return void
+     */
+    protected function addError($phpcsFile, $stackPtr, $function, $pattern=null)
+    {
+        $data  = array($function);
+        $error = 'The use of function %s() is ';
+        if ($this->error === true) {
+            $type   = 'Found';
+            $error .= 'forbidden';
+        } else {
+            $type   = 'Discouraged';
+            $error .= 'discouraged';
+        }
+
+        if ($pattern === null) {
+            $pattern = $function;
+        }
+
+        if ($this->forbiddenFunctions[$pattern] !== null) {
+            $type  .= 'WithAlternative';
+            $data[] = $this->forbiddenFunctions[$pattern];
+            $error .= '; use %s() instead';
+        }
+
+        if ($this->error === true) {
+            $phpcsFile->addError($error, $stackPtr, $type, $data);
+        } else {
+            $phpcsFile->addWarning($error, $stackPtr, $type, $data);
+        }
+
+    }//end addError()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/PHP/LowerCaseConstantSniff.php

@@ -0,0 +1,93 @@
+<?php
+/**
+ * Generic_Sniffs_PHP_LowerCaseConstantSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_PHP_LowerCaseConstantSniff.
+ *
+ * Checks that all uses of true, false and null are lowerrcase.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_PHP_LowerCaseConstantSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A list of tokenizers this sniff supports.
+     *
+     * @var array
+     */
+    public $supportedTokenizers = array(
+                                   'PHP',
+                                   'JS',
+                                  );
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(
+                T_TRUE,
+                T_FALSE,
+                T_NULL,
+               );
+
+    }//end register()
+
+
+    /**
+     * Processes this sniff, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in the
+     *                                        stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // Is this a member var name?
+        $prevPtr = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);
+        if ($tokens[$prevPtr]['code'] === T_OBJECT_OPERATOR) {
+            return;
+        }
+
+        $keyword = $tokens[$stackPtr]['content'];
+        if (strtolower($keyword) !== $keyword) {
+            $error = 'TRUE, FALSE and NULL must be lowercase; expected "%s" but found "%s"';
+            $data  = array(
+                      strtolower($keyword),
+                      $keyword,
+                     );
+            $phpcsFile->addError($error, $stackPtr, 'Found', $data);
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/PHP/NoSilencedErrorsSniff.php

@@ -0,0 +1,81 @@
+<?php
+/**
+ * Generic_Sniffs_PHP_NoSilencedErrorsSniff
+ *
+ * PHP version 5
+ *
+ * @category PHP
+ * @package  PHP_CodeSniffer
+ * @author   Andy Brockhurst <abrock@yahoo-inc.com>
+ * @license  http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link     http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_PHP_NoSilencedErrorsSniff.
+ *
+ * Throws an error or warning when any code prefixed with an asperand is encountered.
+ *
+ * <code>
+ *  if (@in_array($array, $needle))
+ *  {
+ *      doSomething();
+ *  }
+ * </code>
+ *
+ * @category PHP
+ * @package  PHP_CodeSniffer
+ * @author   Andy Brockhurst <abrock@yahoo-inc.com>
+ * @license  http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version  Release: 1.3.3
+ * @link     http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_PHP_NoSilencedErrorsSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * If true, an error will be thrown; otherwise a warning.
+     *
+     * @var bool
+     */
+    public $error = false;
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_ASPERAND);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $error = 'Silencing errors is forbidden';
+        if ($this->error === true) {
+            $error = 'Silencing errors is forbidden';
+            $phpcsFile->addError($error, $stackPtr, 'Forbidden');
+        } else {
+            $error = 'Silencing errors is discouraged';
+            $phpcsFile->addWarning($error, $stackPtr, 'Discouraged');
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/PHP/UpperCaseConstantSniff.php

@@ -0,0 +1,84 @@
+<?php
+/**
+ * Generic_Sniffs_PHP_UpperCaseConstantSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_PHP_UpperCaseConstantSniff.
+ *
+ * Checks that all uses of TRUE, FALSE and NULL are uppercase.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_PHP_UpperCaseConstantSniff implements PHP_CodeSniffer_Sniff
+{
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(
+                T_TRUE,
+                T_FALSE,
+                T_NULL,
+               );
+
+    }//end register()
+
+
+    /**
+     * Processes this sniff, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token in the
+     *                                        stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // Is this a member var name?
+        $prevPtr = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);
+        if ($tokens[$prevPtr]['code'] === T_OBJECT_OPERATOR) {
+            return;
+        }
+
+        $keyword = $tokens[$stackPtr]['content'];
+        if (strtoupper($keyword) !== $keyword) {
+            $error = 'TRUE, FALSE and NULL must be uppercase; expected "%s" but found "%s"';
+            $data  = array(
+                      strtoupper($keyword),
+                      $keyword,
+                     );
+            $phpcsFile->addError($error, $stackPtr, 'Found', $data);
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/Strings/UnnecessaryStringConcatSniff.php

@@ -0,0 +1,125 @@
+<?php
+/**
+ * Generic_Sniffs_Strings_UnnecessaryStringConcatSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Strings_UnnecessaryStringConcatSniff.
+ *
+ * Checks that two strings are not concatenated together; suggests
+ * using one string instead.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_Strings_UnnecessaryStringConcatSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A list of tokenizers this sniff supports.
+     *
+     * @var array
+     */
+    public $supportedTokenizers = array(
+                                   'PHP',
+                                   'JS',
+                                  );
+
+    /**
+     * If true, an error will be thrown; otherwise a warning.
+     *
+     * @var bool
+     */
+    public $error = true;
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(
+                T_STRING_CONCAT,
+                T_PLUS,
+               );
+
+    }//end register()
+
+
+    /**
+     * Processes this sniff, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        // Work out which type of file this is for.
+        $tokens = $phpcsFile->getTokens();
+        if ($tokens[$stackPtr]['code'] === T_STRING_CONCAT) {
+            if ($phpcsFile->tokenizerType === 'JS') {
+                return;
+            }
+        } else {
+            if ($phpcsFile->tokenizerType === 'PHP') {
+                return;
+            }
+        }
+
+        $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);
+        $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true);
+        if ($prev === false || $next === false) {
+            return;
+        }
+
+        $stringTokens = PHP_CodeSniffer_Tokens::$stringTokens;
+        if (in_array($tokens[$prev]['code'], $stringTokens) === true
+            && in_array($tokens[$next]['code'], $stringTokens) === true
+        ) {
+            if ($tokens[$prev]['content'][0] === $tokens[$next]['content'][0]) {
+                // Before we throw an error for PHP, allow strings to be
+                // combined if they would have < and ? next to each other because
+                // this trick is sometimes required in PHP strings.
+                if ($phpcsFile->tokenizerType === 'PHP') {
+                    $prevChar = substr($tokens[$prev]['content'], -2, 1);
+                    $nextChar = $tokens[$next]['content'][1];
+                    $combined = $prevChar.$nextChar;
+                    if ($combined === '?'.'>' || $combined === '<'.'?') {
+                        return;
+                    }
+                }
+
+                $error = 'String concat is not required here; use a single string instead';
+                if ($this->error === true) {
+                    $phpcsFile->addError($error, $stackPtr, 'Found');
+                } else {
+                    $phpcsFile->addWarning($error, $stackPtr, 'Found');
+                }
+            }
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/VersionControl/SubversionPropertiesSniff.php

@@ -0,0 +1,206 @@
+<?php
+/**
+ * Generic_Sniffs_VersionControl_SubversionPropertiesSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Jack Bates <ms419@freezone.co.uk>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_VersionControl_SubversionPropertiesSniff.
+ *
+ * Tests that the correct Subversion properties are set.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Jack Bates <ms419@freezone.co.uk>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_VersionControl_SubversionPropertiesSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * The Subversion properties that should be set.
+     *
+     * Key of array is the SVN property and the value is the
+     * exact value the property should have or NULL if the
+     * property should just be set but the value is not fixed.
+     *
+     * @var array
+     */
+    protected $properties = array(
+                             'svn:keywords'  => 'Author Id Revision',
+                             'svn:eol-style' => 'native',
+                            );
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_OPEN_TAG);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // Make sure this is the first PHP open tag so we don't process the
+        // same file twice.
+        $prevOpenTag = $phpcsFile->findPrevious(T_OPEN_TAG, ($stackPtr - 1));
+        if ($prevOpenTag !== false) {
+            return;
+        }
+
+        $path       = $phpcsFile->getFileName();
+        $properties = $this->getProperties($path);
+        if ($properties === null) {
+            // Not under version control.
+            return;
+        }
+
+        $properties += $this->properties;
+        foreach ($properties as $key => $value) {
+            if (isset($properties[$key]) === true
+                && isset($this->properties[$key]) === false
+            ) {
+                $error = 'Unexpected Subversion property "%s" = "%s"';
+                $data  = array(
+                          $key,
+                          $properties[$key],
+                         );
+                $phpcsFile->addError($error, $stackPtr, 'Unexpected', $data);
+                continue;
+            }
+
+            if (isset($properties[$key]) === false
+                && isset($this->properties[$key]) === true
+            ) {
+                $error = 'Missing Subversion property "%s" = "%s"';
+                $data  = array(
+                          $key,
+                          $this->properties[$key],
+                         );
+                $phpcsFile->addError($error, $stackPtr, 'Missing', $data);
+                continue;
+            }
+
+            if ($properties[$key] !== null
+                && $properties[$key] !== $this->properties[$key]
+            ) {
+                $error = 'Subversion property "%s" = "%s" does not match "%s"';
+                $data  = array(
+                          $key,
+                          $properties[$key],
+                          $this->properties[$key],
+                         );
+                $phpcsFile->addError($error, $stackPtr, 'NoMatch', $data);
+            }
+        }//end foreach
+
+    }//end process()
+
+
+    /**
+     * Returns the Subversion properties which are actually set on a path.
+     *
+     * Returns NULL if the file is not under version control.
+     *
+     * @param string $path The path to return Subversion properties on.
+     *
+     * @return array
+     * @throws PHP_CodeSniffer_Exception If Subversion properties file could
+     *                                   not be opened.
+     */
+    protected function getProperties($path)
+    {
+        $properties = array();
+
+        $paths   = array();
+        $paths[] = dirname($path).'/.svn/props/'.basename($path).'.svn-work';
+        $paths[] = dirname($path).'/.svn/prop-base/'.basename($path).'.svn-base';
+
+        $foundPath = false;
+        foreach ($paths as $path) {
+            if (file_exists($path) === true) {
+                $foundPath = true;
+
+                $handle = fopen($path, 'r');
+                if ($handle === false) {
+                    $error = 'Error opening file; could not get Subversion properties';
+                    throw new PHP_CodeSniffer_Exception($error);
+                }
+
+                while (feof($handle) === false) {
+                    // Read a key length line. Might be END, though.
+                    $buffer = trim(fgets($handle));
+
+                    // Check for the end of the hash.
+                    if ($buffer === 'END') {
+                        break;
+                    }
+
+                    // Now read that much into a buffer.
+                    $key = fread($handle, substr($buffer, 2));
+
+                    // Suck up extra newline after key data.
+                    fgetc($handle);
+
+                    // Read a value length line.
+                    $buffer = trim(fgets($handle));
+
+                    // Now read that much into a buffer.
+                    $length = substr($buffer, 2);
+                    if ($length === '0') {
+                        // Length of value is ZERO characters, so
+                        // value is actually empty.
+                        $value = '';
+                    } else {
+                        $value = fread($handle, $length);
+                    }
+
+                    // Suck up extra newline after value data.
+                    fgetc($handle);
+
+                    $properties[$key] = $value;
+                }//end while
+
+                fclose($handle);
+            }//end if
+        }//end foreach
+
+        if ($foundPath === false) {
+            return null;
+        }
+
+        return $properties;
+
+    }//end getProperties()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/WhiteSpace/DisallowTabIndentSniff.php

@@ -0,0 +1,86 @@
+<?php
+/**
+ * Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff.
+ *
+ * Throws errors if tabs are used for indentation.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_WhiteSpace_DisallowTabIndentSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * A list of tokenizers this sniff supports.
+     *
+     * @var array
+     */
+    public $supportedTokenizers = array(
+                                   'PHP',
+                                   'JS',
+                                   'CSS',
+                                  );
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return array(T_WHITESPACE);
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile All the tokens found in the document.
+     * @param int                  $stackPtr  The position of the current token in
+     *                                        the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // Make sure this is whitespace used for indentation.
+        $line = $tokens[$stackPtr]['line'];
+        if ($stackPtr > 0 && $tokens[($stackPtr - 1)]['line'] === $line) {
+            return;
+        }
+
+        if (strpos($tokens[$stackPtr]['content'], "\t") !== false) {
+            $error = 'Spaces must be used to indent lines; tabs are not allowed';
+            $phpcsFile->addError($error, $stackPtr, 'TabsUsed');
+        }
+
+    }//end process()
+
+
+}//end class
+
+?>

database/php/pear/PHP/CodeSniffer/Standards/Generic/Sniffs/WhiteSpace/ScopeIndentSniff.php

@@ -0,0 +1,346 @@
+<?php
+/**
+ * Generic_Sniffs_Whitespace_ScopeIndentSniff.
+ *
+ * PHP version 5
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+
+/**
+ * Generic_Sniffs_Whitespace_ScopeIndentSniff.
+ *
+ * Checks that control structures are structured correctly, and their content
+ * is indented correctly. This sniff will throw errors if tabs are used
+ * for indentation rather than spaces.
+ *
+ * @category  PHP
+ * @package   PHP_CodeSniffer
+ * @author    Greg Sherwood <gsherwood@squiz.net>
+ * @author    Marc McIntyre <mmcintyre@squiz.net>
+ * @copyright 2006-2011 Squiz Pty Ltd (ABN 77 084 670 600)
+ * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence
+ * @version   Release: 1.3.3
+ * @link      http://pear.php.net/package/PHP_CodeSniffer
+ */
+class Generic_Sniffs_WhiteSpace_ScopeIndentSniff implements PHP_CodeSniffer_Sniff
+{
+
+    /**
+     * The number of spaces code should be indented.
+     *
+     * @var int
+     */
+    public $indent = 4;
+
+    /**
+     * Does the indent need to be exactly right.
+     *
+     * If TRUE, indent needs to be exactly $ident spaces. If FALSE,
+     * indent needs to be at least $ident spaces (but can be more).
+     *
+     * @var bool
+     */
+    public $exact = false;
+
+    /**
+     * Any scope openers that should not cause an indent.
+     *
+     * @var array(int)
+     */
+    protected $nonIndentingScopes = array();
+
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @return array
+     */
+    public function register()
+    {
+        return PHP_CodeSniffer_Tokens::$scopeOpeners;
+
+    }//end register()
+
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @param PHP_CodeSniffer_File $phpcsFile All the tokens found in the document.
+     * @param int                  $stackPtr  The position of the current token
+     *                                        in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+
+        // If this is an inline condition (ie. there is no scope opener), then
+        // return, as this is not a new scope.
+        if (isset($tokens[$stackPtr]['scope_opener']) === false) {
+            return;
+        }
+
+        if ($tokens[$stackPtr]['code'] === T_ELSE) {
+            $next = $phpcsFile->findNext(
+                PHP_CodeSniffer_Tokens::$emptyTokens,
+                ($stackPtr + 1),
+                null,
+                true
+            );
+
+            // We will handle the T_IF token in another call to process.
+            if ($tokens[$next]['code'] === T_IF) {
+                return;
+            }
+        }
+
+        // Find the first token on this line.
+        $firstToken = $stackPtr;
+        for ($i = $stackPtr; $i >= 0; $i--) {
+            // Record the first code token on the line.
+            if (in_array($tokens[$i]['code'], PHP_CodeSniffer_Tokens::$emptyTokens) === false) {
+                $firstToken = $i;
+            }
+
+            // It's the start of the line, so we've found our first php token.
+            if ($tokens[$i]['column'] === 1) {
+                break;
+            }
+        }
+
+        // Based on the conditions that surround this token, determine the
+        // indent that we expect this current content to be.
+        $expectedIndent = $this->calculateExpectedIndent($tokens, $firstToken);
+
+        // Don't process the first token if it is a closure because they have
+        // different indentation rules as they are often used as function arguments
+        // for multi-line function calls. But continue to process the content of the
+        // closure because it should be indented as normal.
+        if ($tokens[$firstToken]['code'] !== T_CLOSURE
+            && $tokens[$firstToken]['column'] !== $expectedIndent
+        ) {
+            $error = 'Line indented incorrectly; expected %s spaces, found %s';
+            $data  = array(
+                      ($expectedIndent - 1),
+                      ($tokens[$firstToken]['column'] - 1),
+                     );
+            $phpcsFile->addError($error, $stackPtr, 'Incorrect', $data);
+        }
+
+        $scopeOpener = $tokens[$stackPtr]['scope_opener'];
+        $scopeCloser = $tokens[$stackPtr]['scope_closer'];
+
+        // Some scopes are expected not to have indents.
+        if (in_array($tokens[$firstToken]['code'], $this->nonIndentingScopes) === false) {
+            $indent = ($expectedIndent + $this->indent);
+        } else {
+            $indent = $expectedIndent;
+        }
+
+        $newline     = false;
+        $commentOpen = false;
+        $inHereDoc   = false;
+
+        // Only loop over the content between the opening and closing brace, not
+        // the braces themselves.
+        for ($i = ($scopeOpener + 1); $i < $scopeCloser; $i++) {
+
+            // If this token is another scope, skip it as it will be handled by
+            // another call to this sniff.
+            if (in_array($tokens[$i]['code'], PHP_CodeSniffer_Tokens::$scopeOpeners) === true) {
+                if (isset($tokens[$i]['scope_opener']) === true) {
+                    $i = $tokens[$i]['scope_closer'];
+
+                    // If the scope closer is followed by a semi-colon, the semi-colon is part
+                    // of the closer and should also be ignored. This most commonly happens with
+                    // CASE statements that end with "break;", where we don't want to stop
+                    // ignoring at the break, but rather at the semi-colon.
+                    $nextToken = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($i + 1), null, true);
+                    if ($tokens[$nextToken]['code'] === T_SEMICOLON) {
+                        $i = $nextToken;
+                    }
+                } else {
+                    // If this token does not have a scope_opener indice, then
+                    // it's probably an inline scope, so let's skip to the next
+                    // semicolon. Inline scopes include inline if's, abstract
+                    // methods etc.
+                    $nextToken = $phpcsFile->findNext(T_SEMICOLON, $i, $scopeCloser);
+                    if ($nextToken !== false) {
+                        $i = $nextToken;
+                    }
+                }
+
+                continue;
+            }//end if
+
+            // If this is a HEREDOC then we need to ignore it as the
+            // whitespace before the contents within the HEREDOC are
+            // considered part of the content.
+            if ($tokens[$i]['code'] === T_START_HEREDOC) {
+                $inHereDoc = true;
+                continue;
+            } else if ($inHereDoc === true) {
+                if ($tokens[$i]['code'] === T_END_HEREDOC) {
+                    $inHereDoc = false;
+                }
+
+                continue;
+            }
+
+            if ($tokens[$i]['column'] === 1) {
+                // We started a newline.
+                $newline = true;
+            }
+
+            if ($newline === true && $tokens[$i]['code'] !== T_WHITESPACE) {
+                // If we started a newline and we find a token that is not
+                // whitespace, then this must be the first token on the line that
+                // must be indented.
+                $newline    = false;
+                $firstToken = $i;
+
+                $column = $tokens[$firstToken]['column'];
+
+                // Special case for non-PHP code.
+                if ($tokens[$firstToken]['code'] === T_INLINE_HTML) {
+                    $trimmedContentLength
+                        = strlen(ltrim($tokens[$firstToken]['content']));
+                    if ($trimmedContentLength === 0) {
+                        continue;
+                    }
+
+                    $contentLength = strlen($tokens[$firstToken]['content']);
+                    $column        = ($contentLength - $trimmedContentLength + 1);
+                }
+
+                // Check to see if this constant string spans multiple lines.
+                // If so, then make sure that the strings on lines other than the
+                // first line are indented appropriately, based on their whitespace.
+                if (in_array($tokens[$firstToken]['code'], PHP_CodeSniffer_Tokens::$stringTokens) === true) {
+                    if (in_array($tokens[($firstToken - 1)]['code'], PHP_CodeSniffer_Tokens::$stringTokens) === true) {
+                        // If we find a string that directly follows another string
+                        // then its just a string that spans multiple lines, so we
+                        // don't need to check for indenting.
+                        continue;
+                    }
+                }
+
+                // This is a special condition for T_DOC_COMMENT and C-style
+                // comments, which contain whitespace between each line.
+                $comments = array(
+                             T_COMMENT,
+                             T_DOC_COMMENT
+                            );
+
+                if (in_array($tokens[$firstToken]['code'], $comments) === true) {
+                    $content = trim($tokens[$firstToken]['content']);
+                    if (preg_match('|^/\*|', $content) !== 0) {
+                        // Check to see if the end of the comment is on the same line
+                        // as the start of the comment. If it is, then we don't
+                        // have to worry about opening a comment.
+                        if (preg_match('|\*/$|', $content) === 0) {
+                            // We don't have to calculate the column for the
+                            // start of the comment as there is a whitespace
+                            // token before it.
+                            $commentOpen = true;
+                        }
+                    } else if ($commentOpen === true) {
+                        if ($content === '') {
+                            // We are in a comment, but this line has nothing on it
+                            // so let's skip it.
+                            continue;
+                        }
+
+                        $contentLength = strlen($tokens[$firstToken]['content']);
+                        $trimmedContentLength
+                            = strlen(ltrim($tokens[$firstToken]['content']));
+
+                        $column = ($contentLength - $trimmedContentLength + 1);
+                        if (preg_match('|\*/$|', $content) !== 0) {
+                            $commentOpen = false;
+                        }
+                    }//end if
+                }//end if
+
+                // The token at the start of the line, needs to have its' column
+                // greater than the relative indent we set above. If it is less,
+                // an error should be shown.
+                if ($column !== $indent) {
+                    if ($this->exact === true || $column < $indent) {
+                        $type  = 'IncorrectExact';
+                        $error = 'Line indented incorrectly; expected ';
+                        if ($this->exact === false) {
+                            $error .= 'at least ';
+                            $type   = 'Incorrect';
+                        }
+
+                        $error .= '%s spaces, found %s';
+                        $data = array(
+                                  ($indent - 1),
+                                  ($column - 1),
+                                );
+                        $phpcsFile->addError($error, $firstToken, $type, $data);
+                    }
+                }//end if
+            }//end if
+        }//end for
+
+    }//end process()
+
+
+    /**
+     * Calculates the expected indent of a token.
+     *
+     * Returns the column at which the token should be indented to, so 1 means
+     * that the token should not be indented at all.
+     *
+     * @param array $tokens   The stack of tokens for this file.
+     * @param int   $stackPtr The position of the token to get indent for.
+     *
+     * @return int
+     */
+    protected function calculateExpectedIndent(array $tokens, $stackPtr)
+    {
+        $conditionStack = array();
+
+        // Empty conditions array (top level structure).
+        if (empty($tokens[$stackPtr]['conditions']) === true) {
+            if (isset($tokens[$stackPtr]['nested_parenthesis']) === true
+                && empty($tokens[$stackPtr]['nested_parenthesis']) === false
+            ) {
+                // Wrapped in parenthesis means it is probably in a
+                // function call (like a closure) so we have to assume indent
+                // is correct here and someone else will check it more
+                // carefully in another sniff.
+                return $tokens[$stackPtr]['column'];
+            } else {
+                return 1;
+            }
+        }
+
+        $tokenConditions = $tokens[$stackPtr]['conditions'];
+        foreach ($tokenConditions as $id => $condition) {
+            // If it's an indenting scope ie. it's not in our array of
+            // scopes that don't indent, add it to our condition stack.
+            if (in_array($condition, $this->nonIndentingScopes) === false) {
+                $conditionStack[$id] = $condition;
+            }
+        }
+
+        $indent = ((count($conditionStack) * $this->indent) + 1);
+        return $indent;
+
+    }//end calculateExpectedIndent()
+
+
+}//end class
+
+?>