Inheritance: extends Symfony\Component\Finder\SplFileInfo, implements SensioLabs\DeprecationDetector\FileInfo\DeprecationCollectionInterface
 /**
  * {@inheritdoc}
  */
 public function enterNode(Node $node)
 {
     if ($node instanceof Node\Stmt\ClassLike) {
         if (isset($node->namespacedName)) {
             $this->parentName = $node->namespacedName->toString();
         } else {
             $this->parentName = $node->name;
         }
     }
     if ($node instanceof Node\Expr\MethodCall) {
         // skips concat method names like $twig->{'get'.ucfirst($type)}()
         if ($node->name instanceof Node\Expr\BinaryOp\Concat) {
             return;
         }
         // skips variable methods like $definition->$method
         if (!is_string($node->name)) {
             return;
         }
         $type = $node->var->getAttribute('guessedType', null);
         if (null !== $type) {
             $methodUsage = new MethodUsage($node->name, $type, $node->getLine(), false);
             $this->phpFileInfo->addMethodUsage($methodUsage);
         }
     }
 }
 /**
  * {@inheritdoc}
  */
 public function enterNode(Node $node)
 {
     if ($node instanceof Node\Stmt\ClassLike) {
         if ($node instanceof Node\Stmt\Class_ && $node->isAnonymous()) {
             return;
         }
         $this->parentName = $node->namespacedName->toString();
     }
     if (!$this->hasDeprecatedDocComment($node)) {
         return;
     }
     if ($node instanceof Node\Stmt\Function_) {
         $this->phpFileInfo->addFunctionDeprecation(new FunctionDeprecation($node->name, $this->getDeprecatedDocComment($node)));
         return;
     }
     if ($node instanceof Node\Stmt\Class_) {
         $this->phpFileInfo->addClassDeprecation(new ClassDeprecation($this->parentName, $this->getDeprecatedDocComment($node)));
         return;
     }
     if ($node instanceof Node\Stmt\Interface_) {
         $this->phpFileInfo->addInterfaceDeprecation(new InterfaceDeprecation($this->parentName, $this->getDeprecatedDocComment($node)));
         return;
     }
     if ($node instanceof Node\Stmt\ClassMethod) {
         $this->phpFileInfo->addMethodDeprecation(new MethodDeprecation($this->parentName, $node->name, $this->getDeprecatedDocComment($node)));
         return;
     }
 }
 /**
  * {@inheritdoc}
  */
 public function enterNode(Node $node)
 {
     if ($node instanceof Node\Expr\New_ && $node->class instanceof Node\Name) {
         $classUsage = new ClassUsage($node->class->toString(), $node->getLine());
         $this->phpFileInfo->addClassUsage($classUsage);
     }
 }
 /**
  * {@inheritdoc}
  */
 public function enterNode(Node $node)
 {
     if ($node instanceof Node\Param && $node->type instanceof Node\Name) {
         $typeHintUsage = new TypeHintUsage($node->type->toString(), $node->getLine());
         $this->phpFileInfo->addTypeHintUsage($typeHintUsage);
     }
 }
 /**
  * {@inheritdoc}
  */
 public function enterNode(Node $node)
 {
     if ($node instanceof Node\Stmt\Class_ && $node->extends instanceof Node\Name) {
         $superTypeUsage = new SuperTypeUsage($node->extends->toString(), $node->namespacedName->toString(), $node->getLine());
         $this->phpFileInfo->addSuperTypeUsage($superTypeUsage);
     }
 }
 /**
  * {@inheritdoc}
  */
 public function check(PhpFileInfo $phpFileInfo, RuleSet $ruleSet)
 {
     $violations = array();
     foreach ($phpFileInfo->getDeprecatedLanguageUsages() as $deprecatedLanguageUsage) {
         $violations[] = new Violation($deprecatedLanguageUsage, $phpFileInfo, $deprecatedLanguageUsage->comment());
     }
     return $violations;
 }
 /**
  * {@inheritdoc}
  */
 public function check(PhpFileInfo $phpFileInfo, RuleSet $ruleSet)
 {
     $violations = array();
     foreach ($phpFileInfo->getFunctionUsages() as $functionUsage) {
         if ($ruleSet->hasFunction($functionUsage->name())) {
             $violations[] = new Violation($functionUsage, $phpFileInfo, $ruleSet->getFunction($functionUsage->name())->comment());
         }
     }
     return $violations;
 }
 /**
  * {@inheritdoc}
  */
 public function check(PhpFileInfo $phpFileInfo)
 {
     $violations = array();
     foreach ($phpFileInfo->classUsages() as $classUsage) {
         if ($this->ruleSet->hasClass($classUsage->name())) {
             $violations[] = new Violation($classUsage, $phpFileInfo, $this->ruleSet->getClass($classUsage->name())->comment());
         }
     }
     return $violations;
 }
 /**
  * @param PhpFileInfo $phpFileInfo
  *
  * @return PhpFileInfo
  */
 public function parseFile(PhpFileInfo $phpFileInfo)
 {
     $nodes = $this->parse($phpFileInfo->getContents());
     $nodes = $this->nameResolver->traverse($nodes);
     $nodes = $this->staticTraverser->traverse($nodes);
     foreach ($this->violationVisitors as $visitor) {
         $visitor->setPhpFileInfo($phpFileInfo);
     }
     $this->violationTraverser->traverse($nodes);
     return $phpFileInfo;
 }
 /**
  * {@inheritdoc}
  */
 public function check(PhpFileInfo $phpFileInfo, RuleSet $ruleSet)
 {
     $violations = array();
     foreach ($phpFileInfo->interfaceUsages() as $interfaceUsageGroup) {
         foreach ($interfaceUsageGroup as $interfaceUsage) {
             if ($ruleSet->hasInterface($interfaceUsage->name())) {
                 $violations[] = new Violation($interfaceUsage, $phpFileInfo, $ruleSet->getInterface($interfaceUsage->name())->comment());
             }
         }
     }
     return $violations;
 }
 /**
  * {@inheritdoc}
  */
 public function check(PhpFileInfo $phpFileInfo, RuleSet $ruleSet)
 {
     $violations = array();
     foreach ($phpFileInfo->typeHintUsages() as $typeHintUsage) {
         $isClass = $ruleSet->hasClass($typeHintUsage->name());
         if ($isClass || $ruleSet->hasInterface($typeHintUsage->name())) {
             $usage = $isClass ? new ClassUsage($typeHintUsage->name(), $typeHintUsage->getLineNumber()) : new InterfaceUsage($typeHintUsage->name(), '', $typeHintUsage->getLineNumber());
             $comment = $isClass ? $ruleSet->getClass($typeHintUsage->name())->comment() : $ruleSet->getInterface($typeHintUsage->name())->comment();
             $violations[] = new Violation($usage, $phpFileInfo, $comment);
         }
     }
     return $violations;
 }
 /**
  * {@inheritdoc}
  */
 public function check(PhpFileInfo $phpFileInfo)
 {
     $violations = array();
     foreach ($phpFileInfo->methodDefinitions() as $methodDefinition) {
         $ancestors = $this->ancestorResolver->getClassAncestors($phpFileInfo, $methodDefinition->parentName());
         foreach ($ancestors as $ancestor) {
             if ($this->ruleSet->hasMethod($methodDefinition->name(), $ancestor)) {
                 $violations[] = new Violation($methodDefinition, $phpFileInfo, $this->ruleSet->getMethod($methodDefinition->name(), $ancestor)->comment());
             }
         }
     }
     return $violations;
 }
 /**
  * {@inheritdoc}
  */
 public function enterNode(Node $node)
 {
     if ($node instanceof Node\Stmt\ClassLike) {
         if (isset($node->namespacedName)) {
             $this->parentName = $node->namespacedName->toString();
         } else {
             $this->parentName = $node->name;
         }
     }
     if ($node instanceof Node\Stmt\ClassMethod) {
         $methodDefinition = new MethodDefinition($node->name, $this->parentName, $node->getLine());
         $this->phpFileInfo->addMethodDefinition($methodDefinition);
     }
 }
    public function testVariableResolver()
    {
        $source = <<<'EOC'
<?php
namespace Foo;
class Bar
{
    function a() {
    }
    function b() {
        $this->a();
        $x = new Bar1();
        $x->a();
        $x->b();
        $c = new Bar2();
        $y = $c;
        $f = $y;
        $f->a();
    }
}
EOC;
        $fileInfo = PhpFileInfo::create($this->prophesize('Symfony\\Component\\Finder\\SplFileInfo')->reveal());
        $contents = $this->traverseSourceAndReturnContents($source, $fileInfo);
        $methodUsages = $contents->methodUsages();
        $this->assertCount(4, $methodUsages);
        $this->assertEquals(new MethodUsage('a', 'Foo\\Bar', 8, false), $methodUsages[0]);
        $this->assertEquals(new MethodUsage('a', 'Bar1', 10, false), $methodUsages[1]);
        $this->assertEquals(new MethodUsage('b', 'Bar1', 11, false), $methodUsages[2]);
        $this->assertEquals(new MethodUsage('a', 'Bar2', 15, false), $methodUsages[3]);
    }
 /**
  * @param int         $current
  * @param PhpFileInfo $file
  */
 public function advance($current, PhpFileInfo $file)
 {
     if (!$this->verbose) {
         return;
     }
     if (1 === $current) {
         $format = '<info>%message%</info>' . "\n" . $this->label . ': <info>%current%</info>/<info>%max%</info>';
         $this->progressBar->clear();
         $this->progressBar->setFormat($format);
     }
     $message = $file->getRelativePathname();
     $this->progressBar->setMessage($message);
     $this->progressBar->clear();
     $this->progressBar->advance();
     $this->progressBar->display();
 }
 /**
  * {@inheritdoc}
  */
 public function enterNode(Node $node)
 {
     if ($node instanceof Node\Expr\AssignRef) {
         $this->phpFileInfo->addDeprecatedLanguageUsage(new DeprecatedLanguageUsage('assign by reference(&=)', 'Since PHP 5.3 use normal assignment instead.', $node->getLine()));
     }
     if ($node instanceof Node\Stmt\Class_) {
         $method = $node->getMethod($node->name);
         if ($method instanceof Node\Stmt\ClassMethod) {
             $this->phpFileInfo->addDeprecatedLanguageUsage(new DeprecatedLanguageUsage('PHP4 constructor', 'Since PHP 7.0, use __construct() instead.', $method->getLine()));
         }
     }
     if ($node instanceof Node\Arg) {
         if (true === $node->byRef) {
             $this->phpFileInfo->addDeprecatedLanguageUsage(new DeprecatedLanguageUsage('call-time pass-by-reference', 'Since PHP 5.3 and removed in PHP 5.4', $node->getLine()));
         }
     }
 }
 /**
  * {@inheritdoc}
  */
 public function check(PhpFileInfo $phpFileInfo, RuleSet $ruleSet)
 {
     $violations = array();
     foreach ($phpFileInfo->methodUsages() as $methodUsage) {
         $className = $methodUsage->className();
         if ($ruleSet->hasMethod($methodUsage->name(), $className)) {
             $violations[] = new Violation($methodUsage, $phpFileInfo, $ruleSet->getMethod($methodUsage->name(), $className)->comment());
         }
         $ancestors = $this->ancestorResolver->getClassAncestors($phpFileInfo, $methodUsage->className());
         foreach ($ancestors as $ancestor) {
             if ($ruleSet->hasMethod($methodUsage->name(), $ancestor)) {
                 $violations[] = new Violation(new MethodUsage($methodUsage->name(), $ancestor, $methodUsage->getLineNumber(), $methodUsage->isStatic()), $phpFileInfo, $ruleSet->getMethod($methodUsage->name(), $ancestor)->comment());
             }
         }
     }
     return $violations;
 }
 /**
  * @return \Iterator
  */
 public function getIterator()
 {
     $iterator = parent::getIterator();
     $files = new \ArrayIterator();
     foreach ($iterator as $file) {
         $file = PhpFileInfo::create($file);
         if (null !== $this->parser) {
             $this->parser->parseFile($file);
         }
         $files->append($file);
     }
     return $files;
 }
    public function testNoNewStatement()
    {
        $source = <<<'EOC'
<?php

$foo = 'hello';
$bar = Bar::bazinga();

EOC;
        $splFileInfo = $this->prophesize('Symfony\\Component\\Finder\\SplFileInfo');
        $usageCollection = $this->parsePhpFileFromStringAndTraverseWithVisitor($file = PhpFileInfo::create($splFileInfo->reveal()), $source, new FindClasses());
        $this->assertEquals(array(), $usageCollection->classUsages());
    }
    public function testClassWithoutInterface()
    {
        $source = <<<EOC
<?php
namespace Foo;

class Bar
{
}
EOC;
        $splFileInfo = $this->prophesize('Symfony\\Component\\Finder\\SplFileInfo');
        $phpFileInfo = $this->parsePhpFileFromStringAndTraverseWithVisitor($file = PhpFileInfo::create($splFileInfo->reveal()), $source, new FindInterfaces());
        $this->assertEquals(array(), $phpFileInfo->interfaceUsages());
    }
    public function testNoNewStatement()
    {
        $source = <<<'EOC'
<?php

$bar = Bar::bazinga();
Logger::log('hello world');

EOC;
        $splFileInfo = $this->prophesize('Symfony\\Component\\Finder\\SplFileInfo');
        $phpFileInfo = $this->parsePhpFileFromStringAndTraverseWithVisitor($file = PhpFileInfo::create($splFileInfo->reveal()), $source, new FindStaticMethodCalls());
        $usages = $phpFileInfo->methodUsages();
        $this->assertEquals(new MethodUsage('bazinga', 'Bar', 3, true), $usages[0]);
        $this->assertEquals(new MethodUsage('log', 'Logger', 4, true), $usages[1]);
    }
 /**
  * @return \Iterator
  */
 public function getIterator()
 {
     $iterator = parent::getIterator();
     $files = new \ArrayIterator();
     foreach ($iterator as $file) {
         $file = PhpFileInfo::create($file);
         if (null !== $this->parser) {
             try {
                 $this->parser->parseFile($file);
             } catch (\PhpParser\Error $ex) {
                 $raw = $ex->getRawMessage() . ' in file ' . $file;
                 $ex->setRawMessage($raw);
                 $this->parserErrors[] = $ex;
             }
         }
         $files->append($file);
     }
     return $files;
 }
    public function testLambdaInClass()
    {
        $source = <<<'EOC'
<?php
namespace Foo;

class Bar
{
    public static function method() {
        function(\A $a, A $a) {};
    }
}
EOC;
        $splFileInfo = $this->prophesize('Symfony\\Component\\Finder\\SplFileInfo');
        $usages = $this->parseFileAndReturnClassUsages($file = PhpFileInfo::create($splFileInfo->reveal()), $source);
        $this->assertCount(2, $usages);
        $this->assertContains('A::7', $usages);
        $this->assertContains('Foo\\A::7', $usages);
    }
 /**
  * @return \Iterator
  */
 public function getIterator()
 {
     $iterator = parent::getIterator();
     $files = new \ArrayIterator();
     $total = $this->count();
     $this->progressOutput->start($total);
     $i = 0;
     foreach ($iterator as $file) {
         $file = PhpFileInfo::create($file);
         try {
             $this->progressOutput->advance(++$i, $file);
             $this->parser->parseFile($file);
         } catch (\PhpParser\Error $ex) {
             $raw = $ex->getRawMessage() . ' in file ' . $file;
             $ex->setRawMessage($raw);
             $this->parserErrors[] = $ex;
         }
         $files->append($file);
     }
     $this->progressOutput->end();
     return $files;
 }
 /**
  * @param string $path
  *
  * @return Result
  */
 public function parsePhpFiles($path)
 {
     $files = $this->finderFactory->createFinder()->in($path);
     $parsedFiles = array();
     $parserErrors = array();
     $this->progressOutput->start($fileCount = $files->count());
     $i = 0;
     foreach ($files->getIterator() as $file) {
         $file = PhpFileInfo::create($file);
         try {
             $this->progressOutput->advance(++$i, $file);
             $this->parser->parseFile($file);
         } catch (Error $ex) {
             $raw = $ex->getRawMessage() . ' in file ' . $file;
             $ex->setRawMessage($raw);
             $parserErrors[] = $ex;
         }
         $parsedFiles[] = $file;
     }
     $this->progressOutput->end();
     return new Result($parsedFiles, $parserErrors, $fileCount);
 }
 /**
  * {@inheritdoc}
  */
 public function enterNode(Node $node)
 {
     if ($node instanceof Node\Expr\FuncCall && $node->name instanceof Node\Name) {
         $this->phpFileInfo->addFunctionUsage(new FunctionUsage($node->name->toString(), $node->getLine()));
     }
 }
 public function testAddAndGetDeprecatedLanguageUsage()
 {
     $fileInfo = PhpFileInfo::create($this->prophesize('Symfony\\Component\\Finder\\SplFileInfo')->reveal());
     $this->assertSame(array(), $fileInfo->getDeprecatedLanguageUsages());
     $deprecatedLanguageUsage = $this->prophesize('SensioLabs\\DeprecationDetector\\FileInfo\\Usage\\DeprecatedLanguageUsage')->reveal();
     $fileInfo->addDeprecatedLanguageUsage($deprecatedLanguageUsage);
     $this->assertSame(array($deprecatedLanguageUsage), $fileInfo->getDeprecatedLanguageUsages());
 }
 /**
  * @param $name
  *
  * @return PhpFileInfo|null
  */
 protected function findDefinitionFileByName($name)
 {
     $namespaceParts = explode('\\', $name);
     $filename = array_pop($namespaceParts) . '.php';
     $namespace = implode('\\', $namespaceParts);
     $finder = new Finder();
     $finder->name($filename)->in($this->sourcePaths);
     $files = array();
     /** @var SplFileInfo $file */
     foreach ($finder as $file) {
         if (empty($namespace) || is_int(strpos($file->getContents(), $namespace))) {
             $baseFile = PhpFileInfo::create($file);
             $files[] = $this->container['parser.usage']->parseFile($baseFile);
         }
     }
     $file = current($files);
     if (!$file instanceof PhpFileInfo) {
         return;
     }
     return $file;
 }
 /**
  * @param PhpFileInfo $file
  *
  * @return TableCell[]
  */
 protected function getFileHeader(PhpFileInfo $file)
 {
     $cell = new TableCell(sprintf('<comment>%s</comment>', $file->getPathname()), array('colspan' => 3));
     return array(new TableCell(), $cell);
 }
 public function testAddAndGetMethodDefinitions()
 {
     $fileInfo = PhpFileInfo::create($this->prophesize('Symfony\\Component\\Finder\\SplFileInfo')->reveal());
     $this->assertSame(array(), $fileInfo->methodDefinitions());
     $methodDefinition = $this->prophesize('SensioLabs\\DeprecationDetector\\FileInfo\\MethodDefinition')->reveal();
     $fileInfo->addMethodDefinition($methodDefinition);
     $this->assertSame(array($methodDefinition), $fileInfo->methodDefinitions());
 }