public function create($overwrite = false)
{
try {
$this->class->elevateClass();
// @todo das mal konfigurieren und fixen
} catch (\Exception $e) {
$this->log('Klasse für den Test kann nicht elevated werden: ' . $e->getMessage());
} catch (\Psc\Code\Generate\ReflectionException $e) {
$this->log('Klasse für den Test kann nicht elevated werden: ' . $e->getMessage());
}
$class = new GClass();
$class->setName($this->class->getClassName() . 'Test');
$class->setNamespace($this->class->getNamespace());
$class->setParentClass($this->testClass);
$writer = new ClassWriter();
$writer->setClass($class);
$class = $this->createStub($class);
$file = $this->getTestFile();
if (isset($this->createCallback)) {
$class = call_user_func($this->createCallback, $class, $this, $writer, $file);
}
$writer->addImport($this->class);
// not really necessary (weil ist ja derselbe NS, aber who knows)
$file->getDirectory()->create();
$writer->write($file, array(), $overwrite);
return $file;
}
/**
* Gibt die Klasse als PHP Code zurück
*
* die Klasse ist noch nicht mit Namespace vor class notiert!
* Eingerückt wird mit 2 whitespaces.
* Em Ende befindet sich hinter der schließenden Klammer ein LF
*/
public function php()
{
$cr = "\n";
$php = $this->phpDocBlock(0);
$ms = array(self::MODIFIER_ABSTRACT => 'abstract', self::MODIFIER_FINAL => 'final');
foreach ($ms as $const => $modifier) {
if (($const & $this->modifiers) == $const) {
$php .= $modifier . ' ';
}
}
$php .= 'class ' . $this->getClassName() . ' ';
/* Extends */
if (isset($this->parentClass)) {
if ($this->parentClass->getNamespace() === $this->getNamespace()) {
$php .= 'extends ' . $this->parentClass->getClassName() . ' ';
// don't prefix namespace
} else {
$php .= 'extends ' . '\\' . $this->parentClass->getFQN() . ' ';
}
}
/* Interfaces */
if (count($this->getInterfaces()) > 0) {
$php .= 'implements ';
$that = $this;
$php .= A::implode($this->getInterfaces(), ', ', function (GClass $iClass) use($that) {
if ($that->getNamespace() === $iClass->getNamespace()) {
return $iClass->getClassName();
} else {
return '\\' . $iClass->getFQN();
}
});
$php .= ' ';
}
$php .= '{' . $cr;
/* Die Funktionen machen immer den Abstand nach oben. Also vor jedem Property und jeder Methode macht dies ein "\n" */
/* Constants */
$php .= A::joinc($this->getConstants(), ' ' . $cr . '%s;' . $cr, function ($constant) {
return $constant->php(2);
});
/* Properties */
$php .= A::joinc($this->getProperties(), ' ' . $cr . '%s;' . $cr, function ($property) {
return $property->php(2);
// hier jetzt auch wegen DocBlock einrücken
});
/* Methods */
$php .= A::joinc($this->getMethods(), ' ' . $cr . '%s' . $cr, function ($method) {
return $method->php(2);
// rückt selbst zwischen den Klammern ein, aber wir wollen ja den body z.b. auf 4 haben nicht auf 2
});
$php .= '}';
// kein umbruch hinten, immer abstand nach oben!
return $php;
}
public function generatePHP(array $imports = array())
{
if (!isset($this->gClass)) {
throw new ClassWritingException('Klasse nicht gesetzt. (zuerst setClass() dann write().');
}
$use = NULL;
/* merge mit params */
foreach ($imports as $iClass) {
$alias = NULL;
if (is_array($iClass)) {
list($iClass, $alias) = $iClass;
}
if (!$iClass instanceof GClass) {
throw new \Psc\Exception('Imports können nur vom typ GClass sein');
}
$this->addImport($iClass, $alias);
}
if (count($this->foundImports) > 0) {
$useImports = array();
foreach ($this->foundImports as $alias => $gClass) {
// wir filten nach den imports, die im selben Namespace sind und keinen besonderen Alias haben
if ($alias !== $gClass->getClassName() || $gClass->getNamespace() !== $this->gClass->getNamespace()) {
$useImports[$alias] = $gClass;
}
}
/* Render PHP */
$classAlias = function ($gClass, $alias) {
if ($alias === $gClass->getClassName()) {
return $gClass->getFQN();
} else {
return $gClass->getFQN() . ' AS ' . $alias;
}
};
if (count($useImports) > 0) {
$use .= "\n";
// abstand zu namespace (neue Zeile)
if ($this->useStyle === self::USE_STYLE_LINES) {
$use .= A::joinc($useImports, "use %s;\n", $classAlias);
} else {
$use .= 'use ' . A::implode($useImports, ",\n ", $classAlias);
$use .= ';';
$use .= "\n";
// abstand zu class (neue Zeile)
}
}
}
$php = TPL::miniTemplate($this->template, array('class' => $this->gClass->php(), 'use' => $use, 'namespace' => $this->gClass->getNamespace() != NULL ? 'namespace ' . ltrim($this->gClass->getNamespace(), '\\') . ';' : NULL));
return $php;
}
/**
* @TODO test interfaces und extends!
*/
public function testClass()
{
$cr = "\n";
$class = GClass::factory(__NAMESPACE__ . '\\TestClass');
$this->assertInstanceOf('Psc\\Code\\Generate\\GMethod', $class->getMethod('method2'));
$this->assertInstanceOf('Psc\\Code\\Generate\\GProperty', $class->getProperty('prop1'));
$gClass = new GClass('Psc\\Code\\Generate\\GClass');
$this->assertEquals('GClass', $gClass->getClassName());
$this->assertEquals('\\Psc\\Code\\Generate', $gClass->getNamespace());
$this->assertEquals('Psc\\Code\\Generate\\GClass', $gClass->getFQN());
/* test final + abstract zeuch */
$this->assertFalse($gClass->isFinal());
$this->assertFalse($gClass->isAbstract());
$gClass->setFinal(TRUE);
$this->assertTrue($gClass->isFinal());
$gClass->setAbstract(TRUE);
$this->assertTrue($gClass->isAbstract());
$gClass->setModifier(GClass::MODIFIER_ABSTRACT, FALSE);
$gClass->setModifier(GClass::MODIFIER_FINAL, FALSE);
$this->assertFalse($gClass->isAbstract());
$this->assertFalse($gClass->isFinal());
/* testClass (denn da wissen wir die line-nummern besser und die ist auch abstract */
$testClass = new GClass(new ReflectionClass(__NAMESPACE__ . '\\TestClass'));
$this->assertTrue($testClass->isAbstract());
$this->assertFalse($testClass->isFinal());
$this->assertEquals(self::$startLine, $testClass->getStartLine());
$this->assertEquals(self::$endLine, $testClass->getEndLine());
$testHint = new GClass('SomeClassForAHint');
$this->assertEquals('class SomeClassForAHint {' . $cr . '}', $testHint->php(), sprintf("output: '%s'", $testHint->php()));
//file_put_contents('D:\fixture.txt', self::$testClassCode);
//file_put_contents('D:\compiled.txt',$testClass->php());
$this->assertEquals(self::$testClassCode, $testClass->php(), 'Code für Klasse ist nicht identisch');
//identisch bis auf whitespaces! (das ist irgendwie ein bissl variabel, aber okay
// geiler wäre halt assertEqualsCode, hmmm das ginge sogar mit token_get_all und so?
}
public function inferFile(GClass $class)
{
if ($class->getNamespace() === $this->module->getEntitiesNamespace()) {
$file = $this->module->getEntitiesPath()->getFile($class->getClassName() . '.php');
} else {
$file = Code::mapClassToFile($class->getFQN(), $this->module->getProject()->dir('lib'));
}
return $file;
}
public function testOwnMethodsGetter()
{
$gClass = new GClass($refl = new ReflectionClass('Psc\\Code\\Compile\\Compiler'));
$this->assertEquals('\\Psc\\Code\\Compile', $gClass->getNamespace());
$gm = $gClass->getMethod('getClassName');
// getClassName ist aus Psc\SimpleObject und somit eine Methode einer Vaterklasse
$m = $refl->getMethod('getClassName');
$this->assertEquals((string) $m->getDeclaringClass()->getName(), (string) $gm->getDeclaringClass()->getFQN());
$this->assertArrayHasKey('getClassName', $gClass->getAllMethods());
$this->assertArrayNotHasKey('getClassName', $gClass->getMethods());
$this->assertLessThan(count($gClass->getAllMethods()), count($gClass->getMethods()));
$m = $gClass->createMethod('Test');
$this->assertNotEmpty($m->getDeclaringClass());
/* BUG: Namespace verändern verändert die Rückggabe der Methoden */
$gClass = GClass::factory('Psc\\Code\\Generate\\MyTestClass');
$this->assertEquals(2, count($gClass->getMethods()));
$this->assertEquals(2, count($gClass->getAllMethods()));
$gClass->setNamespace('Psc\\Other\\Than\\Before');
$this->assertEquals(2, count($gClass->getMethods()));
$this->assertEquals(2, count($gClass->getAllMethods()));
}
/**
*
* - $entity($name, $parentClass)
* erstellt das Entity mit ClassDocBlock und einigen Methoden aus dem Interface
*
* - $property($name, $type(), $flag1, $flag2, ...) // $flag kann z.b. $nullable sein
* erstellt ein Property mit dem Namen und dem DatenTyp $type. Erstellt Setter + Getter für dieses Property
* Properties, die in einer Relation sind, müssen nicht extra erstellt werden
* - $setIdentifier($name) setzt den Identifier der Klasse als string (wird für alle Relations benötigt die nicht 'id' als identifier haben)
* - $relation($targetEntity, $relationType, $direction = EntityRelation::BIDIRECTIONAL, $whoIsOwningSide = NULL, $source = NULL)
* - $oneToMany($targetEntity, $propertyNamePlural = NULL, $targetPropertyName = NULL, $settings = array())
* - $manyToOne($targetEntity, $propertyNameSingular = NULL, $targetPropertyName = NULL, $settings = array())
* - $manyToMany($targetEntity, bool|NULL $isOwningSide, $propertyNamePlural = NULL, $targetPropertyName = NULL, $settings = array())
*
* Erstellt eine Relation zwischen dem aktuellen $entity() und $targetEntity. Ist $propertyName nicht angegeben wird $targetEntity zum Plural-Property gemacht (wenn Many-Seite)
* ist $isOwningSide NULL bei ManyToMany wird die Relation unidirektional angelegt
*
* - $flag(string $constant) die Klassenkonstante (nur der Name als String)
*
* HelpersHelpers
* - $entityClass() erweitert einen Shortname zu einer Klasse
* - $extends gibt eine Klasse zurück. Ist dies ein String ohne \ wird angenommen, dass dies ein EntityName ist
* - $type() erstellt einen Type mit Type::create()
* - $enumType(string $class) erstellt einen Doctrine Enum Type
* - $targetMeta($entityName) erstellt eine EntityRelationMeta (als parameter für relation) um z. B. die Property-Namen zu ändern
*/
public function getClosureHelpers()
{
$mc = $this;
// helperHelpers
$entityClass = function ($class) use($mc) {
if ($class instanceof GClass) {
return $class;
}
$gclass = new \Psc\Code\Generate\GClass($class);
if ($gclass->getNamespace() === NULL) {
$gclass->setNamespace($mc->getDefaultNamespace());
}
// geht nicht weil argumente ja zuerst ausgewertet werden, dann ist entity() noch nicht gesetzt
return $gclass;
};
$expandClass = function ($class) use($mc) {
return $mc->getDefaultNamespace() . '\\' . ltrim($class, '\\');
};
$undefined = function () {
return GParameter::UNDEFINED;
};
$type = function ($name) {
if ($name instanceof Type) {
return $name;
}
return Type::createArgs($name, array_slice(func_get_args(), 1));
};
//entity
$entity = function ($entityName, \Psc\Code\Generate\GClass $baseEntity = NULL, $tableName = NULL) use($mc) {
$mc->setEntityBuilder($entityBuilder = $mc->createEntityBuilder($entityName));
if (isset($baseEntity)) {
$entityBuilder->setBaseEntity($baseEntity);
} else {
$entityBuilder->setBaseEntity(new \Psc\Code\Generate\GClass('Psc\\CMS\\AbstractEntity'));
}
if (isset($tableName)) {
$entityBuilder->setTableName($tableName);
}
return $entityBuilder;
};
$getGClass = function () use($mc) {
return $mc->getEntityBuilder()->getGClass();
};
$relationTypeConstant = function ($relation) {
switch ($relation) {
case 'ManyToMany':
return EntityRelation::MANY_TO_MANY;
case 'OneToMany':
return EntityRelation::ONE_TO_MANY;
case 'ManyToOne':
return EntityRelation::MANY_TO_ONE;
case 'OneToOne':
return EntityRelation::ONE_TO_ONE;
default:
throw new \InvalidArgumentException('String als relation ist nicht bekannt: ' . $relation);
}
};
$directionConstant = function ($direction) {
switch ($direction) {
case 'bidirectional':
return EntityRelation::BIDIRECTIONAL;
case 'unidirectional':
return EntityRelation::UNIDIRECTIONAL;
case 'self':
case 'self-referencing':
case 'selfreferencing':
case 'self_referencing':
return EntityRelation::SELF_REFERENCING;
default:
throw new \InvalidArgumentException('String als direction ist nicht bekannt: ' . $direction);
}
};
// relations
$targetMeta = function ($targetEntity, $propertyName = NULL) use($entityClass) {
if ($targetEntity instanceof EntityRelationMeta) {
return $targetEntity;
}
$erm = new EntityRelationMeta($entityClass($targetEntity), 'target');
if (isset($propertyName)) {
$erm->setPropertyName($propertyName);
}
return $erm;
};
$sourceMeta = function ($source, $propertyName = NULL) use($mc) {
if ($source instanceof EntityRelationMeta) {
return $source;
}
$erm = $mc->getEntityBuilder()->getEntityRelationMeta();
$erm->setGClass($mc->getOriginalEntityClass());
if (isset($propertyName)) {
$erm->setPropertyName($propertyName);
}
return $erm;
};
$defaultSettings = function (array $settings = array()) {
$defaults = array('updateOtherSide' => TRUE, 'bidirectional' => TRUE);
// $settings / $defaults == 0
if (count($unknownSettings = array_diff(array_keys($settings), array_keys($defaults))) > 0) {
throw new \InvalidArgumentException('Das Setting / Die Settings: ' . implode(',', $unknownSettings) . ' sind nicht bekannt. Möglich sind: ' . implode(",", array_keys($defaults)));
}
return (object) array_merge($defaults, $settings);
};
/* wir müssen hier etwas mit dem letzten parameter für createRelation rumtricksen
da wir als propertyNamen hier nicht $this->compiledPersons sondern $this->persons erzeugen wollen */
$OneToMany = $oneToMany = function ($targetEntity, $propertyNamePlural = NULL, $targetPropertyName = NULL, array $settings = array()) use($mc, $entityClass, $sourceMeta, $targetMeta, $defaultSettings) {
$settings = $defaultSettings($settings);
return $mc->getEntityBuilder()->createRelation($rt = EntityBuilder::RELATION_ONE_TO_MANY, $sourceMeta($targetPropertyName, $targetPropertyName), $targetMeta($targetEntity, $propertyNamePlural), $settings->bidirectional ? EntityBuilder::SIDE_INVERSE : NULL, $settings->updateOtherSide);
};
$ManyToOne = $manyToOne = function ($targetEntity, $propertyNameSingular = NULL, $targetPropertyName = NULL, array $settings = array()) use($mc, $entityClass, $sourceMeta, $targetMeta, $defaultSettings) {
$settings = $defaultSettings($settings);
return $mc->getEntityBuilder()->createRelation($rt = EntityBuilder::RELATION_MANY_TO_ONE, $sourceMeta($targetPropertyName, $targetPropertyName), $targetMeta($targetEntity, $propertyNameSingular), $settings->bidirectional ? EntityBuilder::SIDE_OWNING : NULL, $settings->updateOtherSide);
};
$ManyToMany = $manyToMany = function ($targetEntity, $isOwningSide, $propertyNamePlural = NULL, $targetPropertyName = NULL, array $settings = array()) use($mc, $entityClass, $targetMeta, $sourceMeta, $defaultSettings) {
$settings = $defaultSettings($settings);
return $mc->getEntityBuilder()->createRelation($rt = EntityBuilder::RELATION_MANY_TO_MANY, $sourceMeta($targetPropertyName, $targetPropertyName), $targetMeta($targetEntity, $propertyNamePlural), $isOwningSide !== NULL ? $isOwningSide ? EntityBuilder::SIDE_OWNING : EntityBuilder::SIDE_INVERSE : NULL, $settings->updateOtherSide);
};
$relation = function ($targetEntity, $relationType, $direction = EntityRelation::BIDIRECTIONAL, $whoIsOwningSide = NULL, $source = NULL) use($sourceMeta, $targetMeta, $relationTypeConstant, $directionConstant) {
return new EntityRelation($sourceMeta($source), $targetMeta($targetEntity), $relationTypeConstant($relationType), $directionConstant($direction), $whoIsOwningSide);
};
// builded 1 oder mehrere items
$build = function () use($mc) {
foreach (func_get_args() as $item) {
if ($item instanceof EntityRelation) {
return $mc->getEntityBuilder()->buildRelation($item);
} elseif ($item instanceof GMethod) {
return $mc->getEntityBuilder()->addMethod($item);
} else {
throw new \InvalidArgumentException('Dont Know how to build: ' . Code::varInfo($item));
}
}
};
$builder = function () use($mc) {
return $mc->getEntityBuilder();
};
$method = function ($name, $params = array(), $body = NULL, $modifiers = 256) use($mc) {
return $mc->getEntityBuilder()->createMethod($name, $params, $body, $modifiers);
};
// constructor
$constructor = function () use($mc) {
return $mc->getEntityBuilder()->generatePropertiesConstructor(func_get_args());
};
$argument = function ($propertyName, $default = GParameter::UNDEFINED, $propertyType = NULL) use($mc, $type) {
if (!$mc->getEntityBuilder()->hasProperty($propertyName)) {
throw new \InvalidArgumentException("Das Property: '" . $propertyName . "'" . ' existiert nicht in der kompilierten Klasse: ' . $mc->getEntityBuilder()->getGClass()->getName() . '.' . "\n" . 'Wenn das Property durch eine Relation hinzugefügt wurde, muss die Relation vor $argument() hinzugefügt und build() werden: $build($relation(...) benutzen');
}
$arg['property'] = $mc->getEntityBuilder()->getProperty($propertyName);
if (isset($propertyType)) {
$arg['property']->setType($type($propertyType));
}
if ($default !== GParameter::UNDEFINED) {
$arg['default'] = $default;
}
return $arg;
};
// properties
$property = function ($name, Type $type) use($mc) {
$flags = 0x0;
foreach (array_slice(func_get_args(), 2) as $flagSetter) {
$flagSetter($flags);
}
$alias = NULL;
if (is_array($name)) {
list($name, $alias) = $name;
}
$eb = $mc->getEntityBuilder();
return $eb->createProperty($name, $type, $flags, NULL, $alias);
};
$isId = function () {
return function (&$flags) {
$flags |= \Psc\Doctrine\EntityBuilder::IDENTIFIER;
};
};
$setIdentifier = function ($name) use($mc) {
return $mc->getEntityBuilder()->setIdentifier($name);
};
$nullable = function () {
return function (&$flags) {
$flags |= \Psc\Doctrine\EntityBuilder::NULLABLE;
};
};
$unique = function () {
return function (&$flags) {
$flags |= \Psc\Doctrine\EntityBuilder::UNIQUE;
};
};
$i18n = function () {
return function (&$flags) {
$flags |= \Psc\Doctrine\EntityBuilder::I18N;
};
};
$defaultId = function () use($mc) {
return $mc->getEntityBuilder()->createDefaultId();
};
// helpers
$extends = function ($class) use($entityClass) {
if ($class instanceof \Psc\Code\Generate\GClass) {
return $class;
}
if (mb_strpos($class, '\\')) {
return new \Psc\Code\Generate\GClass($class);
} else {
return $entityClass($class);
}
};
$enumType = function ($class) {
return new DCEnumType(new GClass($class));
};
$flag = function ($constant) use($mc) {
$constant = mb_strtoupper($constant);
if (!defined($c = 'Psc\\Doctrine\\ModelCompiler::' . $constant)) {
throw new \InvalidArgumentException('Konstante: ' . $c . ' ist unbekannt');
}
$mc->addFlag(constant($c));
return $mc->getFlags();
};
return compact('entity', 'expandClass', 'entityClass', 'extends', 'getGClass', 'property', 'enumType', 'flag', 'nullable', 'unique', 'type', 'undefined', 'i18n', 'method', 'constructor', 'argument', 'builder', 'setIdentifier', 'isId', 'defaultId', 'relation', 'addRelation', 'build', 'oneToMany', 'manyToMany', 'manyToOne', 'OneToMany', 'ManyToMany', 'ManyToOne', 'targetMeta', 'sourceMeta', 'defaultSettings', 'directionConstant', 'relationTypeConstant');
}