function RequireMultiLineCallSniff::process

* @phpcsSuppress SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint *

Parameters

int $stringPointer:

Overrides Sniff::process

File

vendor/slevomat/coding-standard/SlevomatCodingStandard/Sniffs/Functions/RequireMultiLineCallSniff.php, line 38

Class

RequireMultiLineCallSniff

Namespace

SlevomatCodingStandard\Sniffs\Functions

Code

public function process(File $phpcsFile, $stringPointer) : void {
    $this->minLineLength = SniffSettingsHelper::normalizeInteger($this->minLineLength);
    if (!$this->isCall($phpcsFile, $stringPointer)) {
        return;
    }
    $tokens = $phpcsFile->getTokens();
    $parenthesisOpenerPointer = TokenHelper::findNextEffective($phpcsFile, $stringPointer + 1);
    $parenthesisCloserPointer = $tokens[$parenthesisOpenerPointer]['parenthesis_closer'];
    // No parameters
    $effectivePointerAfterParenthesisOpener = TokenHelper::findNextEffective($phpcsFile, $parenthesisOpenerPointer + 1);
    if ($effectivePointerAfterParenthesisOpener === $parenthesisCloserPointer) {
        return;
    }
    $parametersPointers = [
        TokenHelper::findNextEffective($phpcsFile, $parenthesisOpenerPointer + 1),
    ];
    $level = 0;
    $pointers = TokenHelper::findNextAll($phpcsFile, [
        T_COMMA,
        T_OPEN_PARENTHESIS,
        T_CLOSE_PARENTHESIS,
        T_OPEN_SHORT_ARRAY,
        T_CLOSE_SHORT_ARRAY,
    ], $parenthesisOpenerPointer + 1, $parenthesisCloserPointer);
    foreach ($pointers as $pointer) {
        if (in_array($tokens[$pointer]['code'], [
            T_OPEN_PARENTHESIS,
            T_OPEN_SHORT_ARRAY,
        ], true)) {
            $level++;
            continue;
        }
        if (in_array($tokens[$pointer]['code'], [
            T_CLOSE_PARENTHESIS,
            T_CLOSE_SHORT_ARRAY,
        ], true)) {
            $level--;
            continue;
        }
        if ($level !== 0) {
            continue;
        }
        $parameterPointer = TokenHelper::findNextEffective($phpcsFile, $pointer + 1, $parenthesisCloserPointer);
        if ($parameterPointer !== null) {
            $parametersPointers[] = $parameterPointer;
        }
    }
    $lines = [
        $tokens[$parenthesisOpenerPointer]['line'],
        $tokens[$parenthesisCloserPointer]['line'],
    ];
    foreach ($parametersPointers as $parameterPointer) {
        $lines[] = $tokens[$parameterPointer]['line'];
    }
    // Each parameter on its line
    if (count(array_unique($lines)) - 2 >= count($parametersPointers)) {
        return;
    }
    if ($this->shouldBeSkipped($phpcsFile, $stringPointer, $parenthesisCloserPointer)) {
        return;
    }
    $lineStart = $this->getLineStart($phpcsFile, $parenthesisOpenerPointer);
    if ($tokens[$parenthesisCloserPointer]['line'] === $tokens[$stringPointer]['line']) {
        $call = $this->getCall($phpcsFile, $parenthesisOpenerPointer, $parenthesisCloserPointer);
        $lineEnd = $this->getLineEnd($phpcsFile, $parenthesisCloserPointer);
        $lineLength = strlen($lineStart . $call . $lineEnd);
    }
    else {
        $lineEnd = $this->getLineEnd($phpcsFile, $parenthesisOpenerPointer);
        $lineLength = strlen($lineStart . $lineEnd);
    }
    $firstNonWhitespaceOnLine = TokenHelper::findFirstNonWhitespaceOnLine($phpcsFile, $stringPointer);
    $indentation = IndentationHelper::getIndentation($phpcsFile, $firstNonWhitespaceOnLine);
    $oneIndentation = IndentationHelper::getOneIndentationLevel($indentation);
    if (!$this->shouldReportError($lineLength, $lineStart, $lineEnd, count($parametersPointers), strlen(IndentationHelper::convertTabsToSpaces($phpcsFile, $oneIndentation)))) {
        return;
    }
    $previousPointer = TokenHelper::findPreviousEffective($phpcsFile, $stringPointer - 1);
    $name = ltrim($tokens[$stringPointer]['content'], '\\');
    if (in_array($tokens[$previousPointer]['code'], [
        T_OBJECT_OPERATOR,
        T_DOUBLE_COLON,
    ], true)) {
        $error = sprintf('Call of method %s() should be split to more lines.', $name);
    }
    elseif ($tokens[$previousPointer]['code'] === T_NEW) {
        $error = 'Constructor call should be split to more lines.';
    }
    else {
        $error = sprintf('Call of function %s() should be split to more lines.', $name);
    }
    $fix = $phpcsFile->addFixableError($error, $stringPointer, self::CODE_REQUIRED_MULTI_LINE_CALL);
    if (!$fix) {
        return;
    }
    $parametersIndentation = IndentationHelper::addIndentation($indentation);
    $phpcsFile->fixer
        ->beginChangeset();
    for ($i = $parenthesisOpenerPointer + 1; $i < $parenthesisCloserPointer; $i++) {
        if (in_array($i, $parametersPointers, true)) {
            FixerHelper::removeWhitespaceBefore($phpcsFile, $i);
            $phpcsFile->fixer
                ->addContentBefore($i, $phpcsFile->eolChar . $parametersIndentation);
        }
        elseif ($tokens[$i]['content'] === $phpcsFile->eolChar) {
            $phpcsFile->fixer
                ->addContent($i, $oneIndentation);
        }
        else {
            // Create conflict so inner calls are fixed in next loop
            $phpcsFile->fixer
                ->replaceToken($i, $tokens[$i]['content']);
        }
    }
    $phpcsFile->fixer
        ->addContentBefore($parenthesisCloserPointer, $phpcsFile->eolChar . $indentation);
    $phpcsFile->fixer
        ->endChangeset();
}