/** * This method may transform the supplied source and return a new replacement for it * * @param StreamMetaData $metadata Metadata for source * @return boolean Return false if transformation should be stopped */ public function transform(StreamMetaData $metadata) { $totalTransformations = 0; $fileName = $metadata->uri; $astTree = ReflectionEngine::parseFile($fileName, $metadata->source); $parsedSource = new ReflectionFile($fileName, $astTree); // Check if we have some new aspects that weren't loaded yet $unloadedAspects = $this->aspectLoader->getUnloadedAspects(); if (!empty($unloadedAspects)) { $this->loadAndRegisterAspects($unloadedAspects); } $advisors = $this->container->getByTag('advisor'); $namespaces = $parsedSource->getFileNamespaces(); $lineOffset = 0; foreach ($namespaces as $namespace) { $classes = $namespace->getClasses(); foreach ($classes as $class) { // Skip interfaces and aspects if ($class->isInterface() || in_array(Aspect::class, $class->getInterfaceNames())) { continue; } $wasClassProcessed = $this->processSingleClass($advisors, $metadata, $class, $lineOffset); $totalTransformations += (int) $wasClassProcessed; } $wasFunctionsProcessed = $this->processFunctions($advisors, $metadata, $namespace); $totalTransformations += (int) $wasFunctionsProcessed; } // If we return false this will indicate no more transformation for following transformers return $totalTransformations > 0; }
protected function setUp() { $this->originalRefClass = $refClass = new \ReflectionClass(self::STUB_CLASS); $fileName = $refClass->getFileName(); $fileNode = ReflectionEngine::parseFile($fileName); $reflectionFile = new ReflectionFile($fileName, $fileNode); $parsedClass = $reflectionFile->getFileNamespace($refClass->getNamespaceName())->getClass($refClass->getName()); $this->parsedRefClass = $parsedClass; }
protected function setUp() { $fileName = stream_resolve_include_path(__DIR__ . self::STUB_FILE); $fileNode = ReflectionEngine::parseFile($fileName); $reflectionFile = new ReflectionFile($fileName, $fileNode); $parsedFileNamespace = $reflectionFile->getFileNamespace('Go\\ParserReflection\\Stub'); $this->parsedRefFileNamespace = $parsedFileNamespace; include_once $fileName; }
protected function setUp() { $container = $this->getMock(AspectContainer::class); $reader = $this->getMock(Reader::class); $loader = $this->getMock(AspectLoader::class, [], array($container, $reader)); $this->adviceMatcher = new AdviceMatcher($loader, $container); $reflectionFile = new ReflectionFile(__FILE__); $this->reflectionClass = $reflectionFile->getFileNamespace(__NAMESPACE__)->getClass(__CLASS__); }
public function testGetTypeMethod() { if (PHP_VERSION_ID < 70000) { $this->markTestSkipped('Test available only for PHP7.0 and newer'); } foreach ($this->parsedRefFile->getFileNamespaces() as $fileNamespace) { foreach ($fileNamespace->getFunctions() as $refFunction) { $functionName = $refFunction->getName(); foreach ($refFunction->getParameters() as $refParameter) { $parameterName = $refParameter->getName(); $originalRefParameter = new \ReflectionParameter($functionName, $parameterName); $hasType = $refParameter->hasType(); $this->assertSame($originalRefParameter->hasType(), $hasType, "Presence of type for parameter {$functionName}:{$parameterName} should be equal"); if ($hasType) { $parsedReturnType = $refParameter->getType(); $originalReturnType = $originalRefParameter->getType(); $this->assertSame($originalReturnType->allowsNull(), $parsedReturnType->allowsNull()); $this->assertSame($originalReturnType->isBuiltin(), $parsedReturnType->isBuiltin()); $this->assertSame($originalReturnType->__toString(), $parsedReturnType->__toString()); } else { $this->assertSame($originalRefParameter->getType(), $refParameter->getType()); } } } } }
private function buildClass($replacement) { $type = $this->splitNsandClass($replacement['originalFullyQualifiedType']); $class = new ClassGenerator(); $class->setName($type['class']); $class->setNamespaceName($type['ns']); $class->setExtendedClass('\\Brads\\Ppm\\Proxy'); $properties = []; $methods = []; $implementedInterfaces = []; foreach ($versions as $version => $info) { foreach ($info['files'] as $file) { echo "Parsing: " . $this->vendorDir . '/' . $package . '/' . $version . '/' . $file . "\n"; $parsedFile = new ReflectionFile($this->vendorDir . '/' . $package . '/' . $version . '/' . $file); $parsedClass = $parsedFile->getFileNamespace($info['toNs'])->getClass($info['toNs'] . '\\' . $type['class']); if ($parsedClass->getInterfaceNames() != null) { $implementedInterfaces = array_merge($implementedInterfaces, $parsedClass->getInterfaceNames()); } foreach ($parsedClass->getMethods() as $method) { if ($method->isPublic()) { $generatedMethod = new MethodGenerator(); $generatedMethod->setName($method->name); $generatedMethod->setBody('echo "Hello world!";'); $generatedMethod->setAbstract($method->isAbstract()); $generatedMethod->setFinal($method->isFinal()); $generatedMethod->setStatic($method->isStatic()); $generatedMethod->setVisibility(MethodGenerator::VISIBILITY_PUBLIC); foreach ($method->getParameters() as $param) { $generatedParam = new ParameterGenerator(); $generatedParam->setName($param->name); if ($param->hasType()) { $generatedParam->setType($param->getType()); } //$generatedParam->setDefaultValue($param->getDefaultValue()); $generatedParam->setPosition($param->getPosition()); $generatedParam->setVariadic($param->isVariadic()); $generatedParam->setPassedByReference($param->isPassedByReference()); $generatedMethod->setParameter($generatedParam); } $existingMethod = Linq::from($methods)->firstOrDefault(null, function (MethodGenerator $v) use($method) { return $v->getName() == $method->name; }); if ($existingMethod != null) { $existingParams = $existingMethod->getParameters(); foreach ($generatedMethod->getParameters() as $newParam) { $existingParam = Linq::from($existingParams)->firstOrDefault(function (ParameterGenerator $v) { return $v->getName() == $newParam->getName(); }); if ($existingParam == null) { $existingMethod->setParameter($newParam); } } } else { $methods[] = $generatedMethod; } } } foreach ($parsedClass->getProperties() as $prop) { //$properties[] = PropertyGenerator::fromReflection($prop); } } } $class->setImplementedInterfaces($implementedInterfaces); $class->addMethods($methods); $class->addProperties($properties); return (new FileGenerator(['classes' => [$class]]))->generate(); }
/** * Processes file. * * @param string $file File. * * @return integer */ protected function processFile($file) { $size = filesize($file); $relative_file = $this->removeProjectPath($file); $sql = 'SELECT Id, Size FROM Files WHERE Name = :name'; $file_data = $this->db->fetchOne($sql, array('name' => $relative_file)); $this->db->beginTransaction(); if ($file_data === false) { $sql = 'INSERT INTO Files (Name, Size) VALUES (:name, :size)'; $this->db->perform($sql, array('name' => $relative_file, 'size' => $size)); $file_id = $this->db->lastInsertId(); } else { $file_id = $file_data['Id']; } // File is not changed since last time it was indexed. if ($file_data !== false && (int) $file_data['Size'] === $size) { $sql = 'UPDATE Files SET Found = 1 WHERE Id = :file_id'; $this->db->perform($sql, array('file_id' => $file_data['Id'])); $this->db->commit(); return $file_data['Id']; } $sql = 'UPDATE Files SET Found = 1 WHERE Id = :file_id'; $this->db->perform($sql, array('file_id' => $file_data['Id'])); $new_classes = array(); $parsed_file = new ReflectionFile($file); foreach ($parsed_file->getFileNamespaces() as $namespace) { foreach ($namespace->getClasses() as $class) { $new_classes[] = $class->getName(); $this->processClass($file_id, $class); } } if ($new_classes) { $sql = 'SELECT Id FROM Classes WHERE FileId = :file_id AND Name NOT IN (:classes)'; $deleted_classes = $this->db->fetchCol($sql, array('file_id' => $file_id, 'classes' => $new_classes)); } else { $sql = 'SELECT Id FROM Classes WHERE FileId = :file_id'; $deleted_classes = $this->db->fetchCol($sql, array('file_id' => $file_id)); } foreach ($deleted_classes as $deleted_class_id) { $this->deleteClass($deleted_class_id); } $this->db->commit(); ReflectionEngine::unsetFile($file); return $file_id; }
private function showAdvisorInformation(SymfonyStyle $io, $advisorId) { $aspectContainer = $this->aspectKernel->getContainer(); /** @var AdviceMatcher $adviceMatcher */ $adviceMatcher = $aspectContainer->get('aspect.advice_matcher'); $this->loadAdvisorsList($aspectContainer); $advisor = $aspectContainer->getAdvisor($advisorId); $options = $this->aspectKernel->getOptions(); $enumerator = new Enumerator($options['appDir'], $options['includePaths'], $options['excludePaths']); $iterator = $enumerator->enumerate(); $totalFiles = iterator_count($iterator); $io->writeln("Total <info>{$totalFiles}</info> files to analyze."); $iterator->rewind(); foreach ($iterator as $file) { $reflectionFile = new ReflectionFile((string) $file); $reflectionNamespaces = $reflectionFile->getFileNamespaces(); foreach ($reflectionNamespaces as $reflectionNamespace) { foreach ($reflectionNamespace->getClasses() as $reflectionClass) { $advices = $adviceMatcher->getAdvicesForClass($reflectionClass, array($advisor)); if (!empty($advices)) { $this->writeInfoAboutAdvices($io, $reflectionClass, $advices); } } } } }
/** * Tests specific features of PHP5.6 and newer, for example, array constants, etc */ public function testGettersPHP56() { if (PHP_VERSION_ID < 50600) { $this->markTestSkipped("Can not test new features on old version of PHP"); } $fileName = stream_resolve_include_path(__DIR__ . self::STUB_FILE56); $fileNode = ReflectionEngine::parseFile($fileName); $reflectionFile = new ReflectionFile($fileName, $fileNode); include_once $fileName; $parsedFileNamespace = $reflectionFile->getFileNamespace('Go\\ParserReflection\\Stub'); foreach ($parsedFileNamespace->getClasses() as $parsedRefClass) { $this->performGeneralMethodComparison($parsedRefClass); } }