1982 lines
63 KiB
PHP
1982 lines
63 KiB
PHP
<?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-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
|
|
*/
|
|
|
|
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 (class_exists('PHP_CodeSniffer_CLI', true) === false) {
|
|
throw new PHP_CodeSniffer_Exception('Class PHP_CodeSniffer_CLI 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-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 PHP_CodeSniffer
|
|
{
|
|
|
|
/**
|
|
* The file or directory that is currently being processed.
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $file = '';
|
|
|
|
/**
|
|
* The files that have been processed.
|
|
*
|
|
* @var array(PHP_CodeSniffer_File)
|
|
*/
|
|
protected $files = array();
|
|
|
|
/**
|
|
* The directory to search for sniffs in.
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $standardDir = '';
|
|
|
|
/**
|
|
* The CLI object controlling the run.
|
|
*
|
|
* @var string
|
|
*/
|
|
public $cli = null;
|
|
|
|
/**
|
|
* An array of sniffs that are being used to check files.
|
|
*
|
|
* @var array(PHP_CodeSniffer_Sniff)
|
|
*/
|
|
protected $listeners = array();
|
|
|
|
/**
|
|
* An array of rules from the ruleset.xml file.
|
|
*
|
|
* It may be empty, indicating that the ruleset does not override
|
|
* any of the default sniff settings.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $ruleset = 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 tokenizer debug information.
|
|
* 3: Print sniff 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.
|
|
* @param string $encoding The charset of the sniffed files.
|
|
* This is important for some reports that output
|
|
* with utf-8 encoding as you don't want it double
|
|
* encoding messages.
|
|
* @param bool $interactive If TRUE, will stop after each file with errors
|
|
* and wait for user input.
|
|
*
|
|
* @see process()
|
|
*/
|
|
public function __construct(
|
|
$verbosity=0,
|
|
$tabWidth=0,
|
|
$encoding='iso-8859-1',
|
|
$interactive=false
|
|
) {
|
|
if (defined('PHP_CODESNIFFER_VERBOSITY') === false) {
|
|
define('PHP_CODESNIFFER_VERBOSITY', $verbosity);
|
|
}
|
|
|
|
if (defined('PHP_CODESNIFFER_TAB_WIDTH') === false) {
|
|
define('PHP_CODESNIFFER_TAB_WIDTH', $tabWidth);
|
|
}
|
|
|
|
if (defined('PHP_CODESNIFFER_ENCODING') === false) {
|
|
define('PHP_CODESNIFFER_ENCODING', $encoding);
|
|
}
|
|
|
|
if (defined('PHP_CODESNIFFER_INTERACTIVE') === false) {
|
|
define('PHP_CODESNIFFER_INTERACTIVE', $interactive);
|
|
}
|
|
|
|
if (defined('PHPCS_DEFAULT_ERROR_SEV') === false) {
|
|
define('PHPCS_DEFAULT_ERROR_SEV', 5);
|
|
}
|
|
|
|
if (defined('PHPCS_DEFAULT_WARN_SEV') === false) {
|
|
define('PHPCS_DEFAULT_WARN_SEV', 5);
|
|
}
|
|
|
|
// Change into a directory that we know about to stop any
|
|
// relative path conflicts.
|
|
if (defined('PHPCS_CWD') === false) {
|
|
define('PHPCS_CWD', getcwd());
|
|
}
|
|
|
|
chdir(dirname(__FILE__).'/CodeSniffer/');
|
|
|
|
// Set default CLI object in case someone is running us
|
|
// without using the command line script.
|
|
$this->cli = new PHP_CodeSniffer_CLI();
|
|
$this->cli->errorSeverity = PHPCS_DEFAULT_ERROR_SEV;
|
|
$this->cli->warningSeverity = PHPCS_DEFAULT_WARN_SEV;
|
|
|
|
}//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(PHPCS_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()
|
|
|
|
|
|
/**
|
|
* Gets the array of ignore patterns.
|
|
*
|
|
* Optionally takes a listener to get ignore patterns specified
|
|
* for that sniff only.
|
|
*
|
|
* @param string $listener The listener to get patterns for. If NULL, all
|
|
* patterns are returned.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getIgnorePatterns($listener=null)
|
|
{
|
|
if ($listener === null) {
|
|
return $this->ignorePatterns;
|
|
}
|
|
|
|
if (isset($this->ignorePatterns[$listener]) === true) {
|
|
return $this->ignorePatterns[$listener];
|
|
}
|
|
|
|
return array();
|
|
|
|
}//end getIgnorePatterns()
|
|
|
|
|
|
/**
|
|
* Sets the internal CLI object.
|
|
*
|
|
* @param object $cli The CLI object controlling the run.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function setCli($cli)
|
|
{
|
|
$this->cli = $cli;
|
|
|
|
}//end setCli()
|
|
|
|
|
|
/**
|
|
* 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->ruleset = array();
|
|
$this->_tokenListeners = array(
|
|
'file' => array(),
|
|
'multifile' => array(),
|
|
);
|
|
|
|
// Ensure this option is enabled or else line endings will not always
|
|
// be detected properly for files created on a Mac with the /r line ending.
|
|
ini_set('auto_detect_line_endings', true);
|
|
|
|
if (PHP_CODESNIFFER_VERBOSITY > 0) {
|
|
// If this is a custom ruleset.xml file, load the standard name
|
|
// from the file. I know this looks a little ugly, but it is
|
|
// just when verbose output is on so we have to go to the effort
|
|
// of finding the correct name.
|
|
$standardName = basename($standard);
|
|
if (is_file($standard) === true) {
|
|
$ruleset = simplexml_load_file($standard);
|
|
if ($ruleset !== false) {
|
|
$standardName = (string) $ruleset['name'];
|
|
}
|
|
} else if (is_file(realpath(PHPCS_CWD.'/'.$standard)) === true) {
|
|
$ruleset = simplexml_load_file(realpath(PHPCS_CWD.'/'.$standard));
|
|
if ($ruleset !== false) {
|
|
$standardName = (string) $ruleset['name'];
|
|
}
|
|
}
|
|
|
|
echo "Registering sniffs in $standardName standard... ";
|
|
if (PHP_CODESNIFFER_VERBOSITY > 2) {
|
|
echo PHP_EOL;
|
|
}
|
|
}//end if
|
|
|
|
$this->setTokenListeners($standard, $sniffs);
|
|
$this->populateCustomRules();
|
|
$this->populateTokenListeners();
|
|
|
|
if (PHP_CODESNIFFER_VERBOSITY > 0) {
|
|
$numSniffs = count($this->listeners);
|
|
echo "DONE ($numSniffs sniffs registered)".PHP_EOL;
|
|
}
|
|
|
|
// The SVN pre-commit calls process() to init the sniffs
|
|
// and ruleset so there may not be any files to process.
|
|
// But this has to come after that initial setup.
|
|
if (empty($files) === true) {
|
|
return;
|
|
}
|
|
|
|
$reporting = new PHP_CodeSniffer_Reporting();
|
|
$cliValues = $this->cli->getCommandLineValues();
|
|
$showProgress = $cliValues['showProgress'];
|
|
|
|
if (PHP_CODESNIFFER_VERBOSITY > 0) {
|
|
$numSniffs = count($this->listeners);
|
|
echo 'Creating file list... ';
|
|
}
|
|
|
|
$todo = $this->getFilesToProcess($files, $local);
|
|
$numFiles = count($todo);
|
|
|
|
if (PHP_CODESNIFFER_VERBOSITY > 0) {
|
|
$numSniffs = count($this->listeners);
|
|
echo "DONE ($numFiles files in queue)".PHP_EOL;
|
|
}
|
|
|
|
$numProcessed = 0;
|
|
$dots = 0;
|
|
$maxLength = strlen($numFiles);
|
|
foreach ($todo as $file) {
|
|
$this->file = $file;
|
|
$phpcsFile = $this->processFile($file);
|
|
$numProcessed++;
|
|
|
|
if (PHP_CODESNIFFER_VERBOSITY > 0
|
|
|| PHP_CODESNIFFER_INTERACTIVE === true
|
|
|| $showProgress === false
|
|
) {
|
|
continue;
|
|
}
|
|
|
|
// Show progress information.
|
|
if ($phpcsFile === null) {
|
|
echo 'S';
|
|
} else {
|
|
$errors = $phpcsFile->getErrorCount();
|
|
$warnings = $phpcsFile->getWarningCount();
|
|
if ($errors > 0) {
|
|
echo 'E';
|
|
} else if ($warnings > 0) {
|
|
echo 'W';
|
|
} else {
|
|
echo '.';
|
|
}
|
|
}
|
|
|
|
$dots++;
|
|
if ($dots === 60) {
|
|
$padding = ($maxLength - strlen($numProcessed));
|
|
echo str_repeat(' ', $padding);
|
|
echo " $numProcessed / $numFiles".PHP_EOL;
|
|
$dots = 0;
|
|
}
|
|
}//end foreach
|
|
|
|
if (PHP_CODESNIFFER_VERBOSITY === 0
|
|
&& PHP_CODESNIFFER_INTERACTIVE === false
|
|
&& $showProgress === true
|
|
) {
|
|
echo PHP_EOL.PHP_EOL;
|
|
}
|
|
|
|
// Now process the multi-file sniffs, assuming there are
|
|
// multiple files being sniffed.
|
|
if (count($files) > 1 || is_dir($files[0]) === true) {
|
|
$this->processMulti();
|
|
}
|
|
|
|
}//end process()
|
|
|
|
|
|
/**
|
|
* Processes multi-file sniffs.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function processMulti()
|
|
{
|
|
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 processMulti()
|
|
|
|
|
|
/**
|
|
* Sets 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.
|
|
* If the standard is a file, will skip transversal and just load sniffs
|
|
* from the file.
|
|
*
|
|
* @param string $standard The name of the coding standard we are checking.
|
|
* Can also be a path to a custom standard dir
|
|
* containing a ruleset.xml file or can be a path
|
|
* to a custom ruleset file.
|
|
* @param array $sniffs The sniff names to restrict the allowed
|
|
* listeners to.
|
|
*
|
|
* @return void
|
|
* @throws PHP_CodeSniffer_Exception If the standard is not valid.
|
|
*/
|
|
public function setTokenListeners($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 if (is_file($standard) === true) {
|
|
// Might be a custom ruleset file.
|
|
$ruleset = simplexml_load_file($standard);
|
|
if ($ruleset === false) {
|
|
throw new PHP_CodeSniffer_Exception("Ruleset $standard is not valid");
|
|
}
|
|
|
|
if (basename($standard) === 'ruleset.xml') {
|
|
// The ruleset uses the generic name, so this may actually
|
|
// be a complete standard with it's own sniffs. By setting the
|
|
// the standardDir to be the directory, we will process both
|
|
// the directory (for custom sniffs) and the ruleset.xml file
|
|
// (as it uses the generic name) in getSniffFiles.
|
|
$this->standardDir = dirname($standard);
|
|
} else {
|
|
// This is a custom ruleset file with a custom name, so we have
|
|
// to assume there are no custom sniffs to go with this otherwise
|
|
// we'd be recursing through directories on every run, even if
|
|
// we don't need to.
|
|
$this->standardDir = $standard;
|
|
}
|
|
|
|
$standard = (string) $ruleset['name'];
|
|
} 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.
|
|
$path = realpath(PHPCS_CWD.'/'.$standard);
|
|
if (is_dir($path) === true) {
|
|
// This is a relative path to a custom standard.
|
|
$this->standardDir = $path;
|
|
$standard = basename($standard);
|
|
} else if (is_file($path) === true) {
|
|
// Might be a custom ruleset file.
|
|
$ruleset = simplexml_load_file($path);
|
|
if ($ruleset === false) {
|
|
throw new PHP_CodeSniffer_Exception("Ruleset $path is not valid");
|
|
}
|
|
|
|
// See comments in ELSE IF condition above for why we do this.
|
|
if (basename($path) === 'ruleset.xml') {
|
|
$this->standardDir = dirname($path);
|
|
} else {
|
|
$this->standardDir = $path;
|
|
}
|
|
|
|
$standard = (string) $ruleset['name'];
|
|
}
|
|
}
|
|
}//end if
|
|
|
|
$files = $this->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
|
|
|
|
$this->listeners = $listeners;
|
|
|
|
}//end setTokenListeners()
|
|
|
|
|
|
/**
|
|
* 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 function getSniffFiles($dir, $standard=null)
|
|
{
|
|
$ownSniffs = array();
|
|
$includedSniffs = array();
|
|
$excludedSniffs = array();
|
|
|
|
if (is_dir($dir) === true) {
|
|
$di = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir));
|
|
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
|
|
}//end if
|
|
|
|
if ($standard !== null) {
|
|
$rulesetPath = $dir;
|
|
if (is_dir($rulesetPath) === true) {
|
|
$rulesetPath .= '/ruleset.xml';
|
|
}
|
|
|
|
$ruleset = simplexml_load_file($rulesetPath);
|
|
if ($ruleset === false) {
|
|
throw new PHP_CodeSniffer_Exception("Ruleset $rulesetPath is not valid");
|
|
}
|
|
|
|
foreach ($ruleset->rule as $rule) {
|
|
$includedSniffs = array_merge($includedSniffs, $this->_expandRulesetReference($rule['ref']));
|
|
|
|
if (isset($rule->exclude) === true) {
|
|
foreach ($rule->exclude as $exclude) {
|
|
$excludedSniffs = array_merge($excludedSniffs, $this->_expandRulesetReference($exclude['name']));
|
|
}
|
|
}
|
|
}//end foreach
|
|
}//end if
|
|
|
|
$includedSniffs = array_unique($includedSniffs);
|
|
$excludedSniffs = array_unique($excludedSniffs);
|
|
|
|
// Merge our own sniff list with our externally 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 array_unique($files);
|
|
|
|
}//end getSniffFiles()
|
|
|
|
|
|
/**
|
|
* Expand a ruleset sniff reference into a list of sniff files.
|
|
*
|
|
* @param string $sniff The sniff reference from the rulset.xml file.
|
|
*
|
|
* @return array
|
|
* @throws PHP_CodeSniffer_Exception If the sniff reference is invalid.
|
|
*/
|
|
private function _expandRulesetReference($sniff)
|
|
{
|
|
$referencedSniffs = array();
|
|
|
|
// Ignore internal sniffs as they are used to only
|
|
// hide and change internal messages.
|
|
if (substr($sniff, 0, 9) === 'Internal.') {
|
|
return $referencedSniffs;
|
|
}
|
|
|
|
$isDir = false;
|
|
$path = $sniff;
|
|
if (is_dir($sniff) === true) {
|
|
// Referencing a custom standard.
|
|
$isDir = true;
|
|
$path = $sniff;
|
|
$sniff = basename($path);
|
|
} else if (is_file($sniff) === false) {
|
|
// See if this is a whole standard being referenced.
|
|
$path = realpath(dirname(__FILE__).'/CodeSniffer/Standards/'.$sniff);
|
|
if (is_dir($path) === true) {
|
|
$isDir = true;
|
|
} else {
|
|
// Work out the sniff path.
|
|
$parts = explode('.', $sniff);
|
|
if (count($parts) < 3) {
|
|
$error = "Referenced sniff $sniff does not exist";
|
|
throw new PHP_CodeSniffer_Exception($error);
|
|
}
|
|
|
|
$path = $parts[0].'/Sniffs/'.$parts[1].'/'.$parts[2].'Sniff.php';
|
|
$path = realpath(dirname(__FILE__).'/CodeSniffer/Standards/'.$path);
|
|
}
|
|
}//end if
|
|
|
|
if ($isDir === true) {
|
|
if (self::isInstalledStandard($sniff) === true) {
|
|
// We are referencing a coding standard.
|
|
$referencedSniffs = $this->getSniffFiles($path, $sniff);
|
|
$this->populateCustomRules($path);
|
|
} else {
|
|
// We are referencing a whole directory of sniffs.
|
|
$referencedSniffs = $this->getSniffFiles($path);
|
|
}
|
|
} else {
|
|
if (is_file($path) === false) {
|
|
$error = "Referenced sniff $sniff does not exist";
|
|
throw new PHP_CodeSniffer_Exception($error);
|
|
}
|
|
|
|
if (substr($path, -9) === 'Sniff.php') {
|
|
// A single sniff.
|
|
$referencedSniffs[] = $path;
|
|
} else {
|
|
// Assume an external ruleset.xml file.
|
|
$referencedSniffs = $this->getSniffFiles($path, $sniff);
|
|
}
|
|
}//end if
|
|
|
|
return $referencedSniffs;
|
|
|
|
}//end _expandRulesetReference()
|
|
|
|
|
|
/**
|
|
* Sets installed sniffs in the coding standard being used.
|
|
*
|
|
* @param string $standard The name of the coding standard we are checking.
|
|
* Can also be a path to a custom ruleset.xml file.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function populateCustomRules($standard=null)
|
|
{
|
|
if ($standard === null) {
|
|
$standard = $this->standardDir;
|
|
}
|
|
|
|
if (is_file($standard) === false) {
|
|
$standard .= '/ruleset.xml';
|
|
if (is_file($standard) === false) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
$ruleset = simplexml_load_file($standard);
|
|
foreach ($ruleset->rule as $rule) {
|
|
if (isset($rule['ref']) === false) {
|
|
continue;
|
|
}
|
|
|
|
$code = (string) $rule['ref'];
|
|
|
|
// Custom severity.
|
|
if (isset($rule->severity) === true) {
|
|
if (isset($this->ruleset[$code]) === false) {
|
|
$this->ruleset[$code] = array();
|
|
}
|
|
|
|
$this->ruleset[$code]['severity'] = (int) $rule->severity;
|
|
}
|
|
|
|
// Custom message.
|
|
if (isset($rule->message) === true) {
|
|
if (isset($this->ruleset[$code]) === false) {
|
|
$this->ruleset[$code] = array();
|
|
}
|
|
|
|
$this->ruleset[$code]['message'] = (string) $rule->message;
|
|
}
|
|
|
|
// Custom properties.
|
|
if (isset($rule->properties) === true) {
|
|
foreach ($rule->properties->property as $prop) {
|
|
if (isset($this->ruleset[$code]) === false) {
|
|
$this->ruleset[$code] = array(
|
|
'properties' => array(),
|
|
);
|
|
} else if (isset($this->ruleset[$code]['properties']) === false) {
|
|
$this->ruleset[$code]['properties'] = array();
|
|
}
|
|
|
|
$name = (string) $prop['name'];
|
|
if (isset($prop['type']) === true
|
|
&& (string) $prop['type'] === 'array'
|
|
) {
|
|
$value = (string) $prop['value'];
|
|
$this->ruleset[$code]['properties'][$name] = explode(',', $value);
|
|
} else {
|
|
$this->ruleset[$code]['properties'][$name] = (string) $prop['value'];
|
|
}
|
|
}
|
|
}//end if
|
|
|
|
// Ignore patterns.
|
|
foreach ($rule->{'exclude-pattern'} as $pattern) {
|
|
if (isset($this->ignorePatterns[$code]) === false) {
|
|
$this->ignorePatterns[$code] = array();
|
|
}
|
|
|
|
$this->ignorePatterns[$code][] = (string) $pattern;
|
|
}
|
|
}//end foreach
|
|
|
|
// Process custom ignore pattern rules.
|
|
foreach ($ruleset->{'exclude-pattern'} as $pattern) {
|
|
$this->ignorePatterns[] = (string) $pattern;
|
|
}
|
|
|
|
}//end populateCustomRules()
|
|
|
|
|
|
/**
|
|
* Populates the array of PHP_CodeSniffer_Sniff's for this file.
|
|
*
|
|
* @return void
|
|
* @throws PHP_CodeSniffer_Exception If sniff registration fails.
|
|
*/
|
|
public function populateTokenListeners()
|
|
{
|
|
// Construct a list of listeners indexed by token being listened for.
|
|
$this->_tokenListeners = array(
|
|
'file' => array(),
|
|
'multifile' => array(),
|
|
);
|
|
|
|
foreach ($this->listeners as $listenerClass) {
|
|
$listener = new $listenerClass();
|
|
|
|
// Work out the internal code for this sniff.
|
|
$parts = explode('_', $listenerClass);
|
|
$code = $parts[0].'.'.$parts[2].'.'.$parts[3];
|
|
$code = substr($code, 0, -5);
|
|
|
|
// Set custom properties.
|
|
if (isset($this->ruleset[$code]['properties']) === true) {
|
|
foreach ($this->ruleset[$code]['properties'] as $name => $value) {
|
|
// Special case for booleans.
|
|
if ($value === 'true') {
|
|
$value = true;
|
|
} else if ($value === 'false') {
|
|
$value = false;
|
|
}
|
|
|
|
$listener->$name = $value;
|
|
}
|
|
}
|
|
|
|
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()
|
|
|
|
|
|
/**
|
|
* Get a list of files that will be processed.
|
|
*
|
|
* If passed directories, this method will find all files within them.
|
|
* The method will also perform file extension and ignore pattern filtering.
|
|
*
|
|
* @param string $paths A list of file or directory paths to process.
|
|
* @param boolean $local If true, only process 1 level of files in directories
|
|
*
|
|
* @return array
|
|
* @throws Exception If there was an error opening a directory.
|
|
* @see shouldProcessFile()
|
|
*/
|
|
public function getFilesToProcess($paths, $local=false)
|
|
{
|
|
$files = array();
|
|
|
|
foreach ($paths as $path) {
|
|
if (is_dir($path) === true) {
|
|
if ($local === true) {
|
|
$di = new DirectoryIterator($path);
|
|
} else {
|
|
$di = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path));
|
|
}
|
|
|
|
foreach ($di as $file) {
|
|
// Check if the file exists after all symlinks are reolved.
|
|
$filePath = realpath($file->getPathname());
|
|
if ($filePath === false) {
|
|
continue;
|
|
}
|
|
|
|
if (is_dir($filePath) === true) {
|
|
continue;
|
|
}
|
|
|
|
if ($this->shouldProcessFile($file->getPathname()) === false) {
|
|
continue;
|
|
}
|
|
|
|
$files[] = $file->getPathname();
|
|
}//end foreach
|
|
} else {
|
|
if ($this->shouldIgnoreFile($path) === true) {
|
|
continue;
|
|
}
|
|
|
|
$files[] = $path;
|
|
}//end if
|
|
}//end foreach
|
|
|
|
return $files;
|
|
|
|
}//end getFilesToProcess()
|
|
|
|
|
|
/**
|
|
* Checks filtering rules to see if a file should be checked.
|
|
*
|
|
* Checks both file extension filters and path ignore filters.
|
|
*
|
|
* @param string $path The path to the file being checked.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function shouldProcessFile($path)
|
|
{
|
|
// Check that the file's extension is one we are checking.
|
|
// We are strict about checking the extension and we don't
|
|
// let files through with no extension or that start with a dot.
|
|
$fileName = basename($path);
|
|
$fileParts = explode('.', $fileName);
|
|
if ($fileParts[0] === $fileName || $fileParts[0] === '') {
|
|
return false;
|
|
}
|
|
|
|
// Checking multi-part file extensions, so need to create a
|
|
// complete extension list and make sure one is allowed.
|
|
$extensions = array();
|
|
array_shift($fileParts);
|
|
foreach ($fileParts as $part) {
|
|
$extensions[implode('.', $fileParts)] = 1;
|
|
array_shift($fileParts);
|
|
}
|
|
|
|
$matches = array_intersect_key($extensions, $this->allowedFileExtensions);
|
|
if (empty($matches) === true) {
|
|
return false;
|
|
}
|
|
|
|
// If the file's path matches one of our ignore patterns, skip it.
|
|
if ($this->shouldIgnoreFile($path) === true) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
|
|
}//end shouldProcessFile()
|
|
|
|
|
|
/**
|
|
* Checks filtering rules to see if a file should be ignored.
|
|
*
|
|
* @param string $path The path to the file being checked.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function shouldIgnoreFile($path)
|
|
{
|
|
foreach ($this->ignorePatterns as $pattern) {
|
|
if (is_array($pattern) === true) {
|
|
// A sniff specific ignore pattern.
|
|
continue;
|
|
}
|
|
|
|
$replacements = array(
|
|
'\\,' => ',',
|
|
'*' => '.*',
|
|
);
|
|
|
|
$pattern = strtr($pattern, $replacements);
|
|
if (preg_match("|{$pattern}|i", $path) === 1) {
|
|
return true;
|
|
}
|
|
}//end foreach
|
|
|
|
return false;
|
|
|
|
}//end shouldIgnoreFile()
|
|
|
|
|
|
/**
|
|
* 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. Returns the processed file object, or NULL
|
|
* if no file was processed due to error.
|
|
*
|
|
* @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 PHP_CodeSniffer_File
|
|
* @throws PHP_CodeSniffer_Exception If the file could not be processed.
|
|
* @see _processFile()
|
|
*/
|
|
public function processFile($file, $contents=null)
|
|
{
|
|
if ($contents === null && file_exists($file) === false) {
|
|
throw new PHP_CodeSniffer_Exception("Source file $file does not exist");
|
|
}
|
|
|
|
$filePath = realpath($file);
|
|
if ($filePath === false) {
|
|
$filePath = $file;
|
|
}
|
|
|
|
// 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 && is_readable($filePath) === true) {
|
|
$handle = fopen($filePath, '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($filePath).PHP_EOL;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
$phpcsFile = $this->_processFile($file, $contents);
|
|
} catch (Exception $e) {
|
|
$trace = $e->getTrace();
|
|
|
|
$filename = $trace[0]['args'][0];
|
|
if (is_object($filename) === true
|
|
&& get_class($filename) === 'PHP_CodeSniffer_File'
|
|
) {
|
|
$filename = $filename->getFilename();
|
|
} else 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();
|
|
}
|
|
}
|
|
} else if (is_string($filename) === false) {
|
|
$filename = (string) $filename;
|
|
}
|
|
|
|
$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->ruleset,
|
|
$this
|
|
);
|
|
|
|
$this->addFile($phpcsFile);
|
|
$phpcsFile->addError($error, null);
|
|
}//end try
|
|
|
|
if (PHP_CODESNIFFER_INTERACTIVE === false) {
|
|
return $phpcsFile;
|
|
}
|
|
|
|
/*
|
|
Running interactively.
|
|
Print the error report for the current file and then wait for user input.
|
|
*/
|
|
|
|
$reporting = new PHP_CodeSniffer_Reporting();
|
|
$cliValues = $this->cli->getCommandLineValues();
|
|
|
|
// Get current violations and then clear the list to make sure
|
|
// we only print violations for a single file each time.
|
|
$numErrors = null;
|
|
while ($numErrors !== 0) {
|
|
$filesViolations = $this->getFilesErrors();
|
|
$this->files = array();
|
|
|
|
$numErrors = $reporting->printReport(
|
|
'full',
|
|
$filesViolations,
|
|
$cliValues['showSources'],
|
|
null,
|
|
$cliValues['reportWidth']
|
|
);
|
|
|
|
if ($numErrors === 0) {
|
|
continue;
|
|
}
|
|
|
|
echo '<ENTER> to recheck, [s] to skip or [q] to quit : ';
|
|
$input = fgets(STDIN);
|
|
$input = trim($input);
|
|
|
|
switch ($input) {
|
|
case 's':
|
|
break;
|
|
case 'q':
|
|
exit(0);
|
|
break;
|
|
default:
|
|
// Repopulate the sniffs because some of them save their state
|
|
// and only clear it when the file changes, but we are rechecking
|
|
// the same file.
|
|
$this->populateTokenListeners();
|
|
$phpcsFile = $this->_processFile($file, $contents);
|
|
break;
|
|
}
|
|
}//end while
|
|
|
|
return $phpcsFile;
|
|
|
|
}//end processFile()
|
|
|
|
|
|
/**
|
|
* Process the sniffs for a single file.
|
|
*
|
|
* Does raw processing only. No interactive support or error checking.
|
|
*
|
|
* @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 PHP_CodeSniffer_File
|
|
* @see processFile()
|
|
*/
|
|
private function _processFile($file, $contents)
|
|
{
|
|
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->ruleset,
|
|
$this
|
|
);
|
|
$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 (PHP_CODESNIFFER_INTERACTIVE === false
|
|
&& 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;
|
|
}
|
|
|
|
return $phpcsFile;
|
|
|
|
}//end _processFile()
|
|
|
|
|
|
/**
|
|
* Gives collected violations for reports.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getFilesErrors()
|
|
{
|
|
$files = array();
|
|
foreach ($this->files as $file) {
|
|
$files[$file->getFilename()]
|
|
= array(
|
|
'warnings' => $file->getWarnings(),
|
|
'errors' => $file->getErrors(),
|
|
'numWarnings' => $file->getWarningCount(),
|
|
'numErrors' => $file->getErrorCount(),
|
|
);
|
|
}
|
|
|
|
return $files;
|
|
|
|
}//end getFilesErrors()
|
|
|
|
|
|
/**
|
|
* Generates documentation for a coding standard.
|
|
*
|
|
* @param string $standard The standard to generate docs for
|
|
* @param array $sniffs A list of sniffs to limit the docs to.
|
|
* @param string $generator The name of the generator class to use.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function generateDocs($standard, array $sniffs=array(), $generator='Text')
|
|
{
|
|
if (class_exists('PHP_CodeSniffer_DocGenerators_'.$generator, true) === false) {
|
|
throw new PHP_CodeSniffer_Exception('Class PHP_CodeSniffer_DocGenerators_'.$generator.' not found');
|
|
}
|
|
|
|
$class = "PHP_CodeSniffer_DocGenerators_$generator";
|
|
$generator = new $class($standard, $sniffs);
|
|
|
|
$generator->generate();
|
|
|
|
}//end generateDocs()
|
|
|
|
|
|
/**
|
|
* Returns the PHP_CodeSniffer file objects.
|
|
*
|
|
* @return array(PHP_CodeSniffer_File)
|
|
*/
|
|
public function getFiles()
|
|
{
|
|
return $this->files;
|
|
|
|
}//end getFiles()
|
|
|
|
|
|
/**
|
|
* Gets the array of PHP_CodeSniffer_Sniff's.
|
|
*
|
|
* @return array(PHP_CodeSniffer_Sniff)
|
|
*/
|
|
public function getSniffs()
|
|
{
|
|
return $this->listeners;
|
|
|
|
}//end getSniffs()
|
|
|
|
|
|
/**
|
|
* Gets the array of PHP_CodeSniffer_Sniff's indexed by token type.
|
|
*
|
|
* @return array()
|
|
*/
|
|
public function getTokenSniffs()
|
|
{
|
|
return $this->_tokenListeners;
|
|
|
|
}//end getTokenSniffs()
|
|
|
|
|
|
/**
|
|
* Takes a token produced from <code>token_get_all()</code> and produces a
|
|
* more uniform token.
|
|
*
|
|
* Note that this method also resolves T_STRING tokens into more descrete
|
|
* types, therefore there is no need to call resolveTstringToken()
|
|
*
|
|
* @param string|array $token The token to convert.
|
|
*
|
|
* @return array The new token.
|
|
*/
|
|
public static function standardiseToken($token)
|
|
{
|
|
if (is_array($token) === false) {
|
|
$newToken = self::resolveSimpleToken($token);
|
|
} else {
|
|
switch ($token[0]) {
|
|
case T_STRING:
|
|
// Some T_STRING tokens can be more specific.
|
|
$newToken = self::resolveTstringToken($token);
|
|
break;
|
|
case T_CURLY_OPEN:
|
|
$newToken = array(
|
|
'code' => T_OPEN_CURLY_BRACKET,
|
|
'content' => $token[1],
|
|
'type' => 'T_OPEN_CURLY_BRACKET',
|
|
);
|
|
break;
|
|
default:
|
|
$newToken = array(
|
|
'code' => $token[0],
|
|
'content' => $token[1],
|
|
'type' => token_name($token[0]),
|
|
);
|
|
break;
|
|
}//end switch
|
|
}//end if
|
|
|
|
return $newToken;
|
|
|
|
}//end standardiseToken()
|
|
|
|
|
|
/**
|
|
* Converts T_STRING tokens into more usable token names.
|
|
*
|
|
* The token should be produced using the token_get_all() function.
|
|
* Currently, not all T_STRING tokens are converted.
|
|
*
|
|
* @param string|array $token The T_STRING token to convert as constructed
|
|
* by token_get_all().
|
|
*
|
|
* @return array The new token.
|
|
*/
|
|
public static function resolveTstringToken(array $token)
|
|
{
|
|
$newToken = array();
|
|
switch (strtolower($token[1])) {
|
|
case 'false':
|
|
$newToken['type'] = 'T_FALSE';
|
|
break;
|
|
case 'true':
|
|
$newToken['type'] = 'T_TRUE';
|
|
break;
|
|
case 'null':
|
|
$newToken['type'] = 'T_NULL';
|
|
break;
|
|
case 'self':
|
|
$newToken['type'] = 'T_SELF';
|
|
break;
|
|
case 'parent':
|
|
$newToken['type'] = 'T_PARENT';
|
|
break;
|
|
default:
|
|
$newToken['type'] = 'T_STRING';
|
|
break;
|
|
}
|
|
|
|
$newToken['code'] = constant($newToken['type']);
|
|
$newToken['content'] = $token[1];
|
|
|
|
return $newToken;
|
|
|
|
}//end resolveTstringToken()
|
|
|
|
|
|
/**
|
|
* Converts simple tokens into a format that conforms to complex tokens
|
|
* produced by token_get_all().
|
|
*
|
|
* Simple tokens are tokens that are not in array form when produced from
|
|
* token_get_all().
|
|
*
|
|
* @param string $token The simple token to convert.
|
|
*
|
|
* @return array The new token in array format.
|
|
*/
|
|
public static function resolveSimpleToken($token)
|
|
{
|
|
$newToken = array();
|
|
|
|
switch ($token) {
|
|
case '{':
|
|
$newToken['type'] = 'T_OPEN_CURLY_BRACKET';
|
|
break;
|
|
case '}':
|
|
$newToken['type'] = 'T_CLOSE_CURLY_BRACKET';
|
|
break;
|
|
case '[':
|
|
$newToken['type'] = 'T_OPEN_SQUARE_BRACKET';
|
|
break;
|
|
case ']':
|
|
$newToken['type'] = 'T_CLOSE_SQUARE_BRACKET';
|
|
break;
|
|
case '(':
|
|
$newToken['type'] = 'T_OPEN_PARENTHESIS';
|
|
break;
|
|
case ')':
|
|
$newToken['type'] = 'T_CLOSE_PARENTHESIS';
|
|
break;
|
|
case ':':
|
|
$newToken['type'] = 'T_COLON';
|
|
break;
|
|
case '.':
|
|
$newToken['type'] = 'T_STRING_CONCAT';
|
|
break;
|
|
case '?':
|
|
$newToken['type'] = 'T_INLINE_THEN';
|
|
break;
|
|
case ';':
|
|
$newToken['type'] = 'T_SEMICOLON';
|
|
break;
|
|
case '=':
|
|
$newToken['type'] = 'T_EQUAL';
|
|
break;
|
|
case '*':
|
|
$newToken['type'] = 'T_MULTIPLY';
|
|
break;
|
|
case '/':
|
|
$newToken['type'] = 'T_DIVIDE';
|
|
break;
|
|
case '+':
|
|
$newToken['type'] = 'T_PLUS';
|
|
break;
|
|
case '-':
|
|
$newToken['type'] = 'T_MINUS';
|
|
break;
|
|
case '%':
|
|
$newToken['type'] = 'T_MODULUS';
|
|
break;
|
|
case '^':
|
|
$newToken['type'] = 'T_POWER';
|
|
break;
|
|
case '&':
|
|
$newToken['type'] = 'T_BITWISE_AND';
|
|
break;
|
|
case '|':
|
|
$newToken['type'] = 'T_BITWISE_OR';
|
|
break;
|
|
case '<':
|
|
$newToken['type'] = 'T_LESS_THAN';
|
|
break;
|
|
case '>':
|
|
$newToken['type'] = 'T_GREATER_THAN';
|
|
break;
|
|
case '!':
|
|
$newToken['type'] = 'T_BOOLEAN_NOT';
|
|
break;
|
|
case ',':
|
|
$newToken['type'] = 'T_COMMA';
|
|
break;
|
|
case '@':
|
|
$newToken['type'] = 'T_ASPERAND';
|
|
break;
|
|
case '$':
|
|
$newToken['type'] = 'T_DOLLAR';
|
|
break;
|
|
case '`':
|
|
$newToken['type'] = 'T_BACKTICK';
|
|
break;
|
|
default:
|
|
$newToken['type'] = 'T_NONE';
|
|
break;
|
|
}//end switch
|
|
|
|
$newToken['code'] = constant($newToken['type']);
|
|
$newToken['content'] = $token;
|
|
|
|
return $newToken;
|
|
|
|
}//end resolveSimpleToken()
|
|
|
|
|
|
/**
|
|
* Returns true if the specified string is in the camel caps format.
|
|
*
|
|
* @param string $string The string the verify.
|
|
* @param boolean $classFormat If true, check to see if the string is in the
|
|
* class format. Class format strings must start
|
|
* with a capital letter and contain no
|
|
* underscores.
|
|
* @param boolean $public If true, the first character in the string
|
|
* must be an a-z character. If false, the
|
|
* character must be an underscore. This
|
|
* argument is only applicable if $classFormat
|
|
* is false.
|
|
* @param boolean $strict If true, the string must not have two captial
|
|
* letters next to each other. If false, a
|
|
* relaxed camel caps policy is used to allow
|
|
* for acronyms.
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public static function isCamelCaps(
|
|
$string,
|
|
$classFormat=false,
|
|
$public=true,
|
|
$strict=true
|
|
) {
|
|
// Check the first character first.
|
|
if ($classFormat === false) {
|
|
if ($public === false) {
|
|
$legalFirstChar = '[_][a-z]';
|
|
} else {
|
|
$legalFirstChar = '[a-z]';
|
|
}
|
|
} else {
|
|
$legalFirstChar = '[A-Z]';
|
|
}
|
|
|
|
if (preg_match("|^$legalFirstChar|", $string) === 0) {
|
|
return false;
|
|
}
|
|
|
|
// Check that the name only contains legal characters.
|
|
$legalChars = 'a-zA-Z0-9';
|
|
if (preg_match("|[^$legalChars]|", substr($string, 1)) > 0) {
|
|
return false;
|
|
}
|
|
|
|
if ($strict === true) {
|
|
// Check that there are not two captial letters next to each other.
|
|
$length = strlen($string);
|
|
$lastCharWasCaps = $classFormat;
|
|
|
|
for ($i = 1; $i < $length; $i++) {
|
|
$ascii = ord($string{$i});
|
|
if ($ascii >= 48 && $ascii <= 57) {
|
|
// The character is a number, so it cant be a captial.
|
|
$isCaps = false;
|
|
} else {
|
|
if (strtoupper($string{$i}) === $string{$i}) {
|
|
$isCaps = true;
|
|
} else {
|
|
$isCaps = false;
|
|
}
|
|
}
|
|
|
|
if ($isCaps === true && $lastCharWasCaps === true) {
|
|
return false;
|
|
}
|
|
|
|
$lastCharWasCaps = $isCaps;
|
|
}
|
|
}//end if
|
|
|
|
return true;
|
|
|
|
}//end isCamelCaps()
|
|
|
|
|
|
/**
|
|
* Returns true if the specified string is in the underscore caps format.
|
|
*
|
|
* @param string $string The string to verify.
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public static function isUnderscoreName($string)
|
|
{
|
|
// If there are space in the name, it can't be valid.
|
|
if (strpos($string, ' ') !== false) {
|
|
return false;
|
|
}
|
|
|
|
$validName = true;
|
|
$nameBits = explode('_', $string);
|
|
|
|
if (preg_match('|^[A-Z]|', $string) === 0) {
|
|
// Name does not begin with a capital letter.
|
|
$validName = false;
|
|
} else {
|
|
foreach ($nameBits as $bit) {
|
|
if ($bit === '') {
|
|
continue;
|
|
}
|
|
|
|
if ($bit{0} !== strtoupper($bit{0})) {
|
|
$validName = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $validName;
|
|
|
|
}//end isUnderscoreName()
|
|
|
|
|
|
/**
|
|
* Returns a valid variable type for param/var tag.
|
|
*
|
|
* If type is not one of the standard type, it must be a custom type.
|
|
* Returns the correct type name suggestion if type name is invalid.
|
|
*
|
|
* @param string $varType The variable type to process.
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function suggestType($varType)
|
|
{
|
|
if ($varType === '') {
|
|
return '';
|
|
}
|
|
|
|
if (in_array($varType, self::$allowedTypes) === true) {
|
|
return $varType;
|
|
} else {
|
|
$lowerVarType = strtolower($varType);
|
|
switch ($lowerVarType) {
|
|
case 'bool':
|
|
return 'boolean';
|
|
case 'double':
|
|
case 'real':
|
|
return 'float';
|
|
case 'int':
|
|
return 'integer';
|
|
case 'array()':
|
|
return 'array';
|
|
}//end switch
|
|
|
|
if (strpos($lowerVarType, 'array(') !== false) {
|
|
// Valid array declaration:
|
|
// array, array(type), array(type1 => type2).
|
|
$matches = array();
|
|
$pattern = '/^array\(\s*([^\s^=^>]*)(\s*=>\s*(.*))?\s*\)/i';
|
|
if (preg_match($pattern, $varType, $matches) !== 0) {
|
|
$type1 = '';
|
|
if (isset($matches[1]) === true) {
|
|
$type1 = $matches[1];
|
|
}
|
|
|
|
$type2 = '';
|
|
if (isset($matches[3]) === true) {
|
|
$type2 = $matches[3];
|
|
}
|
|
|
|
$type1 = self::suggestType($type1);
|
|
$type2 = self::suggestType($type2);
|
|
if ($type2 !== '') {
|
|
$type2 = ' => '.$type2;
|
|
}
|
|
|
|
return "array($type1$type2)";
|
|
} else {
|
|
return 'array';
|
|
}//end if
|
|
} else if (in_array($lowerVarType, self::$allowedTypes) === true) {
|
|
// A valid type, but not lower cased.
|
|
return $lowerVarType;
|
|
} else {
|
|
// Must be a custom type name.
|
|
return $varType;
|
|
}//end if
|
|
}//end if
|
|
|
|
}//end suggestType()
|
|
|
|
|
|
/**
|
|
* Get a list of all coding standards installed.
|
|
*
|
|
* Coding standards are directories located in the
|
|
* CodeSniffer/Standards directory. Valid coding standards
|
|
* include a Sniffs subdirectory.
|
|
*
|
|
* @param boolean $includeGeneric If true, the special "Generic"
|
|
* coding standard will be included
|
|
* if installed.
|
|
* @param string $standardsDir A specific directory to look for standards
|
|
* in. If not specified, PHP_CodeSniffer will
|
|
* look in its default location.
|
|
*
|
|
* @return array
|
|
* @see isInstalledStandard()
|
|
*/
|
|
public static function getInstalledStandards(
|
|
$includeGeneric=false,
|
|
$standardsDir=''
|
|
) {
|
|
$installedStandards = array();
|
|
|
|
if ($standardsDir === '') {
|
|
$standardsDir = dirname(__FILE__).'/CodeSniffer/Standards';
|
|
}
|
|
|
|
$di = new DirectoryIterator($standardsDir);
|
|
foreach ($di as $file) {
|
|
if ($file->isDir() === true && $file->isDot() === false) {
|
|
$filename = $file->getFilename();
|
|
|
|
// Ignore the special "Generic" standard.
|
|
if ($includeGeneric === false && $filename === 'Generic') {
|
|
continue;
|
|
}
|
|
|
|
// Valid coding standard dirs include a standard class.
|
|
$csFile = $file->getPathname().'/ruleset.xml';
|
|
if (is_file($csFile) === true) {
|
|
// We found a coding standard directory.
|
|
$installedStandards[] = $filename;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $installedStandards;
|
|
|
|
}//end getInstalledStandards()
|
|
|
|
|
|
/**
|
|
* Determine if a standard is installed.
|
|
*
|
|
* Coding standards are directories located in the
|
|
* CodeSniffer/Standards directory. Valid coding standards
|
|
* include a Sniffs subdirectory.
|
|
*
|
|
* @param string $standard The name of the coding standard.
|
|
*
|
|
* @return boolean
|
|
* @see getInstalledStandards()
|
|
*/
|
|
public static function isInstalledStandard($standard)
|
|
{
|
|
$standardDir = dirname(__FILE__);
|
|
$standardDir .= '/CodeSniffer/Standards/'.$standard;
|
|
if (is_file($standardDir.'/ruleset.xml') === true) {
|
|
return true;
|
|
} else {
|
|
// This could be a custom standard, installed outside our
|
|
// standards directory.
|
|
$ruleset = rtrim($standard, ' /\\').DIRECTORY_SEPARATOR.'ruleset.xml';
|
|
if (is_file($ruleset) === true) {
|
|
return true;
|
|
}
|
|
|
|
// Might also be an actual ruleset file itself.
|
|
// If it has an XML extension, let's at least try it.
|
|
if (is_file($standard) === true
|
|
&& substr(strtolower($standard), -4) === '.xml'
|
|
) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
|
|
}//end isInstalledStandard()
|
|
|
|
|
|
/**
|
|
* Get a single config value.
|
|
*
|
|
* Config data is stored in the data dir, in a file called
|
|
* CodeSniffer.conf. It is a simple PHP array.
|
|
*
|
|
* @param string $key The name of the config value.
|
|
*
|
|
* @return string
|
|
* @see setConfigData()
|
|
* @see getAllConfigData()
|
|
*/
|
|
public static function getConfigData($key)
|
|
{
|
|
$phpCodeSnifferConfig = self::getAllConfigData();
|
|
|
|
if ($phpCodeSnifferConfig === null) {
|
|
return null;
|
|
}
|
|
|
|
if (isset($phpCodeSnifferConfig[$key]) === false) {
|
|
return null;
|
|
}
|
|
|
|
return $phpCodeSnifferConfig[$key];
|
|
|
|
}//end getConfigData()
|
|
|
|
|
|
/**
|
|
* Set a single config value.
|
|
*
|
|
* Config data is stored in the data dir, in a file called
|
|
* CodeSniffer.conf. It is a simple PHP array.
|
|
*
|
|
* @param string $key The name of the config value.
|
|
* @param string|null $value The value to set. If null, the config
|
|
* entry is deleted, reverting it to the
|
|
* default value.
|
|
* @param boolean $temp Set this config data temporarily for this
|
|
* script run. This will not write the config
|
|
* data to the config file.
|
|
*
|
|
* @return boolean
|
|
* @see getConfigData()
|
|
* @throws PHP_CodeSniffer_Exception If the config file can not be written.
|
|
*/
|
|
public static function setConfigData($key, $value, $temp=false)
|
|
{
|
|
if ($temp === false) {
|
|
$configFile = dirname(__FILE__).'/CodeSniffer.conf';
|
|
if (is_file($configFile) === false) {
|
|
$configFile = '\php\pear\data/PHP_CodeSniffer/CodeSniffer.conf';
|
|
}
|
|
|
|
if (is_file($configFile) === true
|
|
&& is_writable($configFile) === false
|
|
) {
|
|
$error = "Config file $configFile is not writable";
|
|
throw new PHP_CodeSniffer_Exception($error);
|
|
}
|
|
}
|
|
|
|
$phpCodeSnifferConfig = self::getAllConfigData();
|
|
|
|
if ($value === null) {
|
|
if (isset($phpCodeSnifferConfig[$key]) === true) {
|
|
unset($phpCodeSnifferConfig[$key]);
|
|
}
|
|
} else {
|
|
$phpCodeSnifferConfig[$key] = $value;
|
|
}
|
|
|
|
if ($temp === false) {
|
|
$output = '<'.'?php'."\n".' $phpCodeSnifferConfig = ';
|
|
$output .= var_export($phpCodeSnifferConfig, true);
|
|
$output .= "\n?".'>';
|
|
|
|
if (file_put_contents($configFile, $output) === false) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
$GLOBALS['PHP_CODESNIFFER_CONFIG_DATA'] = $phpCodeSnifferConfig;
|
|
|
|
return true;
|
|
|
|
}//end setConfigData()
|
|
|
|
|
|
/**
|
|
* Get all config data in an array.
|
|
*
|
|
* @return string
|
|
* @see getConfigData()
|
|
*/
|
|
public static function getAllConfigData()
|
|
{
|
|
if (isset($GLOBALS['PHP_CODESNIFFER_CONFIG_DATA']) === true) {
|
|
return $GLOBALS['PHP_CODESNIFFER_CONFIG_DATA'];
|
|
}
|
|
|
|
$configFile = dirname(__FILE__).'/CodeSniffer.conf';
|
|
if (is_file($configFile) === false) {
|
|
$configFile = '\php\pear\data/PHP_CodeSniffer/CodeSniffer.conf';
|
|
}
|
|
|
|
if (is_file($configFile) === false) {
|
|
return null;
|
|
}
|
|
|
|
include $configFile;
|
|
$GLOBALS['PHP_CODESNIFFER_CONFIG_DATA'] = $phpCodeSnifferConfig;
|
|
return $GLOBALS['PHP_CODESNIFFER_CONFIG_DATA'];
|
|
|
|
}//end getAllConfigData()
|
|
|
|
|
|
}//end class
|
|
|
|
?>
|