Re-register the view finder with one that allows manipulating the paths array

@param Repository $config

@return void
480857
protected function registerTenantAwareViewFinder(Repository $config)
    {
        $this->app->bind('view.finder', function ($app) use ($config) {
            $paths = $config['view.paths'];

            return new FileViewFinder($app['files'], $paths);
        });
    }
661400
private function register_constants( Config $config ) {
		$this->share( 'file', function() use ( $config ) {
			return $config->file;
		} );
		$this->share( 'url', function() use ( $config ) {
			return $config->url;
		} );
		$this->share( 'path', function() use ( $config ) {
			return $config->path;
		} );
		$this->share( 'basename', function() use ( $config ) {
			return $config->basename;
		} );
		$this->share( 'slug', function() use ( $config ) {
			return $config->slug;
		} );
		$this->share( 'version', static::VERSION );
	}
169722
protected function assignRoles(array $config) : void
    {
        $this->stdout("Assign roles: " . count($config) . "\n", Console::FG_YELLOW);
        foreach ($config as $item) {
            if (!$role = $this->assignRole($item)) {
                $this->stdout("\t- error assigned role: " . Json::encode($item) . "\n", Console::FG_RED);
            }
        }
    }
267238
public function initialize(array $config)
    {
        parent::initialize($config);

        $this->Controller = $this->_registry->getController();

        $this->_addFromConfigure();

        // set up the default helper
        $this->Controller->helpers['Utils.Menu'] = [];
    }
616307
public function load(Config $config)
    {
        $parsed = [];

        if ($this->isFile($this->getPath())) {
            $parsed = $this->parse($this->fetch($this->getPath()));
        }

        if (!is_array($parsed)) {
            $parsed = [];
        }

        $this->apply($parsed, $config);
    }
260932
public function loadFrom(Repository $config, $configPath)
    {
        foreach ($this->filesIn($configPath) as $group => $configFile) {
            $config->set($group, require $configFile);
        }
    }
774658
public function bootTwig($config){
        $app    = $this->app;
        $view   = $app->view;

        $view->parserOptions = $config;
        $view->parserExtensions = array(
            new \Slim\Views\TwigExtension(),
            new \SlimStarter\TwigExtension\MenuRenderer()
        );
    }
708845
public function initialize(array $config)
    {
        parent::initialize($config);

        $this->Controller = $this->_registry->getController();

        if ($this->config('Auth')) {
            $this->Controller->loadComponent('Auth', $this->config('Auth'));
        }

        $this->Controller->loadComponent('Utils.Menu');
    }
956781
public function reload(\Erebot\Interfaces\Config\Server $config)
    {
        $this->loadModules(
            $config,
            \Erebot\Module\Base::RELOAD_ALL
        );
        $this->config = $config;
    }
1324149
public static function start(&$config)
    {
        $config = array_merge(array(
        
            /* default language */
            'language'      => 'en',

            /* GET param to override the language */
            'lang_param'    => 'lang',
            
            /* autodetect browser language */
            'autodetect'    => true,
            
            /* directory where language files are stored */
            'dir'           => 'app/languages'
    
        ), $config);
        self::$config = &$config;

        Atomik::registerHelper('translate', 'Atomik\Translations::translate');
        Atomik::registerHelper('_', 'Atomik\Translations::translate');
    }
1039252
protected function registerConfigBindings()
    {
        $loader = new FileLoader(new Filesystem(), $this->resourcePath('config'));

        $this->singleton('config', function () use ($loader) {
            return new Repository($loader, $this->environment());
        });
    }
716739
public function initialize(array $config)
    {
        if ($this->_config['referenceName'] == null) {
            $this->_config['referenceName'] = $this->_referenceName();
        }
        $this->setupFieldAssociations($this->_config['versionTable']);
    }
1302577
private function initializeClassAliases(Repository $config)
    {
        $list = ClassAliasList::getInstance();
        $list->registerMultiple($config->get('app.aliases'));
        $list->registerMultiple($config->get('app.facades'));

        // Autoload some aliases to prevent typehinting errors
        class_exists('\Request');
        if (version_compare(PHP_VERSION, '7.2.0alpha1') < 0) {
            $list->register('Concrete\Core\Foundation\Object', 'Concrete\Core\Foundation\ConcreteObject');
        }

        return $list;
    }
585982
public function bootstrap( $config = [] ) {
		if ( $this->isBootstrapped() ) {
			throw new ConfigurationException( static::class . ' already bootstrapped.' );
		}

		$this->bootstrapped = true;
		$this->bootstrapApplication( $config );
	}
504631
public function initiate(Repository $config)
    {
        if (extension_active('tester')) {
            try {
                $this->generator = app(\Antares\Tester\Builder\Generator::class);
            } catch (Exception $ex) {
                
            }
        }
        $this->fieldsets = new Collection();
        foreach ($config->get('antares/html::form', []) as $key => $value) {
            if (property_exists($this, $key)) {
                $this->{$key} = $value;
            }
        }

        $this->row = [];
    }
917436
protected function registerEntityValidator(Repository $config)
    {
        $this->app->singleton(Factories\EntityValidationFactory::class, function ($app) use ($config) {
            $factory = new Factories\EntityValidationFactory(
                $app->make(Factories\HydratorFactory::class), $app['validator']
            );

            foreach ($config->get('doctrine_validation.mappings') as $entity => $rules) {
                $factory->addEntityRulesMapping($entity, $app->make($rules));
            }

            return $factory;
        });
    }
951933
private function configure(array $config = []): void
    {
        foreach ($config as $param => $value) {
            $property = $this->toCamelCase($param);
            if (property_exists(self::class, $property)) {
                $this->$property = $value;
            }
        }
    }