public function testSetIsShared()
{
$def = new Definition('stdClass');
$this->assertTrue($def->isShared(), '->isShared() returns true by default');
$this->assertEquals(spl_object_hash($def), spl_object_hash($def->setShared(false)), '->setShared() implements a fluent interface');
$this->assertFalse($def->isShared(), '->isShared() returns false if the instance must not be shared');
}
public function testAnnotations()
{
$def = new Definition('stdClass');
$this->assertEquals(spl_object_hash($def->addAnnotation('foo')), spl_object_hash($def), '->addAnnotation() implements a fluent interface');
$this->assertEquals($def->getAnnotation('foo'), array(array()), '->getAnnotation() returns attributes for an annotation name');
$def->addAnnotation('foo', array('foo' => 'bar'));
$this->assertEquals($def->getAnnotation('foo'), array(array(), array('foo' => 'bar')), '->addAnnotation() can adds the same annotation several times');
$def->addAnnotation('bar', array('bar' => 'bar'));
$this->assertEquals($def->getAnnotations(), array('foo' => array(array(), array('foo' => 'bar')), 'bar' => array(array('bar' => 'bar'))), '->getAnnotations() returns all annotations');
}
/**
* Gets an entity manager cache driver definition for metadata, query and result caches.
*
* @param array $entityManager
* @param string $cacheDriver
* @param ContainerBuilder $container
* @return Definition $cacheDef
*/
protected function getEntityManagerCacheDefinition(array $entityManager, $cacheDriver, ContainerBuilder $container)
{
$type = is_array($cacheDriver) && isset($cacheDriver['type']) ? $cacheDriver['type'] : $cacheDriver;
if ($type === 'memcache') {
$memcacheClass = isset($cacheDriver['class']) ? $cacheDriver['class'] : '%' . sprintf('doctrine.orm.cache.%s_class', $type) . '%';
$cacheDef = new Definition($memcacheClass);
$memcacheHost = isset($cacheDriver['host']) ? $cacheDriver['host'] : '%doctrine.orm.cache.memcache_host%';
$memcachePort = isset($cacheDriver['port']) ? $cacheDriver['port'] : '%doctrine.orm.cache.memcache_port%';
$memcacheInstanceClass = isset($cacheDriver['instance_class']) ? $cacheDriver['instance_class'] : '%doctrine.orm.cache.memcache_instance_class%';
$memcacheInstance = new Definition($memcacheInstanceClass);
$memcacheInstance->addMethodCall('connect', array($memcacheHost, $memcachePort));
$container->setDefinition(sprintf('doctrine.orm.%s_memcache_instance', $entityManager['name']), $memcacheInstance);
$cacheDef->addMethodCall('setMemcache', array(new Reference(sprintf('doctrine.orm.%s_memcache_instance', $entityManager['name']))));
} else {
$cacheDef = new Definition('%' . sprintf('doctrine.orm.cache.%s_class', $type) . '%');
}
return $cacheDef;
}
/**
* Loads the Doctrine ORM configuration.
*
* @param array $config A configuration array
*
* @return BuilderConfiguration A BuilderConfiguration instance
*/
public function ormLoad($config)
{
$configuration = new BuilderConfiguration();
$loader = new XmlFileLoader(__DIR__ . '/../Resources/config');
$configuration->merge($loader->load($this->resources['orm']));
$config['default_entity_manager'] = isset($config['default_entity_manager']) ? $config['default_entity_manager'] : 'default';
foreach (array('metadata_driver', 'cache_driver') as $key) {
if (isset($config[$key])) {
$configuration->setParameter('doctrine.orm.' . $key, $config[$key]);
}
}
$config['entity_managers'] = isset($config['entity_managers']) ? $config['entity_managers'] : array($config['default_entity_manager'] => array());
foreach ($config['entity_managers'] as $name => $connection) {
$ormConfigDef = new Definition('Doctrine\\ORM\\Configuration');
$configuration->setDefinition(sprintf('doctrine.orm.%s_configuration', $name), $ormConfigDef);
$drivers = array('metadata', 'query', 'result');
foreach ($drivers as $driver) {
$definition = $configuration->getDefinition(sprintf('doctrine.orm.cache.%s', $configuration->getParameter('doctrine.orm.cache_driver')));
$clone = clone $definition;
$clone->addMethodCall('setNamespace', array(sprintf('doctrine_%s_', $driver)));
$configuration->setDefinition(sprintf('doctrine.orm.%s_cache', $driver), $clone);
}
// configure metadata driver for each bundle based on the type of mapping files found
$mappingDriverDef = new Definition('Doctrine\\ORM\\Mapping\\Driver\\DriverChain');
$bundleEntityMappings = array();
$bundleDirs = $this->bundleDirs;
$aliasMap = array();
foreach (array_reverse($this->bundles) as $className) {
$tmp = dirname(str_replace('\\', '/', $className));
$namespace = str_replace('/', '\\', dirname($tmp));
$class = basename($tmp);
if (!isset($bundleDirs[$namespace])) {
continue;
}
$type = false;
if (is_dir($dir = $bundleDirs[$namespace] . '/' . $class . '/Resources/config/doctrine/metadata')) {
$type = $this->detectMappingType($dir);
}
if (is_dir($dir = $bundleDirs[$namespace] . '/' . $class . '/Entities')) {
if ($type === false) {
$type = 'annotation';
}
$aliasMap[$class] = $namespace . '\\' . $class . '\\Entities';
}
if (false !== $type) {
$mappingDriverDef->addMethodCall('addDriver', array(new Reference(sprintf('doctrine.orm.metadata_driver.%s', $type)), $namespace . '\\' . $class . '\\Entities'));
}
}
$ormConfigDef->addMethodCall('setEntityNamespaces', array($aliasMap));
$configuration->setDefinition('doctrine.orm.metadata_driver', $mappingDriverDef);
$methods = array('setMetadataCacheImpl' => new Reference('doctrine.orm.metadata_cache'), 'setQueryCacheImpl' => new Reference('doctrine.orm.query_cache'), 'setResultCacheImpl' => new Reference('doctrine.orm.result_cache'), 'setMetadataDriverImpl' => new Reference('doctrine.orm.metadata_driver'), 'setProxyDir' => '%kernel.cache_dir%/doctrine/Proxies', 'setProxyNamespace' => 'Proxies', 'setAutoGenerateProxyClasses' => true);
foreach ($methods as $method => $arg) {
$ormConfigDef->addMethodCall($method, array($arg));
}
$ormEmArgs = array(new Reference(sprintf('doctrine.dbal.%s_connection', isset($connection['connection']) ? $connection['connection'] : $name)), new Reference(sprintf('doctrine.orm.%s_configuration', $name)));
$ormEmDef = new Definition('Doctrine\\ORM\\EntityManager', $ormEmArgs);
$ormEmDef->setConstructor('create');
$configuration->setDefinition(sprintf('doctrine.orm.%s_entity_manager', $name), $ormEmDef);
if ($name == $config['default_entity_manager']) {
$configuration->setAlias('doctrine.orm.entity_manager', sprintf('doctrine.orm.%s_entity_manager', $name));
}
}
$configuration->setAlias('doctrine.orm.cache', sprintf('doctrine.orm.cache.%s', $configuration->getParameter('doctrine.orm.cache_driver')));
return $configuration;
}
$t->is($def->getClass(), 'foo', '->getClass() returns the class name');
// ->setArguments() ->getArguments() ->addArgument()
$t->diag('->setArguments() ->getArguments() ->addArgument()');
$def = new Definition('stdClass');
$t->is(spl_object_hash($def->setArguments(array('foo'))), spl_object_hash($def), '->setArguments() implements a fluent interface');
$t->is($def->getArguments(), array('foo'), '->getArguments() returns the arguments');
$t->is(spl_object_hash($def->addArgument('bar')), spl_object_hash($def), '->addArgument() implements a fluent interface');
$t->is($def->getArguments(), array('foo', 'bar'), '->addArgument() adds an argument');
// ->setMethodCalls() ->getMethodCalls() ->addMethodCall()
$t->diag('->setMethodCalls() ->getMethodCalls() ->addMethodCall()');
$def = new Definition('stdClass');
$t->is(spl_object_hash($def->setMethodCalls(array(array('foo', array('foo'))))), spl_object_hash($def), '->setMethodCalls() implements a fluent interface');
$t->is($def->getMethodCalls(), array(array('foo', array('foo'))), '->getMethodCalls() returns the methods to call');
$t->is(spl_object_hash($def->addMethodCall('bar', array('bar'))), spl_object_hash($def), '->addMethodCall() implements a fluent interface');
$t->is($def->getMethodCalls(), array(array('foo', array('foo')), array('bar', array('bar'))), '->addMethodCall() adds a method to call');
// ->setFile() ->getFile()
$t->diag('->setFile() ->getFile()');
$def = new Definition('stdClass');
$t->is(spl_object_hash($def->setFile('foo')), spl_object_hash($def), '->setFile() implements a fluent interface');
$t->is($def->getFile(), 'foo', '->getFile() returns the file to include');
// ->setShared() ->isShared()
$t->diag('->setShared() ->isShared()');
$def = new Definition('stdClass');
$t->is($def->isShared(), true, '->isShared() returns true by default');
$t->is(spl_object_hash($def->setShared(false)), spl_object_hash($def), '->setShared() implements a fluent interface');
$t->is($def->isShared(), false, '->isShared() returns false if the instance must not be shared');
// ->setConfigurator() ->getConfigurator()
$t->diag('->setConfigurator() ->getConfigurator()');
$def = new Definition('stdClass');
$t->is(spl_object_hash($def->setConfigurator('foo')), spl_object_hash($def), '->setConfigurator() implements a fluent interface');
$t->is($def->getConfigurator(), 'foo', '->getConfigurator() returns the configurator');
protected function parseDefinition(BuilderConfiguration $configuration, $id, $service, $file)
{
if (is_string($service) && 0 === strpos($service, '@')) {
$configuration->setAlias($id, substr($service, 1));
return;
}
$definition = new Definition($service['class']);
if (isset($service['shared'])) {
$definition->setShared($service['shared']);
}
if (isset($service['constructor'])) {
$definition->setConstructor($service['constructor']);
}
if (isset($service['file'])) {
$definition->setFile($service['file']);
}
if (isset($service['arguments'])) {
$definition->setArguments($this->resolveServices($service['arguments']));
}
if (isset($service['configurator'])) {
if (is_string($service['configurator'])) {
$definition->setConfigurator($service['configurator']);
} else {
$definition->setConfigurator(array($this->resolveServices($service['configurator'][0]), $service['configurator'][1]));
}
}
if (isset($service['calls'])) {
foreach ($service['calls'] as $call) {
$definition->addMethodCall($call[0], $this->resolveServices($call[1]));
}
}
if (isset($service['annotations'])) {
foreach ($service['annotations'] as $annotation) {
$name = $annotation['name'];
unset($annotation['name']);
$definition->addAnnotation($name, $annotation);
}
}
$configuration->setDefinition($id, $definition);
}
protected function parseDefinition(BuilderConfiguration $configuration, $id, $service, $file)
{
if ((string) $service['alias']) {
$configuration->setAlias($id, (string) $service['alias']);
return;
}
$definition = new Definition((string) $service['class']);
foreach (array('shared', 'factory-method', 'factory-service', 'factory-class') as $key) {
if (isset($service[$key])) {
$method = 'set' . str_replace('-', '', $key);
$definition->{$method}((string) $service->getAttributeAsPhp($key));
}
}
if ($service->file) {
$definition->setFile((string) $service->file);
}
$definition->setArguments($service->getArgumentsAsPhp('argument'));
if (isset($service->configurator)) {
if (isset($service->configurator['function'])) {
$definition->setConfigurator((string) $service->configurator['function']);
} else {
if (isset($service->configurator['service'])) {
$class = new Reference((string) $service->configurator['service']);
} else {
$class = (string) $service->configurator['class'];
}
$definition->setConfigurator(array($class, (string) $service->configurator['method']));
}
}
foreach ($service->call as $call) {
$definition->addMethodCall((string) $call['method'], $call->getArgumentsAsPhp('argument'));
}
foreach ($service->annotation as $annotation) {
$parameters = array();
foreach ($annotation->attributes() as $name => $value) {
if ('name' === $name) {
continue;
}
$parameters[$name] = SimpleXMLElement::phpize($value);
}
$definition->addAnnotation((string) $annotation['name'], $parameters);
}
$configuration->setDefinition($id, $definition);
}
protected function parseDefinition(BuilderConfiguration $configuration, $id, $service, $file)
{
if ((string) $service['alias']) {
$configuration->setAlias($id, (string) $service['alias']);
return;
}
$definition = new Definition((string) $service['class']);
foreach (array('shared', 'constructor') as $key) {
$method = 'set' . ucfirst($key);
if (isset($service[$key])) {
$definition->{$method}((string) $service->getAttributeAsPhp($key));
}
}
if ($service->file) {
$definition->setFile((string) $service->file);
}
$definition->setArguments($service->getArgumentsAsPhp('argument'));
if (isset($service->configurator)) {
if (isset($service->configurator['function'])) {
$definition->setConfigurator((string) $service->configurator['function']);
} else {
if (isset($service->configurator['service'])) {
$class = new Reference((string) $service->configurator['service']);
} else {
$class = (string) $service->configurator['class'];
}
$definition->setConfigurator(array($class, (string) $service->configurator['method']));
}
}
foreach ($service->call as $call) {
$definition->addMethodCall((string) $call['method'], $call->getArgumentsAsPhp('argument'));
}
$configuration->setDefinition($id, $definition);
}
/**
* Detects and builds the appropriate metadata driver for each bundle.
*
* @param Symfony\Components\DependencyInjection\BuilderConfiguration $configuration A builder configuration
*
* @return Symfony\Components\DependencyInjection\Definition A definition for the metadata service
*/
protected function buildMetadataDefinition(BuilderConfiguration $configuration)
{
$definition = new Definition('%doctrine.odm.mongodb.metadata.chain_class%');
foreach ($this->bundles as $bundle) {
$reflection = new \ReflectionClass($bundle);
if ($driver = static::detectMetadataDriver(dirname($reflection->getFilename()), $configuration)) {
$definition->addMethodCall('addDriver', array(new Reference('doctrine.odm.mongodb.metadata.' . $driver), $reflection->getNamespaceName() . '\\Document'));
}
}
return $definition;
}
$t->diag('->setMethodCalls() ->getMethodCalls() ->addMethodCall()');
$def = new Definition('stdClass');
$t->is(spl_object_hash($def->setMethodCalls(array(array('foo', array('foo'))))), spl_object_hash($def), '->setMethodCalls() implements a fluent interface');
$t->is($def->getMethodCalls(), array(array('foo', array('foo'))), '->getMethodCalls() returns the methods to call');
$t->is(spl_object_hash($def->addMethodCall('bar', array('bar'))), spl_object_hash($def), '->addMethodCall() implements a fluent interface');
$t->is($def->getMethodCalls(), array(array('foo', array('foo')), array('bar', array('bar'))), '->addMethodCall() adds a method to call');
// ->setFile() ->getFile()
$t->diag('->setFile() ->getFile()');
$def = new Definition('stdClass');
$t->is(spl_object_hash($def->setFile('foo')), spl_object_hash($def), '->setFile() implements a fluent interface');
$t->is($def->getFile(), 'foo', '->getFile() returns the file to include');
// ->setShared() ->isShared()
$t->diag('->setShared() ->isShared()');
$def = new Definition('stdClass');
$t->is($def->isShared(), true, '->isShared() returns true by default');
$t->is(spl_object_hash($def->setShared(false)), spl_object_hash($def), '->setShared() implements a fluent interface');
$t->is($def->isShared(), false, '->isShared() returns false if the instance must not be shared');
// ->setConfigurator() ->getConfigurator()
$t->diag('->setConfigurator() ->getConfigurator()');
$def = new Definition('stdClass');
$t->is(spl_object_hash($def->setConfigurator('foo')), spl_object_hash($def), '->setConfigurator() implements a fluent interface');
$t->is($def->getConfigurator(), 'foo', '->getConfigurator() returns the configurator');
// ->getAnnotations() ->getAnnotation() ->addAnnotation()
$t->diag('->getAnnotations() ->getAnnotation() ->addAnnotation()');
$def = new Definition('stdClass');
$t->is(spl_object_hash($def->addAnnotation('foo')), spl_object_hash($def), '->addAnnotation() implements a fluent interface');
$t->is($def->getAnnotation('foo'), array(array()), '->getAnnotation() returns attributes for an annotation name');
$def->addAnnotation('foo', array('foo' => 'bar'));
$t->is($def->getAnnotation('foo'), array(array(), array('foo' => 'bar')), '->addAnnotation() can adds the same annotation several times');
$def->addAnnotation('bar', array('bar' => 'bar'));
$t->is($def->getAnnotations(), array('foo' => array(array(), array('foo' => 'bar')), 'bar' => array(array('bar' => 'bar'))), '->getAnnotations() returns all annotations');
/**
* Creates a service for a service definition.
*
* @param Definition $definition A service definition instance
* @param string $id The service identifier
*
* @return object The service described by the service definition
*
* @throws \InvalidArgumentException When configure callable is not callable
*/
protected function createService(Definition $definition, $id)
{
if (null !== $definition->getFile()) {
require_once $this->getParameterBag()->resolveValue($definition->getFile());
}
$arguments = $this->resolveServices($this->getParameterBag()->resolveValue($definition->getArguments()));
if (null !== $definition->getFactoryMethod()) {
if (null !== $definition->getFactoryService()) {
$factory = $this->get($this->getParameterBag()->resolveValue($definition->getFactoryService()));
} else {
$factory = $this->getParameterBag()->resolveValue($definition->getClass());
}
$service = call_user_func_array(array($factory, $definition->getFactoryMethod()), $arguments);
} else {
$r = new \ReflectionClass($this->getParameterBag()->resolveValue($definition->getClass()));
$service = null === $r->getConstructor() ? $r->newInstance() : $r->newInstanceArgs($arguments);
}
if ($definition->isShared()) {
$this->services[$id] = $service;
}
foreach ($definition->getMethodCalls() as $call) {
$services = self::getServiceConditionals($call[1]);
$ok = true;
foreach ($services as $s) {
if (!$this->has($s)) {
$ok = false;
break;
}
}
if ($ok) {
call_user_func_array(array($service, $call[0]), $this->resolveServices($this->getParameterBag()->resolveValue($call[1])));
}
}
if ($callable = $definition->getConfigurator()) {
if (is_array($callable) && is_object($callable[0]) && $callable[0] instanceof Reference) {
$callable[0] = $this->get((string) $callable[0]);
} elseif (is_array($callable)) {
$callable[0] = $this->getParameterBag()->resolveValue($callable[0]);
}
if (!is_callable($callable)) {
throw new \InvalidArgumentException(sprintf('The configure callable for class "%s" is not a callable.', get_class($service)));
}
call_user_func($callable, $service);
}
return $service;
}
/**
* Loads the configured document manager metadata cache driver.
*
* @param array $config A configured document manager array
* @param ContainerBuilder $container A ContainerBuilder instance
*/
protected function loadDocumentManagerMetadataCacheDriver(array $documentManager, ContainerBuilder $container)
{
$metadataCacheDriver = $container->getParameter('doctrine.odm.mongodb.metadata_cache_driver');
$dmMetadataCacheDriver = isset($documentManager['metadata_cache_driver']) ? $documentManager['metadata_cache_driver'] : $metadataCacheDriver;
$type = is_array($dmMetadataCacheDriver) && isset($dmMetadataCacheDriver['type']) ? $dmMetadataCacheDriver['type'] : $dmMetadataCacheDriver;
if ($type === 'memcache') {
$memcacheClass = isset($dmMetadataCacheDriver['class']) ? $dmMetadataCacheDriver['class'] : '%' . sprintf('doctrine.odm.mongodb.cache.%s_class', $type) . '%';
$cacheDef = new Definition($memcacheClass);
$memcacheHost = isset($dmMetadataCacheDriver['host']) ? $dmMetadataCacheDriver['host'] : '%doctrine.odm.mongodb.cache.memcache_host%';
$memcachePort = isset($dmMetadataCacheDriver['port']) ? $dmMetadataCacheDriver['port'] : '%doctrine.odm.mongodb.cache.memcache_port%';
$memcacheInstanceClass = isset($dmMetadataCacheDriver['instance_class']) ? $dmMetadataCacheDriver['instance_class'] : '%doctrine.odm.mongodb.cache.memcache_instance_class%';
$memcacheInstance = new Definition($memcacheInstanceClass);
$memcacheInstance->addMethodCall('connect', array($memcacheHost, $memcachePort));
$container->setDefinition(sprintf('doctrine.odm.mongodb.%s_memcache_instance', $documentManager['name']), $memcacheInstance);
$cacheDef->addMethodCall('setMemcache', array(new Reference(sprintf('doctrine.odm.mongodb.%s_memcache_instance', $documentManager['name']))));
} else {
$cacheDef = new Definition('%' . sprintf('doctrine.odm.mongodb.cache.%s_class', $type) . '%');
}
$container->setDefinition(sprintf('doctrine.odm.mongodb.%s_metadata_cache', $documentManager['name']), $cacheDef);
}
