PHP Tokens::clearCache方法代码示例

 /**
  * @param int    $expected
  * @param string $code
  * @param int    $index
  *
  * @dataProvider provideCommentBlockStartDetectionCases
  */
 public function testCommentBlockStartDetection($expected, $code, $index)
 {
     Tokens::clearCache();
     $tokens = Tokens::fromCode($code);
     $fixer = $this->getFixer();
     $method = new \ReflectionMethod($fixer, 'findCommentBlockStart');
     $method->setAccessible(true);
     if ($expected !== ($result = $method->invoke($fixer, $tokens, $index))) {
         $this->fail(sprintf('Expected index %d (%s) got index %d (%s).', $expected, $tokens[$expected]->toJson(), $result, $tokens[$result]->toJson()));
     }
 }

 /**
  * @return array
  */
 public function fix()
 {
     $changed = array();
     $config = $this->config;
     $finder = $config->getFinder();
     $finderIterator = $finder instanceof \IteratorAggregate ? $finder->getIterator() : $finder;
     $fileFilteredFileIterator = new FileFilterIterator($finderIterator, $this->eventDispatcher, $this->cacheManager);
     $collection = $this->linter->isAsync() ? new FileCachingLintingIterator($fileFilteredFileIterator, $this->linter) : new FileLintingIterator($fileFilteredFileIterator, $this->linter);
     foreach ($collection as $file) {
         $fixInfo = $this->fixFile($file, $collection->currentLintingResult());
         if ($fixInfo) {
             $name = $this->getFileRelativePathname($file);
             $changed[$name] = $fixInfo;
         }
         // we do not need Tokens to still caching just fixed file - so clear the cache
         Tokens::clearCache();
     }
     return $changed;
 }

 /**
  * @dataProvider provideFindHeaderCommentInsertionIndexCases
  */
 public function testFindHeaderCommentInsertionIndex($expected, $code, array $config)
 {
     Tokens::clearCache();
     $tokens = Tokens::fromCode($code);
     $fixer = $this->getFixer();
     $fixer->configure($config);
     $method = new \ReflectionMethod($fixer, 'findHeaderCommentInsertionIndex');
     $method->setAccessible(true);
     $this->assertSame($expected, $method->invoke($fixer, $tokens));
 }

 /**
  * @param string  $source
  * @param int[]   $indexes
  * @param Token[] $expected
  */
 private function doTestClearTokens($source, array $indexes, array $expected)
 {
     Tokens::clearCache();
     $tokens = Tokens::fromCode($source);
     foreach ($indexes as $index) {
         $tokens->clearTokenAndMergeSurroundingWhitespace($index);
     }
     $this->assertSame(count($expected), $tokens->count());
     foreach ($expected as $index => $expectedToken) {
         $token = $tokens[$index];
         $expectedPrototype = $expectedToken->getPrototype();
         if (is_array($expectedPrototype)) {
             unset($expectedPrototype[2]);
             // don't compare token lines as our token mutations don't deal with line numbers
         }
         $this->assertTrue($token->equals($expectedPrototype), sprintf('The token at index %d should be %s, got %s', $index, json_encode($expectedPrototype), $token->toJson()));
     }
 }

 /**
  * Tests if a fixer fixes a given string to match the expected result.
  *
  * It is used both if you want to test if something is fixed or if it is not touched by the fixer.
  * It also makes sure that the expected output does not change when run through the fixer. That means that you
  * do not need two test cases like [$expected] and [$expected, $input] (where $expected is the same in both cases)
  * as the latter covers both of them.
  * This method throws an exception if $expected and $input are equal to prevent test cases that accidentally do
  * not test anything.
  *
  * @param string              $expected The expected fixer output.
  * @param string|null         $input    The fixer input, or null if it should intentionally be equal to the output.
  * @param \SplFileInfo|null   $file     The file to fix, or null if unneeded.
  * @param FixerInterface|null $fixer    The fixer to be used, or null if it should be inferred from the test name.
  */
 protected function doTest($expected, $input = null, \SplFileInfo $file = null, FixerInterface $fixer = null)
 {
     if ($expected === $input) {
         throw new \InvalidArgumentException('Input parameter must not be equal to expected parameter.');
     }
     $fixer = $fixer ?: $this->getFixer();
     $file = $file ?: $this->getTestFile();
     $fileIsSupported = $fixer->supports($file);
     if (null !== $input) {
         $this->assertNull($this->lintSource($input));
         Tokens::clearCache();
         $tokens = Tokens::fromCode($input);
         if ($fileIsSupported) {
             $this->assertTrue($fixer->isCandidate($tokens), 'Fixer must be a candidate for input code.');
             $fixResult = $fixer->fix($file, $tokens);
             $this->assertNull($fixResult, '->fix method must return null.');
         }
         $this->assertTrue($tokens->isChanged(), 'Tokens collection built on input code must be marked as changed after fixing.');
         $this->assertSame($expected, $tokens->generateCode(), 'Code build on input code must match expected code.');
         Tokens::clearCache();
         $expectedTokens = Tokens::fromCode($expected);
         $tokens->clearEmptyTokens();
         $this->assertTokens($expectedTokens, $tokens);
     }
     $this->assertNull($this->lintSource($expected));
     Tokens::clearCache();
     $tokens = Tokens::fromCode($expected);
     if ($fileIsSupported) {
         $fixResult = $fixer->fix($file, $tokens);
         $this->assertNull($fixResult, '->fix method must return null.');
     }
     $this->assertFalse($tokens->isChanged(), 'Tokens collection built on expected code must not be marked as changed after fixing.');
     $this->assertSame($expected, $tokens->generateCode(), 'Code build on expected code must not change.');
 }

 private function fixFile(\SplFileInfo $file, LintingResultInterface $lintingResult)
 {
     $name = $this->getFileRelativePathname($file);
     try {
         $lintingResult->check();
     } catch (LintingException $e) {
         $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_INVALID));
         $this->errorsManager->report(new Error(Error::TYPE_INVALID, $name));
         return;
     }
     $fixers = $this->config->getFixers();
     $old = file_get_contents($file->getRealPath());
     $new = $old;
     $name = $this->getFileRelativePathname($file);
     $appliedFixers = array();
     // we do not need Tokens to still caching previously fixed file - so clear the cache
     Tokens::clearCache();
     $tokens = Tokens::fromCode($old);
     $newHash = $oldHash = $tokens->getCodeHash();
     try {
         foreach ($fixers as $fixer) {
             if (!$fixer->supports($file) || !$fixer->isCandidate($tokens)) {
                 continue;
             }
             $fixer->fix($file, $tokens);
             if ($tokens->isChanged()) {
                 $tokens->clearEmptyTokens();
                 $tokens->clearChanged();
                 $appliedFixers[] = $fixer->getName();
             }
         }
     } catch (\Exception $e) {
         $this->processException($name);
         return;
     } catch (\Throwable $e) {
         $this->processException($name);
         return;
     }
     $fixInfo = null;
     if (!empty($appliedFixers)) {
         $new = $tokens->generateCode();
         $newHash = $tokens->getCodeHash();
     }
     // We need to check if content was changed and then applied changes.
     // But we can't simple check $appliedFixers, because one fixer may revert
     // work of other and both of them will mark collection as changed.
     // Therefore we need to check if code hashes changed.
     if ($oldHash !== $newHash) {
         try {
             $this->linter->lintSource($new)->check();
         } catch (LintingException $e) {
             $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_LINT));
             $this->errorsManager->report(new Error(Error::TYPE_LINT, $name));
             return;
         }
         if (!$this->isDryRun) {
             if (false === @file_put_contents($file->getRealPath(), $new)) {
                 $error = error_get_last();
                 if ($error) {
                     throw new IOException(sprintf('Failed to write file "%s", "%s".', $file->getRealPath(), $error['message']), 0, null, $file->getRealPath());
                 }
                 throw new IOException(sprintf('Failed to write file "%s".', $file->getRealPath()), 0, null, $file->getRealPath());
             }
         }
         $fixInfo = array('appliedFixers' => $appliedFixers, 'diff' => $this->differ->diff($old, $new));
     }
     $this->cacheManager->setFile($name, $new);
     $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus($fixInfo ? FixerFileProcessedEvent::STATUS_FIXED : FixerFileProcessedEvent::STATUS_NO_CHANGES));
     return $fixInfo;
 }

 /**
  * Tests if a fixer fixes a given string to match the expected result.
  *
  * It is used both if you want to test if something is fixed or if it is not touched by the fixer.
  * It also makes sure that the expected output does not change when run through the fixer. That means that you
  * do not need two test cases like [$expected] and [$expected, $input] (where $expected is the same in both cases)
  * as the latter covers both of them.
  * This method throws an exception if $expected and $input are equal to prevent test cases that accidentally do
  * not test anything.
  *
  * @param string              $expected The expected fixer output
  * @param string|null         $input    The fixer input, or null if it should intentionally be equal to the output
  * @param \SplFileInfo|null   $file     The file to fix, or null if unneeded
  * @param FixerInterface|null $fixer    The fixer to be used, or null if it should be inferred from the test name
  */
 protected function doTest($expected, $input = null, \SplFileInfo $file = null, FixerInterface $fixer = null)
 {
     if ($expected === $input) {
         throw new \InvalidArgumentException('Input parameter must not be equal to expected parameter.');
     }
     $fixer = $fixer ?: $this->getFixer();
     $file = $file ?: $this->getTestFile();
     $fileIsSupported = $fixer->supports($file);
     if (null !== $input) {
         $this->assertNull($this->lintSource($input));
         Tokens::clearCache();
         $tokens = Tokens::fromCode($input);
         if ($fileIsSupported) {
             $this->assertTrue($fixer->isCandidate($tokens), 'Fixer must be a candidate for input code.');
             $fixResult = $fixer->fix($file, $tokens);
             $this->assertNull($fixResult, '->fix method must return null.');
         }
         $this->assertSame($expected, $tokens->generateCode(), 'Code build on input code must match expected code.');
         $this->assertTrue($tokens->isChanged(), 'Tokens collection built on input code must be marked as changed after fixing.');
         $tokens->clearEmptyTokens();
         $this->assertSame(count($tokens), count(array_unique(array_map(function (Token $token) {
             return spl_object_hash($token);
         }, $tokens->toArray()))), 'Token items inside Tokens collection must be unique.');
         Tokens::clearCache();
         $expectedTokens = Tokens::fromCode($expected);
         $this->assertTokens($expectedTokens, $tokens);
     }
     $this->assertNull($this->lintSource($expected));
     Tokens::clearCache();
     $tokens = Tokens::fromCode($expected);
     $isCandidate = $fixer->isCandidate($tokens);
     $this->assertFalse($tokens->isChanged(), 'Fixer should not touch Tokens on candidate check.');
     if (!$isCandidate) {
         return;
     }
     if ($fileIsSupported) {
         $fixResult = $fixer->fix($file, $tokens);
         $this->assertNull($fixResult, '->fix method must return null.');
     }
     $this->assertSame($expected, $tokens->generateCode(), 'Code build on expected code must not change.');
     $this->assertFalse($tokens->isChanged(), 'Tokens collection built on expected code must not be marked as changed after fixing.');
 }

 /**
  * @dataProvider provideBlockDetectionCases
  */
 public function testBlockDetection(array $expected, $source, $index)
 {
     Tokens::clearCache();
     $tokens = Tokens::fromCode($source);
     $fixer = $this->getFixer();
     $method = new \ReflectionMethod($fixer, 'getPreviousBlock');
     $method->setAccessible(true);
     $result = $method->invoke($fixer, $tokens, $index);
     $this->assertSame($expected, $result);
 }

 public function fixFile(\SplFileInfo $file, array $fixers, $dryRun, $diff, FileCacheManager $fileCacheManager)
 {
     $new = $old = file_get_contents($file->getRealPath());
     $name = $this->getFileRelativePathname($file);
     if ('' === $old || !$fileCacheManager->needFixing($name, $old) || PHP_VERSION_ID >= 50306 && PHP_VERSION_ID < 50400 && false !== stripos($old, '__halt_compiler()')) {
         $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_SKIPPED));
         return;
     }
     try {
         $this->linter->lintFile($file->getRealPath());
     } catch (LintingException $e) {
         $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_INVALID));
         $this->errorsManager->report(new Error(Error::TYPE_INVALID, $name));
         return;
     }
     $appliedFixers = array();
     // we do not need Tokens to still caching previously fixed file - so clear the cache
     Tokens::clearCache();
     $tokens = Tokens::fromCode($old);
     $newHash = $oldHash = $tokens->getCodeHash();
     try {
         foreach ($fixers as $fixer) {
             if (!$fixer->supports($file) || !$fixer->isCandidate($tokens)) {
                 continue;
             }
             $fixer->fix($file, $tokens);
             if ($tokens->isChanged()) {
                 $tokens->clearEmptyTokens();
                 $tokens->clearChanged();
                 $appliedFixers[] = $fixer->getName();
             }
         }
     } catch (\Exception $e) {
         $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_EXCEPTION));
         $this->errorsManager->report(new Error(Error::TYPE_EXCEPTION, $name));
         return;
     }
     $fixInfo = null;
     if (!empty($appliedFixers)) {
         $new = $tokens->generateCode();
         $newHash = $tokens->getCodeHash();
     }
     // We need to check if content was changed and then applied changes.
     // But we can't simple check $appliedFixers, because one fixer may revert
     // work of other and both of them will mark collection as changed.
     // Therefore we need to check if code hashes changed.
     if ($oldHash !== $newHash) {
         try {
             $this->linter->lintSource($new);
         } catch (LintingException $e) {
             $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_LINT));
             $this->errorsManager->report(new Error(Error::TYPE_LINT, $name));
             return;
         }
         if (!$dryRun && false === @file_put_contents($file->getRealPath(), $new)) {
             $error = error_get_last();
             if ($error) {
                 throw new IOException(sprintf('Failed to write file "%s", "%s".', $file->getRealpath(), $error['message']), 0, null, $file->getRealpath());
             }
             throw new IOException(sprintf('Failed to write file "%s".', $file->getRealpath()), 0, null, $file->getRealpath());
         }
         $fixInfo = array('appliedFixers' => $appliedFixers);
         if ($diff) {
             $fixInfo['diff'] = $this->stringDiff($old, $new);
         }
     }
     $fileCacheManager->setFile($name, $new);
     $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus($fixInfo ? FixerFileProcessedEvent::STATUS_FIXED : FixerFileProcessedEvent::STATUS_NO_CHANGES));
     return $fixInfo;
 }

 /**
  * @param string $source     valid PHP source code
  * @param int    $startIndex start index of the comment block
  * @param int    $endIndex   expected index of the last token of the block
  * @param bool   $isEmpty    expected value of empty flag returned
  *
  * @dataProvider provideCommentBlockCases
  */
 public function testGetCommentBlock($source, $startIndex, $endIndex, $isEmpty)
 {
     Tokens::clearCache();
     $tokens = Tokens::fromCode($source);
     $this->assertTrue($tokens[$startIndex]->isComment(), sprintf('Misconfiguration of test, expected comment token at index "%d".', $startIndex));
     $fixer = $this->getFixer();
     $method = new \ReflectionMethod($fixer, 'getCommentBlock');
     $method->setAccessible(true);
     list($foundStart, $foundEnd, $foundIsEmpty) = $method->invoke($fixer, $tokens, $startIndex);
     $this->assertSame($startIndex, $foundStart, 'Find start index of block failed.');
     $this->assertSame($endIndex, $foundEnd, 'Find end index of block failed.');
     $this->assertSame($isEmpty, $foundIsEmpty, 'Is empty comment block detection failed.');
 }