Subversion-Projekte lars-tiefland.php_share

<?php

/*

 *	$Id$

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * This software consists of voluntary contributions made by many individuals

 * and is licensed under the LGPL. For more information please see

 * <http://phing.info>.

 */

require_once 'phing/Task.php';

/**

 * A PHP code sniffer task. Checking the style of one or more PHP source files.

 *

 * @author	Dirk Thomas <dirk.thomas@4wdmedia.de>

 * @package	phing.tasks.ext

 */

class PhpCodeSnifferTask extends Task {

	protected $file;	// the source file (from xml attribute)

	protected $filesets = array(); // all fileset objects assigned to this task

	// parameters for php code sniffer

	protected $standard = 'Generic';

	protected $sniffs = array();

	protected $showWarnings = true;

	protected $verbosity = 0;

	protected $tabWidth = 0;

	protected $allowedFileExtensions = array('php');

	protected $ignorePatterns = false;

	protected $noSubdirectories = false;

	protected $configData = array();

	// parameters to customize output

	protected $showSniffs = false;

	protected $outputFormat = 'default';

	/**

	 * File to be performed syntax check on

	 * @param PhingFile $file

	 */

	public function setFile(PhingFile $file) {

		$this->file = $file;

	}

	/**

	 * Nested creator, creates a FileSet for this task

	 *

	 * @return FileSet The created fileset object

	 */

	function createFileSet() {

		$num = array_push($this->filesets, new FileSet());

		return $this->filesets[$num-1];

	}

	/**

	 * Sets the standard to test for

	 * @param string $standard

	 */

	public function setStandard($standard)

	{

		if (DIRECTORY_SEPARATOR != '/') $standard = str_replace('/', DIRECTORY_SEPARATOR, $standard);

		$this->standard = $standard;

	}

	/**

	 * Sets the sniffs which the standard should be restricted to

	 * @param string $sniffs

	 */

	public function setSniffs($sniffs)

	{

		$token = ' ,;';

		$sniff = strtok($sniffs, $token);

		while ($sniff !== false) {

			$this->sniffs[] = $sniff;

			$sniff = strtok($token);

		}

	}

	/**

	 * Sets the flag if warnings should be shown

	 * @param boolean $show

	 */

	public function setShowWarnings($show)

	{

		$this->showWarnings = StringHelper::booleanValue($show);

	}

	/**

	 * Sets the verbosity level

	 * @param int $level

	 */

	public function setVerbosity($level)

	{

		$this->verbosity = (int)$level;

	}

	/**

	 * Sets the tab width to replace tabs with spaces

	 * @param int $width

	 */

	public function setTabWidth($width)

	{

		$this->tabWidth = (int)$width;

	}

	/**

	 * Sets the allowed file extensions when using directories instead of specific files

	 * @param array $extensions

	 */

	public function setAllowedFileExtensions($extensions)

	{

		$this->allowedFileExtensions = array();

		$token = ' ,;';

		$ext = strtok($extensions, $token);

		while ($ext !== false) {

			$this->allowedFileExtensions[] = $ext;

			$ext = strtok($token);

		}

	}

	/**

	 * Sets the ignore patterns to skip files when using directories instead of specific files

	 * @param array $extensions

	 */

	public function setIgnorePatterns($patterns)

	{

		$this->ignorePatterns = array();

		$token = ' ,;';

		$pattern = strtok($patterns, $token);

		while ($pattern !== false) {

			$this->ignorePatterns[] = $pattern;

			$pattern = strtok($token);

		}

	}

	/**

	 * Sets the flag if subdirectories should be skipped

	 * @param boolean $subdirectories

	 */

	public function setNoSubdirectories($subdirectories)

	{

		$this->noSubdirectories = StringHelper::booleanValue($subdirectories);

	}

	/**

	 * Creates a config parameter for this task

	 *

	 * @return Parameter The created parameter

	 */

	public function createConfig() {

		$num = array_push($this->configData, new Parameter());

		return $this->configData[$num-1];

	}

	/**

	 * Sets the flag if the used sniffs should be listed

	 * @param boolean $show

	 */

	public function setShowSniffs($show)

	{

		$this->showSniffs = StringHelper::booleanValue($show);

	}

	/**

	 * Sets the output format

	 * @param string $format

	 */

	public function setFormat($format)

	{

		$this->outputFormat = $format;

	}

	/**

	 * Executes PHP code sniffer against PhingFile or a FileSet

	 */

	public function main() {

		if(!isset($this->file) and count($this->filesets) == 0) {

			throw new BuildException("Missing either a nested fileset or attribute 'file' set");

		}

		require_once 'PHP/CodeSniffer.php';

		$codeSniffer = new PHP_CodeSniffer($this->verbosity, $this->tabWidth);

		$codeSniffer->setAllowedFileExtensions($this->allowedFileExtensions);

		if (is_array($this->ignorePatterns)) $codeSniffer->setIgnorePatterns($this->ignorePatterns);

		foreach ($this->configData as $configData) {

			$codeSniffer->setConfigData($configData->getName(), $configData->getValue(), true);

		}

		if ($this->file instanceof PhingFile) {

			$codeSniffer->process($this->file->getPath(), $this->standard, $this->sniffs, $this->noSubdirectories);

		} else {

			$fileList = array();

			$project = $this->getProject();

			foreach ($this->filesets as $fs) {

				$ds = $fs->getDirectoryScanner($project);

				$files = $ds->getIncludedFiles();

				$dir = $fs->getDir($this->project)->getPath();

				foreach ($files as $file) {

					$fileList[] = $dir.DIRECTORY_SEPARATOR.$file;

				}

			}

			$codeSniffer->process($fileList, $this->standard, $this->sniffs, $this->noSubdirectories);

		}

		$this->output($codeSniffer);

	}

	/**

	 * Outputs the results

	 * @param PHP_CodeSniffer $codeSniffer

	 */

	protected function output($codeSniffer) {

		if ($this->showSniffs) {

			$sniffs = $codeSniffer->getSniffs();

			$sniffStr = '';

			foreach ($sniffs as $sniff) {

				$sniffStr .= '- ' . $sniff.PHP_EOL;

			}

			$this->log('The list of used sniffs (#' . count($sniffs) . '): ' . PHP_EOL . $sniffStr, Project::MSG_INFO);

		}

		switch ($this->outputFormat) {

			case 'default':

				$this->outputCustomFormat($codeSniffer);

				break;

			case 'xml':

				$codeSniffer->printXMLErrorReport($this->showWarnings);

				break;

			case 'checkstyle':

				$codeSniffer->printCheckstyleErrorReport($this->showWarnings);

				break;

			case 'csv':

				$codeSniffer->printCSVErrorReport($this->showWarnings);

				break;

			case 'report':

				$codeSniffer->printErrorReport($this->showWarnings);

				break;

			case 'summary':

				$codeSniffer->printErrorReportSummary($this->showWarnings);

				break;

			case 'doc':

				$codeSniffer->generateDocs($this->standard, $this->sniffs);

				break;

			default:

				$this->log('Unknown output format "' . $this->outputFormat . '"', Project::MSG_INFO);

				break;

		}

	}

	/**

	 * Outputs the results with a custom format

	 * @param PHP_CodeSniffer $codeSniffer

	 */

	protected function outputCustomFormat($codeSniffer) {

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

		$files = $report['files'];

		foreach ($files as $file => $attributes) {

			$errors = $attributes['errors'];

			$warnings = $attributes['warnings'];

			$messages = $attributes['messages'];

			if ($errors > 0) {

				$this->log($file . ': ' . $errors . ' error' . ($errors > 1 ? 's' : '') . ' detected', Project::MSG_ERR);

				$this->outputCustomFormatMessages($messages, 'ERROR');

			} else {

				$this->log($file . ': No syntax errors detected', Project::MSG_VERBOSE);

			}

			if ($warnings > 0) {

				$this->log($file . ': ' . $warnings . ' warning' . ($warnings > 1 ? 's' : '') . ' detected', Project::MSG_WARN);

				$this->outputCustomFormatMessages($messages, 'WARNING');

			}

		}

		$totalErrors = $report['totals']['errors'];

		$totalWarnings = $report['totals']['warnings'];

		$this->log(count($files) . ' files where checked', Project::MSG_INFO);

		if ($totalErrors > 0) {

			$this->log($totalErrors . ' error' . ($totalErrors > 1 ? 's' : '') . ' detected', Project::MSG_ERR);

		} else {

			$this->log('No syntax errors detected', Project::MSG_INFO);

		}

		if ($totalWarnings > 0) {

			$this->log($totalWarnings . ' warning' . ($totalWarnings > 1 ? 's' : '') . ' detected', Project::MSG_INFO);

		}

	}

	/**

	 * Outputs the messages of a specific type for one file

	 * @param array $messages

	 * @param string $type

	 */

	protected function outputCustomFormatMessages($messages, $type) {

		foreach ($messages as $line => $messagesPerLine) {

			foreach ($messagesPerLine as $column => $messagesPerColumn) {

				foreach ($messagesPerColumn as $message) {

					$msgType = $message['type'];

					if ($type == $msgType) {

						$logLevel = Project::MSG_INFO;

						if ($msgType == 'ERROR') {

							$logLevel = Project::MSG_ERR;

						} else if ($msgType == 'WARNING') {

							$logLevel = Project::MSG_WARN;

						}

						$text = $message['message'];

						$string = $msgType . ' in line ' . $line . ' column ' . $column . ': ' . $text;

						$this->log($string, $logLevel);

					}

				}

			}

		}

	}

}