/** * Replace all `else if` (T_ELSE T_IF) with `elseif` (T_ELSEIF) * * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); foreach ($tokens as $index => $token) { // if token is not T_ELSE - continue searching, this is not right token to fix if (!$token->isGivenKind(T_ELSE)) { continue; } $nextIndex = null; $nextToken = $tokens->getNextNonWhitespace($index, array(), $nextIndex); // if next meaning token is not T_IF - continue searching, this is not the case for fixing if (!$nextToken->isGivenKind(T_IF)) { continue; } // now we have T_ELSE following by T_IF so we could fix this // 1. clear whitespaces between T_ELSE and T_IF $tokens[$index + 1]->clear(); // 2. change token from T_ELSE into T_ELSEIF $token->content = 'elseif'; $token->id = T_ELSEIF; // 3. clear succeeding T_IF $nextToken->clear(); } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); $uses = array_reverse($tokens->getNamespaceUseIndexes()); foreach ($uses as $index) { $endIndex = null; $tokens->getNextTokenOfKind($index, array(';'), $endIndex); $declarationContent = $tokens->generatePartialCode($index + 1, $endIndex - 1); $declarationParts = explode(',', $declarationContent); if (1 === count($declarationParts)) { continue; } $declarationContent = array(); foreach ($declarationParts as $declarationPart) { $declarationContent[] = 'use ' . trim($declarationPart) . ';'; } $declarationContent = implode("\n" . $this->detectIndent($tokens, $index), $declarationContent); for ($i = $index; $i <= $endIndex; ++$i) { $tokens[$i]->clear(); } $declarationTokens = Tokens::fromCode('<?php ' . $declarationContent); $declarationTokens[0]->clear(); $tokens->insertAt($index, $declarationTokens); } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); for ($index = $tokens->count() - 1; $index >= 0; --$index) { $token = $tokens[$index]; if (T_NEW !== $token->id) { continue; } $nextIndex = null; $nextToken = $tokens->getNextTokenOfKind($index, array(';', ',', '(', ')', '[', ']'), $nextIndex); // no correct end of code - break if (null === $nextToken) { break; } // entrance into array index syntax - need to look for exit if (!$nextToken->isArray() && '[' === $nextToken->content) { $braceLevel = 1; while (0 < $braceLevel) { $nextToken = $tokens->getNextTokenOfKind($nextIndex, array('[', ']'), $nextIndex); $braceLevel += '[' === $nextToken->content ? 1 : -1; } $nextToken = $tokens[++$nextIndex]; } // new statement with () - nothing to do if (!$nextToken->isArray() && '(' === $nextToken->content) { continue; } $meaningBeforeNextIndex = null; $tokens->getPrevNonWhitespace($nextIndex, array(), $meaningBeforeNextIndex); $tokens->insertAt($meaningBeforeNextIndex + 1, array(new Token('('), new Token(')'))); } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); for ($index = 0, $limit = $tokens->count(); $index < $limit; ++$index) { $token = $tokens[$index]; if (!$token->isGivenKind(T_RETURN)) { continue; } $prevNonWhitespaceToken = $tokens->getPrevNonWhitespace($index); if (!$prevNonWhitespaceToken->equalsAny(array(';', '}'))) { continue; } $prevToken = $tokens[$index - 1]; if ($prevToken->isWhitespace()) { $parts = explode("\n", $prevToken->content); $countParts = count($parts); if (1 === $countParts) { $prevToken->content = rtrim($prevToken->content, " \t") . "\n\n"; } elseif (count($parts) <= 2) { $prevToken->content = "\n" . $prevToken->content; } } else { $tokens->insertAt($index, new Token(array(T_WHITESPACE, "\n\n"))); ++$index; ++$limit; } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); $includies = $this->findIncludies($tokens); $this->clearIncludies($tokens, $includies); return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); foreach ($tokens as $token) { if (!$token->isGivenKind(T_WHITESPACE)) { continue; } $content = ''; $count = 0; $parts = explode("\n", $token->content); for ($i = 0, $last = count($parts) - 1; $i <= $last; ++$i) { if ('' === $parts[$i]) { // if part is empty then we between two \n ++$count; } else { $count = 0; $content .= $parts[$i]; } if ($i !== $last && $count < 3) { $content .= "\n"; } } $token->content = $content; } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); $namespacesImports = $tokens->getNamespaceUseIndexes(true); $usesOrder = array(); if (!count($namespacesImports)) { return $content; } foreach ($namespacesImports as $uses) { $uses = array_reverse($uses); $usesOrder = array_replace($usesOrder, $this->getNewOrder($uses, $tokens)); } // First clean the old content // This must be done first as the indexes can be scattered foreach ($usesOrder as $use) { for ($i = $use[1]; $i <= $use[2]; ++$i) { $tokens[$i]->clear(); } } $usesOrder = array_reverse($usesOrder, true); // Now insert the new tokens, starting from the end foreach ($usesOrder as $index => $use) { $declarationTokens = Tokens::fromCode('<?php use ' . $use[0] . ';'); $declarationTokens[0]->clear(); // <?php $declarationTokens[1]->clear(); // use $declarationTokens[2]->clear(); // space $declarationTokens[count($declarationTokens) - 1]->clear(); // ; $tokens->insertAt($index, $declarationTokens); } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); foreach ($tokens as $token) { if ($token->isKeyword()) { $token->content = strtolower($token->content); } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); foreach ($tokens as $index => $token) { if ($token->isGivenKind(T_IS_NOT_EQUAL)) { $tokens[$index]->content = '!='; } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); for ($index = $tokens->count() - 1; $index >= 0; --$index) { if ($tokens->isArray($index)) { $this->fixArray($tokens, $index); } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); foreach ($tokens as $index => $token) { if (!$token->isWhitespace()) { continue; } $tokens[$index]->content = preg_replace('/(?:(?<! ) {1,3})?\\t/', ' ', $token->content); } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); foreach ($tokens as $index => $token) { if (!$token->isGivenKind(T_DOC_COMMENT)) { continue; } $tokens[$index]->content = $this->fixDocBlock($token->content); } return $tokens->generateCode(); }
public function testReadFromCacheAfterClearing() { $code = '<?php echo 1;'; $tokens = Tokens::fromCode($code); $countBefore = $tokens->count(); for ($i = 0; $i < $countBefore; ++$i) { $tokens[$i]->clear(); } $tokens = Tokens::fromCode($code); $this->assertSame($countBefore, $tokens->count()); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); $whitespaces = array('whitespaces' => " \t"); foreach ($tokens as $index => $token) { if (!$token->isArray() && '.' === $token->content) { $tokens->removeLeadingWhitespace($index, $whitespaces); $tokens->removeTrailingWhitespace($index, $whitespaces); } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); $this->fixCommentBeforeBrace($tokens); $this->fixMissingControlBraces($tokens); $this->fixIndents($tokens); $this->fixControlContinuationBraces($tokens); $this->fixSpaceAroundToken($tokens); $this->fixDoWhile($tokens); $this->fixLambdas($tokens); return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); for ($index = 0, $c = $tokens->count(); $index < $c; ++$index) { $token = $tokens[$index]; if ($token->isGivenKind(T_ARRAY) && '(' === $tokens->getNextNonWhitespace($index)->content) { $this->fixArray($tokens, $index); continue; } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); $namespace = $this->detectNamespace($tokens); $useDeclarationsIndexes = $tokens->getNamespaceUseIndexes(); $useDeclarations = $this->getNamespaceUseDeclarations($tokens, $useDeclarationsIndexes); $contentWithoutUseDeclarations = $this->generateCodeWithoutUses($tokens, $useDeclarations); $useUsages = $this->detectUseUsages($contentWithoutUseDeclarations, $useDeclarations); $this->removeUnusedUseDeclarations($tokens, $useDeclarations, $useUsages); $this->removeUsesInSameNamespace($tokens, $useDeclarations, $namespace); return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); foreach ($tokens as $index => $token) { if ($token->isNativeConstant()) { if ($tokens->getPrevNonWhitespace($index, array('whitespaces' => " \t\n"))->isArray() || $tokens->getNextNonWhitespace($index, array('whitespaces' => " \t\n"))->isArray()) { continue; } $token->content = strtolower($token->content); } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); for ($index = $tokens->count() - 1; $index >= 0; --$index) { $token = $tokens[$index]; if (!$token->isArray() && '.' === $token->content) { if (!$tokens[$index + 1]->isWhitespace()) { $tokens->insertAt($index + 1, new Token(array(T_WHITESPACE, ' '))); } if (!$tokens[$index - 1]->isWhitespace()) { $tokens->insertAt($index, new Token(array(T_WHITESPACE, ' '))); } } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); for ($index = $tokens->count() - 1; $index >= 0; --$index) { $token = $tokens[$index]; if (!$token->isGivenKind(T_FUNCTION)) { continue; } $startParenthesisIndex = null; $tokens->getNextTokenOfKind($index, array('('), $startParenthesisIndex); $endParenthesisIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startParenthesisIndex); $startBraceIndex = null; $startBraceToken = $tokens->getNextTokenOfKind($endParenthesisIndex, array(';', '{'), $startBraceIndex); if ($startBraceToken->equals('{')) { // fix single-line whitespace before { // eg: `function foo(){}` => `function foo() {}` // eg: `function foo() {}` => `function foo() {}` if (!$tokens[$startBraceIndex - 1]->isWhitespace() || $tokens[$startBraceIndex - 1]->isWhitespace($this->singleLineWhitespaceOptions)) { $tokens->ensureWhitespaceAtIndex($startBraceIndex - 1, 1, ' '); } } $afterParenthesisIndex = null; $afterParenthesisToken = $tokens->getNextNonWhitespace($endParenthesisIndex, array(), $afterParenthesisIndex); if ($afterParenthesisToken->isGivenKind(T_USE)) { $useStartParenthesisIndex = null; $tokens->getNextTokenOfKind($afterParenthesisIndex, array('('), $useStartParenthesisIndex); $useEndParenthesisIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $useStartParenthesisIndex); // fix whitespace after T_USE $tokens->ensureWhitespaceAtIndex($afterParenthesisIndex + 1, 0, ' '); // remove single-line edge whitespaces inside use parentheses $this->fixParenthesisInnerEdge($tokens, $useStartParenthesisIndex, $useEndParenthesisIndex); // fix whitespace before T_USE $tokens->ensureWhitespaceAtIndex($afterParenthesisIndex - 1, 1, ' '); } // remove single-line edge whitespaces inside parameters list parentheses $this->fixParenthesisInnerEdge($tokens, $startParenthesisIndex, $endParenthesisIndex); // remove whitespace before ( // eg: `function foo () {}` => `function foo() {}` if ($tokens[$startParenthesisIndex - 1]->isWhitespace()) { $tokens[$startParenthesisIndex - 1]->clear(); } // fix whitespace after T_FUNCTION // eg: `function foo() {}` => `function foo() {}` $tokens->ensureWhitespaceAtIndex($index + 1, 0, ' '); } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { // replace all <? with <?php to replace all short open tags even without short_open_tag option enabled $newContent = preg_replace('/<\\?(\\s|$)/', '<?php$1', $content); /* the following code is magic to revert previous replacements which should NOT be replaced, for example incorrectly replacing * > echo '<? '; * with * > echo '<?php '; */ $tokens = Tokens::fromCode($newContent); $tokensOldContent = ''; $tokensOldContentLength = 0; foreach ($tokens as $token) { if ($token->isGivenKind(T_OPEN_TAG)) { $tokenContent = $token->content; if ('<?php' !== substr($content, $tokensOldContentLength, 5)) { $tokenContent = '<? '; } $tokensOldContent .= $tokenContent; $tokensOldContentLength += strlen($tokenContent); continue; } if ($token->isGivenKind(array(T_COMMENT, T_DOC_COMMENT, T_CONSTANT_ENCAPSED_STRING, T_ENCAPSED_AND_WHITESPACE, T_STRING))) { $tokenContent = ''; $tokenContentLength = 0; $parts = explode('<?php ', $token->content); $iLast = count($parts) - 1; foreach ($parts as $i => $part) { $tokenContent .= $part; $tokenContentLength += strlen($part); if ($i !== $iLast) { if ('<?php' === substr($content, $tokensOldContentLength + $tokenContentLength, 5)) { $tokenContent .= '<?php '; $tokenContentLength += 6; } else { $tokenContent .= '<? '; $tokenContentLength += 3; } } } $token->content = $tokenContent; } $tokensOldContent .= $token->content; $tokensOldContentLength += strlen($token->content); } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { static $insideCastSpaceReplaceMap = array(' ' => '', "\t" => '', "\n" => ''); $tokens = Tokens::fromCode($content); foreach ($tokens as $index => $token) { if ($token->isCast()) { $token->content = strtr($token->content, $insideCastSpaceReplaceMap); // force single whitespace after cast token: if ($tokens[$index + 1]->isWhitespace(array('whitespaces' => " \t"))) { // - if next token is whitespaces that contains only spaces and tabs - override next token with single space $tokens[$index + 1]->content = ' '; } elseif (!$tokens[$index + 1]->isWhitespace()) { // - if next token is not whitespaces that contains spaces, tabs and new lines - append single space to current token $tokens->insertAt($index + 1, new Token(' ')); } } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); $elements = $tokens->getClassyElements(); foreach (array_reverse($elements, true) as $index => $element) { if ('method' === $element['type']) { $tokens->applyAttribs($index, $tokens->grabAttribsBeforeMethodToken($index)); // force whitespace between function keyword and function name to be single space char $tokens[++$index]->content = ' '; } elseif ('property' === $element['type']) { $prevToken = $tokens->getPrevTokenOfKind($index, array(';', ',')); $nextToken = $tokens->getNextTokenOfKind($index, array(';', ',')); if ((!$prevToken || ',' !== $prevToken->content) && (!$nextToken || ',' !== $nextToken->content)) { $tokens->applyAttribs($index, $tokens->grabAttribsBeforePropertyToken($index)); } } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { // [Structure] there should not be space before or after T_OBJECT_OPERATOR $tokens = Tokens::fromCode($content); foreach ($tokens as $index => $token) { // skip if $token is not -> if (!$token->isGivenKind(T_OBJECT_OPERATOR)) { continue; } // clear whitespace before -> if ($tokens[$index - 1]->isWhitespace(array('whitespaces' => " \t")) && !$tokens[$index - 2]->isComment()) { $tokens[$index - 1]->clear(); } // clear whitespace after -> if ($tokens[$index + 1]->isWhitespace(array('whitespaces' => " \t")) && !$tokens[$index + 2]->isComment()) { $tokens[$index + 1]->clear(); } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); for ($index = $tokens->count() - 1; $index >= 0; --$index) { $token = $tokens[$index]; if (T_NAMESPACE === $token->id) { $semicolonIndex = null; $semicolonToken = $tokens->getNextTokenOfKind($index, array(';', '{'), $semicolonIndex); if (!$semicolonToken || ';' !== $semicolonToken->content || !isset($tokens[$semicolonIndex + 1])) { continue; } $nextToken = $tokens[$semicolonIndex + 1]; if (!$nextToken->isWhitespace()) { $tokens->insertAt($semicolonIndex + 1, new Token(array(T_WHITESPACE, "\n\n"))); } else { $nextToken->content = "\n\n" . ltrim($nextToken->content); } } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $ternaryLevel = 0; $tokens = Tokens::fromCode($content); foreach ($tokens as $index => $token) { if ($token->isArray()) { continue; } if ('?' === $token->content) { ++$ternaryLevel; $nextNonWhitespaceIndex = null; $nextNonWhitespaceToken = $tokens->getNextNonWhitespace($index, array(), $nextNonWhitespaceIndex); if (!$nextNonWhitespaceToken->isArray() && ':' === $nextNonWhitespaceToken->content) { // for `$a ?: $b` remove spaces between `?` and `:` if ($tokens[$index + 1]->isWhitespace()) { $tokens[$index + 1]->clear(); } } else { // for `$a ? $b : $c` ensure space after `?` $this->ensureWhitespaceExistance($tokens, $index + 1, true); } // for `$a ? $b : $c` ensure space before `?` $this->ensureWhitespaceExistance($tokens, $index - 1, false); continue; } if ($ternaryLevel && ':' === $token->content) { // for `$a ? $b : $c` ensure space after `:` $this->ensureWhitespaceExistance($tokens, $index + 1, true); $prevNonWhitespaceToken = $tokens->getPrevNonWhitespace($index); if ($prevNonWhitespaceToken->isArray() || '?' !== $prevNonWhitespaceToken->content) { // for `$a ? $b : $c` ensure space before `:` $this->ensureWhitespaceExistance($tokens, $index - 1, false); } --$ternaryLevel; } } return $tokens->generateCode(); }
/** * {@inheritdoc} */ public function fix(\SplFileInfo $file, $content) { $tokens = Tokens::fromCode($content); $this->fixComparisons($tokens); return $tokens->generateCode(); }