public function setUp()
 {
     $kernel = static::createKernel();
     $kernel->boot();
     if ($kernel->getContainer()->getParameter('database_driver') == 'pdo_sqlite') {
         $this->markTestSkipped("The SQLite does not support joins.");
     }
     $this->em = $kernel->getContainer()->get('knp_bundles.entity_manager');
     $fileLocator = new FileLocator(__DIR__ . '/fixtures/');
     $path = $fileLocator->locate('trending-bundles.yml');
     $data = Yaml::parse($path);
     $developer = new Developer();
     $developer->setName('someName');
     $developer->setScore(0);
     $this->em->persist($developer);
     foreach ($data['bundles'] as $bundleName => $bundleData) {
         $bundle = new Bundle('vendor/' . $bundleName);
         $bundle->setDescription('some description');
         $bundle->setScore(100);
         $bundle->setOwner($developer);
         foreach ($bundleData['scores'] as $scoreData) {
             $bundle->setDescription(md5(time() . serialize($scoreData)));
             $score = new Score();
             $score->setDate(new \DateTime($scoreData['date']));
             $score->setBundle($bundle);
             $score->setValue($scoreData['value']);
             $this->em->persist($score);
         }
         $this->em->persist($bundle);
     }
     $this->em->flush();
 }
 /**
  * Loads the config
  */
 private function loadConfig()
 {
     $directories = [BASE_DIR . '/config', '/etc/blackhole-bot/'];
     $locator = new FileLocator($directories);
     $loader = new YamlConfigLoader($locator);
     $this->container->set('config', (new Processor())->processConfiguration($this, $loader->load($locator->locate('blackhole.yml'))));
 }
 /**
  * @return DatabaseBackupStrategyModel[]
  */
 public function collectDatabasesStrategies()
 {
     $fileLocator = new FileLocator(__DIR__ . '/../../../app/config');
     try {
         $fileStrategies = $fileLocator->locate('strategies.yml');
     } catch (InvalidArgumentException $ex) {
         /* No strategies file detected? No strategies then. :=) */
         return [];
     }
     $strategies = file_get_contents($fileStrategies);
     $config = Yaml::parse($strategies);
     $config = $config['easy_backups'];
     $processor = new Processor();
     $configuration = new DatabaseStrategyConfiguration();
     $validatedConfig = $processor->processConfiguration($configuration, [$config]);
     $strategies = [];
     if (isset($validatedConfig['strategies'])) {
         foreach ($validatedConfig['strategies'] as $strategyConfig) {
             $strategy = new DatabaseBackupStrategyModel($strategyConfig['identifier'], $strategyConfig['compressor_strategy'], $strategyConfig['saver_strategy'], $strategyConfig['dump_settings']['type'], new DatabaseSettings($strategyConfig['dump_settings']['options']['host'], $strategyConfig['dump_settings']['options']['user'], $strategyConfig['dump_settings']['options']['pass'], $strategyConfig['dump_settings']['options']['name'], $strategyConfig['dump_settings']['options']['port'], $strategyConfig['dump_settings']['options']['ignore_tables'], $strategyConfig['dump_settings']['options']['one_dump_per_table']));
             $strategy->setDescription($strategyConfig['description']);
             $strategies[] = $strategy;
         }
     }
     return $strategies;
 }
 /**
  * @return array
  */
 private static function getParameters()
 {
     $locator = new FileLocator(__DIR__ . '/../../../../');
     $configLoc = $locator->locate('config.yml');
     $config = Yaml::parse($configLoc);
     return $config['parameters'];
 }
 /**
  * Initialize the service container (and extensions), and load the config file
  *
  * @param \Symfony\Component\Console\Input\InputInterface $input
  * @param \Symfony\Component\Console\Output\OutputInterface $output
  *
  * @throws \Exception if user-provided configuration file causes an error
  */
 protected function initialize(InputInterface $input, OutputInterface $output)
 {
     $root = $input->getArgument('root');
     // Setup container
     $containerBuilder = new ContainerBuilder();
     $extension = new BrancherExtension();
     $containerBuilder->registerExtension($extension);
     $containerBuilder->addCompilerPass(new ExtensionCompilerPass());
     $containerBuilder->addCompilerPass(new RegisterListenersPass('event_dispatcher', 'brancher.event_listener', 'brancher.event_subscriber'));
     // Try and load config file
     $locator = new FileLocator([getcwd(), $input->getArgument('root'), __DIR__ . '/../']);
     /** @var \Symfony\Component\DependencyInjection\Loader\FileLoader $loader */
     $loader = new DelegatingLoader(new LoaderResolver([new YamlFileLoader($containerBuilder, $locator), new XmlFileLoader($containerBuilder, $locator), new PhpFileLoader($containerBuilder, $locator), new IniFileLoader($containerBuilder, $locator)]));
     $config = null;
     try {
         $config = $locator->locate($input->getOption('config'));
         $loader->load($input->getOption('config'));
     } catch (\Exception $ex) {
         // Only rethrow if the issue was with the user-provided value
         if ($input->getOption('config') !== '_config.yml') {
             throw $ex;
         }
     }
     // Add in final config from command line options
     $containerBuilder->setParameter('castlepointanime.brancher.build.config', $config);
     $containerBuilder->loadFromExtension($extension->getAlias(), ['build' => array_filter(['config' => dirname($config) ?: $root, 'root' => $root, 'special' => $input->getOption('special'), 'output' => $input->getArgument('output'), 'templates' => array_filter(array_map('realpath', $input->getOption('template-dir')), 'is_dir'), 'data' => $input->getOption('data-dir'), 'exclude' => $input->getOption('exclude')])]);
     $containerBuilder->compile();
     $this->setContainer($containerBuilder);
 }
Beispiel #6
0
 protected function setConnection()
 {
     $fileLocator = new FileLocator(getcwd());
     $configFile = $fileLocator->locate('rentgen.yml');
     $config = Yaml::parse($configFile);
     $this->connection = new Connection(new ConnectionConfig($config['connection']));
 }
 /**
  * @param string $file
  * @return array
  */
 public function loadConfig($file = self::DEFAULT_CONFIG)
 {
     $configDirectories = ['./'];
     $locator = new FileLocator($configDirectories);
     $file = $locator->locate($file);
     return json_decode(file_get_contents($file), true);
 }
 /**
  * @expectedException \InvalidArgumentException
  */
 public function testFileNotFound()
 {
     $configDirectories = array(FIXTURES_PATH);
     $locator = new FileLocator($configDirectories);
     $PhpLoader = new PhpLoader($locator);
     $PhpLoader->load($locator->locate('notFound.php'));
 }
Beispiel #9
0
 /**
  * Loads the configuration file data.
  */
 public function load($workingDir)
 {
     $locator = new FileLocator($this->getPotentialDirectories($workingDir));
     $loader = new YamlLoader($locator);
     // Config validation.
     $processor = new Processor();
     $schema = new BuddySchema();
     $files = $locator->locate(static::FILENAME, NULL, FALSE);
     foreach ($files as $file) {
         // After loading the raw data from the yaml file, we validate given
         // configuration.
         $raw = $loader->load($file);
         $conf = $processor->processConfiguration($schema, array('buddy' => $raw));
         if (isset($conf['commands'])) {
             foreach ($conf['commands'] as $command => $specs) {
                 if (!isset($this->commands[$command])) {
                     $this->commands[$command] = array('options' => $specs, 'file' => $file);
                 }
             }
         }
         // In the case 'root' is set, we do not process any parent buddy files.
         if (!empty($values['root'])) {
             break;
         }
     }
     return $this;
 }
 /**
  * {@inheritDoc}
  */
 public function getStructureMetadata($type, $structureType = null)
 {
     $cacheKey = $type . $structureType;
     if (isset($this->cache[$cacheKey])) {
         return $this->cache[$cacheKey];
     }
     $this->assertExists($type);
     if (!$structureType) {
         $structureType = $this->getDefaultStructureType($type);
     }
     if (!is_string($structureType)) {
         throw new \InvalidArgumentException(sprintf('Expected string for structureType, got: %s', is_object($structureType) ? get_class($structureType) : gettype($structureType)));
     }
     $cachePath = sprintf('%s/%s%s', $this->cachePath, Inflector::camelize($type), Inflector::camelize($structureType));
     $cache = new ConfigCache($cachePath, $this->debug);
     if ($this->debug || !$cache->isFresh()) {
         $paths = $this->getPaths($type);
         // reverse paths, so that the last path overrides previous ones
         $fileLocator = new FileLocator(array_reverse($paths));
         try {
             $filePath = $fileLocator->locate(sprintf('%s.xml', $structureType));
         } catch (\InvalidArgumentException $e) {
             throw new Exception\StructureTypeNotFoundException(sprintf('Could not load structure type "%s" for document type "%s", looked in "%s"', $structureType, $type, implode('", "', $paths)), null, $e);
         }
         $metadata = $this->loader->load($filePath, $type);
         $resources = [new FileResource($filePath)];
         $cache->write(sprintf('<?php $metadata = \'%s\';', serialize($metadata)), $resources);
     }
     require $cachePath;
     $structure = unserialize($metadata);
     $this->cache[$cacheKey] = $structure;
     return $structure;
 }
Beispiel #11
0
 /**
  * {@inheritdoc}
  * @SuppressWarnings(PHPMD.StaticAccess)
  */
 public function load()
 {
     $locator = new FileLocator($this->paths);
     $configFile = $locator->locate('pgca.yml');
     $fileContents = Yaml::parse(file_get_contents($configFile), true);
     $this->config = new Data($fileContents);
 }
 public function __construct($configFile)
 {
     $locator = new FileLocator(array(dirname($configFile)));
     $loader = new YamlLoader($locator);
     $processor = new Processor();
     $this->configuration = $processor->processConfiguration(new Definition(), $loader->load($locator->locate(basename($configFile))));
 }
Beispiel #13
0
 /**
  * {@inheritdoc}
  */
 public function execute(ImageInterface $image, $parameters)
 {
     $maskPath = isset($parameters['image']) ? $this->fileLocator->locate($parameters['image']) : null;
     if (!$maskPath) {
         return $image;
     }
     $originalWidth = $image->getSize()->getWidth();
     $originalHeight = $image->getSize()->getHeight();
     $top = isset($parameters['top']) ? $parameters['top'] : 0;
     $left = isset($parameters['left']) ? $parameters['left'] : 0;
     $width = isset($parameters['width']) ? $parameters['width'] : $originalWidth;
     $height = isset($parameters['height']) ? $parameters['height'] : $originalHeight;
     // imagine will error when mask is bigger then the given image
     // this could happen in forceRatio true mode so we need also scale the mask
     if ($width > $originalWidth) {
         $width = $originalWidth;
         $height = (int) ($height / $width * $originalWidth);
     }
     if ($height > $originalHeight) {
         $height = $originalHeight;
         $width = (int) ($width / $height * $originalHeight);
     }
     // create mask
     $mask = $this->createMask($maskPath, $width, $height);
     // add mask to image
     $image->paste($mask, new Point($top, $left));
     return $image;
 }
    /**
     * 
     * @param string $configDirectories
     * @param string $configFiles
     * @param string $cachePath
     * @param bool $debug
     */
    public function __construct($configDirectories, $configFiles, $cachePath, $debug = false)
    {
        $this->configDirectories = (array) $configDirectories;
        $this->configFiles = (array) $configFiles;
        $this->cachePath = $cachePath . '/faker_config.php';
        $configCache = new ConfigCache($this->cachePath, $debug);
        if (!$configCache->isFresh()) {
            $locator = new FileLocator($this->configDirectories);
            $loaderResolver = new LoaderResolver([new YamlLoader($locator)]);
            $delegatingLoader = new DelegatingLoader($loaderResolver);
            $resources = [];
            $config = [];
            foreach ($this->configFiles as $configFile) {
                $path = $locator->locate($configFile);
                $config = array_merge($config, $delegatingLoader->load($path));
                $resources[] = new FileResource($path);
            }
            $exportConfig = var_export($this->parseRawConfig(isset($config['faker']) ? $config['faker'] : []), true);
            $code = <<<PHP
<?php
return {$exportConfig};
PHP;
            $configCache->write($code, $resources);
        }
        if (file_exists($this->cachePath)) {
            $this->config = (include $this->cachePath);
        }
    }
Beispiel #15
0
 /**
  * @param string $path the working directory for filesystem operations
  *
  * @throws \InvalidArgumentException
  * @throws IOException
  */
 public function setWorkingDirectory($path)
 {
     $directory = preg_replace('#/+#', '/', $path);
     // remove multiple slashes
     try {
         $directory = $this->locator->locate($directory);
         if (false === is_string($directory)) {
             $directory = strval(reset($directory));
             $this->logger->alert(sprintf('Ambiguous filename %s, choosing %s', $path, $directory));
         }
     } catch (\InvalidArgumentException $exception) {
         // continue to check if dir exists even if locator doesn't locate
     }
     $exists = $this->filesystem->exists($directory);
     if (!$exists) {
         try {
             $this->filesystem->mkdir($directory);
             $this->logger->notice("Working directory created at " . $directory);
         } catch (IOException $exception) {
             $this->logger->error("An error occurred while creating directory at " . $exception->getPath(), $exception->getTrace());
             throw $exception;
         }
     }
     $this->directory = $directory;
 }
 /**
  * @expectedException \Symfony\Component\Yaml\Exception\ParseException
  */
 public function testInvalid()
 {
     $configDirectories = array(FIXTURES_PATH);
     $locator = new FileLocator($configDirectories);
     $YamlLoader = new YamlLoader($locator);
     $YamlLoader->load($locator->locate('invalid.yml'));
 }
Beispiel #17
0
 /** {@inheritdoc} */
 public function prepend(ContainerBuilder $container)
 {
     $configs = Yaml::parse($this->fileLocator->locate('redis.yml'));
     foreach ($configs as $name => $config) {
         $container->prependExtensionConfig($name, $config);
     }
 }
 /**
  * {@inheritDoc}
  */
 public function load(array $configs, ContainerBuilder $container)
 {
     $configuration = new Configuration();
     $config = $this->processConfiguration($configuration, $configs);
     $this->bindParameters($container, $this->getAlias(), $config);
     // Fallback for missing intl extension
     $intlExtensionInstalled = extension_loaded('intl');
     $container->setParameter('lunetics_locale.intl_extension_installed', $intlExtensionInstalled);
     $iso3166 = array();
     $iso639one = array();
     $iso639two = array();
     $localeScript = array();
     if (!$intlExtensionInstalled) {
         $yamlParser = new YamlParser();
         $file = new FileLocator(__DIR__ . '/../Resources/config');
         $iso3166 = $yamlParser->parse(file_get_contents($file->locate('iso3166-1-alpha-2.yml')));
         $iso639one = $yamlParser->parse(file_get_contents($file->locate('iso639-1.yml')));
         $iso639two = $yamlParser->parse(file_get_contents($file->locate('iso639-2.yml')));
         $localeScript = $yamlParser->parse(file_get_contents($file->locate('locale_script.yml')));
     }
     $container->setParameter('lunetics_locale.intl_extension_fallback.iso3166', $iso3166);
     $mergedValues = array_merge($iso639one, $iso639two);
     $container->setParameter('lunetics_locale.intl_extension_fallback.iso639', $mergedValues);
     $container->setParameter('lunetics_locale.intl_extension_fallback.script', $localeScript);
     $loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
     $loader->load('validator.xml');
     $loader->load('guessers.xml');
     $loader->load('services.xml');
     $loader->load('switcher.xml');
     $loader->load('form.xml');
     if (!$config['strict_match']) {
         $container->removeDefinition('lunetics_locale.best_locale_matcher');
     }
 }
Beispiel #19
0
 public function load(array $configs, ContainerBuilder $container)
 {
     foreach ($configs as $config) {
         if ($this->isConnectionConfig($config)) {
             $connectionConfig = $config;
         }
     }
     if ($container->hasParameter('connection_config')) {
         $connectionConfig = $container->getParameter('connection_config');
     }
     $this->defineParameters($container);
     $definition = new Definition('Symfony\\Component\\EventDispatcher\\ContainerAwareEventDispatcher');
     $definition->setArguments(array(new Reference('service_container')));
     $container->setDefinition('event_dispatcher', $definition);
     $definition = new Definition('Rentgen\\Schema\\Manipulation');
     $definition->setArguments(array(new Reference('service_container')));
     $container->setDefinition('rentgen.schema.manipulation', $definition);
     $definition = new Definition('Rentgen\\Schema\\Info');
     $definition->setArguments(array(new Reference('service_container')));
     $container->setDefinition('rentgen.schema.info', $definition);
     if (!isset($connectionConfig)) {
         $fileLocator = new FileLocator(getcwd());
         try {
             $configFile = $fileLocator->locate('rentgen.yml');
             $content = file_get_contents('rentgen.yml');
             $config = Yaml::parse($content);
             $connectionConfig = $config;
         } catch (\InvalidArgumentException $e) {
             $connectionConfig['environments']['dev'] = array('adapter' => 'pgsql', 'host' => 'localhost', 'database' => null, 'username' => 'postgres', 'password' => '', 'port' => 5432);
         }
     }
     $definition = new Definition('Rentgen\\Database\\Connection\\ConnectionConfig');
     $definition->setArguments(array($connectionConfig['environments']));
     $container->setDefinition('connection_config', $definition);
     $definition = new Definition('Rentgen\\Database\\Connection\\Connection');
     $definition->setArguments(array(new Reference('connection_config')));
     $container->setDefinition('connection', $definition);
     $this->connection = $container->getDefinition('connection');
     $this->eventDispatcher = $container->getDefinition('event_dispatcher');
     $this->setDefinition('rentgen.create_table', 'rentgen.command.manipulation.create_table.class', $container);
     $this->setDefinition('rentgen.drop_table', 'rentgen.command.manipulation.drop_table.class', $container);
     $this->setDefinition('rentgen.add_column', 'rentgen.command.manipulation.add_column.class', $container);
     $this->setDefinition('rentgen.drop_column', 'rentgen.command.manipulation.drop_column.class', $container);
     $this->setDefinition('rentgen.add_constraint', 'rentgen.command.manipulation.add_constraint.class', $container);
     $this->setDefinition('rentgen.drop_constraint', 'rentgen.command.manipulation.drop_constraint.class', $container);
     $this->setDefinition('rentgen.create_index', 'rentgen.command.manipulation.create_index.class', $container);
     $this->setDefinition('rentgen.create_schema', 'rentgen.command.manipulation.create_schema.class', $container);
     $this->setDefinition('rentgen.drop_schema', 'rentgen.command.manipulation.drop_schema.class', $container);
     $this->setDefinition('rentgen.drop_index', 'rentgen.command.manipulation.drop_index.class', $container);
     $this->setDefinition('rentgen.table_exists', 'rentgen.command.info.table_exists.class', $container);
     $this->setDefinition('rentgen.get_table', 'rentgen.command.info.get_table.class', $container);
     $this->setDefinition('rentgen.get_tables', 'rentgen.command.info.get_tables.class', $container);
     $this->setDefinition('rentgen.get_schemas', 'rentgen.command.info.get_schemas.class', $container);
     $this->setDefinition('rentgen.schema_exists', 'rentgen.command.info.schema_exists.class', $container);
     $definition = new Definition($container->getParameter('rentgen.command.manipulation.clear_database.class'), array(new Reference('rentgen.get_schemas')));
     $definition->addMethodCall('setConnection', array(new Reference('connection')));
     $definition->addMethodCall('setEventDispatcher', array(new Reference('event_dispatcher')));
     $container->setDefinition('rentgen.clear_database', $definition);
 }
Beispiel #20
0
 /**
  * Constructor
  *
  * @param string $configFileName
  * @param array  $configDirectories
  */
 public function __construct($configFileName, array $configDirectories = array('.'))
 {
     $this->configFileName = $configFileName;
     $this->configDirectories = $configDirectories;
     $locator = new FileLocator($this->configDirectories);
     $this->configFilePath = $locator->locate($this->configFileName);
     $this->parseAndValidateConfig();
 }
Beispiel #21
0
function getConfig($yml)
{
    $m = new FileLocator(PATH_CONFIG);
    $yaml = new Parser();
    $file = $m->locate($yml);
    $parameters = $yaml->parse(file_get_contents($file));
    return $parameters;
}
 public static function setUpBeforeClass()
 {
     $yamlParser = new YamlParser();
     $file = new FileLocator(__DIR__ . '/../../Resources/config');
     self::$iso3166 = $yamlParser->parse(file_get_contents($file->locate('iso3166-1-alpha-2.yml')));
     self::$iso639 = array_merge($yamlParser->parse(file_get_contents($file->locate('iso639-1.yml'))), $yamlParser->parse(file_get_contents($file->locate('iso639-2.yml'))));
     self::$script = $yamlParser->parse(file_get_contents($file->locate('locale_script.yml')));
 }
Beispiel #23
0
 private static function prepareConfig()
 {
     $configDirectories = array(dirname(__FILE__) . '/../../config');
     $locator = new FileLocator($configDirectories);
     $loaderResolver = new LoaderResolver(array(new \App\ConfigLoader($locator)));
     $ymlConfig = $locator->locate(dirname(__FILE__) . '/../../config/config.yml', null, false);
     return $loaderResolver->resolve($ymlConfig)->load($ymlConfig);
 }
 public function testWarmUpEmpty()
 {
     $this->templateFinder->expects($this->once())->method('findAllTemplates')->will($this->returnValue(array()));
     $this->fileLocator->expects($this->never())->method('locate');
     $warmer = new TemplatePathsCacheWarmer($this->templateFinder, $this->templateLocator);
     $warmer->warmUp($this->tmpDir);
     $this->assertFileExists($this->tmpDir . '/templates.php');
     $this->assertSame(file_get_contents(__DIR__ . '/../Fixtures/TemplatePathsCache/templates-empty.php'), file_get_contents($this->tmpDir . '/templates.php'));
 }
 public function __construct()
 {
     $locator = new FileLocator(array(__DIR__ . '/ServiceDescription'));
     $jsonLoader = new JsonLoader($locator);
     $description = $jsonLoader->load($locator->locate('services.json'));
     $headers = ['X-Mashape-Key' => 'dwOm8WpRxamshUJeTSKCuZJ9lWLkp1JPxzijsnejSHNGN7sz25', 'Accept' => 'text/plain'];
     $httpClient = new Client(['defaults' => ['headers' => $headers]]);
     $this->client = new GuzzleClient($httpClient, new Description($description));
 }
Beispiel #26
0
 /**
  * @param $configFile   string
  * @param $paths        string|array
  *
  * @return $this
  */
 public function loadConfig($configFile, $paths)
 {
     $paths = (array) $paths;
     $fileLocator = new FileLocator($paths);
     $configLoader = $this->getConfigLoader();
     $configLoader->parseFile($fileLocator->locate($configFile));
     $configLoader->loadModules();
     return $this;
 }
 /**
  * @param string $filename
  * @return array|string
  */
 protected function findBootstrapFile($filename)
 {
     if (null === $filename) {
         $filename = 'phpmig.php';
     }
     $cwd = getcwd();
     $locator = new FileLocator(array($cwd . DIRECTORY_SEPARATOR . 'config', $cwd));
     return $locator->locate($filename);
 }
 /**
  * Validates the received data with the given json schema
  *
  * @param Schema $annotation
  * @param array $data
  *
  * @throws JsonSchemaException
  */
 public function validate(Schema $annotation, $data)
 {
     $schemaUrl = $this->fileLocator->locate($annotation->getPathToSchema());
     $schema = json_decode(file_get_contents($schemaUrl));
     $data = json_decode(json_encode($data));
     if (!$this->validator->isValid($data, $schema)) {
         throw new JsonSchemaException($this->validator->getErrors());
     }
 }
 /**
  * Initialize the static object
  * 
  * This function will initialize the configuration values in the static
  * object, if they have not yet been initialized.
  */
 private static function init()
 {
     if (is_null(self::$configValues)) {
         self::$configDir = realpath(__DIR__ . '/config');
         $locator = new FileLocator(self::$configDir);
         $yamlConfigFiles = $locator->locate('config.yml', null, false);
         self::$configValues = Yaml::parse(file_get_contents($yamlConfigFiles[0]));
     }
 }
 public function configure($directory)
 {
     $locator = new FileLocator($directory);
     // Load services.yml into di-container
     $loader = new YamlFileLoader($this->container, $locator);
     $loader->load('services.yml');
     // Load config.yml into variable
     $this->config = Yaml::parse(file_get_contents($locator->locate('config.yml')));
 }