Subversion-Projekte lars-tiefland.php_share

<?php

/**

 * PHP_CodeSniffer tokenises PHP code and detects violations of a

 * defined set of coding standards.

 *

 * PHP version 5

 *

 * @category  PHP

 * @package   PHP_CodeSniffer

 * @author    Greg Sherwood <gsherwood@squiz.net>

 * @author    Marc McIntyre <mmcintyre@squiz.net>

 * @copyright 2006 Squiz Pty Ltd (ABN 77 084 670 600)

 * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence

 * @version   CVS: $Id: CodeSniffer.php 290802 2009-11-16 06:06:29Z squiz $

 * @link      http://pear.php.net/package/PHP_CodeSniffer

 */

spl_autoload_register(array('PHP_CodeSniffer', 'autoload'));

if (class_exists('PHP_CodeSniffer_Exception', true) === false) {

    throw new Exception('Class PHP_CodeSniffer_Exception not found');

}

if (class_exists('PHP_CodeSniffer_File', true) === false) {

    throw new PHP_CodeSniffer_Exception('Class PHP_CodeSniffer_File not found');

}

if (class_exists('PHP_CodeSniffer_Tokens', true) === false) {

    throw new PHP_CodeSniffer_Exception('Class PHP_CodeSniffer_Tokens not found');

}

if (interface_exists('PHP_CodeSniffer_Sniff', true) === false) {

    throw new PHP_CodeSniffer_Exception('Interface PHP_CodeSniffer_Sniff not found');

}

if (interface_exists('PHP_CodeSniffer_MultiFileSniff', true) === false) {

    throw new PHP_CodeSniffer_Exception('Interface PHP_CodeSniffer_MultiFileSniff not found');

}

/**

 * PHP_CodeSniffer tokenises PHP code and detects violations of a

 * defined set of coding standards.

 *

 * Standards are specified by classes that implement the PHP_CodeSniffer_Sniff

 * interface. A sniff registers what token types it wishes to listen for, then

 * PHP_CodeSniffer encounters that token, the sniff is invoked and passed

 * information about where the token was found in the stack, and the token stack

 * itself.

 *

 * Sniff files and their containing class must be prefixed with Sniff, and

 * have an extension of .php.

 *

 * Multiple PHP_CodeSniffer operations can be performed by re-calling the

 * process function with different parameters.

 *

 * @category  PHP

 * @package   PHP_CodeSniffer

 * @author    Greg Sherwood <gsherwood@squiz.net>

 * @author    Marc McIntyre <mmcintyre@squiz.net>

 * @copyright 2006 Squiz Pty Ltd (ABN 77 084 670 600)

 * @license   http://matrix.squiz.net/developer/tools/php_cs/licence BSD Licence

 * @version   Release: 1.2.1

 * @link      http://pear.php.net/package/PHP_CodeSniffer

 */

class PHP_CodeSniffer

{

    /**

     * The file or directory that is currently being processed.

     *

     * @var string

     */

    protected $file = array();

    /**

     * The directory to search for sniffs in.

     *

     * @var string

     */

    protected $standardDir = '';

    /**

     * The files that have been processed.

     *

     * @var array(PHP_CodeSniffer_File)

     */

    protected $files = array();

    /**

     * The path that that PHP_CodeSniffer is being run from.

     *

     * Stored so that the path can be restored after it is changed

     * in the constructor.

     *

     * @var string

     */

    private $_cwd = null;

    /**

     * The listeners array.

     *

     * @var array(PHP_CodeSniffer_Sniff)

     */

    protected $listeners = array();

    /**

     * The listeners array, indexed by token type.

     *

     * @var array()

     */

    private $_tokenListeners = array(

                                'file'      => array(),

                                'multifile' => array(),

                               );

    /**

     * An array of patterns to use for skipping files.

     *

     * @var array()

     */

    protected $ignorePatterns = array();

    /**

     * An array of extensions for files we will check.

     *

     * @var array

     */

    public $allowedFileExtensions = array(

                                     'php' => 'PHP',

                                     'inc' => 'PHP',

                                     'js'  => 'JS',

                                     'css' => 'CSS',

                                    );

    /**

     * An array of variable types for param/var we will check.

     *

     * @var array(string)

     */

    public static $allowedTypes = array(

                                   'array',

                                   'boolean',

                                   'float',

                                   'integer',

                                   'mixed',

                                   'object',

                                   'string',

                                  );

    /**

     * Constructs a PHP_CodeSniffer object.

     *

     * @param int $verbosity The verbosity level.

     *                       1: Print progress information.

     *                       2: Print developer debug information.

     * @param int $tabWidth  The number of spaces each tab represents.

     *                       If greater than zero, tabs will be replaced

     *                       by spaces before testing each file.

     *

     * @see process()

     */

    public function __construct($verbosity=0, $tabWidth=0)

    {

        if (defined('PHP_CODESNIFFER_VERBOSITY') === false) {

            define('PHP_CODESNIFFER_VERBOSITY', $verbosity);

        }

        if (defined('PHP_CODESNIFFER_TAB_WIDTH') === false) {

            define('PHP_CODESNIFFER_TAB_WIDTH', $tabWidth);

        }

        // Change into a directory that we know about to stop any

        // relative path conflicts.

        $this->_cwd = getcwd();

        chdir(dirname(__FILE__).'/CodeSniffer/');

    }//end __construct()

    /**

     * Destructs a PHP_CodeSniffer object.

     *

     * Restores the current working directory to what it

     * was before we started our run.

     *

     * @return void

     */

    public function __destruct()

    {

        chdir($this->_cwd);

    }//end __destruct()

    /**

     * Autoload static method for loading classes and interfaces.

     *

     * @param string $className The name of the class or interface.

     *

     * @return void

     */

    public static function autoload($className)

    {

        if (substr($className, 0, 4) === 'PHP_') {

            $newClassName = substr($className, 4);

        } else {

            $newClassName = $className;

        }

        $path = str_replace('_', '/', $newClassName).'.php';

        if (is_file(dirname(__FILE__).'/'.$path) === true) {

            // Check standard file locations based on class name.

            include dirname(__FILE__).'/'.$path;

        } else if (is_file(dirname(__FILE__).'/CodeSniffer/Standards/'.$path) === true) {

            // Check for included sniffs.

            include dirname(__FILE__).'/CodeSniffer/Standards/'.$path;

        } else {

            // Everything else.

            @include $path;

        }

    }//end autoload()

    /**

     * Sets an array of file extensions that we will allow checking of.

     *

     * If the extension is one of the defaults, a specific tokenizer

     * will be used. Otherwise, the PHP tokenizer will be used for

     * all extensions passed.

     *

     * @param array $extensions An array of file extensions.

     *

     * @return void

     */

    public function setAllowedFileExtensions(array $extensions)

    {

        $newExtensions = array();

        foreach ($extensions as $ext) {

            if (isset($this->allowedFileExtensions[$ext]) === true) {

                $newExtensions[$ext] = $this->allowedFileExtensions[$ext];

            } else {

                $newExtensions[$ext] = 'PHP';

            }

        }

        $this->allowedFileExtensions = $newExtensions;

    }//end setAllowedFileExtensions()

    /**

     * Sets an array of ignore patterns that we use to skip files and folders.

     *

     * Patterns are not case sensitive.

     *

     * @param array $patterns An array of ignore patterns.

     *

     * @return void

     */

    public function setIgnorePatterns(array $patterns)

    {

        $this->ignorePatterns = $patterns;

    }//end setIgnorePatterns()

    /**

     * Adds a file to the list of checked files.

     *

     * Checked files are used to generate error reports after the run.

     *

     * @param PHP_CodeSniffer_File $phpcsFile The file to add.

     *

     * @return void

     */

    public function addFile(PHP_CodeSniffer_File $phpcsFile)

    {

        $this->files[] = $phpcsFile;

    }//end addFile()

    /**

     * Processes the files/directories that PHP_CodeSniffer was constructed with.

     *

     * @param string|array $files    The files and directories to process. For

     *                               directories, each sub directory will also

     *                               be traversed for source files.

     * @param string       $standard The set of code sniffs we are testing

     *                               against.

     * @param array        $sniffs   The sniff names to restrict the allowed

     *                               listeners to.

     * @param boolean      $local    If true, don't recurse into directories.

     *

     * @return void

     * @throws PHP_CodeSniffer_Exception If files or standard are invalid.

     */

    public function process($files, $standard, array $sniffs=array(), $local=false)

    {

        if (is_array($files) === false) {

            if (is_string($files) === false || $files === null) {

                throw new PHP_CodeSniffer_Exception('$file must be a string');

            }

            $files = array($files);

        }

        if (is_string($standard) === false || $standard === null) {

            throw new PHP_CodeSniffer_Exception('$standard must be a string');

        }

        // Reset the members.

        $this->listeners       = array();

        $this->files           = array();

        $this->_tokenListeners = array(

                                  'file'      => array(),

                                  'multifile' => array(),

                                 );

        if (PHP_CODESNIFFER_VERBOSITY > 0) {

            echo "Registering sniffs in ".basename($standard)." standard... ";

            if (PHP_CODESNIFFER_VERBOSITY > 2) {

                echo PHP_EOL;

            }

        }

        $this->setTokenListeners($standard, $sniffs);

        if (PHP_CODESNIFFER_VERBOSITY > 0) {

            $numSniffs = count($this->listeners);

            echo "DONE ($numSniffs sniffs registered)".PHP_EOL;

        }

        $this->populateTokenListeners();

        foreach ($files as $file) {

            $this->file = $file;

            if (is_dir($this->file) === true) {

                $this->processFiles($this->file, $local);

            } else {

                $this->processFile($this->file);

            }

        }

        // Now process the multi-file sniffs, assuming there are

        // multiple files being sniffed.

        if (count($files) > 1 || is_dir($files[0]) === true) {

            foreach ($this->_tokenListeners['multifile'] as $listener) {

                // Set the name of the listener for error messages.

                $activeListener = get_class($listener);

                foreach ($this->files as $file) {

                    $file->setActiveListener($activeListener);

                }

                $listener->process($this->files);

            }

        }

    }//end process()

    /**

     * Gets installed sniffs in the coding standard being used.

     *

     * Traverses the standard directory for classes that implement the

     * PHP_CodeSniffer_Sniff interface asks them to register. Each of the

     * sniff's class names must be exact as the basename of the sniff file.

     *

     * Returns an array of sniff class names.

     *

     * @param string $standard The name of the coding standard we are checking.

     * @param array  $sniffs   The sniff names to restrict the allowed

     *                         listeners to.

     *

     * @return array

     * @throws PHP_CodeSniffer_Exception If any of the tests failed in the

     *                                   registration process.

     */

    public function getTokenListeners($standard, array $sniffs=array())

    {

        if (is_dir($standard) === true) {

            // This is an absolute path to a custom standard.

            $this->standardDir = $standard;

            $standard          = basename($standard);

        } else {

            $this->standardDir = realpath(dirname(__FILE__).'/CodeSniffer/Standards/'.$standard);

            if (is_dir($this->standardDir) === false) {

                // This isn't looking good. Let's see if this

                // is a relative path to a custom standard.

                if (is_dir(realpath($this->_cwd.'/'.$standard)) === true) {

                    // This is a relative path to a custom standard.

                    $this->standardDir = realpath($this->_cwd.'/'.$standard);

                    $standard          = basename($standard);

                }

            }

        }

        $files = self::getSniffFiles($this->standardDir, $standard);

        if (empty($sniffs) === false) {

            // Convert the allowed sniffs to lower case so

            // they are easier to check.

            foreach ($sniffs as &$sniff) {

                $sniff = strtolower($sniff);

            }

        }

        $listeners = array();

        foreach ($files as $file) {

            // Work out where the position of /StandardName/Sniffs/... is

            // so we can determine what the class will be called.

            $sniffPos = strrpos($file, DIRECTORY_SEPARATOR.'Sniffs'.DIRECTORY_SEPARATOR);

            if ($sniffPos === false) {

                continue;

            }

            $slashPos = strrpos(substr($file, 0, $sniffPos), DIRECTORY_SEPARATOR);

            if ($slashPos === false) {

                continue;

            }

            $className = substr($file, ($slashPos + 1));

            $className = substr($className, 0, -4);

            $className = str_replace(DIRECTORY_SEPARATOR, '_', $className);

            include_once $file;

            // If they have specified a list of sniffs to restrict to, check

            // to see if this sniff is allowed.

            $allowed = in_array(strtolower($className), $sniffs);

            if (empty($sniffs) === false && $allowed === false) {

                continue;

            }

            $listeners[] = $className;

            if (PHP_CODESNIFFER_VERBOSITY > 2) {

                echo "\tRegistered $className".PHP_EOL;

            }

        }//end foreach

        return $listeners;

    }//end getTokenListeners()

    /**

     * Sets installed sniffs in the coding standard being used.

     *

     * @param string $standard The name of the coding standard we are checking.

     * @param array  $sniffs   The sniff names to restrict the allowed

     *                         listeners to.

     *

     * @return null

     */

    public function setTokenListeners($standard, array $sniffs=array())

    {

        $this->listeners = $this->getTokenListeners($standard, $sniffs);

    }//end setTokenListeners()

    /**

     * Populates the array of PHP_CodeSniffer_Sniff's for this file.

     *

     * @return void

     */

    public function populateTokenListeners()

    {

        // Construct a list of listeners indexed by token being listened for.

        foreach ($this->listeners as $listenerClass) {

            $listener = new $listenerClass();

            if (($listener instanceof PHP_CodeSniffer_Sniff) === true) {

                $tokens = $listener->register();

                if (is_array($tokens) === false) {

                    $msg = "Sniff $listenerClass register() method must return an array";

                    throw new PHP_CodeSniffer_Exception($msg);

                }

                foreach ($tokens as $token) {

                    if (isset($this->_tokenListeners['file'][$token]) === false) {

                        $this->_tokenListeners['file'][$token] = array();

                    }

                    if (in_array($listener, $this->_tokenListeners['file'][$token], true) === false) {

                        $this->_tokenListeners['file'][$token][] = $listener;

                    }

                }

            } else if (($listener instanceof PHP_CodeSniffer_MultiFileSniff) === true) {

                $this->_tokenListeners['multifile'][] = $listener;

            }

        }//end foreach

    }//end populateTokenListeners()

    /**

     * Return a list of sniffs that a coding standard has defined.

     *

     * Sniffs are found by recursing the standard directory and also by

     * asking the standard for included sniffs.

     *

     * @param string $dir      The directory where to look for the files.

     * @param string $standard The name of the coding standard. If NULL, no

     *                         included sniffs will be checked for.

     *

     * @return array

     * @throws PHP_CodeSniffer_Exception If an included or excluded sniff does

     *                                   not exist.

     */

    public static function getSniffFiles($dir, $standard=null)

    {

        $di = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir));

        $ownSniffs      = array();

        $includedSniffs = array();

        $excludedSniffs = array();

        foreach ($di as $file) {

            $fileName = $file->getFilename();

            // Skip hidden files.

            if (substr($fileName, 0, 1) === '.') {

                continue;

            }

            // We are only interested in PHP and sniff files.

            $fileParts = explode('.', $fileName);

            if (array_pop($fileParts) !== 'php') {

                continue;

            }

            $basename = basename($fileName, '.php');

            if (substr($basename, -5) !== 'Sniff') {

                continue;

            }

            $ownSniffs[] = $file->getPathname();

        }//end foreach

        // Load the standard class and ask it for a list of external

        // sniffs to include in the standard.

        if ($standard !== null

            && is_file("$dir/{$standard}CodingStandard.php") === true

        ) {

            include_once "$dir/{$standard}CodingStandard.php";

            $standardClassName = "PHP_CodeSniffer_Standards_{$standard}_{$standard}CodingStandard";

            $standardClass     = new $standardClassName;

            $included = $standardClass->getIncludedSniffs();

            foreach ($included as $sniff) {

                if (is_dir($sniff) === true) {

                    // Trying to include from a custom standard.

                    $sniffDir = $sniff;

                    $sniff    = basename($sniff);

                } else if (is_file($sniff) === true) {

                    // Trying to include a custom sniff.

                    $sniffDir = $sniff;

                } else {

                    $sniffDir = realpath(dirname(__FILE__)."/CodeSniffer/Standards/$sniff");

                    if ($sniffDir === false) {

                        $error = "Included sniff $sniff does not exist";

                        throw new PHP_CodeSniffer_Exception($error);

                    }

                }

                if (is_dir($sniffDir) === true) {

                    if (self::isInstalledStandard($sniff) === true) {

                        // We are including a whole coding standard.

                        $includedSniffs = array_merge($includedSniffs, self::getSniffFiles($sniffDir, $sniff));

                    } else {

                        // We are including a whole directory of sniffs.

                        $includedSniffs = array_merge($includedSniffs, self::getSniffFiles($sniffDir));

                    }

                } else {

                    if (substr($sniffDir, -9) !== 'Sniff.php') {

                        $error = "Included sniff $sniff does not exist";

                        throw new PHP_CodeSniffer_Exception($error);

                    }

                    $includedSniffs[] = $sniffDir;

                }

            }//end foreach

            $excluded = $standardClass->getExcludedSniffs();

            foreach ($excluded as $sniff) {

                if (is_dir($sniff) === true) {

                    // Trying to exclude from a custom standard.

                    $sniffDir = $sniff;

                    $sniff    = basename($sniff);

                } else if (is_file($sniff) === true) {

                    // Trying to exclude a custom sniff.

                    $sniffDir = $sniff;

                } else {

                    $sniffDir = realpath(dirname(__FILE__)."/CodeSniffer/Standards/$sniff");

                    if ($sniffDir === false) {

                        $error = "Excluded sniff $sniff does not exist";

                        throw new PHP_CodeSniffer_Exception($error);

                    }

                }

                if (is_dir($sniffDir) === true) {

                    if (self::isInstalledStandard($sniff) === true) {

                        // We are excluding a whole coding standard.

                        $excludedSniffs = array_merge(

                            $excludedSniffs,

                            self::getSniffFiles($sniffDir, $sniff)

                        );

                    } else {

                        // We are excluding a whole directory of sniffs.

                        $excludedSniffs = array_merge(

                            $excludedSniffs,

                            self::getSniffFiles($sniffDir)

                        );

                    }

                } else {

                    if (substr($sniffDir, -9) !== 'Sniff.php') {

                        $error = "Excluded sniff $sniff does not exist";

                        throw new PHP_CodeSniffer_Exception($error);

                    }

                    $excludedSniffs[] = $sniffDir;

                }

            }//end foreach

        }//end if

        // Merge our own sniff list with our exnternally included

        // sniff list, but filter out any excluded sniffs.

        $files = array();

        foreach (array_merge($ownSniffs, $includedSniffs) as $sniff) {

            if (in_array($sniff, $excludedSniffs) === true) {

                continue;

            } else {

                $files[] = $sniff;

            }

        }

        return $files;

    }//end getSniffFiles()

    /**

     * Run the code sniffs over each file in a given directory.

     *

     * Recusively reads the specified directory and performs the PHP_CodeSniffer

     * sniffs on each source file found within the directories.

     *

     * @param string  $dir   The directory to process.

     * @param boolean $local If true, only process files in this directory, not

     *                       sub directories.

     *

     * @return void

     * @throws Exception If there was an error opening the directory.

     */

    public function processFiles($dir, $local=false)

    {

        try {

            if ($local === true) {

                $di = new DirectoryIterator($dir);

            } else {

                $di = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir));

            }

            foreach ($di as $file) {

                $filePath = realpath($file->getPathname());

                if (is_dir($filePath) === true) {

                    continue;

                }

                // Check that the file's extension is one we are checking.

                // Note that because we are doing a whole directory, we

                // are strict about checking the extension and we don't

                // let files with no extension through.

                $fileParts = explode('.', $file);

                $extension = array_pop($fileParts);

                if ($extension === $file) {

                    continue;

                }

                if (isset($this->allowedFileExtensions[$extension]) === false) {

                    continue;

                }

                $this->processFile($filePath);

            }//end foreach

        } catch (Exception $e) {

            $trace = $e->getTrace();

            $filename = $trace[0]['args'][0];

            if (is_numeric($filename) === true) {

                // See if we can find the PHP_CodeSniffer_File object.

                foreach ($trace as $data) {

                    if (isset($data['args'][0]) === true && ($data['args'][0] instanceof PHP_CodeSniffer_File) === true) {

                        $filename = $data['args'][0]->getFilename();

                    }

                }

            }

            $error = 'An error occurred during processing; checking has been aborted. The error message was: '.$e->getMessage();

            $phpcsFile = new PHP_CodeSniffer_File($filename, $this->listeners, $this->allowedFileExtensions);

            $this->addFile($phpcsFile);

            $phpcsFile->addError($error, null);

            return;

        }

    }//end processFiles()

    /**

     * Run the code sniffs over a single given file.

     *

     * Processes the file and runs the PHP_CodeSniffer sniffs to verify that it

     * conforms with the standard.

     *

     * @param string $file     The file to process.

     * @param string $contents The contents to parse. If NULL, the content

     *                         is taken from the file system.

     *

     * @return void

     * @throws PHP_CodeSniffer_Exception If the file could not be processed.

     */

    public function processFile($file, $contents=null)

    {

        if ($contents === null && file_exists($file) === false) {

            throw new PHP_CodeSniffer_Exception("Source file $file does not exist");

        }

        // If the file's path matches one of our ignore patterns, skip it.

        foreach ($this->ignorePatterns as $pattern) {

            $replacements = array(

                             '\\,' => ',',

                             '*'   => '.*',

                            );

            $pattern = strtr($pattern, $replacements);

            if (preg_match("|{$pattern}|i", $file) === 1) {

                return;

            }

        }

        // Before we go and spend time tokenizing this file, just check

        // to see if there is a tag up top to indicate that the whole

        // file should be ignored. It must be on one of the first two lines.

        $firstContent = $contents;

        if ($contents === null) {

            $handle = fopen($file, 'r');

            if ($handle !== false) {

                $firstContent  = fgets($handle);

                $firstContent .= fgets($handle);

                fclose($handle);

            }

        }

        if (strpos($firstContent, '@codingStandardsIgnoreFile') !== false) {

            // We are ignoring the whole file.

            if (PHP_CODESNIFFER_VERBOSITY > 0) {

                echo 'Ignoring '.basename($file).PHP_EOL;

            }

            return;

        }

        if (PHP_CODESNIFFER_VERBOSITY > 0) {

            $startTime = time();

            echo 'Processing '.basename($file).' ';

            if (PHP_CODESNIFFER_VERBOSITY > 1) {

                echo PHP_EOL;

            }

        }

        $phpcsFile = new PHP_CodeSniffer_File(

            $file,

            $this->_tokenListeners['file'],

            $this->allowedFileExtensions

        );

        $this->addFile($phpcsFile);

        $phpcsFile->start($contents);

        // Clean up the test if we can to save memory. This can't be done if

        // we need to leave the files around for multi-file sniffs.

        if (empty($this->_tokenListeners['multifile']) === true) {

            $phpcsFile->cleanUp();

        }

        if (PHP_CODESNIFFER_VERBOSITY > 0) {

            $timeTaken = (time() - $startTime);

            if ($timeTaken === 0) {

                echo 'DONE in < 1 second';

            } else if ($timeTaken === 1) {

                echo 'DONE in 1 second';

            } else {

                echo "DONE in $timeTaken seconds";

            }

            $errors   = $phpcsFile->getErrorCount();

            $warnings = $phpcsFile->getWarningCount();

            echo " ($errors errors, $warnings warnings)".PHP_EOL;

        }

    }//end processFile()

    /**

     * Pre-process and package errors and warnings for all files.

     *

     * Used by error reports to get a packaged list of all errors and

     * warnings in each file.

     *

     * @param boolean $showWarnings Show warnings as well as errors.

     *

     * @return array

     */

    public function prepareErrorReport($showWarnings=true)

    {

        $report = array(

                   'totals' => array(

                                'warnings' => 0,

                                'errors'   => 0,

                               ),

                   'files'  => array(),

                  );

        foreach ($this->files as $file) {

            $warnings    = $file->getWarnings();

            $errors      = $file->getErrors();

            $numWarnings = $file->getWarningCount();

            $numErrors   = $file->getErrorCount();

            $filename    = $file->getFilename();

            $report['files'][$filename] = array(

                                           'errors'   => 0,

                                           'warnings' => 0,

                                           'messages' => array(),

                                          );

            if ($numErrors === 0 && $numWarnings === 0) {

                // Prefect score!

                continue;

            }

            if ($numErrors === 0 && $showWarnings === false) {

                // Prefect score (sort of).

                continue;

            }

            $report['files'][$filename]['errors'] = $numErrors;

            if ($showWarnings === true) {

                $report['files'][$filename]['warnings'] = $numWarnings;

            } else {

                $report['files'][$filename]['warnings'] = 0;

            }

            $report['totals']['errors'] += $numErrors;

            if ($showWarnings === true) {

                $report['totals']['warnings'] += $numWarnings;

            }

            // Merge errors and warnings.

            foreach ($errors as $line => $lineErrors) {

                foreach ($lineErrors as $column => $colErrors) {

                    $newErrors = array();

                    foreach ($colErrors as $data) {

                        $newErrors[] = array(

                                        'message' => $data['message'],

                                        'source'  => $data['source'],

                                        'type'    => 'ERROR',

                                       );

                    }

                    $errors[$line][$column] = $newErrors;

                }

            }//end foreach

            if ($showWarnings === true) {

                foreach ($warnings as $line => $lineWarnings) {

                    foreach ($lineWarnings as $column => $colWarnings) {

                        $newWarnings = array();

                        foreach ($colWarnings as $data) {

                            $newWarnings[] = array(

                                              'message' => $data['message'],

                                              'source'  => $data['source'],

                                              'type'    => 'WARNING',

                                             );

                        }

                        if (isset($errors[$line]) === false) {

                            $errors[$line] = array();

                        }

                        if (isset($errors[$line][$column]) === true) {

                            $errors[$line][$column] = array_merge(

                                $newWarnings,

                                $errors[$line][$column]

                            );

                        } else {

                            $errors[$line][$column] = $newWarnings;

                        }

                    }

                }//end foreach

            }//end if

            ksort($errors);

            $report['files'][$filename]['messages'] = $errors;

        }//end foreach

        ksort($report['files']);

        return $report;

    }//end prepareErrorReport()

    /**

     * Prints all errors and warnings for each file processed, in an XML format.

     *

     * Errors and warnings are displayed together, grouped by file.

     *

     * @param boolean $showWarnings Show warnings as well as errors.

     *

     * @return int The number of error and warning messages shown.

     */

    public function printXMLErrorReport($showWarnings=true)

    {

        echo '<?xml version="1.0" encoding="UTF-8"?>'.PHP_EOL;

        echo '<phpcs version="1.2.1">'.PHP_EOL;

        $errorsShown = 0;

        $report = $this->prepareErrorReport($showWarnings);

        foreach ($report['files'] as $filename => $file) {

            if (empty($file['messages']) === true) {

                continue;

            }

            echo ' <file name="'.$filename.'" errors="'.$file['errors'].'" warnings="'.$file['warnings'].'">'.PHP_EOL;

            foreach ($file['messages'] as $line => $lineErrors) {

                foreach ($lineErrors as $column => $colErrors) {

                    foreach ($colErrors as $error) {

                        $error['type'] = strtolower($error['type']);

                        echo '  <'.$error['type'].' line="'.$line.'" column="'.$column.'" source="'.$error['source'].'">';

                        echo htmlspecialchars($error['message']).'</'.$error['type'].'>'.PHP_EOL;

                        $errorsShown++;

                    }

                }

            }//end foreach

            echo ' </file>'.PHP_EOL;

        }//end foreach

        echo '</phpcs>'.PHP_EOL;

        return $errorsShown;

    }//end printXMLErrorReport()

    /**

     * Prints all errors and warnings for processed files, in a Checkstyle format.

     *

     * Errors and warnings are displayed together, grouped by file.

     *

     * @param boolean $showWarnings Show warnings as well as errors.

     *

     * @return int The number of error and warning messages shown.

     */

    public function printCheckstyleErrorReport($showWarnings=true)

    {

        echo '<?xml version="1.0" encoding="UTF-8"?>'.PHP_EOL;

        echo '<checkstyle version="1.2.1">'.PHP_EOL;

        $errorsShown = 0;

        $report = $this->prepareErrorReport($showWarnings);

        foreach ($report['files'] as $filename => $file) {

            echo ' <file name="'.$filename.'">'.PHP_EOL;

            foreach ($file['messages'] as $line => $lineErrors) {

                foreach ($lineErrors as $column => $colErrors) {

                    foreach ($colErrors as $error) {

                        $error['type'] = strtolower($error['type']);

                        echo '  <error';

                        echo ' line="'.$line.'" column="'.$column.'"';

                        echo ' severity="'.$error['type'].'"';

                        $message = utf8_encode(htmlspecialchars($error['message']));

                        echo ' message="'.$message.'"';

                        echo ' source="'.$error['source'].'"';

                        echo '/>'.PHP_EOL;

                        $errorsShown++;

                    }

                }

            }//end foreach

            echo ' </file>'.PHP_EOL;

        }//end foreach