/** * @param \ReflectionProperty $accessedProperty * @param string $nameSuffix */ public function __construct(\ReflectionProperty $accessedProperty, $nameSuffix) { $this->accessedProperty = $accessedProperty; $originalName = $accessedProperty->getName(); $name = UniqueIdentifierGenerator::getIdentifier($originalName . $nameSuffix); parent::__construct(Class_::MODIFIER_PRIVATE, [new PropertyProperty($name)]); }
/** * {@inheritDoc} */ public function setUp() { $this->generatedClassName = UniqueIdentifierGenerator::getIdentifier('foo'); $this->config = new Configuration($this->generatedClassName); $generatorStrategy = new EvaluatingGeneratorStrategy(); $reflection = new ReflectionClass('GeneratedHydratorTestAsset\\ClassWithMixedProperties'); $generator = new ClassBuilder(); $traverser = new NodeTraverser(); $renamer = new ClassRenamerVisitor($reflection, $this->generatedClassName); $traverser->addVisitor($renamer); // evaluating the generated class //die(var_dump($traverser->traverse($generator->fromReflection($reflection)))); $ast = $traverser->traverse($generator->fromReflection($reflection)); $generatorStrategy->generate($ast); $this->config->setGeneratorStrategy($generatorStrategy); }
/** * @dataProvider getTestedImplementations * * Verifies that generated code is valid and implements expected interfaces */ public function testGeneratesValidCode($className) { $generator = new HydratorGenerator(); $generatedClassName = UniqueIdentifierGenerator::getIdentifier('HydratorGeneratorTest'); $originalClass = new ReflectionClass($className); $generatorStrategy = new EvaluatingGeneratorStrategy(); $traverser = new NodeTraverser(); $traverser->addVisitor(new ClassRenamerVisitor($originalClass, $generatedClassName)); $generatorStrategy->generate($traverser->traverse($generator->generate($originalClass))); $generatedReflection = new ReflectionClass($generatedClassName); if ($originalClass->isInterface()) { $this->assertTrue($generatedReflection->implementsInterface($className)); } else { $this->assertInstanceOf('ReflectionClass', $generatedReflection->getParentClass()); $this->assertSame($originalClass->getName(), $generatedReflection->getParentClass()->getName()); } $this->assertSame($generatedClassName, $generatedReflection->getName()); foreach ($this->getExpectedImplementedInterfaces() as $interface) { $this->assertTrue($generatedReflection->implementsInterface($interface)); } }
/** * {@inheritDoc} * * @covers \GeneratedHydrator\Factory\HydratorFactory::__construct * @covers \GeneratedHydrator\Factory\HydratorFactory::getHydratorClass * * NOTE: serious mocking going on in here (a class is generated on-the-fly) - careful */ public function testWillTryAutoGeneration() { $className = UniqueIdentifierGenerator::getIdentifier('foo'); $generatedClassName = UniqueIdentifierGenerator::getIdentifier('bar'); $generator = $this->getMock('CodeGenerationUtils\\GeneratorStrategy\\GeneratorStrategyInterface'); $autoloader = $this->getMock('CodeGenerationUtils\\Autoloader\\AutoloaderInterface'); $this->config->expects($this->any())->method('getHydratedClassName')->will($this->returnValue($className)); $this->config->expects($this->any())->method('doesAutoGenerateProxies')->will($this->returnValue(true)); $this->config->expects($this->any())->method('getGeneratorStrategy')->will($this->returnValue($generator)); $this->config->expects($this->any())->method('getGeneratedClassAutoloader')->will($this->returnValue($autoloader)); $generator->expects($this->once())->method('generate')->with($this->isType('array')); // simulate autoloading $autoloader->expects($this->once())->method('__invoke')->with($generatedClassName)->will($this->returnCallback(function () use($generatedClassName) { eval('class ' . $generatedClassName . ' {}'); })); $this->inflector->expects($this->once())->method('getGeneratedClassName')->with('GeneratedHydratorTestAsset\\BaseClass')->will($this->returnValue($generatedClassName)); $this->inflector->expects($this->once())->method('getUserClassName')->with($className)->will($this->returnValue('GeneratedHydratorTestAsset\\BaseClass')); $factory = new HydratorFactory($this->config); /* @var $generatedClass \GeneratedHydratorTestAsset\LazyLoadingMock */ $generatedClass = $factory->getHydratorClass(); $this->assertInstanceOf($generatedClassName, new $generatedClass()); }
/** * @return \PhpParser\Node[][] */ public function classAstProvider() { $parser = new Parser(new Lexer()); $className = UniqueIdentifierGenerator::getIdentifier('Foo'); $classCode = 'class ' . $className . ' { private $bar; private $baz; protected $tab; ' . 'protected $tar; public $taw; public $tam; }'; eval($classCode); $staticClassName = UniqueIdentifierGenerator::getIdentifier('Foo'); $staticClassCode = 'class ' . $staticClassName . ' { private static $bar; ' . 'protected static $baz; public static $tab; private $taz; }'; eval($staticClassCode); return [[$className, $parser->parse('<?php ' . $classCode)[0], ['bar', 'baz', 'tab', 'tar', 'taw', 'tam']], [$staticClassName, $parser->parse('<?php ' . $staticClassCode)[0], ['taz']]]; }
/** * Generates a hydrator for the given class name, and retrieves its class name * * @param object $instance * * @return \GeneratedHydratorTestAsset\HydratedObject|\Zend\Stdlib\Hydrator\HydratorInterface */ private function generateHydrator($instance) { $parentClassName = get_class($instance); $generatedClassName = __NAMESPACE__ . '\\' . UniqueIdentifierGenerator::getIdentifier('Foo'); $config = new Configuration($parentClassName); $inflector = $this->getMock('CodeGenerationUtils\\Inflector\\ClassNameInflectorInterface'); $inflector->expects($this->any())->method('getGeneratedClassName')->with($parentClassName)->will($this->returnValue($generatedClassName)); $inflector->expects($this->any())->method('getUserClassName')->with($parentClassName)->will($this->returnValue($parentClassName)); $config->setClassNameInflector($inflector); $config->setGeneratorStrategy(new EvaluatingGeneratorStrategy()); $generatedClass = $config->createFactory()->getHydratorClass(); return new $generatedClass(); }