PHP Tokenizer\Token类代码示例

 public static function calculateTrailingWhitespaceIndent(Token $token)
 {
     if (!$token->isWhitespace()) {
         throw new \InvalidArgumentException('The given token must be whitespace.');
     }
     return ltrim(strrchr(str_replace(array("\r\n", "\r"), "\n", $token->getContent()), 10), "\n");
 }

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

 /**
  * Check if token is equals to given one.
  *
  * If tokens are arrays, then only keys defined in parameter token are checked.
  *
  * @param Token|array|string $other         token or it's prototype
  * @param bool               $caseSensitive perform a case sensitive comparison
  *
  * @return bool
  */
 public function equals($other, $caseSensitive = true)
 {
     $otherPrototype = $other instanceof Token ? $other->getPrototype() : $other;
     if ($this->isArray() !== is_array($otherPrototype)) {
         return false;
     }
     if (!$this->isArray()) {
         return $this->content === $otherPrototype;
     }
     $selfPrototype = $this->getPrototype();
     foreach ($otherPrototype as $key => $val) {
         // make sure the token has such key
         if (!isset($selfPrototype[$key])) {
             return false;
         }
         if (1 === $key && !$caseSensitive) {
             // case-insensitive comparison only applies to the content (key 1)
             if (0 !== strcasecmp($val, $selfPrototype[1])) {
                 return false;
             }
         } else {
             // regular comparison
             if ($selfPrototype[$key] !== $val) {
                 return false;
             }
         }
     }
     return true;
 }

 private function fixWhitespace(Token $token)
 {
     $content = $token->getContent();
     if (substr_count($content, "\n") > 1) {
         $lines = Utils::splitLines($content);
         $token->setContent("\n" . end($lines));
     }
 }

 /**
  * {@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, ']'));
 }

 /**
  * {@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()));
     }
 }

 /**
  * Cleanup a whitespace token.
  *
  * @param Token $token
  */
 private function fixWhitespace(Token $token)
 {
     $content = $token->getContent();
     // if there is more than one new line in the whitespace, then we need to fix it
     if (substr_count($content, "\n") > 1) {
         // the final bit of the whitespace must be the next statement's indentation
         $lines = Utils::splitLines($content);
         $token->setContent("\n" . end($lines));
     }
 }

 /**
  * {@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()));
     }
 }

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

 /**
  * {@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()));
     }
 }

 private function isValidList(Tokens $tokens, Token $docsToken, $listIndex)
 {
     $endIndex = $tokens->getNextTokenOfKind($listIndex, array(')'));
     $docsContent = $docsToken->getContent();
     for ($index = $listIndex + 1; $index < $endIndex; ++$index) {
         $token = $tokens[$index];
         if ($token->isGivenKind(T_VARIABLE) && false !== strpos($docsContent, $token->getContent())) {
             return true;
         }
     }
     return false;
 }

 /**
  * {@inheritdoc}
  */
 public function process(Tokens $tokens, Token $token, $index)
 {
     if (!$token->isComment()) {
         return;
     }
     $content = $token->getContent();
     $trimmedContent = rtrim($content);
     // nothing trimmed, nothing to do
     if ($content === $trimmedContent) {
         return;
     }
     $whitespaces = substr($content, strlen($trimmedContent));
     $token->setContent($trimmedContent);
     if (isset($tokens[$index + 1]) && $tokens[$index + 1]->isGivenKind(T_WHITESPACE)) {
         $tokens[$index + 1]->setContent($whitespaces . $tokens[$index + 1]->getContent());
     } else {
         $tokens->insertAt($index + 1, new Token(array(T_WHITESPACE, $whitespaces)));
     }
 }

 /**
  * Checks variable assignments for correct docblock usage.
  *
  * @param Tokens $tokens
  * @param Token  $docsToken     docs Token
  * @param int    $variableIndex index of variable Token
  *
  * @return bool
  */
 private function isValidVariable(Tokens $tokens, Token $docsToken, $variableIndex)
 {
     $nextIndex = $tokens->getNextMeaningfulToken($variableIndex);
     if (!$tokens[$nextIndex]->equals('=')) {
         return false;
     }
     return false !== strpos($docsToken->getContent(), $tokens[$variableIndex]->getContent());
 }

 /**
  * If given token is a single line whitespace then fix it to be a single space.
  *
  * @param Token $token
  */
 private function fixWhitespace(Token $token)
 {
     if ($token->isWhitespace(" \t")) {
         $token->setContent(' ');
     }
 }

 private function fixWhitespace(Token $token)
 {
     if ($token->isWhitespace(array('whitespaces' => " \t"))) {
         $token->setContent(' ');
     }
 }