function getAssets() { $serviceDefinition = new ServiceDefinition(); $serviceDefinition->setClass('Mike227\\NAssetic\\AssetCollection'); $serviceDefinition->setArguments(array(array('test6.js'), array(new TestFilter('#FILTER')), __DIR__ . '/../sources/')); return array('js1' => new GlobAsset(__DIR__ . '/../sources/test1.*'), 'js2' => array(new GlobAsset(__DIR__ . '/../sources/test2.*'), __DIR__ . '/../sources/test3.js', array(__DIR__ . '/../sources/test4.js', new GlobAsset(__DIR__ . '/../sources/test5.*')), 'serviceDef' => $serviceDefinition)); }
/** * @param string $class * @return ServiceDefinition */ public function createServiceDefinition($class) { $definition = new ServiceDefinition(); $definition->setClass($class); $definition->addTag('kdyby.subscriber'); return $definition; }
private function updateDefinition(DI\ServiceDefinition $def) { $class = $def->getClass(); $setups = $def->getSetup(); foreach (self::getInjectProperties($class) as $property => $type) { $builder = $this->getContainerBuilder(); $inject = new DI\Statement('$' . $property, ['@\\' . ltrim($type, '\\')]); foreach ($setups as $key => $setup) { if ($setup->getEntity() === $inject->getEntity()) { $inject = $setup; $builder = NULL; unset($setups[$key]); } } self::checkType($class, $property, $type, $builder); array_unshift($setups, $inject); } foreach (array_reverse(self::getInjectMethods($def->getClass())) as $method) { $inject = new DI\Statement($method); foreach ($setups as $key => $setup) { if ($setup->getEntity() === $inject->getEntity()) { $inject = $setup; unset($setups[$key]); } } array_unshift($setups, $inject); } $def->setSetup($setups); }
/** * @param ServiceDefinition $def */ private function registerToLatte(ServiceDefinition $def) { $def->addSetup('?->onCompile[] = function (Latte\\Engine $engine) { (new Texy\\Bridges\\Latte\\TexyMacro($engine, ?))->install(); }', ['@self', $this->prefix('@texy')])->addSetup('addFilter', ['texy', [$this->prefix('@texy'), 'process']]); if (method_exists('Latte\\Engine', 'addProvider')) { $def->addSetup('addProvider', ['texy', $this->prefix('@texy')]); } else { $def->addSetup('?->addFilter(\'getTexy\', function () { return ?;})', ['@self', $this->prefix('@texy')]); } }
/** * @param \Nette\DI\ServiceDefinition $configuration * @param string $namespace * @param array $config */ private function applyNamespaceConfiguration(ServiceDefinition $configuration, $namespace, array $config) { $builder = $this->getContainerBuilder(); $safeNamespace = str_replace('-', '_', Strings::webalize($namespace)); if ($namespace === Configuration::DEFAULT_NAMESPACE_NAME || $config['nameResolver']['class']) { if (!class_exists($config['nameResolver']['class'])) { throw new ConfigurationException('Name resolver ' . $config['nameResolver']['class'] . ' for namespace ' . $namespace . ' does not exists.'); } $nameResolver = $builder->addDefinition($this->prefix('nameResolver.' . $safeNamespace))->setClass($config['nameResolver']['class']); $configuration->addSetup('setNameResolver', [$namespace, $nameResolver]); } if ($config['default'] !== null) { $configuration->addSetup('setDefaultImage', [$namespace, $config['default']]); } if ($config['resizeFlag'] !== null) { $resizeFlag = Helpers::parseResizeFlags($config['resizeFlag']); $configuration->addSetup('setResizeFlag', [$namespace, $resizeFlag]); } if ($config['quality'] !== null) { $configuration->addSetup('setQuality', [$namespace, $config['quality']]); } if (isset($config['presets']) && count($config['presets'])) { foreach ($config['presets'] as $name => $preset) { if ($preset instanceof Statement) { $size = Helpers::parseSize($preset->getEntity()); $resizeFlags = Helpers::parseResizeFlags($preset->arguments); } else { $size = Helpers::parseSize($preset); $resizeFlags = null; } $configuration->addSetup('addPreset', [$namespace, $name, $size[0], $size[1], $resizeFlags]); } } if ($config['dummy']['enabled'] !== null) { $configuration->addSetup('enableDummy', [$namespace, $config['dummy']['enabled']]); } if ($config['dummy']['class'] !== null) { if (!class_exists($config['dummy']['class'])) { throw new ConfigurationException('Dummy provider class ' . $config['dummy']['class'] . ' for namespace ' . $namespace . ' does not exists.'); } $provider = $builder->addDefinition($this->prefix('dummy.' . $safeNamespace))->setClass($config['dummy']['class']); $configuration->addSetup('setDummyProvider', [$namespace, $provider]); } if ($config['dummy']['category'] !== null) { $configuration->addSetup('setDummyCategory', [$namespace, $config['dummy']['category']]); } if ($config['dummy']['fallbackSize'] !== null) { $size = $config['dummy']['fallbackSize']; $configuration->addSetup('setDummyFallbackSize', [$namespace, $size[0], $size[1]]); } if ($config['dummy']['chance'] !== null) { $configuration->addSetup('setDummyDisplayChance', [$namespace, $config['dummy']['chance']]); } }
/** * @param ServiceDefinition $service * @return array */ private function parseSubscriberTags(ServiceDefinition $service) { $tags = $service->getTags(); // Array contains EVENT_TAG_NAME key if (isset($tags[self::EVENT_TAG_NAME]) && is_array($tags[self::EVENT_TAG_NAME])) { return $tags[self::EVENT_TAG_NAME]; } // Array contains other tags $etags = []; foreach ($tags as $tag => $value) { if (strncmp($tag, self::EVENT_TAG_PREFIX, strlen(self::EVENT_TAG_PREFIX)) === 0) { $etags[] = trim(substr($tag, strlen(self::EVENT_TAG_PREFIX)), '.:'); } } return $etags; }
public function process(ServiceDefinition $definition, $tags) { if (is_string($tags)) { $tags = array($tags); } $currentTags = $definition->getTags(); foreach ((array) $tags as $tag => $attrs) { if (is_int($tag) && is_string($attrs)) { $tag = $attrs; $attrs = TRUE; } if (!isset($currentTags[$tag])) { $definition->addTag($tag, $attrs); } } }
/** * @param ServiceDefinition * @return string|null */ protected static function detectClass(ServiceDefinition $def) { if ($def->getClass()) { return $def->getClass(); } elseif ($interface = $def->getImplement()) { $rc = Reflection\ClassType::from($interface); $method = $rc->hasMethod('create') ? 'create' : ($rc->hasMethod('get') ? 'get' : NULL); if ($method === NULL) { return NULL; } if (!($returnType = $rc->getMethod($method)->getAnnotation('return'))) { return NULL; } return Reflection\AnnotationsParser::expandClassName(preg_replace('#[|\\s].*#', '', $returnType), $rc); } return NULL; }
private function configureEndpoints($config, ServiceDefinition $solarium) { if (empty($config['endpoints'])) { $endpoints = ['default' => array_intersect_key($config, $this->endpointDefaults)]; } else { $endpoints = $config['endpoints']; } $solarium->addSetup('clearEndpoints'); $default = TRUE; foreach ($endpoints as $name => $options) { $options += $this->endpointDefaults; $options += ['key' => $name]; $solarium->addSetup('addEndpoint', [array_diff_key($options, ['default' => TRUE])]); if ($default === TRUE && $options['default'] === NULL || $options['default'] === TRUE) { $solarium->addSetup('setDefaultEndpoint', [$name]); } } }
private function decorateServiceDefinitionWithNetteEvent(ServiceDefinition $serviceDefinition, NetteEventItemInterface $netteEvent) { $propertyStatement = new Statement('function () { $class = ?; $event = new $class(...func_get_args()); ?->dispatch(?, $event); }', [$netteEvent->getEventClass(), '@' . EventDispatcherInterface::class, $netteEvent->getEventName()]); $serviceDefinition->addSetup('$service->?[] = ?;', [$netteEvent->getProperty(), $propertyStatement]); }
public function process(ServiceDefinition $definition, $methods) { $currentSetupMethods = array_map(function (Statement $statement) { return $statement->getEntity(); }, $definition->getSetup()); Validators::assert($methods, 'array'); foreach ($methods as $setup) { $method = $setup; $args = array(); if ($method instanceof Statement) { $args = $method->arguments; $method = $method->getEntity(); } if (!in_array($method, $currentSetupMethods)) { $definition->addSetup($method, $args); } } }
/** * Configures BowerLoader instance. * @param ServiceDefinition * @return void */ private function setupService(ServiceDefinition $service) { // Bower components directory $service->addSetup('setBowerDir', array($this->getBowerDir())); // Setup autoloading $service->addSetup('setAutoload', array(isset($this->config['autoload']) ? $this->config['autoload'] : TRUE)); // Setup package files prepending $service->addSetup('setPrepend', array(isset($this->config['prepend']) ? $this->config['prepend'] : TRUE)); // Set cache storage $service->addSetup('setCacheStorage', array('@cacheStorage')); }
private function registerExtension($extension) { $builder = $this->containerBuilder; // Statement if ($extension instanceof Statement) { $class = $extension->getEntity(); } elseif (is_string($extension) && Strings::startsWith($extension, '@')) { $class = $builder->getDefinition($builder->getServiceName($extension))->getClass(); } elseif (is_string($extension)) { $class = $extension; $extension = new Statement($extension); } else { throw new UnexpectedTypeException("Extension has to be string or Statement, given " . (is_object($extension) ? get_class($extension) : gettype($extension)) . "."); } if (!class_exists($class)) { throw new InvalidArgumentException("Form extension class {$class} not found."); } $reflection = new ClassType($class); $matched = FALSE; if ($reflection->implementsInterface('NForms\\Builder\\Components\\IBeforeCreateContainer')) { $this->beforeCreateContainerOpSet->addSetup('add', array($extension)); $matched = TRUE; } if ($reflection->implementsInterface('NForms\\Builder\\Components\\IContainerFactory')) { $this->containerFactories->addSetup('add', array($extension)); $matched = TRUE; } if ($reflection->implementsInterface('NForms\\Builder\\Components\\IAfterCreateContainer')) { $this->afterCreateContainerOpSet->addSetup('add', array($extension)); $matched = TRUE; } if ($reflection->implementsInterface('NForms\\Builder\\Components\\IBeforeCreateControl')) { $this->beforeCreateControlOpSet->addSetup('add', array($extension)); $matched = TRUE; } if ($reflection->implementsInterface('NForms\\Builder\\Components\\IControlFactory')) { $this->controlFactories->addSetup('add', array($extension)); $matched = TRUE; } if ($reflection->implementsInterface('NForms\\Builder\\Components\\IAfterCreateControl')) { $this->afterCreateControlOpSet->addSetup('add', array($extension)); $matched = TRUE; } if ($reflection->implementsInterface('NForms\\Mapping\\IControlMapper')) { $this->controlMapperSet->addSetup('add', array($extension)); $matched = TRUE; } if (!$matched) { throw new UnexpectedTypeException("Extension does not implement any of the expected interface. Given: '" . get_class($extension) . "'." . "Expected interfaces: IBeforeCreateContainer, IContainerFactory, IAfterCreateContainer, IBeforeCreateControl, IControlFactory, IAfterCreateControl, IControlMapper."); } return $this; }
/** * Create definition statement for method * @param ServiceDefinition $definition * @param \Nette\Reflection\Method $method */ protected function autowireParams(ServiceDefinition $definition, \Nette\Reflection\Method $method) { $parameters = $method->getParameters(); foreach ($parameters as $num => $param) { /** @var \Nette\Reflection\Parameter $param */ if ($targetClass = $param->getClass()) { if ($targetClass->getName() === 'Kdyby\\Doctrine\\EntityDao' && !isset($definition->factory->arguments[$num])) { $annotations = $method->getAnnotations(); $entity = $this->getEntityName($param, $annotations); if ($definition->factory === NULL) { $definition->setFactory($definition->class); } $definition->factory->arguments[$num] = new \Nette\DI\Statement('@doctrine.dao', array($entity)); } } } }
/** * Parses single service from configuration file. * @return void */ public static function parseService(ServiceDefinition $definition, $config) { if ($config === NULL) { return; } elseif (is_string($config) && interface_exists($config)) { $config = ['class' => NULL, 'implement' => $config]; } elseif ($config instanceof Statement && is_string($config->getEntity()) && interface_exists($config->getEntity())) { $config = ['class' => NULL, 'implement' => $config->getEntity(), 'factory' => array_shift($config->arguments)]; } elseif (!is_array($config) || isset($config[0], $config[1])) { $config = ['class' => NULL, 'create' => $config]; } if (array_key_exists('factory', $config)) { $config['create'] = $config['factory']; unset($config['factory']); } $known = ['class', 'create', 'arguments', 'setup', 'autowired', 'dynamic', 'inject', 'parameters', 'implement', 'run', 'tags']; if ($error = array_diff(array_keys($config), $known)) { throw new Nette\InvalidStateException(sprintf("Unknown or deprecated key '%s' in definition of service.", implode("', '", $error))); } $config = Helpers::filterArguments($config); $arguments = []; if (array_key_exists('arguments', $config)) { Validators::assertField($config, 'arguments', 'array'); $arguments = $config['arguments']; $definition->setArguments($arguments); } if (array_key_exists('class', $config) || array_key_exists('create', $config)) { $definition->setClass(NULL); $definition->setFactory(NULL); } if (array_key_exists('class', $config)) { Validators::assertField($config, 'class', 'string|Nette\\DI\\Statement|null'); if (!$config['class'] instanceof Statement) { $definition->setClass($config['class']); } $definition->setFactory($config['class'], $arguments); } if (array_key_exists('create', $config)) { Validators::assertField($config, 'create', 'callable|Nette\\DI\\Statement|null'); $definition->setFactory($config['create'], $arguments); } if (isset($config['setup'])) { if (Config\Helpers::takeParent($config['setup'])) { $definition->setSetup([]); } Validators::assertField($config, 'setup', 'list'); foreach ($config['setup'] as $id => $setup) { Validators::assert($setup, 'callable|Nette\\DI\\Statement', "setup item #{$id}"); $definition->addSetup($setup); } } if (isset($config['parameters'])) { Validators::assertField($config, 'parameters', 'array'); $definition->setParameters($config['parameters']); } if (isset($config['implement'])) { Validators::assertField($config, 'implement', 'string'); $definition->setImplement($config['implement']); $definition->setAutowired(TRUE); } if (isset($config['autowired'])) { Validators::assertField($config, 'autowired', 'bool'); $definition->setAutowired($config['autowired']); } if (isset($config['dynamic'])) { Validators::assertField($config, 'dynamic', 'bool'); $definition->setDynamic($config['dynamic']); } if (isset($config['inject'])) { Validators::assertField($config, 'inject', 'bool'); $definition->addTag(Extensions\InjectExtension::TAG_INJECT, $config['inject']); } if (isset($config['run'])) { $config['tags']['run'] = (bool) $config['run']; } if (isset($config['tags'])) { Validators::assertField($config, 'tags', 'array'); if (Config\Helpers::takeParent($config['tags'])) { $definition->setTags([]); } foreach ($config['tags'] as $tag => $attrs) { if (is_int($tag) && is_string($attrs)) { $definition->addTag($attrs); } else { $definition->addTag($tag, $attrs); } } } }
/** * @param ServiceDefinition $definition * @param ClassType $class * @param array $methodMapping */ public function injectToDefinition(ServiceDefinition $definition, ClassType $class, array $methodMapping) { $injectionProperties = $this->getInjectionByNameProperties($class, $methodMapping); // Copy original setup method to be able to place them after injection $setupSave = $definition->setup; $definition->setup = []; foreach ($injectionProperties as $injectionProperty => $injectedServiceName) { $definition->addSetup($methodMapping[self::IIS_INJECT_SERVICE_METHOD], [$injectionProperty, '@' . $injectedServiceName]); } $injectionProperties = $this->getInjectionByTypeProperties($class, $methodMapping); foreach ($injectionProperties as $injectionProperty => $injectedServiceType) { $definition->addSetup($methodMapping[self::IIS_INJECT_SERVICE_METHOD], [$injectionProperty, '@' . $injectedServiceType]); } $definition->addSetup($methodMapping[self::IIS_INJECT_PARAMETERS_METHOD], ['@container']); $definition->addSetup($methodMapping[self::IIS_INJECTION_COMPLETED_METHOD], []); // Add original setup statements after injection completed method call foreach ($setupSave as $originalSetup) { $definition->addSetup($originalSetup); } }
public function process(ServiceDefinition $definition, $args) { if ($args === TRUE) { $definition->setInject(TRUE); } }
/** * @param \Nette\DI\ServiceDefinition $def */ private function registerMacros(ServiceDefinition $def) { $def->addSetup('Ark8\\Security\\Latte\\AuthorizatorMacros::install(?->getCompiler())', ['@self']); }
/** * @param Nette\DI\ServiceDefinition $def * @return string[] */ protected function getServiceBoundManagers(Nette\DI\ServiceDefinition $def) { $builder = $this->getContainerBuilder(); $boundManagers = $def->getTag(self::TAG_BIND_TO_MANAGER); return is_array($boundManagers) ? $boundManagers : array($builder->parameters[$this->name]['orm']['defaultEntityManager']); }
/** * @param string $class * @return ServiceDefinition */ public function createServiceDefinition($class) { $definition = new ServiceDefinition(); $definition->setClass($class); return $definition; }
/** * Registers new entity in mapper * @param ServiceDefinition * @param array [table => '', primaryKey => '', entity => '', repository => ''] * @return void */ protected function registerInMapper(ServiceDefinition $mapper, array $mapping = NULL) { if ($mapping === NULL) { return; } if (!isset($mapping['table']) || !is_string($mapping['table'])) { throw new \InvalidArgumentException('Table name missing or it\'s not string'); } if (!isset($mapping['entity']) || !is_string($mapping['entity'])) { throw new \InvalidArgumentException('Entity class missing or it\'s not string'); } $repositoryClass = isset($mapping['repository']) ? $mapping['repository'] : NULL; $primaryKey = isset($mapping['primaryKey']) ? $mapping['primaryKey'] : NULL; if (!is_string($repositoryClass) && !is_null($repositoryClass)) { throw new \InvalidArgumentException('Repository class must be string or NULL, ' . gettype($repositoryClass) . ' given'); } if (!is_string($primaryKey) && !is_null($primaryKey)) { throw new \InvalidArgumentException('Primary key must be string or NULL, ' . gettype($primaryKey) . ' given'); } $mapper->addSetup('register', array($mapping['table'], $mapping['entity'], $repositoryClass, $primaryKey)); }
/** * @param ServiceDefinition $filterManager * @param array $aliases * @throws \Mike227\NAssetic\Exceptions\UnexpectedValueException */ private static function setupFilters(ServiceDefinition $filterManager, array $aliases) { foreach ($aliases as $name => $filter) { if (is_object($filter)) { $statement = $filter instanceof Statement ? $filter : new Statement($filter->value, $filter->attributes); $filterManager->addSetup('set', array($name, $statement)); } else { if (class_exists($filter)) { $filterManager->addSetup('set', array($name, new Statement($filter))); } else { if (Strings::startsWith($filter, '@')) { $filterManager->addSetup('set', array($name, $filter)); } else { if (is_string($filter)) { throw new UnexpectedValueException("Filter \"{$name}: {$filter}\" class not found."); } else { throw new UnexpectedValueException("Invalid filter definition \"{$name}: {$filter}\"."); } } } } } }
/** * @param $interface * @return mixed|ServiceDefinition */ public function createFactoryDefinition($interface) { $definition = new ServiceDefinition(); $definition->setImplement($interface); return $definition; }
/** * @param string $class * @return ServiceDefinition * @throws \Nette\InvalidArgumentException */ public function createServiceDefinition($class) { // Validate annotation attributes if (count($this->parameters) === 0) { throw new InvalidArgumentException("Annotation @" . get_class() . " of class {$class} expects one or more parameters."); } // Create service definition $definition = new ServiceDefinition(); $definition->setClass($class); $definition->setInject(TRUE); // Parameters for service's constructor $serviceParameters = array(); // One parameter - @DaoManager("Name\Space\EntityClass") if (count($this->parameters) === 1 && isset($this->parameters[0])) { $entityName = $this->parameters[0]; $daoParameters = $this->findConstructorDaoParameters($class); if (count($daoParameters) === 0) { throw new InvalidArgumentException("Annotation @" . get_class() . ": {$class}::__construct() does not contain attribute with type hint " . self::DAO_CLASS); } else { if (count($daoParameters) > 1) { throw new InvalidArgumentException("Annotation @" . get_class() . ": {$class}::__construct() contains multiple attributes with type hint " . self::DAO_CLASS); } } $serviceParameters = array($daoParameters[0] => $this->createDaoStatement($entityName)); } else { foreach ($this->parameters as $attributeName => $entityName) { $serviceParameters[$attributeName] = $this->createDaoStatement($entityName); } } $definition->setArguments($serviceParameters); return $definition; }
protected function bindEventProperties(Nette\DI\ServiceDefinition $def, Nette\Reflection\ClassType $class) { foreach ($class->getProperties(Nette\Reflection\Property::IS_PUBLIC) as $property) { if (!preg_match('#^on[A-Z]#', $name = $property->getName())) { continue; } if ($property->hasAnnotation('persistent') || $property->hasAnnotation('inject')) { // definitely not an event continue; } $def->addSetup('$' . $name, array(new Nette\DI\Statement($this->prefix('@manager') . '::createEvent', array(array($class->getName(), $name), new Code\PhpLiteral('$service->' . $name))))); } }
/** * @param \Nette\DI\ServiceDefinition $metadataDriver * @param string $namespace * @param string|object $driver * @param string $prefix * @throws \Nette\Utils\AssertionException * @return string */ protected function processMetadataDriver(Nette\DI\ServiceDefinition $metadataDriver, $namespace, $driver, $prefix) { if (!is_string($namespace) || !Strings::match($namespace, '#^' . self::PHP_NAMESPACE . '\\z#')) { throw new Nette\Utils\AssertionException("The metadata namespace expects to be valid namespace, {$namespace} given."); } $namespace = ltrim($namespace, '\\'); if (is_string($driver) || is_array($driver)) { $paths = is_array($driver) ? $driver : array($driver); foreach ($paths as $path) { if (($pos = strrpos($path, '*')) !== FALSE) { $path = substr($path, 0, $pos); } if (!file_exists($path)) { throw new Nette\Utils\AssertionException("The metadata path expects to be an existing directory, {$path} given."); } } $driver = new Statement(self::ANNOTATION_DRIVER, is_array($paths) ? $paths : array($paths)); } $impl = $driver instanceof \stdClass ? $driver->value : ($driver instanceof Statement ? $driver->entity : (string) $driver); list($driver) = CacheHelpers::filterArgs($driver); /** @var Statement $driver */ if (isset($this->metadataDriverClasses[$impl])) { $driver->entity = $this->metadataDriverClasses[$impl]; } if (is_string($driver->entity) && substr($driver->entity, 0, 1) === '@') { $metadataDriver->addSetup('addDriver', array($driver->entity, $namespace)); return $driver->entity; } if ($impl === self::ANNOTATION_DRIVER) { $driver->arguments = array(Nette\Utils\Arrays::flatten($driver->arguments), 2 => $this->prefix('@cache.' . $prefix . '.metadata')); } $serviceName = $this->prefix($prefix . '.driver.' . str_replace('\\', '_', $namespace) . '.' . $impl . 'Impl'); $this->getContainerBuilder()->addDefinition($serviceName)->setClass('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver')->setFactory($driver->entity, $driver->arguments)->setAutowired(FALSE)->setInject(FALSE); $metadataDriver->addSetup('addDriver', array('@' . $serviceName, $namespace)); return '@' . $serviceName; }
private function resolveImplement(ServiceDefinition $def, $name) { $interface = $def->getImplement(); if (!interface_exists($interface)) { throw new ServiceCreationException("Interface {$interface} used in service '{$name}' not found."); } self::checkCase($interface); $rc = new ReflectionClass($interface); $method = $rc->hasMethod('create') ? $rc->getMethod('create') : ($rc->hasMethod('get') ? $rc->getMethod('get') : NULL); if (count($rc->getMethods()) !== 1 || !$method || $method->isStatic()) { throw new ServiceCreationException("Interface {$interface} used in service '{$name}' must have just one non-static method create() or get()."); } $def->setImplementType($methodName = $rc->hasMethod('create') ? 'create' : 'get'); if (!$def->getClass() && !$def->getEntity()) { $returnType = PhpReflection::getReturnType($method); if (!$returnType) { throw new ServiceCreationException("Method {$interface}::{$methodName}() used in service '{$name}' has no @return annotation."); } elseif (!class_exists($returnType)) { throw new ServiceCreationException("Check a @return annotation of the {$interface}::{$methodName}() method used in service '{$name}', class '{$returnType}' cannot be found."); } $def->setClass($returnType); } if ($methodName === 'get') { if ($method->getParameters()) { throw new ServiceCreationException("Method {$interface}::get() used in service '{$name}' must have no arguments."); } if (!$def->getEntity()) { $def->setFactory('@\\' . ltrim($def->getClass(), '\\')); } elseif (!$this->getServiceName($def->getFactory()->getEntity())) { throw new ServiceCreationException("Invalid factory in service '{$name}' definition."); } } if (!$def->parameters) { $ctorParams = []; if (!$def->getEntity()) { $def->setFactory($def->getClass(), $def->getFactory() ? $def->getFactory()->arguments : []); } if (($class = $this->resolveEntityClass($def->getFactory(), [$name => 1])) && ($ctor = (new ReflectionClass($class))->getConstructor())) { foreach ($ctor->getParameters() as $param) { $ctorParams[$param->getName()] = $param; } } foreach ($method->getParameters() as $param) { $hint = PhpReflection::getParameterType($param); if (isset($ctorParams[$param->getName()])) { $arg = $ctorParams[$param->getName()]; if ($hint !== PhpReflection::getParameterType($arg)) { throw new ServiceCreationException("Type hint for \${$param->getName()} in {$interface}::{$methodName}() doesn't match type hint in {$class} constructor."); } $def->getFactory()->arguments[$arg->getPosition()] = self::literal('$' . $arg->getName()); } $paramDef = $hint . ' ' . $param->getName(); if ($param->isOptional()) { $def->parameters[$paramDef] = $param->getDefaultValue(); } else { $def->parameters[] = $paramDef; } } } }
/** * Parses single service definition from configuration. * @return void */ public static function loadDefinition(ServiceDefinition $definition, $config) { if ($config === NULL) { return; } elseif (is_string($config) && interface_exists($config)) { $config = ['class' => NULL, 'implement' => $config]; } elseif ($config instanceof Statement && is_string($config->getEntity()) && interface_exists($config->getEntity())) { $config = ['class' => NULL, 'implement' => $config->getEntity(), 'factory' => array_shift($config->arguments)]; } elseif (!is_array($config) || isset($config[0], $config[1])) { $config = ['class' => NULL, 'factory' => $config]; } if (array_key_exists('create', $config)) { trigger_error("Key 'create' is deprecated, use 'factory' or 'class' in configuration.", E_USER_DEPRECATED); $config['factory'] = $config['create']; unset($config['create']); } $known = ['class', 'factory', 'arguments', 'setup', 'autowired', 'dynamic', 'inject', 'parameters', 'implement', 'run', 'tags']; if ($error = array_diff(array_keys($config), $known)) { $hints = array_filter(array_map(function ($error) use($known) { return Nette\Utils\ObjectMixin::getSuggestion($known, $error); }, $error)); $hint = $hints ? ", did you mean '" . implode("', '", $hints) . "'?" : '.'; throw new Nette\InvalidStateException(sprintf("Unknown key '%s' in definition of service{$hint}", implode("', '", $error))); } $config = Helpers::filterArguments($config); if (array_key_exists('class', $config) || array_key_exists('factory', $config)) { $definition->setClass(NULL); $definition->setFactory(NULL); } if (array_key_exists('class', $config)) { Validators::assertField($config, 'class', 'string|Nette\\DI\\Statement|null'); if (!$config['class'] instanceof Statement) { $definition->setClass($config['class']); } $definition->setFactory($config['class']); } if (array_key_exists('factory', $config)) { Validators::assertField($config, 'factory', 'callable|Nette\\DI\\Statement|null'); $definition->setFactory($config['factory']); } if (array_key_exists('arguments', $config)) { Validators::assertField($config, 'arguments', 'array'); $arguments = $config['arguments']; if (!Config\Helpers::takeParent($arguments) && !Nette\Utils\Arrays::isList($arguments) && $definition->getFactory()) { $arguments += $definition->getFactory()->arguments; } $definition->setArguments($arguments); } if (isset($config['setup'])) { if (Config\Helpers::takeParent($config['setup'])) { $definition->setSetup([]); } Validators::assertField($config, 'setup', 'list'); foreach ($config['setup'] as $id => $setup) { Validators::assert($setup, 'callable|Nette\\DI\\Statement|array:1', "setup item #{$id}"); if (is_array($setup)) { $setup = new Statement(key($setup), array_values($setup)); } $definition->addSetup($setup); } } if (isset($config['parameters'])) { Validators::assertField($config, 'parameters', 'array'); $definition->setParameters($config['parameters']); } if (isset($config['implement'])) { Validators::assertField($config, 'implement', 'string'); $definition->setImplement($config['implement']); $definition->setAutowired(TRUE); } if (isset($config['autowired'])) { Validators::assertField($config, 'autowired', 'bool|string|array'); $definition->setAutowired($config['autowired']); } if (isset($config['dynamic'])) { Validators::assertField($config, 'dynamic', 'bool'); $definition->setDynamic($config['dynamic']); } if (isset($config['inject'])) { Validators::assertField($config, 'inject', 'bool'); $definition->addTag(Extensions\InjectExtension::TAG_INJECT, $config['inject']); } if (isset($config['run'])) { trigger_error("Option 'run' is deprecated, use 'run' as tag.", E_USER_DEPRECATED); $config['tags']['run'] = (bool) $config['run']; } if (isset($config['tags'])) { Validators::assertField($config, 'tags', 'array'); if (Config\Helpers::takeParent($config['tags'])) { $definition->setTags([]); } foreach ($config['tags'] as $tag => $attrs) { if (is_int($tag) && is_string($attrs)) { $definition->addTag($attrs); } else { $definition->addTag($tag, $attrs); } } } }
/** * Parses single service from configuration file. * @return void */ public static function parseService(Nette\DI\ServiceDefinition $definition, $config, $shared = TRUE) { if ($config === NULL) { return; } elseif (!is_array($config)) { $config = array('class' => NULL, 'factory' => $config); } $known = $shared ? array('class', 'factory', 'arguments', 'setup', 'autowired', 'run', 'tags') : array('class', 'factory', 'arguments', 'setup', 'autowired', 'tags', 'internal', 'parameters'); if ($error = array_diff(array_keys($config), $known)) { throw new Nette\InvalidStateException("Unknown key '" . implode("', '", $error) . "' in definition of service."); } $arguments = array(); if (array_key_exists('arguments', $config)) { Validators::assertField($config, 'arguments', 'array'); $arguments = self::filterArguments($config['arguments']); $definition->setArguments($arguments); } if (array_key_exists('class', $config) || array_key_exists('factory', $config)) { $definition->class = NULL; $definition->factory = NULL; } if (array_key_exists('class', $config)) { Validators::assertField($config, 'class', 'string|stdClass|null'); if ($config['class'] instanceof \stdClass) { $definition->setClass($config['class']->value, self::filterArguments($config['class']->attributes)); } else { $definition->setClass($config['class'], $arguments); } } if (array_key_exists('factory', $config)) { Validators::assertField($config, 'factory', 'callable|stdClass|null'); if ($config['factory'] instanceof \stdClass) { $definition->setFactory($config['factory']->value, self::filterArguments($config['factory']->attributes)); } else { $definition->setFactory($config['factory'], $arguments); } } if (isset($config['setup'])) { if (Helpers::takeParent($config['setup'])) { $definition->setup = array(); } Validators::assertField($config, 'setup', 'list'); foreach ($config['setup'] as $id => $setup) { Validators::assert($setup, 'callable|stdClass', "setup item #{$id}"); if ($setup instanceof \stdClass) { Validators::assert($setup->value, 'callable', "setup item #{$id}"); $definition->addSetup($setup->value, self::filterArguments($setup->attributes)); } else { $definition->addSetup($setup); } } } $definition->setShared($shared); if (isset($config['parameters'])) { Validators::assertField($config, 'parameters', 'array'); $definition->setParameters($config['parameters']); } if (isset($config['autowired'])) { Validators::assertField($config, 'autowired', 'bool'); $definition->setAutowired($config['autowired']); } if (isset($config['internal'])) { Validators::assertField($config, 'internal', 'bool'); $definition->setInternal($config['internal']); } if (isset($config['run'])) { $config['tags']['run'] = (bool) $config['run']; } if (isset($config['tags'])) { Validators::assertField($config, 'tags', 'array'); if (Helpers::takeParent($config['tags'])) { $definition->tags = array(); } foreach ($config['tags'] as $tag => $attrs) { if (is_int($tag) && is_string($attrs)) { $definition->addTag($attrs); } else { $definition->addTag($tag, $attrs); } } } }
/** * Parses single service from configuration file. * @return void */ public static function parseService(ServiceDefinition $definition, $config) { if ($config === NULL) { return; } elseif (is_string($config) && interface_exists($config)) { $config = array('class' => NULL, 'implement' => $config); } elseif ($config instanceof \stdClass && interface_exists($config->value)) { $config = array('class' => NULL, 'implement' => $config->value, 'factory' => array_shift($config->attributes)); } elseif (!is_array($config)) { $config = array('class' => NULL, 'create' => $config); } if (array_key_exists('factory', $config)) { $config['create'] = $config['factory']; unset($config['factory']); }; $known = array('class', 'create', 'arguments', 'setup', 'autowired', 'inject', 'parameters', 'implement', 'run', 'tags'); if ($error = array_diff(array_keys($config), $known)) { throw new Nette\InvalidStateException(sprintf("Unknown or deprecated key '%s' in definition of service.", implode("', '", $error))); } $arguments = array(); if (array_key_exists('arguments', $config)) { Validators::assertField($config, 'arguments', 'array'); $arguments = self::filterArguments($config['arguments']); $definition->setArguments($arguments); } if (array_key_exists('class', $config) || array_key_exists('create', $config)) { $definition->class = NULL; $definition->factory = NULL; } if (array_key_exists('class', $config)) { Validators::assertField($config, 'class', 'string|stdClass|null'); if ($config['class'] instanceof \stdClass) { $definition->setClass($config['class']->value, self::filterArguments($config['class']->attributes)); } else { $definition->setClass($config['class'], $arguments); } } if (array_key_exists('create', $config)) { Validators::assertField($config, 'create', 'callable|stdClass|null'); if ($config['create'] instanceof \stdClass) { $definition->setFactory($config['create']->value, self::filterArguments($config['create']->attributes)); } else { $definition->setFactory($config['create'], $arguments); } } if (isset($config['setup'])) { if (Config\Helpers::takeParent($config['setup'])) { $definition->setup = array(); } Validators::assertField($config, 'setup', 'list'); foreach ($config['setup'] as $id => $setup) { Validators::assert($setup, 'callable|stdClass', "setup item #$id"); if ($setup instanceof \stdClass) { Validators::assert($setup->value, 'callable', "setup item #$id"); $definition->addSetup($setup->value, self::filterArguments($setup->attributes)); } else { $definition->addSetup($setup); } } } if (isset($config['parameters'])) { Validators::assertField($config, 'parameters', 'array'); $definition->setParameters($config['parameters']); } if (isset($config['implement'])) { Validators::assertField($config, 'implement', 'string'); $definition->setImplement($config['implement']); $definition->setAutowired(TRUE); } if (isset($config['autowired'])) { Validators::assertField($config, 'autowired', 'bool'); $definition->setAutowired($config['autowired']); } if (isset($config['inject'])) { Validators::assertField($config, 'inject', 'bool'); $definition->setInject($config['inject']); } if (isset($config['run'])) { $config['tags']['run'] = (bool) $config['run']; } if (isset($config['tags'])) { Validators::assertField($config, 'tags', 'array'); if (Config\Helpers::takeParent($config['tags'])) { $definition->tags = array(); } foreach ($config['tags'] as $tag => $attrs) { if (is_int($tag) && is_string($attrs)) { $definition->addTag($attrs); } else { $definition->addTag($tag, $attrs); } } } }