765:                }
766:    
767:                if (!is_string($val)) {
768:                    return;
769:    
770:                } elseif (substr($val, 0, 2) === '@@') {
771:                    $val = substr($val, 1);
772:    
773:                } elseif (substr($val, 0, 1) === '@') {
774:                    $pair = explode('::', $val, 2);
775:                    $name = $that->getServiceName($pair[0]);
776:                    if (isset($pair[1]) && preg_match('#^[A-Z][A-Z0-9_]*\z#', $pair[1], $m)) {
777:                        $val = $that->getDefinition($name)->getClass() . '::' . $pair[1];
778:                    } else {
779:                        if ($name === ContainerBuilder::THIS_CONTAINER) {

780:                            $val = '$this';
781:                        } elseif ($name === $that->currentService) {
782:                            $val = '$service';
783:                        } else {
784:                            $val = $that->formatStatement(new Statement(array('@' . ContainerBuilder::THIS_CONTAINER, 'getService'), array($name)));
785:                        }
786:                        $val .= (isset($pair[1]) ? PhpHelpers::formatArgs('->?', array($pair[1])) : '');
787:                    }
788:                    $val = ContainerBuilder::literal($val);
789:                }
790:            });
791:            return PhpHelpers::formatArgs($statement, $args);
792:        }
793:    
794:    

695:                return $this->formatPhp('!?', array($arguments[0]));
696:    
697:            } elseif (is_string($entity)) { // class name
698:                $rc = new ReflectionClass($entity);
699:                if ($constructor = $rc->getConstructor()) {
700:                    $this->addDependency($constructor->getFileName());
701:                    $arguments = Helpers::autowireArguments($constructor, $arguments, $this);
702:                } elseif ($arguments) {
703:                    throw new ServiceCreationException("Unable to pass arguments, class $entity has no constructor.");
704:                }
705:                return $this->formatPhp("new $entity" . ($arguments ? '(?*)' : ''), array($arguments));
706:    
707:            } elseif (!Nette\Utils\Arrays::isList($entity) || count($entity) !== 2) {
708:                throw new ServiceCreationException(sprintf('Expected class, method or property, %s given.', PhpHelpers::dump($entity)));
709:    

592:                    array("Unable to create dynamic service '$name', it must be added using addService()")
593:                );
594:            }
595:    
596:            $entity = $def->getFactory()->getEntity();
597:            $serviceRef = $this->getServiceName($entity);
598:            $factory = $serviceRef && !$def->getFactory()->arguments && !$def->getSetup() && $def->getImplementType() !== 'create'
599:                ? new Statement(array('@' . self::THIS_CONTAINER, 'getService'), array($serviceRef))
600:                : $def->getFactory();
601:    
602:            $code = '$service = ' . $this->formatStatement($factory) . ";\n";
603:            $this->currentService = $name;
604:    
605:            if (($class = $def->getClass()) && !$serviceRef && $class !== $entity
606:                && !(is_string($entity) && preg_match('#^[\w\\\\]+\z#', $entity) && is_subclass_of($entity, $class))

556:    
557:            foreach ($definitions as $name => $def) {
558:                try {
559:                    $name = (string) $name;
560:                    $methodName = Container::getMethodName($name);
561:                    if (!PhpHelpers::isIdentifier($methodName)) {
562:                        throw new ServiceCreationException('Name contains invalid characters.');
563:                    }
564:                    $containerClass->addMethod($methodName)
565:                        ->addDocument('@return ' . ($def->getImplement() ?: $def->getClass()))
566:                        ->setBody($name === self::THIS_CONTAINER ? 'return $this;' : $this->generateService($name))
567:                        ->setParameters($def->getImplement() ? array() : $this->convertParameters($def->parameters));
568:                } catch (\Exception $e) {
569:                    throw new ServiceCreationException("Service '$name': " . $e->getMessage(), NULL, $e);
570:                }

200:        public function generateCode($className, $parentName = NULL)
201:        {
202:            $this->builder->prepareClassList();
203:    
204:            foreach ($this->extensions as $extension) {
205:                $extension->beforeCompile();
206:                $rc = new \ReflectionClass($extension);
207:                $this->dependencies[] = $rc->getFileName();
208:            }
209:    
210:            $classes = $this->builder->generateClasses($className, $parentName);
211:            $classes[0]->addMethod('initialize');
212:            $this->addDependencies($this->builder->getDependencies());
213:    
214:            foreach ($this->extensions as $extension) {

129:    
130:        /**
131:         * @return Nette\PhpGenerator\ClassType[]|string
132:         */
133:        public function compile(array $config = NULL, $className = NULL, $parentName = NULL)
134:        {
135:            $this->config = $config ?: $this->config;
136:            $this->processParameters();
137:            $this->processExtensions();
138:            $this->processServices();
139:            $classes = $this->generateCode($className, $parentName);
140:            return func_num_args()
141:                ? implode("\n\n\n", $classes) // back compatiblity
142:                : $classes;
143:        }

257:                list($class, $args) = is_string($extension) ? array($extension, array()) : $extension;
258:                if (class_exists($class)) {
259:                    $rc = new \ReflectionClass($class);
260:                    $args = DI\Helpers::expand($args, $this->parameters, TRUE);
261:                    $compiler->addExtension($name, $args ? $rc->newInstanceArgs($args) : $rc->newInstance());
262:                }
263:            }
264:    
265:            $this->onCompile($this, $compiler);
266:    
267:            $classes = $compiler->compile();
268:    
269:            if (!empty($builder->parameters['container']['parent'])) {
270:                $classes[0]->setExtends($builder->parameters['container']['parent']);
271:            }

101:        }
102:    
103:    
104:        /**
105:         * @return array of (code, file[])
106:         */
107:        protected function generate($class, $generator)
108:        {
109:            $compiler = new Compiler;
110:            $compiler->getContainerBuilder()->setClassName($class);
111:            $code = call_user_func_array($generator, array(& $compiler));
112:            $code = $code ?: implode("\n\n\n", $compiler->compile());
113:            $files = $compiler->getDependencies();
114:            $files = $files ? array_combine($files, $files) : array(); // workaround for PHP 5.3 array_combine
115:            return array(

66:            if (!is_dir($this->tempDirectory)) {
67:                @mkdir($this->tempDirectory); // @ - directory may already exist
68:            }
69:    
70:            $handle = fopen("$file.lock", 'c+');
71:            if (!$handle || !flock($handle, LOCK_EX)) {
72:                throw new Nette\IOException("Unable to acquire exclusive lock on '$file.lock'.");
73:            }
74:    
75:            if (!is_file($file) || $this->isExpired($file)) {
76:                list($toWrite[$file], $toWrite["$file.meta"]) = $this->generate($class, $generator);
77:    
78:                foreach ($toWrite as $name => $content) {
79:                    if (file_put_contents("$name.tmp", $content) !== strlen($content) || !rename("$name.tmp", $name)) {
80:                        @unlink("$name.tmp"); // @ - file may not exist

31:    
32:        /**
33:         * @param  mixed
34:         * @param  callable  function (Nette\DI\Compiler $compiler): string|NULL
35:         * @return string
36:         */
37:        public function load($key, $generator)
38:        {
39:            $class = $this->getClassName($key);
40:            if (!class_exists($class, FALSE)) {
41:                $this->loadFile($class, $generator);
42:            }
43:            return $class;
44:        }
45:    

210:         * @return DI\Container
211:         */
212:        public function createContainer()
213:        {
214:            $loader = new DI\ContainerLoader(
215:                $this->getCacheDirectory() . '/Nette.Configurator',
216:                $this->parameters['debugMode']
217:            );
218:            $class = $loader->load(
219:                array($this->parameters, $this->files),
220:                array($this, 'generateContainer')
221:            );
222:    
223:            $container = new $class;
224:            foreach ($this->services as $name => $service) {

46:    
47:        protected function getDefaultParameters() {
48:            return ['appDir' => ROOT_DIR . '/app'] + parent::getDefaultParameters();
49:        }
50:    
51:        /**
52:         * @return Container
53:         */
54:        public function getContainer() {
55:            if (!$this->container) {
56:                $this->container = $this->createContainer();
57:            }
58:            return $this->container;
59:        }
60:    

1:    <?php
2:    
3:    // Uncomment this line if you must temporarily take down your site for maintenance.
4:    // require '.maintenance.php';
5:    
6:    $container = require __DIR__ . '/../app/bootstrap.php';
7:    
8:    $container->getService('application')->run();
9: