PHP PhpCsFixer\Tokenizer Token::overrideの例

コード例 #1

ファイル: UseTransformer.php プロジェクト: cryode/PHP-CS-Fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if ($token->isGivenKind(T_USE) && $this->isUseForLambda($tokens, $index)) {
         $token->override(array(CT_USE_LAMBDA, $token->getContent()));
     }
     if (!$token->isClassy()) {
         return;
     }
     $prevTokenIndex = $tokens->getPrevMeaningfulToken($index);
     $prevToken = $prevTokenIndex === null ? null : $tokens[$prevTokenIndex];
     if ($prevToken->isGivenKind(T_DOUBLE_COLON)) {
         return;
     }
     // Skip whole class braces content.
     // That way we can skip whole tokens in class declaration, therefore skip `T_USE` for traits.
     $index = $tokens->getNextTokenOfKind($index, array('{'));
     $innerLimit = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $index);
     while ($index < $innerLimit) {
         $token = $tokens[++$index];
         if (!$token->isGivenKind(T_USE)) {
             continue;
         }
         if ($this->isUseForLambda($tokens, $index)) {
             $token->override(array(CT_USE_LAMBDA, $token->getContent()));
         } else {
             $token->override(array(CT_USE_TRAIT, $token->getContent()));
         }
     }
 }

コード例 #2

ファイル: SquareBraceTransformer.php プロジェクト: friendsofphp/php-cs-fixer

 private function transformIntoDestructuringSquareBrace(Tokens $tokens, Token $token, $index)
 {
     if (null === $this->cacheOfArraySquareBraceCloseIndex || !$tokens[$tokens->getNextMeaningfulToken($this->cacheOfArraySquareBraceCloseIndex)]->equals('=')) {
         return;
     }
     $token->override(array(CT::T_DESTRUCTURING_SQUARE_BRACE_OPEN, '['));
     $tokens[$this->cacheOfArraySquareBraceCloseIndex]->override(array(CT::T_DESTRUCTURING_SQUARE_BRACE_CLOSE, ']'));
 }

コード例 #3

ファイル: ArraySquareBraceTransformer.php プロジェクト: infinitely-young/PHP-CS-Fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if (!$this->isShortArray($tokens, $index)) {
         return;
     }
     $endIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_INDEX_SQUARE_BRACE, $index);
     $token->override(array(CT_ARRAY_SQUARE_BRACE_OPEN, '['));
     $tokens[$endIndex]->override(array(CT_ARRAY_SQUARE_BRACE_CLOSE, ']'));
 }

コード例 #4

ファイル: ImportTransformer.php プロジェクト: infinitely-young/PHP-CS-Fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if (!$token->isGivenKind(array(T_CONST, T_FUNCTION))) {
         return;
     }
     $prevToken = $tokens[$tokens->getPrevMeaningfulToken($index)];
     if ($prevToken->isGivenKind(T_USE)) {
         $token->override(array($token->isGivenKind(T_FUNCTION) ? CT_FUNCTION_IMPORT : CT_CONST_IMPORT, $token->getContent()));
     }
 }

コード例 #5

ファイル: ArrayTypehintTransformer.php プロジェクト: cryode/PHP-CS-Fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if (!$token->isGivenKind(T_ARRAY)) {
         return;
     }
     $nextIndex = $tokens->getNextMeaningfulToken($index);
     $nextToken = $tokens[$nextIndex];
     if (!$nextToken->equals('(')) {
         $token->override(array(CT_ARRAY_TYPEHINT, $token->getContent()));
     }
 }

コード例 #6

ファイル: NamespaceOperatorTransformer.php プロジェクト: fabpot/php-cs-fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if (!$token->isGivenKind(T_NAMESPACE)) {
         return;
     }
     $nextIndex = $tokens->getNextMeaningfulToken($index);
     $nextToken = $tokens[$nextIndex];
     if ($nextToken->isGivenKind(T_NS_SEPARATOR)) {
         $token->override(array(CT::T_NAMESPACE_OPERATOR, $token->getContent()));
     }
 }

コード例 #7

ファイル: NullableTypeTransformer.php プロジェクト: fabpot/php-cs-fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if (!$token->equals('?')) {
         return;
     }
     $prevIndex = $tokens->getPrevMeaningfulToken($index);
     $prevToken = $tokens[$prevIndex];
     if ($prevToken->equalsAny(array('(', ',', array(CT::T_TYPE_COLON)))) {
         $token->override(array(CT::T_NULLABLE_TYPE, '?'));
     }
 }

コード例 #8

ファイル: ClassConstantTransformer.php プロジェクト: fabpot/php-cs-fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if (!$token->equalsAny(array(array(T_CLASS, 'class'), array(T_STRING, 'class')), false)) {
         return;
     }
     $prevIndex = $tokens->getPrevMeaningfulToken($index);
     $prevToken = $tokens[$prevIndex];
     if ($prevToken->isGivenKind(T_DOUBLE_COLON)) {
         $token->override(array(CT::T_CLASS_CONSTANT, $token->getContent()));
     }
 }

コード例 #9

ファイル: ClassConstantTransformer.php プロジェクト: infinitely-young/PHP-CS-Fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if (!$token->isGivenKind(T_CLASS)) {
         return;
     }
     $prevIndex = $tokens->getPrevMeaningfulToken($index);
     $prevToken = $tokens[$prevIndex];
     if ($prevToken->isGivenKind(T_DOUBLE_COLON)) {
         $token->override(array(CT_CLASS_CONSTANT, $token->getContent()));
     }
 }

コード例 #10

ファイル: TypeAlternationTransformer.php プロジェクト: fabpot/php-cs-fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if (!$token->equals('|')) {
         return;
     }
     $prevIndex = $tokens->getPrevMeaningfulToken($index);
     $prevToken = $tokens[$prevIndex];
     if (!$prevToken->isGivenKind(T_STRING)) {
         return;
     }
     $prevIndex = $tokens->getPrevMeaningfulToken($prevIndex);
     $prevToken = $tokens[$prevIndex];
     if (!$prevToken->equalsAny(array('(', array(CT::T_TYPE_ALTERNATION)))) {
         return;
     }
     $token->override(array(CT::T_TYPE_ALTERNATION, '|'));
 }

コード例 #11

ファイル: TypeColonTransformer.php プロジェクト: fabpot/php-cs-fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if (!$token->equals(':')) {
         return;
     }
     $endIndex = $tokens->getPrevMeaningfulToken($index);
     if (!$tokens[$endIndex]->equals(')')) {
         return;
     }
     $startIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $endIndex, false);
     $prevIndex = $tokens->getPrevMeaningfulToken($startIndex);
     $prevToken = $tokens[$prevIndex];
     // if this could be a function name we need to take one more step
     if ($prevToken->isGivenKind(T_STRING)) {
         $prevIndex = $tokens->getPrevMeaningfulToken($prevIndex);
         $prevToken = $tokens[$prevIndex];
     }
     if ($prevToken->isGivenKind(array(T_FUNCTION, CT::T_RETURN_REF, CT::T_USE_LAMBDA))) {
         $token->override(array(CT::T_TYPE_COLON, ':'));
     }
 }

コード例 #12

ファイル: CurlyBraceTransformer.php プロジェクト: fabpot/php-cs-fixer

 private function transformIntoGroupUseBraces(Tokens $tokens, Token $token, $index)
 {
     if (!$token->equals('{')) {
         return;
     }
     $prevIndex = $tokens->getPrevMeaningfulToken($index);
     if (!$tokens[$prevIndex]->isGivenKind(T_NS_SEPARATOR)) {
         return;
     }
     $closeIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $index);
     $closeToken = $tokens[$closeIndex];
     $token->override(array(CT::T_GROUP_IMPORT_BRACE_OPEN, '{'));
     $closeToken->override(array(CT::T_GROUP_IMPORT_BRACE_CLOSE, '}'));
 }

コード例 #13

ファイル: TokenTest.php プロジェクト: cryode/PHP-CS-Fixer

 public function testIsEmpty()
 {
     $braceToken = $this->getBraceToken();
     $this->assertFalse($braceToken->isEmpty());
     $braceToken->setContent('');
     $this->assertTrue($braceToken->isEmpty());
     $whitespaceToken = new Token(array(T_WHITESPACE, ' '));
     $this->assertFalse($whitespaceToken->isEmpty());
     $whitespaceToken->setContent('');
     $this->assertTrue($whitespaceToken->isEmpty());
     $whitespaceToken->override(array(null, ''));
     $this->assertTrue($whitespaceToken->isEmpty());
     $whitespaceToken = new Token(array(T_WHITESPACE, ' '));
     $whitespaceToken->clear();
     $this->assertTrue($whitespaceToken->isEmpty());
 }

コード例 #14

ファイル: CurlyBraceTransformer.php プロジェクト: phansys/PHP-CS-Fixer

 private function transformIntoCurlyIndexBraces(Tokens $tokens, Token $token, $index)
 {
     if (!$token->equals('{')) {
         return;
     }
     $prevIndex = $tokens->getPrevMeaningfulToken($index);
     if (!$tokens[$prevIndex]->equalsAny(array(array(T_STRING), array(T_VARIABLE), array(CT_ARRAY_INDEX_CURLY_BRACE_CLOSE), array(CT_ARRAY_SQUARE_BRACE_CLOSE), ']', ')'))) {
         return;
     }
     if ($tokens[$prevIndex]->isGivenKind(T_STRING) && !$tokens[$tokens->getPrevMeaningfulToken($prevIndex)]->isGivenKind(T_OBJECT_OPERATOR)) {
         return;
     }
     if ($tokens[$prevIndex]->equals(')') && !$tokens[$tokens->getPrevMeaningfulToken($tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $prevIndex, false))]->isGivenKind(T_ARRAY)) {
         return;
     }
     $closeIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $index);
     $closeToken = $tokens[$closeIndex];
     $token->override(array(CT_ARRAY_INDEX_CURLY_BRACE_OPEN, '{'));
     $closeToken->override(array(CT_ARRAY_INDEX_CURLY_BRACE_CLOSE, '}'));
 }

コード例 #15

ファイル: ReturnRefTransformer.php プロジェクト: GrahamForks/PHP-CS-Fixer

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if ($token->equals('&') && $tokens[$tokens->getPrevMeaningfulToken($index)]->isGivenKind(T_FUNCTION)) {
         $token->override(array(CT_RETURN_REF, '&'));
     }
 }