setFilepath() public method

public setFilepath ( string $filepath )
$filepath string
Example #1
0
 protected function parseTopDefinitions($topStatement, $aliasManager, $filepath, $namespace)
 {
     foreach ($topStatement as $statement) {
         if ($statement instanceof Node\Stmt\Use_) {
             if (!empty($statement->uses)) {
                 foreach ($statement->uses as $use) {
                     $aliasManager->add($use->name->parts);
                 }
             }
         } elseif ($statement instanceof Node\Stmt\Class_) {
             $definition = new ClassDefinition($statement->name, $statement->type);
             $definition->setFilepath($filepath);
             $definition->setNamespace($namespace);
             foreach ($statement->stmts as $stmt) {
                 if ($stmt instanceof Node\Stmt\ClassMethod) {
                     $method = new ClassMethod($stmt->name, $stmt, $stmt->type);
                     $definition->addMethod($method);
                 } elseif ($stmt instanceof Node\Stmt\Property) {
                     $definition->addProperty($stmt);
                 } elseif ($stmt instanceof Node\Stmt\ClassConst) {
                     $definition->addConst($stmt);
                 }
             }
             $this->getCompiler()->addClass($definition);
         } elseif ($statement instanceof Node\Stmt\Function_) {
             $definition = new FunctionDefinition($statement->name, $statement);
             $definition->setFilepath($filepath);
             $definition->setNamespace($namespace);
             $this->getCompiler()->addFunction($definition);
         }
     }
 }
Example #2
0
 /**
  * @param Node\Stmt|Node\Stmt[] $topStatement
  * @param AliasManager $aliasManager
  * @param string $filepath
  */
 protected function parseTopDefinitions($topStatement, AliasManager $aliasManager, $filepath)
 {
     foreach ($topStatement as $statement) {
         if ($statement instanceof Node\Stmt\Use_) {
             if (count($statement->uses) > 0) {
                 foreach ($statement->uses as $use) {
                     $aliasManager->add($use->name->parts);
                 }
             }
         } elseif ($statement instanceof Node\Stmt\GroupUse) {
             if (count($statement->uses) > 0) {
                 foreach ($statement->uses as $use) {
                     $aliasManager->add($statement->prefix . $use->name->parts);
                 }
             }
         } elseif ($statement instanceof Node\Stmt\Trait_) {
             $definition = new TraitDefinition($statement->name, $statement);
             $definition->setFilepath($filepath);
             $definition->setNamespace($aliasManager->getNamespace());
             $definition->precompile();
             $this->compiler->addTrait($definition);
         } elseif ($statement instanceof Node\Stmt\Class_) {
             $definition = new ClassDefinition($statement->name, $statement, $statement->type);
             $definition->setFilepath($filepath);
             $definition->setNamespace($aliasManager->getNamespace());
             if ($statement->extends) {
                 $definition->setExtendsClass($statement->extends->toString());
             }
             if ($statement->implements) {
                 foreach ($statement->implements as $interface) {
                     $definition->addInterface($interface->toString());
                 }
             }
             foreach ($statement->stmts as $stmt) {
                 if ($stmt instanceof Node\Stmt\ClassMethod) {
                     $definition->addMethod(new ClassMethod($stmt->name, $stmt, $stmt->type));
                 } elseif ($stmt instanceof Node\Stmt\Property) {
                     $definition->addProperty($stmt);
                 } elseif ($stmt instanceof Node\Stmt\TraitUse) {
                     foreach ($stmt->traits as $traitPart) {
                         $traitDefinition = $this->compiler->getTrait($traitPart->toString());
                         if ($traitDefinition) {
                             $definition->mergeTrait($traitDefinition, $stmt->adaptations);
                         }
                     }
                 } elseif ($stmt instanceof Node\Stmt\ClassConst) {
                     $definition->addConst($stmt);
                 }
             }
             $this->compiler->addClass($definition);
         } elseif ($statement instanceof Node\Stmt\Function_) {
             $definition = new FunctionDefinition($statement->name, $statement);
             $definition->setFilepath($filepath);
             $definition->setNamespace($aliasManager->getNamespace());
             $this->compiler->addFunction($definition);
         }
     }
 }
Example #3
0
 /**
  * @param string $filepath
  * @param Parser $parser
  * @param Context $context
  */
 protected function parserFile($filepath, Parser $parser, Context $context)
 {
     try {
         if (!is_readable($filepath)) {
             throw new RuntimeException('File ' . $filepath . ' is not readable');
         }
         $code = file_get_contents($filepath);
         $stmts = $parser->parse($code);
         /**
          * Step 1 Precompile
          */
         if ($stmts[0] instanceof Node\Stmt\Namespace_) {
             $stmts = $stmts[0]->stmts;
         }
         foreach ($stmts as $st) {
             if ($st instanceof Node\Stmt\Class_) {
                 $classDefintion = new ClassDefinition($st->name);
                 $classDefintion->setFilepath($filepath);
                 foreach ($st->stmts as $st) {
                     if ($st instanceof Node\Stmt\ClassMethod) {
                         $method = new ClassMethod($st->name, $st->stmts, $st->type, $st);
                         $classDefintion->addMethod($method);
                     } elseif ($st instanceof Node\Stmt\Property) {
                         $classDefintion->addProperty($st);
                     } elseif ($st instanceof Node\Stmt\ClassConst) {
                         $classDefintion->addConst($st);
                     }
                 }
                 $this->classes[] = $classDefintion;
             }
         }
         $context->clear();
     } catch (\PhpParser\Error $e) {
         $context->sytaxError($e, $filepath);
     } catch (Exception $e) {
         $context->output->writeln("<error>{$e->getMessage()}</error>");
     }
 }