190:                            break;
191:                        }
192:    
193:                        $newIndent = (string) substr($tokens[$n][0], 1);
194:                        if ($indent === NULL) { // first iteration
195:                            $indent = $newIndent;
196:                        }
197:                        $minlen = min(strlen($newIndent), strlen($indent));
198:                        if ($minlen && (string) substr($newIndent, 0, $minlen) !== (string) substr($indent, 0, $minlen)) {
199:                            $n++;
200:                            $this->error('Invalid combination of tabs and spaces');
201:                        }
202:    
203:                        if (strlen($newIndent) > strlen($indent)) { // open new block-array or hash
204:                            if ($hasValue || !$hasKey) {

198:                        if ($minlen && (string) substr($newIndent, 0, $minlen) !== (string) substr($indent, 0, $minlen)) {
199:                            $n++;
200:                            $this->error('Invalid combination of tabs and spaces');
201:                        }
202:    
203:                        if (strlen($newIndent) > strlen($indent)) { // open new block-array or hash
204:                            if ($hasValue || !$hasKey) {
205:                                $n++;
206:                                $this->error('Bad indentation');
207:                            }
208:                            $this->addValue($result, $key, $this->parse($newIndent));
209:                            $newIndent = isset($tokens[$n], $tokens[$n + 1]) ? (string) substr($tokens[$n][0], 1) : ''; // not last
210:                            if (strlen($newIndent) > strlen($indent)) {
211:                                $n++;
212:                                $this->error('Bad indentation');

198:                        if ($minlen && (string) substr($newIndent, 0, $minlen) !== (string) substr($indent, 0, $minlen)) {
199:                            $n++;
200:                            $this->error('Invalid combination of tabs and spaces');
201:                        }
202:    
203:                        if (strlen($newIndent) > strlen($indent)) { // open new block-array or hash
204:                            if ($hasValue || !$hasKey) {
205:                                $n++;
206:                                $this->error('Bad indentation');
207:                            }
208:                            $this->addValue($result, $key, $this->parse($newIndent));
209:                            $newIndent = isset($tokens[$n], $tokens[$n + 1]) ? (string) substr($tokens[$n][0], 1) : ''; // not last
210:                            if (strlen($newIndent) > strlen($indent)) {
211:                                $n++;
212:                                $this->error('Bad indentation');

71:            $pattern = '~(' . implode(')|(', self::$patterns) . ')~Amix';
72:            $this->tokens = preg_split($pattern, $this->input, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE | PREG_SPLIT_DELIM_CAPTURE);
73:    
74:            $last = end($this->tokens);
75:            if ($this->tokens && !preg_match($pattern, $last[0])) {
76:                $this->pos = count($this->tokens) - 1;
77:                $this->error();
78:            }
79:    
80:            $this->pos = 0;
81:            $res = $this->parse(NULL);
82:    
83:            while (isset($this->tokens[$this->pos])) {
84:                if ($this->tokens[$this->pos][0][0] === "\n") {
85:                    $this->pos++;

31:    
32:    
33:        /**
34:         * Decodes a NEON string.
35:         * @param  string
36:         * @return mixed
37:         */
38:        public static function decode($input)
39:        {
40:            $decoder = new Decoder;
41:            return $decoder->decode($input);
42:        }
43:    
44:    }
45:    

22:        const INHERITING_SEPARATOR = '<', // child < parent
23:            PREVENT_MERGING = '!';
24:    
25:        /**
26:         * Reads configuration from NEON file.
27:         * @param  string  file name
28:         * @return array
29:         */
30:        public function load($file)
31:        {
32:            return $this->process((array) Neon\Neon::decode(file_get_contents($file)));
33:        }
34:    
35:    
36:        private function process(array $arr)

33:         * @param  string  file name
34:         * @param  string  optional section to load
35:         * @return array
36:         */
37:        public function load($file, $section = NULL)
38:        {
39:            if (!is_file($file) || !is_readable($file)) {
40:                throw new Nette\FileNotFoundException("File '$file' is missing or is not readable.");
41:            }
42:            $this->dependencies[] = realpath($file);
43:            $data = $this->getAdapter($file)->load($file);
44:    
45:            if ($section) {
46:                if (isset($data[self::INCLUDES_KEY])) {
47:                    throw new Nette\InvalidStateException("Section 'includes' must be placed under some top section in file '$file'.");

237:         * @internal
238:         */
239:        public function generateContainer(DI\Compiler $compiler)
240:        {
241:            $loader = $this->createLoader();
242:            $compiler->addConfig(array('parameters' => $this->parameters));
243:            $fileInfo = array();
244:            foreach ($this->files as $info) {
245:                if (is_scalar($info[0])) {
246:                    $fileInfo[] = "// source: $info[0] $info[1]";
247:                    $info[0] = $loader->load($info[0], $info[1]);
248:                }
249:                $compiler->addConfig($this->fixCompatibility($info[0]));
250:            }
251:            $compiler->addDependencies($loader->getDependencies());

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: