466 lines
16 KiB
PHP
Executable File
466 lines
16 KiB
PHP
Executable File
<?php
|
|
|
|
/**
|
|
* CodeIgniter_Sniffs_Strings_DoubleQuoteUsageSniff.
|
|
*
|
|
* PHP version 5
|
|
*
|
|
* @category PHP
|
|
* @package PHP_CodeSniffer
|
|
* @author Thomas Ernest <thomas.ernest@baobaz.com>
|
|
* @copyright 2011 Thomas Ernest
|
|
* @license http://thomas.ernest.fr/developement/php_cs/licence GNU General Public License
|
|
* @link http://pear.php.net/package/PHP_CodeSniffer
|
|
*/
|
|
|
|
namespace CodeIgniter\Sniffs\Strings;
|
|
|
|
use PHP_CodeSniffer\Sniffs\Sniff;
|
|
use PHP_CodeSniffer\Files\File;
|
|
use Exception;
|
|
|
|
/**
|
|
* CodeIgniter_Sniffs_Strings_DoubleQuoteUsageSniff.
|
|
*
|
|
* Ensures that double-quoted strings are used only to parse variables,
|
|
* to avoid escape characters before single quotes or for chars that need
|
|
* to be interpreted like \r, \n or \t.
|
|
* If a double-quoted string contain both single and double quotes
|
|
* but no variable, then a warning is raised to encourage the use of
|
|
* single-quoted strings.
|
|
*
|
|
* @category PHP
|
|
* @package PHP_CodeSniffer
|
|
* @author Thomas Ernest <thomas.ernest@baobaz.com>
|
|
* @copyright 2011 Thomas Ernest
|
|
* @license http://thomas.ernest.fr/developement/php_cs/licence GNU General Public License
|
|
* @link http://pear.php.net/package/PHP_CodeSniffer
|
|
*/
|
|
class VariableUsageSniff implements Sniff
|
|
{
|
|
/**
|
|
* Returns an array of tokens this test wants to listen for.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function register()
|
|
{
|
|
/*
|
|
return array(
|
|
T_DOUBLE_QUOTED_STRING,
|
|
T_CONSTANT_ENCAPSED_STRING,
|
|
);
|
|
*/
|
|
return array();
|
|
}//end register()
|
|
|
|
|
|
/**
|
|
* Processes this test, when one of its tokens is encountered.
|
|
*
|
|
* @param File $phpcsFile The current file being scanned.
|
|
* @param int $stackPtr The position of the current token
|
|
* in the stack passed in $tokens.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function process(File $phpcsFile, $stackPtr)
|
|
{
|
|
$tokens = $phpcsFile->getTokens();
|
|
$string = $tokens[$stackPtr]['content'];
|
|
// makes sure that it is about a double quote string,
|
|
// since variables are not parsed out of double quoted string
|
|
$openDblQtStr = substr($string, 0, 1);
|
|
if (0 === strcmp($openDblQtStr, '"')) {
|
|
$this->processDoubleQuotedString($phpcsFile, $stackPtr, $string);
|
|
} else if (0 === strcmp($openDblQtStr, "'")) {
|
|
$this->processSingleQuotedString($phpcsFile, $stackPtr, $string);
|
|
}
|
|
}//end process()
|
|
|
|
|
|
/**
|
|
* Processes this test, when the token encountered is a double-quoted string.
|
|
*
|
|
* @param File $phpcsFile The current file being scanned.
|
|
* @param int $stackPtr The position of the current token
|
|
* in the stack passed in $tokens.
|
|
* @param string $dblQtString The double-quoted string content,
|
|
* i.e. without quotes.
|
|
*
|
|
* @return void
|
|
*/
|
|
protected function processDoubleQuotedString (File $phpcsFile, $stackPtr, $dblQtString)
|
|
{
|
|
$variableFound = FALSE;
|
|
$strTokens = token_get_all('<?php '.$dblQtString);
|
|
$strPtr = 1; // skip php opening tag added by ourselves
|
|
$requireDblQuotes = FALSE;
|
|
while ($strPtr < count($strTokens)) {
|
|
$strToken = $strTokens[$strPtr];
|
|
if (is_array($strToken)) {
|
|
if (in_array($strToken[0], array(T_DOLLAR_OPEN_CURLY_BRACES, T_CURLY_OPEN))) {
|
|
$strPtr++;
|
|
try {
|
|
$this->_parseVariable($strTokens, $strPtr);
|
|
} catch (Exception $err) {
|
|
$error = 'There is no variable, object nor array between curly braces. Please use the escape char for $ or {.';
|
|
$phpcsFile->addError($error, $stackPtr, 234);
|
|
}
|
|
$variableFound = TRUE;
|
|
if ('}' !== $strTokens[$strPtr]) {
|
|
$error = 'There is no matching closing curly brace.';
|
|
$phpcsFile->addError($error, $stackPtr, 345);
|
|
}
|
|
// don't move forward, since it will be done in the main loop
|
|
// $strPtr++;
|
|
} else if (T_VARIABLE === $strToken[0]) {
|
|
$variableFound = TRUE;
|
|
$error = "Variable {$strToken[1]} in double-quoted strings should be enclosed with curly braces. Please consider {{$strToken[1]}}";
|
|
$phpcsFile->addError($error, $stackPtr, 456);
|
|
}
|
|
}
|
|
$strPtr++;
|
|
}
|
|
return $variableFound;
|
|
}//end processDoubleQuotedString()
|
|
|
|
|
|
/**
|
|
* Processes this test, when the token encountered is a single-quoted string.
|
|
*
|
|
* @param File $phpcsFile The current file being scanned.
|
|
* @param int $stackPtr The position of the current token
|
|
* in the stack passed in $tokens.
|
|
* @param string $sglQtString The single-quoted string content,
|
|
* i.e. without quotes.
|
|
*
|
|
* @return void
|
|
*/
|
|
protected function processSingleQuotedString (File $phpcsFile, $stackPtr, $sglQtString)
|
|
{
|
|
$variableFound = FALSE;
|
|
$strTokens = token_get_all('<?php '.$sglQtString);
|
|
$strPtr = 1; // skip php opening tag added by ourselves
|
|
while ($strPtr < count($strTokens)) {
|
|
$strToken = $strTokens[$strPtr];
|
|
if (is_array($strToken)) {
|
|
if (T_VARIABLE === $strToken[0]) {
|
|
$error = "Variables like {$strToken[1]} should be in double-quoted strings only.";
|
|
$phpcsFile->addError($error, $stackPtr);
|
|
}
|
|
}
|
|
$strPtr++;
|
|
}
|
|
return $variableFound;
|
|
}//end processSingleQuotedString()
|
|
|
|
/**
|
|
* Grammar rule to parse the use of a variable. Please notice that it
|
|
* doesn't manage the leading $.
|
|
*
|
|
* _parseVariable ::= <variable>
|
|
* | <variable>_parseObjectAttribute()
|
|
* | <variable>_parseArrayIndexes()
|
|
*
|
|
* @exception Exception raised if $strTokens starting from $strPtr
|
|
* doesn't matched the rule.
|
|
*
|
|
* @param array $strTokens Tokens to parse.
|
|
* @param int $strPtr Pointer to the token where parsing starts.
|
|
*
|
|
* @return array The attribute name associated to index 'var', an array with
|
|
* indexes 'obj' and 'attr' or an array with indexes 'arr' and 'idx'.
|
|
*/
|
|
private function _parseVariable ($strTokens, &$strPtr)
|
|
{
|
|
if ( ! in_array($strTokens[$strPtr][0], array(T_VARIABLE, T_STRING_VARNAME))) {
|
|
throw new Exception ('Expected variable name.');
|
|
}
|
|
$var = $strTokens[$strPtr][1];
|
|
$strPtr++;
|
|
$startStrPtr = $strPtr;
|
|
try {
|
|
$attr = $this->_parseObjectAttribute($strTokens, $strPtr);
|
|
return array ('obj' => $var, 'attr' => $attr);
|
|
} catch (Exception $err) {
|
|
if ($strPtr !== $startStrPtr) {
|
|
throw $err;
|
|
}
|
|
}
|
|
try {
|
|
$idx = $this->_parseArrayIndexes($strTokens, $strPtr);
|
|
return array ('arr' => $var, 'idx' => $idx);
|
|
} catch (Exception $err) {
|
|
if ($strPtr !== $startStrPtr) {
|
|
throw $err;
|
|
}
|
|
}
|
|
return array ('var' => $var);
|
|
}//end _parseVariable()
|
|
|
|
|
|
/**
|
|
* Grammar rule to parse the use of an object attribute.
|
|
*
|
|
* _parseObjectAttribute ::= -><attribute>
|
|
* | -><attribute>_parseObjectAttribute()
|
|
* | -><attribute>_parseArrayIndexes()
|
|
*
|
|
* @exception Exception raised if $strTokens starting from $strPtr
|
|
* doesn't matched the rule.
|
|
*
|
|
* @param array $strTokens Tokens to parse.
|
|
* @param int $strPtr Pointer to the token where parsing starts.
|
|
*
|
|
* @return mixed The attribute name as a string, an array with indexes
|
|
* 'obj' and 'attr' or an array with indexes 'arr' and 'idx'.
|
|
*/
|
|
private function _parseObjectAttribute ($strTokens, &$strPtr)
|
|
{
|
|
if (T_OBJECT_OPERATOR !== $strTokens[$strPtr][0]) {
|
|
throw new Exception ('Expected ->.');
|
|
}
|
|
$strPtr++;
|
|
if (T_STRING !== $strTokens[$strPtr][0]) {
|
|
throw new Exception ('Expected an object attribute.');
|
|
}
|
|
$attr = $strTokens[$strPtr][1];
|
|
$strPtr++;
|
|
$startStrPtr = $strPtr;
|
|
try {
|
|
$sub_attr = $this->_parseObjectAttribute($strTokens, $strPtr);
|
|
return array ('obj' => $attr, 'attr' => $sub_attr);
|
|
} catch (Exception $err) {
|
|
if ($strPtr !== $startStrPtr) {
|
|
throw $err;
|
|
}
|
|
}
|
|
try {
|
|
$idx = $this->_parseArrayIndexes($strTokens, $strPtr);
|
|
return array ('arr' => $attr, 'idx' => $idx);
|
|
} catch (Exception $err) {
|
|
if ($strPtr !== $startStrPtr) {
|
|
throw $err;
|
|
}
|
|
}
|
|
return $attr;
|
|
}//end _parseObjectAttribute()
|
|
|
|
|
|
/**
|
|
* Grammar rule to parse the use of one or more array indexes.
|
|
*
|
|
* _parseArrayIndexes ::= _parseArrayIndex()+
|
|
*
|
|
* @exception Exception raised if $strTokens starting from $strPtr
|
|
* doesn't matched the rule.
|
|
*
|
|
* @param array $strTokens Tokens to parse.
|
|
* @param int $strPtr Pointer to the token where parsing starts.
|
|
*
|
|
* @return array Indexes in the same order as in the string.
|
|
*/
|
|
private function _parseArrayIndexes ($strTokens, &$strPtr)
|
|
{
|
|
$indexes = array($this->_parseArrayIndex($strTokens, $strPtr));
|
|
try {
|
|
while (1) {
|
|
$startStrPtr = $strPtr;
|
|
$indexes [] = $this->_parseArrayIndex($strTokens, $strPtr);
|
|
}
|
|
} catch (Exception $err) {
|
|
if (0 !== ($strPtr - $startStrPtr)) {
|
|
throw $err;
|
|
}
|
|
return $indexes;
|
|
}
|
|
}//end _parseArrayIndexes()
|
|
|
|
|
|
/**
|
|
* Grammar rule to parse the use of array index.
|
|
*
|
|
* _parseArrayIndex ::= [<index>]
|
|
*
|
|
* @exception Exception raised if $strTokens starting from $strPtr
|
|
* doesn't matched the rule.
|
|
*
|
|
* @param array $strTokens Tokens to parse.
|
|
* @param int $strPtr Pointer to the token where parsing starts.
|
|
*
|
|
* @return string Index between the 2 square brackets
|
|
*/
|
|
private function _parseArrayIndex ($strTokens, &$strPtr)
|
|
{
|
|
if ('[' !== $strTokens[$strPtr]) {
|
|
throw new Exception ('Expected [.');
|
|
}
|
|
$strPtr++;
|
|
if (! in_array($strTokens[$strPtr][0], array(T_CONSTANT_ENCAPSED_STRING, T_LNUMBER))) {
|
|
throw new Exception ('Expected an array index.');
|
|
}
|
|
$index = $strTokens[$strPtr][1];
|
|
$strPtr++;
|
|
if (']' !== $strTokens[$strPtr]) {
|
|
throw new Exception ('Expected ].');
|
|
}
|
|
$strPtr++;
|
|
return $index;
|
|
}//end _parseArrayIndex()
|
|
|
|
}//end class
|
|
|
|
/**
|
|
* CodeIgniter_Sniffs_Strings_VariableUsageSniff.
|
|
*
|
|
* Ensures that variables parsed in double-quoted strings are enclosed with
|
|
* braces to prevent greedy token parsing.
|
|
* Single-quoted strings don't parse variables, so there is no risk of greedy
|
|
* token parsing.
|
|
*
|
|
* @category PHP
|
|
* @package PHP_CodeSniffer
|
|
* @author Thomas Ernest <thomas.ernest@baobaz.com>
|
|
* @copyright 2011 Thomas Ernest
|
|
* @license http://thomas.ernest.fr/developement/php_cs/licence GNU General Public License
|
|
* @link http://pear.php.net/package/PHP_CodeSniffer
|
|
*/
|
|
class DoubleQuoteUsageSniff extends VariableUsageSniff
|
|
{
|
|
/**
|
|
* Returns an array of tokens this test wants to listen for.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function register()
|
|
{
|
|
return array(
|
|
T_DOUBLE_QUOTED_STRING,
|
|
T_CONSTANT_ENCAPSED_STRING,
|
|
);
|
|
}//end register()
|
|
|
|
/**
|
|
* Processes this test, when one of its tokens is encountered.
|
|
*
|
|
* @param File $phpcsFile The current file being scanned.
|
|
* @param int $stackPtr The position of the current token
|
|
* in the stack passed in $tokens.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function process(File $phpcsFile, $stackPtr)
|
|
{
|
|
// no variable are in the string from here
|
|
$tokens = $phpcsFile->getTokens();
|
|
$qtString = $tokens[$stackPtr]['content'];
|
|
// makes sure that it is about a double quote string,
|
|
// since variables are not parsed out of double quoted string
|
|
$open_qt_str = substr($qtString, 0, 1);
|
|
|
|
// clean the enclosing quotes
|
|
$qtString = substr($qtString, 1, strlen($qtString) - 1 - 1);
|
|
|
|
if (0 === strcmp($open_qt_str, '"')) {
|
|
$this->processDoubleQuotedString($phpcsFile, $stackPtr, $qtString);
|
|
} else if (0 === strcmp($open_qt_str, "'")) {
|
|
$this->processSingleQuotedString($phpcsFile, $stackPtr, $qtString);
|
|
}
|
|
}//end process()
|
|
|
|
|
|
/**
|
|
* Processes this test, when the token encountered is a double-quoted string.
|
|
*
|
|
* @param File $phpcsFile The current file being scanned.
|
|
* @param int $stackPtr The position of the current token
|
|
* in the stack passed in $tokens.
|
|
* @param string $qtString The double-quoted string content,
|
|
* i.e. without quotes.
|
|
*
|
|
* @return void
|
|
*/
|
|
protected function processDoubleQuotedString (File $phpcsFile, $stackPtr, $qtString)
|
|
{
|
|
// so there should be at least a single quote or a special char
|
|
// if there are the 2 kinds of quote and no special char, then add a warning
|
|
$has_variable = parent::processDoubleQuotedString($phpcsFile, $stackPtr, '"'.$qtString.'"');
|
|
$has_specific_sequence = $this->_hasSpecificSequence($qtString);
|
|
$dbl_qt_at = strpos($qtString, '"');
|
|
$smpl_qt_at = strpos($qtString, "'");
|
|
if (false === $has_variable && false === $has_specific_sequence
|
|
&& false === $smpl_qt_at
|
|
) {
|
|
$error = 'Single-quoted strings should be used unless it contains variables, special chars like \n or single quotes.';
|
|
$phpcsFile->addError($error, $stackPtr);
|
|
} else if (false !== $smpl_qt_at && false !== $dbl_qt_at
|
|
&& false === $has_variable && false === $has_specific_sequence
|
|
) {
|
|
$warning = 'It is encouraged to use a single-quoted string, since it doesn\'t contain any variable nor special char though it mixes single and double quotes.';
|
|
$phpcsFile->addWarning($warning, $stackPtr);
|
|
}
|
|
}//end processDoubleQuotedString()
|
|
|
|
|
|
/**
|
|
* Processes this test, when the token encountered is a single-quoted string.
|
|
*
|
|
* @param File $phpcsFile The current file being scanned.
|
|
* @param int $stackPtr The position of the current token
|
|
* in the stack passed in $tokens.
|
|
* @param string $qtString The single-quoted string content,
|
|
* i.e. without quotes.
|
|
*
|
|
* @return void
|
|
*/
|
|
protected function processSingleQuotedString (File $phpcsFile, $stackPtr, $qtString)
|
|
{
|
|
// if there is single quotes without additional double quotes,
|
|
// then user is allowed to use double quote to avoid having to
|
|
// escape single quotes. Don't add the warning, if an error was
|
|
// already added, because a variable was found in a single-quoted
|
|
// string.
|
|
$has_variable = parent::processSingleQuotedString($phpcsFile, $stackPtr, "'".$qtString."'");
|
|
$dbl_qt_at = strpos($qtString, '"');
|
|
$smpl_qt_at = strpos($qtString, "'");
|
|
if (false === $has_variable && false !== $smpl_qt_at && false === $dbl_qt_at) {
|
|
$warning = 'You may also use double-quoted strings if the string contains single quotes, so you do not have to use escape characters.';
|
|
$phpcsFile->addWarning($warning, $stackPtr);
|
|
}
|
|
}//end processSingleQuotedString()
|
|
|
|
/**
|
|
* Return TRUE, if a sequence of chars that is parsed in a specific way
|
|
* in double-quoted strings is found, FALSE otherwise.
|
|
*
|
|
* @param string $string String in which sequence of special chars will
|
|
* be researched.
|
|
*
|
|
* @return TRUE, if a sequence of chars that is parsed in a specific way
|
|
* in double-quoted strings is found, FALSE otherwise.
|
|
*
|
|
* @link http://www.php.net/manual/en/language.types.string.php#language.types.string.syntax.double
|
|
*/
|
|
private function _hasSpecificSequence($string)
|
|
{
|
|
$hasSpecificSequence = FALSE;
|
|
$specialMeaningStrs = array('\n', '\r', '\t', '\v', '\f');
|
|
foreach ($specialMeaningStrs as $splStr) {
|
|
if (FALSE !== strpos($string, $splStr)) {
|
|
$hasSpecificSequence = TRUE;
|
|
}
|
|
}
|
|
$specialMeaningPtrns = array('\[0-7]{1,3}', '\x[0-9A-Fa-f]{1,2}');
|
|
foreach ($specialMeaningPtrns as $splPtrn) {
|
|
if (1 === preg_match("/{$splPtrn}/", $string)) {
|
|
$hasSpecificSequence = TRUE;
|
|
}
|
|
}
|
|
return $hasSpecificSequence;
|
|
}//end _hasSpecificSequence()
|
|
|
|
}//end class
|
|
|
|
?>
|