/** * {@inheritdoc} */ public function fileReflection($filename) { $fileMD5 = $this->files->md5($filename = $this->files->normalizePath($filename)); $reflection = new ReflectionFile($this->fetchTokens($filename), (array) $this->memory->loadData($fileMD5, self::MEMORY_LOCATION)); //Let's save to cache $this->memory->saveData($fileMD5, $reflection->exportSchema(), static::MEMORY_LOCATION); return $reflection; }
/** * Bootload set of classes * * @param array $classes * @param string|null $memory Memory section to be used for caching, set to null to disable * caching. */ public function bootload(array $classes, $memory = null) { if (!empty($memory)) { $schema = $this->memory->loadData($memory); } if (empty($schema) || $schema['snapshot'] != $classes) { //Schema expired or empty $schema = $this->generateSchema($classes, $this->container); if (!empty($memory)) { $this->memory->saveData($memory, $schema); } return; } //We can initiate schema thought the cached schema $this->schematicBootload($this->container, $schema); }
/** * Save language bundle into memory. * * @param string $bundle */ protected function saveBundle($bundle) { if (!isset($this->bundles[$bundle])) { return; } $this->memory->saveData($bundle, $this->bundles[$bundle], $this->languageOptions['directory']); }
/** * Load environment data. * * @return $this */ public function load() { if (!$this->files->exists($this->filename)) { throw new EnvironmentException("Unable to load environment, file is missing"); } //Unique env file hash $this->id = $this->files->md5($this->filename); if (!empty($values = $this->memory->loadData($this->id, static::MEMORY_SECTION))) { //Restore from cache $this->initEnvironment($values); return $this; } //Load env values using DotEnv extension $values = $this->initEnvironment($this->parseValues($this->filename)); $this->memory->saveData($this->id, $values, static::MEMORY_SECTION); return $this; }
/** * Locate every available Symfony command using Tokenizer. * * @return array */ public function locateCommands() { $this->commands = []; foreach ($this->locator->getClasses(SymfonyCommand::class) as $class) { if ($class['abstract']) { continue; } $this->commands[] = $class['name']; } $this->memory->saveData('commands', $this->commands); return $this->commands; }
/** * Locate every available Symfony command using Tokenizer. * * @return array */ public function findCommands() { $this->commands = []; foreach ($this->tokenizer->getClasses(SymfonyCommand::class, null, 'Command') as $class) { if ($class['abstract']) { continue; } $this->commands[] = $class['name']; } $this->memory->saveData('commands', $this->commands); return $this->commands; }
/** * {@inheritdoc} */ public function import($replace = false) { if (empty($this->language)) { throw new ImporterException("Unable to perform bundles import, no language detected."); } if (!isset($this->translator->config()['languages'][$this->language])) { throw new ImporterException("Unable to import language '{$this->language}', no presets found."); } $directory = $this->translator->config()['languages'][$this->language]['directory']; foreach ($this->bundles as $bundle => $strings) { if (!$replace && !empty($existed = $this->memory->loadData($bundle, $directory))) { $strings = $strings + $existed; } $this->memory->saveData($bundle, $strings, $directory); } }
/** * Find class declaration and load it. * * @param string $class Class name with namespace included. * @return bool */ public function loadClass($class) { if (isset($this->loadmap[$class])) { try { //We already know route to class declaration include_once $this->classes[$class] = $this->loadmap[$class]; } catch (\ErrorException $exception) { //File was replaced or removed unset($this->loadmap[$class]); if (!empty($this->name)) { $this->memory->saveData($this->name, $this->loadmap); } //Try to update route to class return $this->loadClass($class); } return true; } //Composer and other loaders. foreach (spl_autoload_functions() as $function) { if ($function instanceof \Closure || $function[0] != $this) { //Calling loaders call_user_func($function, $class); if (class_exists($class, false) || interface_exists($class, false) || trait_exists($class, false)) { //Class has been successfully found by external loader //External loader are not going to provide us any information about class //location, let's get it via Reflection $reflector = new \ReflectionClass($class); try { $filename = str_replace('\\', '/', $reflector->getFileName()); $filename = rtrim(str_replace('//', '/', $filename), '/'); //Direct access to filesystem, yep. if (file_exists($filename)) { $this->loadmap[$class] = $this->classes[$class] = $filename; $this->memory->saveData($this->name, $this->loadmap); } } catch (\ErrorException $exception) { //getFileName can throw and exception, we can ignore it } //Class found return true; } } } return false; }
/** * Get singular primary key associated with desired table. Used to emulate last insert id. * * @param string $table Fully specified table name, including postfix. * @return string * @throws DriverException */ public function getPrimary($table) { if (empty($this->primaryKeys)) { $this->primaryKeys = $this->memory->loadData($this->getSource() . '-primary'); } if (!empty($this->primaryKeys) && array_key_exists($table, $this->primaryKeys)) { return $this->primaryKeys[$table]; } if (!$this->hasTable($table)) { throw new DriverException("Unable to fetch table primary key, no such table '{$table}' exists."); } $this->primaryKeys[$table] = $this->tableSchema($table)->getPrimaryKeys(); if (count($this->primaryKeys[$table]) === 1) { //We do support only single primary key $this->primaryKeys[$table] = $this->primaryKeys[$table][0]; } else { $this->primaryKeys[$table] = null; } //Caching $this->memory->saveData($this->getSource() . '-primary', $this->primaryKeys); return $this->primaryKeys[$table]; }
/** * Load catalogue data from source. * * @param string $locale * @return Catalogue */ protected function loadCatalogue($locale) { $catalogue = new Catalogue($locale, $this->memory); if (array_key_exists($locale, $this->loadedLocales) && $this->config->cacheLocales()) { //Has been loaded return $catalogue; } $benchmark = $this->benchmark('load', $locale); try { //Loading catalogue data from source foreach ($this->source->loadLocale($locale) as $messageCatalogue) { $catalogue->mergeFrom($messageCatalogue); } //To remember that locale already loaded $this->loadedLocales[$locale] = $catalogue->getDomains(); $this->memory->saveData(static::MEMORY, $this->loadedLocales); //Saving domains memory $catalogue->saveDomains(); } finally { $this->benchmark($benchmark); } return $catalogue; }
/** * Update ORM records schema, synchronize declared and database schemas and return instance of * SchemaBuilder. * * @param SchemaBuilder $builder User specified schema builder. * @return SchemaBuilder */ public function updateSchema(SchemaBuilder $builder = null) { $builder = !empty($builder) ? $builder : $this->schemaBuilder(); //Casting relations between records $builder->castRelations(); //Create all required tables and columns $builder->synchronizeSchema(); //Saving $this->memory->saveData(static::SCHEMA_SECTION, $this->schema = $builder->normalizeSchema()); //Let's reinitialize records DataEntity::resetInitiated(); return $builder; }
/** * Update ODM documents schema and return instance of SchemaBuilder. * * @param SchemaBuilder $builder User specified schema builder. * @return SchemaBuilder */ public function updateSchema(SchemaBuilder $builder = null) { $builder = !empty($builder) ? $builder : $this->schemaBuilder(); //We will create all required indexes now $builder->createIndexes(); //Saving $this->memory->saveData(static::SCHEMA_SECTION, $this->schema = $builder->normalizeSchema()); //Let's reinitialize models DataEntity::resetInitiated(); return $builder; }
/** * Update ORM records schema, synchronize declared and database schemas and return instance of * SchemaBuilder. * * @param SchemaBuilder $builder User specified schema builder. * @param bool $syncronize Create all required tables and columns * @return SchemaBuilder */ public function updateSchema(SchemaBuilder $builder = null, $syncronize = false) { if (empty($builder)) { $builder = $this->schemaBuilder(); } //Create all required tables and columns if ($syncronize) { $builder->synchronizeSchema(); } //Getting normalized (cached) version of schema $this->schema = $builder->normalizeSchema(); //Saving $this->memory->saveData(static::MEMORY, $this->schema); //Let's reinitialize records DataEntity::resetInitiated(); return $builder; }
/** * Save domain data into memory. * * @param string $domain * @param array $data */ protected function saveDomain($domain, $data) { $this->memory->saveData("{$this->locale}-{$domain}", $data, static::MEMORY_LOCATION); }
/** * @param HippocampusInterface $memory */ public function perform(HippocampusInterface $memory) { $memory->saveData('bootloading', null); $this->writeln("<info>Bootload cache has been cleared.</info>"); }
/** * Update ODM documents schema and return instance of SchemaBuilder. * * @param SchemaBuilder $builder User specified schema builder. * @param bool $createIndexes * @return SchemaBuilder */ public function updateSchema(SchemaBuilder $builder = null, $createIndexes = false) { if (empty($builder)) { $builder = $this->schemaBuilder(); } //We will create all required indexes now if ($createIndexes) { $builder->createIndexes(); } //Getting cached/normalized schema $this->schema = $builder->normalizeSchema(); //Saving $this->memory->saveData(static::MEMORY, $this->schema); //Let's reinitialize models DataEntity::resetInitiated(); return $builder; }