public function __construct(Clazz $class, Property $property, $declaringClass = null) { $this->class = $class; $this->property = $property; $this->name = $property->getName(); if ($class->getName() === $declaringClass) { $declaringClass = null; } $this->declaringClass = $declaringClass; }
private function insertProperty(Property $property, $packageVersionId) { $this->propertyStmt->bindValue(1, $property->getName()); $this->propertyStmt->bindValue(2, $property->getVisibility(), \PDO::PARAM_INT); $this->propertyStmt->bindValue(3, $this->phpType->convertToDatabaseValue($property->getPhpType(), $this->platform)); $this->propertyStmt->bindValue(4, $packageVersionId, \PDO::PARAM_INT); $this->propertyStmt->execute(); $propertyId = $this->con->lastInsertId(); $this->propertyIdRef->setValue($property, $propertyId); return $propertyId; }
/** * @group packageDependencies */ public function testDeletePackageVersionWhenInheritingBetweenPackages() { $this->packageVersion->addContainer($foo = new Clazz('Foo')); $foo->addProperty($fooProperty = new Property('foo')); $fooProperty->setPhpType($this->typeRegistry->getNativeType('string')); $this->em->persist($this->packageVersion); $this->otherPackageVersion->addDependency($this->packageVersion); $this->otherPackageVersion->addContainer($bar = new Clazz('bar')); $bar->addProperty($fooProperty, 'Foo'); $this->em->persist($this->otherPackageVersion); $this->em->flush(); $this->assertVersionsCount(2); $this->repo->deletePackageVersion($this->packageVersion); $this->em->clear(); $this->assertVersionsCount(0); }
private function inferTypesForProperty(Property $property) { if (($type = $property->getPhpType()) && !$type->isUnknownType()) { return; } if (null !== ($node = $property->getAstNode())) { if ($property instanceof \PHPParser_Node_Stmt_Class) { $type = $this->parser->getTypeFromMagicPropertyAnnotation($node, $property->getName()); } else { $type = $this->parser->getTypeFromVarAnnotation($node); } } if (null === $type) { $type = $this->registry->getNativeType('unknown'); } $property->setPhpType($type); if ($node) { $node->setAttribute('type', $type); } }
public function addProperty(Property $property, $declaringClass = null) { $classProperty = new ClassProperty($this, $property, $declaringClass); $this->properties->set($property->getName(), $classProperty); }
public function parse(\PHPParser_Node $node) { if ($node instanceof \PHPParser_Node_Stmt_Class) { $class = new Clazz(implode("\\", $node->namespacedName->parts)); // convert PHPParser modifier to our modifier $modifier = 0; if (\PHPParser_Node_Stmt_Class::MODIFIER_FINAL === ($node->type & \PHPParser_Node_Stmt_Class::MODIFIER_FINAL)) { $modifier |= Clazz::MODIFIER_FINAL; } if (\PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT === ($node->type & \PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT)) { $modifier |= Clazz::MODIFIER_ABSTRACT; } $class->setModifier($modifier); if (null !== $node->extends) { $class->setSuperClass(implode("\\", $node->extends->parts)); } foreach ($node->implements as $iface) { $class->addImplementedInterface(implode("\\", $iface->parts)); } } else { if ($node instanceof \PHPParser_Node_Stmt_Interface) { $class = new InterfaceC(implode("\\", $node->namespacedName->parts)); foreach ($node->extends as $interface) { $class->addExtendedInterface(implode("\\", $interface->parts)); } } else { if ($node instanceof \PHPParser_Node_Stmt_Trait) { $class = new TraitC(implode("\\", $node->namespacedName->parts)); } else { throw new \LogicException(sprintf('The other statements were exhaustive. The node "%s" is not supported.', get_class($node))); } } } $class->setImportedNamespaces($this->importedNamespaces); $class->setAstNode($node); // add methods, properties, and constants foreach ($node->stmts as $stmt) { if ($stmt instanceof \PHPParser_Node_Stmt_ClassMethod) { $this->scanMethod($stmt, $class); } else { if ($stmt instanceof \PHPParser_Node_Stmt_Property) { $visibility = \PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC === ($stmt->type & \PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC) ? Property::VISIBILITY_PUBLIC : (\PHPParser_Node_Stmt_Class::MODIFIER_PROTECTED === ($stmt->type & \PHPParser_Node_Stmt_Class::MODIFIER_PROTECTED) ? Property::VISIBILITY_PROTECTED : Property::VISIBILITY_PRIVATE); foreach ($stmt->props as $propNode) { assert($propNode instanceof \PHPParser_Node_Stmt_PropertyProperty); // This is a PHP error which we flag in a later pass. Here, we can just ignore the property definition. if ($class->isInterface()) { continue; } assert($class instanceof Clazz || $class instanceof TraitC); $property = new Property($propNode->name); $property->setAstNode($propNode); $property->setVisibility($visibility); $class->addProperty($property); } } else { if ($stmt instanceof \PHPParser_Node_Stmt_ClassConst) { foreach ($stmt->consts as $constNode) { assert($constNode instanceof \PHPParser_Node_Const); $constant = new Constant($constNode->name); $constant->setAstNode($constNode); if (null !== ($type = $constNode->value->getAttribute('type'))) { $constant->setPhpType($type); } $class->addConstant($constant); } } } } } // Add magic properties denoted by @property, @property-read, @property-write. if ($node instanceof \PHPParser_Node_Stmt_Class && preg_match_all('#@(?:property|property-read|property-write)\\s+[^\\s]+\\s+\\$?([^\\s]+)#', $node->getDocComment(), $matches)) { for ($i = 0, $c = count($matches[0]); $i < $c; $i++) { // If there is already an explicitly declared property of the same // name, it has precedence for us. if ($class->hasProperty($matches[1][$i])) { $this->logger->warning(sprintf('The property "%s" is already defined in code; ignoring @property tag.', $matches[1][$i])); continue; } $property = new Property($matches[1][$i]); $property->setAstNode($node); $class->addProperty($property); } } // Add magic methods denoted by @method. if ($node instanceof \PHPParser_Node_Stmt_Class && preg_match_all('#@method\\s+([^@]+)#s', $node->getDocComment(), $matches)) { foreach ($matches[1] as $methodDef) { if (null !== ($method = $this->parseCommentMethodDef($methodDef))) { // An explicitly defined method has precedence. if ($class->hasMethod($method->getName())) { $this->logger->warning(sprintf('The method "%s" is already defined in code; ignoring @method tag.', $method->getName())); continue; } $class->addMethod($method); } } } return $class; }