/**
* {@inheritDoc}
*/
public function isTransient($className)
{
if (strpos($className, self::NAME_SPACE) === 0) {
return $this->builtinDriver->isTransient($className);
}
return $this->wrappedDriver->isTransient($className);
}
/**
* Create a driver from a Doctrine metadata driver
*
* @param MappingDriver $omDriver
* @return DriverInterface
*/
public static function fromMetadataDriver(MappingDriver $omDriver)
{
if ($omDriver instanceof MappingDriverChain) {
$drivers = array();
foreach ($omDriver->getDrivers() as $nestedOmDriver) {
$drivers[] = self::fromMetadataDriver($nestedOmDriver);
}
return new DriverChain($drivers);
}
if ($omDriver instanceof DoctrineAnnotationDriver) {
return new AnnotationDriver($omDriver->getReader());
}
if ($omDriver instanceof DoctrineFileDriver) {
$reflClass = new \ReflectionClass($omDriver);
$driverName = $reflClass->getShortName();
if ($omDriver instanceof SimplifiedYamlDriver || $omDriver instanceof SimplifiedXmlDriver) {
$driverName = str_replace('Simplified', '', $driverName);
}
$class = 'Prezent\\Doctrine\\Translatable\\Mapping\\Driver\\' . $driverName;
if (class_exists($class)) {
return new $class($omDriver->getLocator());
}
}
throw new \InvalidArgumentException('Cannot adapt Doctrine driver of class ' . get_class($omDriver));
}
/**
* {@inheritDoc}
*/
protected function doLoadMetadata($class, $parent, $rootEntityFound)
{
try {
$this->driver->loadMetadataForClass($class->getName(), $class);
} catch (Exception $e) {
throw $e;
}
}
protected function getChildClasses(MappingDriver $driver, $currentClass)
{
$classes = array();
foreach ($driver->getAllClassNames() as $className) {
if (!is_subclass_of($className, $currentClass)) {
continue;
}
$classes[] = $className;
}
return $classes;
}
/**
* @param \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver
* @param string
* @return array
*/
private function getChildClasses(MappingDriver $driver, $currentClass)
{
$classes = array();
foreach ($driver->getAllClassNames() as $className) {
if (!ClassType::from($className)->isSubclassOf($currentClass)) {
continue;
}
$classes[] = $className;
}
return $classes;
}
function it_configures_the_mappings_of_a_model_that_overrides_an_original_model($configuration, ClassMetadataInfo $metadataInfo, MappingDriver $mappingDriver)
{
$originalQux1 = __NAMESPACE__ . '\\OriginalQux1';
$originalQux2 = __NAMESPACE__ . '\\OriginalQux2';
$overrideQux1 = __NAMESPACE__ . '\\OverrideQux1';
$overrideQux2 = __NAMESPACE__ . '\\OverrideQux2';
$mappingDriver->getAllClassNames()->willReturn([$originalQux1]);
$configuration->getMetadataDriverImpl()->willReturn($mappingDriver);
$metadataInfo->getName()->willReturn($overrideQux1);
$mappingDriver->loadMetadataForClass($originalQux1, Argument::any())->shouldBeCalled();
$overrides = [['original' => $originalQux1, 'override' => $overrideQux1], ['original' => $originalQux2, 'override' => $overrideQux2]];
$this->configure($metadataInfo, $overrides, $configuration);
}
protected function mockMeta()
{
$this->mappingDriver = m::mock(MappingDriver::class);
$this->mappingDriver->shouldReceive('addPaths')->with($this->settings['paths']);
$this->mockORMConfiguration();
$this->meta = m::mock(MetaDataManager::class);
$this->meta->shouldReceive('driver')->once()->andReturn($this->mappingDriver);
}
/**
* Forces the factory to load the metadata of all classes known to the underlying
* mapping driver.
*
* @return array The ClassMetadata instances of all mapped classes.
*/
public function getAllMetadata()
{
$metadata = array();
foreach ($this->driver->getAllClassNames() as $className) {
$metadata[] = $this->getMetadataFor($className);
}
return $metadata;
}
/**
* Actually load the metadata from the underlying metadata
*
* @param ClassMetadataInterface|ClassMetadata $class
* @param ClassMetadataInterface|ClassMetadata $parent
* @param bool $rootEntityFound
* @param array $nonSuperclassParents
*/
protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
{
//Manipulates $classMetadata;
$this->driver->loadMetadataForClass($class->getName(), $class);
if ($this->evm->hasListeners(Events::loadClassMetadata)) {
$eventArgs = new LoadClassMetadataEventArgs($class, $this->sm);
$this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
}
}
public function test_can_register_paths()
{
$this->disableDebugbar();
$this->disableSecondLevelCaching();
$this->disableCustomCacheNamespace();
$this->disableCustomFunctions();
$this->enableLaravelNamingStrategy();
$this->mappingDriver->shouldReceive('addPaths')->once()->with($this->settings['paths']);
$manager = $this->factory->create($this->settings);
$this->assertEntityManager($manager);
}
/**
* Loads the metadata of the specified class
*
* @param string $nameName The name of the class for which the metadata
* should be loaded.
*
* @return ClassMetadata
*/
protected function loadMetadata($className)
{
if (false === isset($this->loadedMetadata[$className])) {
if (null === ($class = $this->driver->loadMetadataForClass($className))) {
// FIXXME Improve this
throw new \Exception("Can't load metadata for {$className}");
}
$this->completeMetadata($class);
$this->loadedMetadata[$className] = $class;
}
return $this->loadedMetadata[$className];
}
/**
* {@inheritDoc}
*/
public function isTransient($className)
{
/* @var $driver MappingDriver */
foreach ($this->drivers as $namespace => $driver) {
if (strpos($className, $namespace) === 0) {
return $driver->isTransient($className);
}
}
if ($this->defaultDriver !== null) {
return $this->defaultDriver->isTransient($className);
}
return true;
}
/**
* Returns whether the class with the specified name should have its metadata loaded.
* This is only the case if it is either mapped as an Entity or a MappedSuperclass.
*
* @param string $className
*
* @return boolean
*/
public function isTransient($className)
{
/**
* @var $driver FileDriver
*/
foreach ($this->drivers as $driver) {
$namespace = $driver->getGlobalBasename();
if ($this->classNameIsAllowed($className, $namespace)) {
return $driver->isTransient($className);
}
}
if ($this->defaultDriver !== null) {
return $this->defaultDriver->isTransient($className);
}
return true;
}
/**
* Adds a default discriminator map if no one is given
*
* If an entity is of any inheritance type and does not contain a
* discriminator map, then the map is generated automatically. This process
* is expensive computation wise.
*
* The automatically generated discriminator map contains the lowercase short name of
* each class as key.
*
* @param \Doctrine\ORM\Mapping\ClassMetadata $class
*
* @throws MappingException
*/
private function addDefaultDiscriminatorMap(ClassMetadata $class)
{
$allClasses = $this->driver->getAllClassNames();
$fqcn = $class->getName();
$map = array($this->getShortName($class->name) => $fqcn);
$duplicates = array();
foreach ($allClasses as $subClassCandidate) {
if (is_subclass_of($subClassCandidate, $fqcn)) {
$shortName = $this->getShortName($subClassCandidate);
if (isset($map[$shortName])) {
$duplicates[] = $shortName;
}
$map[$shortName] = $subClassCandidate;
}
}
if ($duplicates) {
throw MappingException::duplicateDiscriminatorEntry($class->name, $duplicates, $map);
}
$class->setDiscriminatorMap($map);
}
public function testDriverDelegatesIsTransientCall()
{
$this->innerDriver->expects($this->once())->method('isTransient');
$this->driver->isTransient('My\\Namespace\\Person');
}
/**
* {@inheritdoc}
*/
protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
{
$this->driver->loadMetadataForClass($class->getName(), $class);
}
/**
* Create a driver from a Doctrine metadata driver.
*
* @param MappingDriver $omDriver
*
* @return DriverInterface
*/
protected function fromMetadataDriver(MappingDriver $omDriver)
{
if ($omDriver instanceof MappingDriverChain) {
$drivers = array();
foreach ($omDriver->getDrivers() as $nestedOmDriver) {
$drivers[] = $this->fromMetadataDriver($nestedOmDriver);
}
return new DriverChain($drivers);
}
if ($omDriver instanceof DoctrineAnnotationDriver) {
return new MergeableDriver($this->createAnnotationDriver($omDriver->getReader()));
}
if ($omDriver instanceof DoctrineFileDriver) {
$reflClass = new \ReflectionClass($omDriver);
$driverName = $reflClass->getShortName();
if (strpos($driverName, 'Simplified') !== false) {
$driverName = str_replace('Simplified', '', $driverName);
}
return new MergeableDriver(call_user_func(array(static::class, 'create' . $driverName), $omDriver->getLocator()));
}
throw new \InvalidArgumentException('Cannot adapt Doctrine driver of class ' . get_class($omDriver));
}
/**
* @inheritdoc
*/
public function isTransient($className)
{
return $this->wrapped->isTransient($className);
}
/**
* Returns whether the class with the specified name should have its metadata loaded.
* This is only the case if it is either mapped as an Entity or a MappedSuperclass.
*
* @param string $className
* @return boolean
*/
public function isTransient($className)
{
return $this->innerDriver->isTransient($className);
}
