/**
  * Gets the hydrator class name.
  *
  * @param string $fqcn
  *
  * @return string
  */
 public function getHydratorClassName($fqcn)
 {
     $config = new Configuration($fqcn);
     $config->setAutoGenerateProxies($this->generateProxies);
     $config->setGeneratedClassesTargetDir($this->cacheDir);
     return $config->createFactory()->getHydratorClass();
 }
Beispiel #2
0
 /**
  * @param $class
  */
 public function __construct($class, AnnotationReader $annotationReader)
 {
     $this->class = $class;
     $this->annotationReader = $annotationReader;
     $config = new Configuration($class);
     $hydratorClass = $config->createFactory()->getHydratorClass();
     $this->hydrator = new $hydratorClass();
 }
 /**
  * @param string $class
  * @return HydratorInterface
  */
 private function getHydrator($class)
 {
     if (empty($this->hydrators[$class])) {
         $config = new Configuration($class);
         $hydratorClass = $config->createFactory()->getHydratorClass();
         $this->hydrators[$class] = new $hydratorClass();
     }
     return $this->hydrators[$class];
 }
Beispiel #4
0
 /**
  * Returns a GeneratedHydrator for the object
  *
  * @param object $object
  *
  * @return HydratorInterface
  */
 private static function getHydrator($object)
 {
     $class = get_class($object);
     if (!isset(self::$hydratorCache[$class])) {
         $configuration = new Configuration($class);
         $hydratorClass = $configuration->createFactory()->getHydratorClass();
         self::$hydratorCache[$class] = new $hydratorClass();
     }
     return self::$hydratorCache[$class];
 }
 public function getHydrator($class)
 {
     if (isset($this->hydrators[$class])) {
         return $this->hydrators[$class];
     }
     $configuration = new Configuration($class);
     $configuration->setGeneratedClassesNamespace('Rogiel\\StarReplay\\Hydrator\\Generated');
     if ($this->directory !== null) {
         $configuration->setGeneratedClassesTargetDir($this->directory);
         spl_autoload_register($configuration->getGeneratedClassAutoloader());
     }
     $hydratorClass = $configuration->createFactory()->getHydratorClass();
     $this->hydrators[$class] = new $hydratorClass();
     return $this->hydrators[$class];
 }
 /**
  * @covers \GeneratedHydrator\Configuration::getGeneratedClassAutoloader
  * @covers \GeneratedHydrator\Configuration::setGeneratedClassAutoloader
  */
 public function testSetGetGeneratedClassAutoloader()
 {
     $this->assertInstanceOf('CodeGenerationUtils\\Autoloader\\AutoloaderInterface', $this->configuration->getGeneratedClassAutoloader());
     $autoloader = $this->getMock('CodeGenerationUtils\\Autoloader\\AutoloaderInterface');
     $this->configuration->setGeneratedClassAutoloader($autoloader);
     $this->assertSame($autoloader, $this->configuration->getGeneratedClassAutoloader());
 }
 public function process(ResponseInterface $response, ResourceDefinitionInterface $resource)
 {
     if (!$response instanceof ApiResponse) {
         throw new InvalidArgumentException(sprintf('Expected an `ApiResponse`, got `%s` instead', get_class($response)));
     }
     $returnType = $resource->getReturnType();
     $config = new Configuration($returnType);
     $hydratorClass = $config->createFactory()->getHydratorClass();
     $hydrator = new $hydratorClass();
     $object = new $returnType();
     if ($resource->getMethod() !== ResourceDefinitionInterface::METHOD_CGET) {
         return $hydrator->hydrate($response->getData(), $object);
     }
     $result = [];
     foreach ($response->getData() as $item) {
         $current = clone $object;
         $result[] = $hydrator->hydrate($item, $current);
     }
     return $result;
 }
 /**
  * {@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());
 }
 /**
  * Retrieves the generated hydrator FQCN
  *
  * @return string
  */
 public function getHydratorClass()
 {
     $inflector = $this->configuration->getClassNameInflector();
     $realClassName = $inflector->getUserClassName($this->configuration->getHydratedClassName());
     $hydratorClassName = $inflector->getGeneratedClassName($realClassName, array('factory' => get_class($this)));
     if (!class_exists($hydratorClassName) && $this->configuration->doesAutoGenerateProxies()) {
         $generator = new HydratorGenerator();
         $originalClass = new ReflectionClass($realClassName);
         $generatedAst = $generator->generate($originalClass);
         $traverser = new NodeTraverser();
         $traverser->addVisitor(new ClassRenamerVisitor($originalClass, $hydratorClassName));
         $this->configuration->getGeneratorStrategy()->generate($traverser->traverse($generatedAst));
         $this->configuration->getGeneratedClassAutoloader()->__invoke($hydratorClassName);
     }
     return $hydratorClassName;
 }
Beispiel #10
0
    protected $bar = 2;
    public $baz = 3;
    public function getFoo()
    {
        return $this->foo;
    }
    public function getBar()
    {
        return $this->bar;
    }
    public function getBaz()
    {
        return $this->baz;
    }
}
$config = new Configuration('Foo');
$hydratorClass = $config->createFactory()->getHydratorClass();
$hydrator = new $hydratorClass();
$foo = new Foo();
$data = $hydrator->extract($foo);
echo "\nExtracted data:\n";
echo "foo: " . $data['foo'] . "\n";
// 1
echo "bar: " . $data['bar'] . "\n";
// 2
echo "baz: " . $data['baz'] . "\n";
// 3
$hydrator->hydrate(array('foo' => 4, 'bar' => 5, 'baz' => 6), $foo);
echo "\nObject hydrated with new data:\n";
echo "foo: " . $foo->getFoo() . "\n";
// 4
 /**
  * @covers \GeneratedHydrator\Factory\HydratorFactory::__construct
  * @covers \GeneratedHydrator\Factory\HydratorFactory::getHydratorClass
  */
 public function testWillGenerateValidClass()
 {
     $generatedClass = $this->config->createFactory()->getHydratorClass();
     $this->assertInstanceOf('Zend\\Stdlib\\Hydrator\\HydratorInterface', new $generatedClass());
 }
 /**
  * Generates a hydrator for the given class name, and retrieves an instance of it
  *
  * @param object $object
  *
  * @return \Zend\Stdlib\Hydrator\HydratorInterface
  */
 private function generateHydrator($object)
 {
     $config = new Configuration(get_class($object));
     $config->setGeneratorStrategy(new EvaluatingGeneratorStrategy());
     $generatedClass = $config->createFactory()->getHydratorClass();
     return new $generatedClass();
 }
 /**
  * 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();
 }