function FunctionCallSignatureSniff::processSingleLineCall

Processes single-line calls.

Parameters

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

int $stackPtr The position of the current token: in the stack passed in $tokens.

int $openBracket The position of the opening bracket: in the stack passed in $tokens.

array $tokens The stack of tokens that make up: the file.

Return value

void

1 call to FunctionCallSignatureSniff::processSingleLineCall()

FunctionCallSignatureSniff::process in vendor/squizlabs/php_codesniffer/src/Standards/PEAR/Sniffs/Functions/FunctionCallSignatureSniff.php

Processes this test, when one of its tokens is encountered.

File

vendor/squizlabs/php_codesniffer/src/Standards/PEAR/Sniffs/Functions/FunctionCallSignatureSniff.php, line 207

Class

FunctionCallSignatureSniff

Namespace

PHP_CodeSniffer\Standards\PEAR\Sniffs\Functions

Code

public function processSingleLineCall(File $phpcsFile, $stackPtr, $openBracket, $tokens) {
    $closer = $tokens[$openBracket]['parenthesis_closer'];
    if ($openBracket === $closer - 1) {
        return;
    }
    // If the function call has no arguments or comments, enforce 0 spaces.
    $next = $phpcsFile->findNext(T_WHITESPACE, $openBracket + 1, $closer, true);
    if ($next === false) {
        $requiredSpacesAfterOpen = 0;
        $requiredSpacesBeforeClose = 0;
    }
    else {
        $requiredSpacesAfterOpen = $this->requiredSpacesAfterOpen;
        $requiredSpacesBeforeClose = $this->requiredSpacesBeforeClose;
    }
    if ($requiredSpacesAfterOpen === 0 && $tokens[$openBracket + 1]['code'] === T_WHITESPACE) {
        // Checking this: $value = my_function([*]...).
        $error = 'Space after opening parenthesis of function call prohibited';
        $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterOpenBracket');
        if ($fix === true) {
            $phpcsFile->fixer
                ->replaceToken($openBracket + 1, '');
        }
    }
    else {
        if ($requiredSpacesAfterOpen > 0) {
            $spaceAfterOpen = 0;
            if ($tokens[$openBracket + 1]['code'] === T_WHITESPACE) {
                $spaceAfterOpen = $tokens[$openBracket + 1]['length'];
            }
            if ($spaceAfterOpen !== $requiredSpacesAfterOpen) {
                $error = 'Expected %s spaces after opening parenthesis; %s found';
                $data = [
                    $requiredSpacesAfterOpen,
                    $spaceAfterOpen,
                ];
                $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterOpenBracket', $data);
                if ($fix === true) {
                    $padding = str_repeat(' ', $requiredSpacesAfterOpen);
                    if ($spaceAfterOpen === 0) {
                        $phpcsFile->fixer
                            ->addContent($openBracket, $padding);
                    }
                    else {
                        $phpcsFile->fixer
                            ->replaceToken($openBracket + 1, $padding);
                    }
                }
            }
        }
    }
    
    //end if
    // Checking this: $value = my_function(...[*]).
    $spaceBeforeClose = 0;
    $prev = $phpcsFile->findPrevious(T_WHITESPACE, $closer - 1, $openBracket, true);
    if ($tokens[$prev]['code'] === T_END_HEREDOC || $tokens[$prev]['code'] === T_END_NOWDOC) {
        // Need a newline after these tokens, so ignore this rule.
        return;
    }
    if ($tokens[$prev]['line'] !== $tokens[$closer]['line']) {
        $spaceBeforeClose = 'newline';
    }
    else {
        if ($tokens[$closer - 1]['code'] === T_WHITESPACE) {
            $spaceBeforeClose = $tokens[$closer - 1]['length'];
        }
    }
    if ($spaceBeforeClose !== $requiredSpacesBeforeClose) {
        $error = 'Expected %s spaces before closing parenthesis; %s found';
        $data = [
            $requiredSpacesBeforeClose,
            $spaceBeforeClose,
        ];
        $fix = $phpcsFile->addFixableError($error, $closer, 'SpaceBeforeCloseBracket', $data);
        if ($fix === true) {
            $padding = str_repeat(' ', $requiredSpacesBeforeClose);
            if ($spaceBeforeClose === 0) {
                $phpcsFile->fixer
                    ->addContentBefore($closer, $padding);
            }
            else {
                if ($spaceBeforeClose === 'newline') {
                    $phpcsFile->fixer
                        ->beginChangeset();
                    $closingContent = ')';
                    $next = $phpcsFile->findNext(T_WHITESPACE, $closer + 1, null, true);
                    if ($tokens[$next]['code'] === T_SEMICOLON) {
                        $closingContent .= ';';
                        for ($i = $closer + 1; $i <= $next; $i++) {
                            $phpcsFile->fixer
                                ->replaceToken($i, '');
                        }
                    }
                    // We want to jump over any whitespace or inline comment and
                    // move the closing parenthesis after any other token.
                    $prev = $closer - 1;
                    while (isset(Tokens::$emptyTokens[$tokens[$prev]['code']]) === true) {
                        if ($tokens[$prev]['code'] === T_COMMENT && strpos($tokens[$prev]['content'], '*/') !== false) {
                            break;
                        }
                        $prev--;
                    }
                    $phpcsFile->fixer
                        ->addContent($prev, $padding . $closingContent);
                    $prevNonWhitespace = $phpcsFile->findPrevious(T_WHITESPACE, $closer - 1, null, true);
                    for ($i = $prevNonWhitespace + 1; $i <= $closer; $i++) {
                        $phpcsFile->fixer
                            ->replaceToken($i, '');
                    }
                    $phpcsFile->fixer
                        ->endChangeset();
                }
                else {
                    $phpcsFile->fixer
                        ->replaceToken($closer - 1, $padding);
                }
            }
            
            //end if
        }
        
        //end if
    }
    
    //end if
}