Beispiel #1
0
 /**
  * @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();
 }