from() public static method

public static from ( $class ) : self
return self
 /**
  * @param \Nette\DI\Container $dic
  * @throws MemberAccessException
  * @internal
  */
 public function injectComponentFactories(Nette\DI\Container $dic)
 {
     if (!$this instanceof Nette\Application\UI\PresenterComponent && !$this instanceof Nette\Application\UI\Component) {
         throw new MemberAccessException('Trait ' . __TRAIT__ . ' can be used only in descendants of PresenterComponent.');
     }
     $this->autowireComponentFactoriesLocator = $dic;
     $storage = $dic->hasService('autowired.cacheStorage') ? $dic->getService('autowired.cacheStorage') : $dic->getByType('Nette\\Caching\\IStorage');
     $cache = new Nette\Caching\Cache($storage, 'Kdyby.Autowired.AutowireComponentFactories');
     if ($cache->load($presenterClass = get_class($this)) !== NULL) {
         return;
     }
     $ignore = class_parents('Nette\\Application\\UI\\Presenter') + ['ui' => 'Nette\\Application\\UI\\Presenter'];
     $rc = new ClassType($this);
     foreach ($rc->getMethods() as $method) {
         if (in_array($method->getDeclaringClass()->getName(), $ignore, TRUE) || !Strings::startsWith($method->getName(), 'createComponent')) {
             continue;
         }
         foreach ($method->getParameters() as $parameter) {
             if (!($class = $parameter->getClassName())) {
                 // has object type hint
                 continue;
             }
             if (!$this->findByTypeForFactory($class) && !$parameter->allowsNull()) {
                 throw new MissingServiceException("No service of type {$class} found. Make sure the type hint in {$method} is written correctly and service of this type is registered.");
             }
         }
     }
     $files = array_map(function ($class) {
         return ClassType::from($class)->getFileName();
     }, array_diff(array_values(class_parents($presenterClass) + ['me' => $presenterClass]), $ignore));
     $files[] = ClassType::from($this->autowireComponentFactoriesLocator)->getFileName();
     $cache->save($presenterClass, TRUE, [$cache::FILES => $files]);
 }
Esempio n. 2
0
 private function setupServices()
 {
     $builder = $this->getContainerBuilder();
     $config = $this->validateConfig($this->defaults);
     $gopay = $builder->getDefinition($this->prefix('gopay'));
     $services = ['payment' => PaymentService::class, 'recurrentPayment' => RecurrentPaymentService::class, 'preAuthorizedPayment' => PreAuthorizedPaymentService::class];
     foreach ($services as $serviceName => $serviceClass) {
         $def = $builder->addDefinition($this->prefix("service.{$serviceName}"))->setClass($serviceClass, [$gopay]);
         if (is_bool($config['payments']['changeChannel'])) {
             $def->addSetup('allowChangeChannel', [$config['payments']['changeChannel']]);
         }
         if (isset($config['payments']['channels'])) {
             $constants = ClassType::from(Gopay::class);
             foreach ($config['payments']['channels'] as $code => $channel) {
                 $constChannel = 'METHOD_' . strtoupper($code);
                 if ($constants->hasConstant($constChannel)) {
                     $code = $constants->getConstant($constChannel);
                 }
                 if (is_array($channel)) {
                     $channel['code'] = $code;
                     $def->addSetup('addChannel', $channel);
                 } else {
                     if (is_scalar($channel)) {
                         $def->addSetup('addChannel', [$code, $channel]);
                     }
                 }
             }
         }
     }
 }
Esempio n. 3
0
 /**
  * @param $class
  */
 public function getSchema($class)
 {
     if (!isset($this->_annotationSchema[$class])) {
         $schema = array();
         $ref = ClassType::from($class);
         if ($ref->hasAnnotation('secured')) {
             foreach ($ref->getMethods() as $method) {
                 $name = $method->getName();
                 if (substr($name, 0, 6) !== 'action' && substr($name, 0, 6) !== 'handle') {
                     continue;
                 }
                 if ($method->hasAnnotation('secured')) {
                     $secured = $method->getAnnotation('secured');
                     $name = $method->getName();
                     $schema[$name] = array();
                     $schema[$name]['resource'] = $this->getSchemaOfResource($method, $secured);
                     $schema[$name]['privilege'] = $this->getSchemaOfPrivilege($method, $secured);
                     $schema[$name]['roles'] = $this->getSchemaOfRoles($method, $secured);
                     $schema[$name]['users'] = $this->getSchemaOfUsers($method, $secured);
                 }
             }
         }
         $this->_annotationSchema[$class] = $schema;
     }
     return $this->_annotationSchema[$class];
 }
Esempio n. 4
0
 public static function build($className)
 {
     $reflection = \Nette\Reflection\ClassType::from($className);
     $annotations = $reflection->getAnnotations();
     $ret = array('entityClass' => $className);
     foreach ($annotations as $key => $value) {
         if ($key == "Entity") {
             $entity = $value[0];
             if (isset($entity->repositoryClass)) {
                 $ret['repositoryClass'] = (string) $entity->repositoryClass;
             } elseif (isset($entity->validatorClass)) {
                 $ret['validatorClass'] = (string) $entity->validatorClass;
             }
         } elseif ($key == "Table") {
             $table = $value[0];
             $ret['table'] = (string) $table->name;
             $ret['mainIndex'] = isset($table->mainIndex) ? (string) $table->mainIndex : NULL;
             $ret['topicIndex'] = isset($table->topicIndex) ? (string) $table->topicIndex : NULL;
         } elseif ($key == "Column") {
             foreach ($value as $column) {
                 $name = $column->name;
                 unset($column->name);
                 $ret['columns'][$name] = (array) $column;
             }
         } elseif (in_array($key, array("AssociationHasOne", "AssociationHasMany"))) {
             foreach ($value as $association) {
                 $name = $association->name;
                 unset($association->name);
                 $ret['associations'][$name] = (array) $association;
             }
         }
     }
     return $ret;
 }
Esempio n. 5
0
	public function testSignalAllow()
	{
		$this->presenter->setSignalMock("test2");
		$this->presenter->checkRequirements(ClassType::from(__NAMESPACE__ . '\BackendPresenter\PresenterMock'));

		$this->assertFalse($this->presenter->isAllowedMock('handleTest1'));
		$this->assertTrue($this->presenter->isAllowedMock('handleTest2'));
	}
Esempio n. 6
0
 public function __construct($type)
 {
     if (strpos($type, '*') !== FALSE) {
         $this->pattern = str_replace('\\*', '.*', preg_quote($type));
     } else {
         $this->type = Nette\Reflection\ClassType::from($type)->getName();
     }
 }
 /**
  * Sets a variable in this session section.
  * @param  string  name
  * @param  mixed   value
  * @return void
  */
 public function __set($name, $value)
 {
     $this->start();
     $this->data[$name] = $value;
     if (is_object($value)) {
         $this->meta[$name]['V'] = Nette\Reflection\ClassType::from($value)->getAnnotation('serializationVersion');
     }
 }
Esempio n. 8
0
 public function loadConfiguration()
 {
     $builder = $this->getContainerBuilder();
     $latte = $builder->hasDefinition('nette.latteFactory') ? $builder->getDefinition('nette.latteFactory') : $builder->getDefinition('nette.latte');
     $latte->addSetup('Lohini\\Latte\\Macros\\CoreMacros::install(?->getCompiler())', ['@self']);
     foreach (\Nette\Reflection\ClassType::from('Lohini\\Latte\\Filters')->getMethods() as $method) {
         $latte->addSetup('addFilter', [$method->name, ['Lohini\\Latte\\Filters', $method->name]]);
     }
 }
Esempio n. 9
0
 public function __construct(Nette\DI\ServiceDefinition $def, $serviceId)
 {
     $this->serviceDefinition = $def;
     if (empty($def->class)) {
         throw new Kdyby\Aop\InvalidArgumentException("Given service definition has unresolved class, please specify service type explicitly.");
     }
     $this->originalType = Nette\Reflection\ClassType::from($def->class);
     $this->serviceId = $serviceId;
 }
Esempio n. 10
0
 /**
  * Registers adapter for given file extension.
  * @param  string  file extension
  * @param  string  class name (IConfigAdapter)
  * @return void
  */
 public static function registerExtension($extension, $class)
 {
     if (!class_exists($class)) {
         throw new Nette\InvalidArgumentException("Class '{$class}' was not found.");
     }
     if (!Nette\Reflection\ClassType::from($class)->implementsInterface('Nette\\Config\\IAdapter')) {
         throw new Nette\InvalidArgumentException("Configuration adapter '{$class}' is not Nette\\Config\\IAdapter implementor.");
     }
     self::$extensions[strtolower($extension)] = $class;
 }
Esempio n. 11
0
 public function beforeCompile()
 {
     $builder = $this->getContainerBuilder();
     $mapping = $builder->getDefinition('movi.entityMapping');
     foreach (array_keys($builder->findByTag(self::REPOSITORY_TAG)) as $repository) {
         $reflection = ClassType::from($builder->getDefinition($repository)->class);
         $class = $reflection->newInstanceWithoutConstructor();
         $mapping->addSetup('registerEntities', array($class->getEntities()));
     }
 }
Esempio n. 12
0
 public function getTests()
 {
     $tests = [];
     foreach (ClassType::from($this)->getMethods(Method::IS_PUBLIC) as $method) {
         $name = $method->getShortName();
         if (preg_match(static::METHOD_PATTERN, $name)) {
             $tests[] = $name;
         }
     }
     return $tests;
 }
Esempio n. 13
0
 /**
  * Získá všechny hodnoty z entity, které mají anotaci @column a nemají anotaci @id.
  * @return array
  */
 public function getValues()
 {
     $reflector = \Nette\Reflection\ClassType::from($this);
     $values = array();
     foreach ($reflector->getProperties() as $property) {
         if ($property->hasAnnotation("column") && !$property->hasAnnotation("id")) {
             $name = $property->getName();
             $values[$this->normalizeColumnName($name)] = $this->{$name};
         }
     }
     return $values;
 }
 public function preFlush(PreFlushEventArgs $args)
 {
     $em = $args->getEntityManager();
     $uow = $em->getUnitOfWork();
     foreach ($uow->getScheduledEntityInsertions() as $entity) {
         $reflection = Nette\Reflection\ClassType::from($entity);
         if ($reflection->hasProperty("priority")) {
             $repository = $em->getRepository($reflection->getName());
             $result = $repository->createQueryBuilder("p")->select("MAX(p.priority)")->getQuery()->execute();
             $entity->priority = ($result ? (int) $result[0][1] : 0) + 1;
         }
     }
 }
Esempio n. 15
0
 /**
  * @param $entity
  * @param callable $modifier
  * @return \Kdyby\Doctrine\QueryBuilder
  */
 private function createBaseQuery($entity, $modifier)
 {
     $reflection = ClassType::from($entity);
     if (!$reflection->hasProperty('priority')) {
         throw new InvalidArgumentException('Entity has not property $priority');
     }
     $qb = $this->entityManager->getRepository($reflection->getName())->createQueryBuilder("e")->select();
     if ($modifier !== NULL) {
         $modifier($qb);
     }
     $qb->setMaxResults(1);
     return $qb;
 }
Esempio n. 16
0
 /**
  * @param string
  * @return array
  */
 protected static function getAllClassTypes($class)
 {
     $rc = Reflection\ClassType::from($class);
     $classTypes = array_merge(array($class), class_parents($class), class_implements($class));
     if (PHP_VERSION_ID >= 50400) {
         do {
             $classTypes = array_merge($classTypes, $rc->getTraitNames());
         } while ($rc = $rc->getParentClass());
     }
     return array_map(function ($val) {
         return ltrim(strtolower($val), '\\');
     }, $classTypes);
 }
Esempio n. 17
0
	/**
	 * @param Container
	 * @param string
	 * @return Service
	 */
	public function __construct(Container $container, $entityClass)
	{
		if (!class_exists($entityClass)) {
			throw new \Nette\InvalidArgumentException("Entity '$entityClass' does not exist");
		} elseif (!\Nette\Reflection\ClassType::from($entityClass)->implementsInterface('Nella\Models\IEntity')) {
			throw new \Nette\InvalidArgumentException(
				"Entity '$entityClass' does not valid entity (must implements Nella\\Models\\IEntity)"
			);
		}

		$this->container = $container;
		$this->entityClass = $entityClass;
	}
Esempio n. 18
0
 protected function loadProperties(&$fileDependencies)
 {
     $classTree = [$current = $this->reflection->name];
     while (($current = get_parent_class($current)) !== false) {
         $classTree[] = $current;
     }
     foreach (array_reverse($classTree) as $class) {
         $reflection = ClassType::from($class);
         $fileDependencies[] = $reflection->getFileName();
         $this->currentReflection = $reflection;
         $this->parseAnnotations($reflection);
     }
 }
 private function initDatabase($fileName = null)
 {
     $reflection = \Nette\Reflection\ClassType::from(get_class($this));
     $dir = dirname($reflection->getFileName());
     $fileName = $fileName ? $fileName : $dir . '/init.sql';
     $initSql = file_get_contents($fileName);
     $queries = explode(';', $initSql);
     foreach ($queries as $query) {
         if (empty($query)) {
             continue;
         }
         $this->database->query(trim($query));
     }
 }
Esempio n. 20
0
 protected function loadProperties(&$fileDependencies)
 {
     $classTree = [$current = $this->reflection->name];
     while (($current = get_parent_class($current)) !== FALSE) {
         if (strpos($current, 'Fragment') !== FALSE) {
             break;
         }
         $classTree[] = $current;
     }
     foreach (array_reverse($classTree) as $class) {
         $reflection = ClassType::from($class);
         $fileDependencies[] = $reflection->getFileName();
         $this->parseAnnotations($reflection);
     }
 }
 /**
  * @return Latte\Token
  */
 private function findCurrentToken()
 {
     static $positionRef, $tokensRef;
     if (!property_exists('Nette\\Latte\\Token', 'empty')) {
         return NULL;
     }
     if (empty($positionRef)) {
         $compilerRef = ClassType::from($this->getCompiler());
         $positionRef = $compilerRef->getProperty('position');
         $positionRef->setAccessible(TRUE);
         $tokensRef = $compilerRef->getProperty('tokens');
         $tokensRef->setAccessible(TRUE);
     }
     $tokens = $tokensRef->getValue($this->getCompiler());
     return $tokens[$positionRef->getValue($this->getCompiler())];
 }
Esempio n. 22
0
	/**
	 * @param string
	 * @param \Doctrine\ORM\Mapping\ClassMetadataInfo
	 */
	public function loadMetadataForClass($className, \Doctrine\ORM\Mapping\ClassMetadataInfo $metadata)
	{
		parent::loadMetadataForClass($className, $metadata);

		if ($metadata instanceof \Nella\Doctrine\Mapping\ClassMetadata) {
			$class = \Nette\Reflection\ClassType::from($className);
			if ($class->hasAnnotation('service')) {
				$service = $class->getAnnotation('service');
				if (!isset($service['class'])) {
					throw new \Doctrine\ORM\Mapping\MappingException("Missing service class.");
				}

				$metadata->setServiceClass($service['class']);
			}
		}
	}
 /**
  * Registers repositories from annotations
  */
 private function registerAnnotations()
 {
     $ref = Nette\Reflection\ClassType::from($this);
     $annotations = $ref->getAnnotations();
     if (isset($annotations['property-read'])) {
         $c = get_called_class();
         $namespace = substr($c, 0, strrpos($c, '\\'));
         foreach ($annotations['property-read'] as $value) {
             if (preg_match('#^([\\\\\\w]+Repository)\\s+\\$(\\w+)$#', $value, $m)) {
                 $class = '\\' . Reflection\AnnotationsParser::expandClassName($m[1], $ref);
                 $this->register($m[2], $class);
                 $this->aliases[$m[2]] = $class;
             }
         }
     }
 }
Esempio n. 24
0
 /**
  * Adds new services from list of definitions. Expands %param% and @service values.
  * Format:
  *   serviceName => array(
  *      class => 'ClassName' or factory => 'Factory::create'
  *      arguments => array(...)
  *      methods => array(
  *         array(methodName, array(...))
  *         ...
  *      )
  *      tags => array(...)
  *   )
  */
 public function addDefinitions(IContainer $container, array $definitions)
 {
     foreach ($definitions as $name => $definition) {
         if (!is_array($definition)) {
             $definition = array('class' => $definition);
         }
         $arguments = isset($definition['arguments']) ? $definition['arguments'] : array();
         $expander = function (&$val) use($container) {
             $val = $val[0] === '@' ? $container->getService(substr($val, 1)) : $container->expand($val);
         };
         if (isset($definition['class'])) {
             $class = $definition['class'];
             $methods = isset($definition['methods']) ? $definition['methods'] : array();
             $factory = function ($container) use($class, $arguments, $methods, $expander) {
                 $class = $container->expand($class);
                 if ($arguments) {
                     array_walk_recursive($arguments, $expander);
                     $service = Nette\Reflection\ClassType::from($class)->newInstanceArgs($arguments);
                 } else {
                     $service = new $class();
                 }
                 array_walk_recursive($methods, $expander);
                 foreach ($methods as $method) {
                     call_user_func_array(array($service, $method[0]), isset($method[1]) ? $method[1] : array());
                 }
                 return $service;
             };
         } elseif (isset($definition['factory'])) {
             array_unshift($arguments, $definition['factory']);
             $factory = function ($container) use($arguments, $expander) {
                 array_walk_recursive($arguments, $expander);
                 $factory = $arguments[0];
                 $arguments[0] = $container;
                 return call_user_func_array($factory, $arguments);
             };
         } else {
             throw new Nette\InvalidStateException("The definition of service '{$name}' is missing factory method.");
         }
         if (isset($definition['tags'])) {
             $tags = (array) $definition['tags'];
             array_walk_recursive($tags, $expander);
         } else {
             $tags = NULL;
         }
         $container->addService($name, $factory, $tags);
     }
 }
Esempio n. 25
0
 public function __construct(Container $container)
 {
     $this->container = $container;
     $listeners = $this->container->findByType('\\Phoenix\\Events\\IEventListener');
     foreach ($listeners as $class) {
         $reflection = ClassType::from($container->getService($class));
         foreach ($reflection->getMethods() as $method) {
             if ($method->hasAnnotation(self::ANNOTATION_EVENT_LISTENER)) {
                 $event = (string) $method->getAnnotation(self::ANNOTATION_EVENT_LISTENER);
                 if (!isset($this->eventListeners[$event])) {
                     $this->eventListeners[$event] = [];
                 }
                 $this->eventListeners[$event][] = new EventListenerWrapper($container->getService($class), $method);
             }
         }
     }
 }
Esempio n. 26
0
 /**
  * Puts data into the cache
  *
  * @param string	The cache id.
  * @param string	The cache entry/data.
  * @param int	The lifetime. If != false, sets a specific lifetime for this cache entry (null => infinite lifeTime).
  * @return boolean	TRUE if the entry was successfully stored in the cache, FALSE otherwise.
  */
 protected function doSave($id, $data, $lifeTime = FALSE)
 {
     $files = array();
     if ($data instanceof ClassMetadata) {
         $ref = ClassType::from($data->name);
         $files[] = $ref->getFileName();
         foreach ($data->parentClasses as $class) {
             $ref = ClassType::from($class);
             $files[] = $ref->getFileName();
         }
     }
     if ($lifeTime != 0) {
         $this->storage->save($id, $data, array(NCache::EXPIRE => time() + $lifeTime, NCache::TAGS => array(static::CACHE_TAG), NCache::FILES => $files));
     } else {
         $this->storage->save($id, $data, array(NCache::TAGS => array(static::CACHE_TAG), NCache::FILES => $files));
     }
     return TRUE;
 }
Esempio n. 27
0
 /**
  * Puts data into the cache
  *
  * @param string    The cache id.
  * @param string    The cache entry/data.
  * @param int    The lifetime. If != false, sets a specific lifetime for this cache entry (null => infinite lifeTime).
  * @return boolean    TRUE if the entry was successfully stored in the cache, FALSE otherwise.
  */
 protected function doSave($id, $data, $lifeTime = false)
 {
     $files = array();
     if ($data instanceof \Doctrine\ORM\Mapping\ClassMetadata) {
         $ref = \Nette\Reflection\ClassType::from($data->name);
         $files[] = $ref->getFileName();
         foreach ($data->parentClasses as $class) {
             $ref = \Nette\Reflection\ClassType::from($class);
             $files[] = $ref->getFileName();
         }
     }
     if ($lifeTime != 0) {
         $this->storage->save($id, $data, array(\Nette\Caching\Cache::EXPIRE => time() + $lifeTime, \Nette\Caching\Cache::TAGS => array(static::CACHE_TAG), \Nette\Caching\Cache::FILES => $files));
     } else {
         $this->storage->save($id, $data, array(\Nette\Caching\Cache::TAGS => array(static::CACHE_TAG), \Nette\Caching\Cache::FILES => $files));
     }
     return TRUE;
 }
Esempio n. 28
0
 /**
  * Invoke filter
  *
  * @param string $code
  * @param \Lohini\WebLoader\WebLoader $loader
  * @param string $file
  * @return string
  */
 public function __invoke($code, \Lohini\WebLoader\WebLoader $loader, $file = NULL)
 {
     if ($file === NULL || !in_array(\Nette\Utils\Strings::lower(pathinfo($file, PATHINFO_EXTENSION)), [\PHPSass\File::SASS, \PHPSass\File::SCSS])) {
         return $code;
     }
     $so = ['style' => \PHPSass\Renderers\Renderer::STYLE_COMPRESSED, 'syntax' => pathinfo($file, PATHINFO_EXTENSION), 'load_paths' => [dirname($file)]];
     if (class_exists('PHPSass\\Extensions\\Compass')) {
         $so['functions'] = \PHPSass\Extensions\Compass::getFunctions('Compass');
         $so['extensions'] = ['Compass'];
         $so['load_paths'][] = dirname(\Nette\Reflection\ClassType::from('PHPSass\\Extensions\\Compass')->getFileName());
     }
     if (!\Nette\Environment::isProduction()) {
         $so['debug'] = TRUE;
         $so['debug_info'] = TRUE;
         $so['style'] = \PHPSass\Renderers\Renderer::STYLE_NESTED;
     }
     $filter = new \PHPSass\Parser($so);
     return $filter->toCss($file, TRUE);
 }
Esempio n. 29
0
    /**
     * {@inheritdoc}
     */
    protected function _doSave($id, $data, $lifeTime = 0)
    {
		$files = array();
		if ($data instanceof \Doctrine\ORM\Mapping\ClassMetadata) {
			$ref = \Nette\Reflection\ClassType::from($data->name);
			$files[] = $ref->getFileName();
			foreach ($data->parentClasses as $class) {
				$ref = \Nette\Reflection\ClassType::from($class);
				$files[] = $ref->getFileName();
			}
		}

		if ($lifeTime != 0) {
			$this->data->save($id, $data, array('expire' => time() + $lifeTime, 'tags' => array("doctrine"), 'files' => $files));
		} else {
			$this->data->save($id, $data, array('tags' => array("doctrine"), 'files' => $files));
		}

		return TRUE;
    }
Esempio n. 30
0
 /**
  * @param $id
  * @param $data
  * @param int $lifeTime
  * @return bool
  */
 protected function doSave($id, $data, $lifeTime = 0)
 {
     if ($this->debug !== TRUE) {
         return $this->doSaveDependingOnFiles($id, $data, array(), $lifeTime);
     }
     $files = array();
     if ($data instanceof Doctrine\ORM\Mapping\ClassMetadata) {
         $files[] = ClassType::from($data->name)->getFileName();
         foreach ($data->parentClasses as $class) {
             $files[] = ClassType::from($class)->getFileName();
         }
     }
     if (!empty($data)) {
         if (is_array($data) && reset($data) instanceof Doctrine\ORM\Mapping\Annotation || $data instanceof Doctrine\ORM\Mapping\Annotation) {
             if (($m = Strings::match($id, '~^\\[(?P<class>[^@$]+)(?:\\$(?P<prop>[^@$]+))?\\@\\[Annot\\]~i')) && class_exists($m['class'])) {
                 $files[] = ClassType::from($m['class'])->getFileName();
             }
         }
     }
     return $this->doSaveDependingOnFiles($id, $data, $files, $lifeTime);
 }