public function FunctionTSniff::processFunctionCall in Coder 8.2

Same name and namespace in other branches

1. 8.3 coder_sniffer/Drupal/Sniffs/Semantics/FunctionTSniff.php \Drupal\Sniffs\Semantics\FunctionTSniff::processFunctionCall()
2. 8.3.x coder_sniffer/Drupal/Sniffs/Semantics/FunctionTSniff.php \Drupal\Sniffs\Semantics\FunctionTSniff::processFunctionCall()

Processes this function call.

Parameters

\PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.:

int $stackPtr The position of the function call in: the stack.

int $openBracket The position of the opening: parenthesis in the stack.

int $closeBracket The position of the closing: parenthesis in the stack.

Return value

void

File

coder_sniffer/Drupal/Sniffs/Semantics/FunctionTSniff.php, line 64

Class

FunctionTSniff

Check the usage of the t() function to not escape translateable strings with back slashes. Also checks that the first argument does not use string concatenation.

Namespace

Drupal\Sniffs\Semantics

Code

public function processFunctionCall(File $phpcsFile, $stackPtr, $openBracket, $closeBracket) {
  $tokens = $phpcsFile
    ->getTokens();
  $argument = $this
    ->getArgument(1);
  if ($argument === false) {
    $error = 'Empty calls to t() are not allowed';
    $phpcsFile
      ->addError($error, $stackPtr, 'EmptyT');
    return;
  }
  if ($tokens[$argument['start']]['code'] !== T_CONSTANT_ENCAPSED_STRING) {

    // Not a translatable string literal.
    $warning = 'Only string literals should be passed to t() where possible';
    $phpcsFile
      ->addWarning($warning, $argument['start'], 'NotLiteralString');
    return;
  }
  $string = $tokens[$argument['start']]['content'];
  if ($string === '""' || $string === "''") {
    $warning = 'Do not pass empty strings to t()';
    $phpcsFile
      ->addWarning($warning, $argument['start'], 'EmptyString');
    return;
  }
  $concatAfter = $phpcsFile
    ->findNext(Tokens::$emptyTokens, $closeBracket + 1, null, true, null, true);
  if ($concatAfter !== false && $tokens[$concatAfter]['code'] === T_STRING_CONCAT) {
    $stringAfter = $phpcsFile
      ->findNext(Tokens::$emptyTokens, $concatAfter + 1, null, true, null, true);
    if ($stringAfter !== false && $tokens[$stringAfter]['code'] === T_CONSTANT_ENCAPSED_STRING && $this
      ->checkConcatString($tokens[$stringAfter]['content']) === false) {
      $warning = 'Do not concatenate strings to translatable strings, they should be part of the t() argument and you should use placeholders';
      $phpcsFile
        ->addWarning($warning, $stringAfter, 'ConcatString');
    }
  }
  $lastChar = substr($string, -1);
  if ($lastChar === '"' || $lastChar === "'") {
    $message = substr($string, 1, -1);
    if ($message !== trim($message)) {
      $warning = 'Translatable strings must not begin or end with white spaces, use placeholders with t() for variables';
      $phpcsFile
        ->addWarning($warning, $argument['start'], 'WhiteSpace');
    }
  }
  $concatFound = $phpcsFile
    ->findNext(T_STRING_CONCAT, $argument['start'], $argument['end']);
  if ($concatFound !== false) {
    $error = 'Concatenating translatable strings is not allowed, use placeholders instead and only one string literal';
    $phpcsFile
      ->addError($error, $concatFound, 'Concat');
  }

  // Check if there is a backslash escaped single quote in the string and
  // if the string makes use of double quotes.
  if ($string[0] === "'" && strpos($string, "\\'") !== false && strpos($string, '"') === false) {
    $warn = 'Avoid backslash escaping in translatable strings when possible, use "" quotes instead';
    $phpcsFile
      ->addWarning($warn, $argument['start'], 'BackslashSingleQuote');
    return;
  }
  if ($string[0] === '"' && strpos($string, '\\"') !== false && strpos($string, "'") === false) {
    $warn = "Avoid backslash escaping in translatable strings when possible, use '' quotes instead";
    $phpcsFile
      ->addWarning($warn, $argument['start'], 'BackslashDoubleQuote');
  }
}