public function register(\Pimple $container)
{
$container['logger'] = function () use($container) {
return $container['monolog'];
};
if ($bridge = class_exists('Symfony\\Bridge\\Monolog\\Logger')) {
$container['monolog.handler.debug'] = function () use($container) {
return new DebugHandler($container['monolog.level']);
};
}
$container['monolog.logger.class'] = $bridge ? 'Symfony\\Bridge\\Monolog\\Logger' : 'Monolog\\Logger';
$container['monolog'] = $container->share(function ($container) {
$log = new $container['monolog.logger.class']($container['monolog.name']);
$log->pushHandler($container['monolog.handler']);
if ($container['debug'] && isset($container['monolog.handler.debug'])) {
$log->pushHandler($container['monolog.handler.debug']);
}
return $log;
});
$container['monolog.handler'] = function () use($container) {
return new StreamHandler($container['monolog.logfile'], $container['monolog.level']);
};
$container['monolog.level'] = function () {
return Logger::DEBUG;
};
$container['monolog.name'] = 'container';
}
/**
* Registers services on the given container.
*
* This method should only be used to configure services and parameters.
* It should not get services.
*
* @param \Pimple $mainContainer An Container instance
*/
public function register(\Pimple $mainContainer)
{
$container = new \Pimple();
$container['profiler'] = $mainContainer->share(function ($container) use($mainContainer) {
$profiler = new Profiler(new FileStorage($mainContainer['config']->get('profiler_path')));
$profiler->addCollector($container['collector.cache']);
$profiler->addCollector($container['collector.database']);
return $profiler;
});
$container['session_storage'] = $mainContainer->share(function () use($mainContainer) {
return new SessionStorage($mainContainer['session']);
});
$container['profiler_manager'] = $mainContainer->share(function ($container) {
return new ProfilerManager($container['profiler']);
});
$container['collector.cache'] = $mainContainer->share(function () {
return new CacheDataCollector();
});
$container['collector.listener'] = $mainContainer->share(function () use($mainContainer) {
return new ListenerDataCollector($mainContainer['core']['dispatcher']);
});
$container['collector.database'] = $mainContainer->share(function () {
return new DatabaseDataCollector();
});
$container['collector.xhprof'] = $mainContainer->share(function () {
return new XhprofDataCollector();
});
$container['listener'] = $mainContainer->share(function ($container) {
return new ProfilerListener($container['profiler']);
});
$container['template_finder'] = $mainContainer->share(function () {
return new Finder();
});
$mainContainer['profiler'] = $container;
}
/**
* @return a new DI container with prefilled values for the news app
*/
function createDIContainer()
{
$container = new \Pimple();
/**
* BASE
*/
$container['API'] = $container->share(function ($c) {
return new API('apptemplate_advanced');
});
$container['Security'] = $container->share(function ($c) {
return new Security($c['API']->getAppName());
});
$container['Request'] = $container->share(function ($c) {
return new Request($_GET, $_POST);
});
/**
* CONTROLLERS
*/
$container['IndexController'] = function ($c) {
return new IndexController($c['API'], $c['Request']);
};
$container['SettingsController'] = function ($c) {
return new SettingsController($c['API'], $c['Request']);
};
$container['AjaxController'] = function ($c) {
return new AjaxController($c['API'], $c['Request']);
};
return $container;
}
public function register(Application $app)
{
$app['mongodbs.options.initializer'] = $app->protect(function () use($app) {
static $initialized = false;
if ($initialized) {
return;
}
$initialized = true;
if (!isset($app['mongodbs.options'])) {
$app['mongodbs.options'] = ['default' => isset($app['mongodb.options']) ? $app['mongodb.options'] : []];
}
$app['mongodbs.options'] = array_map(function ($options) use($app) {
return array_replace($app['mongodb.default_options'], $options);
}, $app['mongodbs.options']);
if (!isset($app['mongodbs.default'])) {
$app['mongodbs.default'] = array_keys(array_slice($app['mongodbs.options'], 0, 1))[0];
}
});
$app['mongodbs'] = $app->share(function (Application $app) {
$app['mongodbs.options.initializer']();
$container = new \Pimple();
foreach ($app['mongodbs.options'] as $name => $options) {
$container[$name] = $container->share(function () use($options) {
return new Manager($options['uri'], $options['options'], $options['driverOptions']);
});
}
return $container;
});
$app['mongodb.default_options'] = ['uri' => 'mongodb://localhost:27017', 'options' => [], 'driverOptions' => []];
// shortcuts for the "first" MongoDB
$app['mongodb'] = $app->share(function (Application $app) {
$dbs = $app['mongodbs'];
return $dbs[$app['mongodbs.default']];
});
}
public function it_normalizes_expressions($parser, \Pimple $container)
{
$container->offsetExists('_normalize')->willReturn(true);
$container->offsetGet('_normalize')->willReturn(array('foo' => 'bar'));
$parser->evaluate('foo', array('foo' => 'bar'))->willReturn('bar')->shouldBeCalled();
$this->normalize('?foo', $container)->shouldReturn('bar');
}
/**
* Registers services on the given container.
*
* This method should only be used to configure services and parameters.
* It should not get services.
*
* @param \Pimple $mainContainer An Container instance
*/
public function register(\Pimple $mainContainer)
{
$mainContainer['core']['db'] = $mainContainer->share(function () {
return \Pelican_Db::getInstance();
});
$mainContainer['core']['listener.ajax_response_render'] = $mainContainer->share(function () {
return new AjaxRenderResponseListener(new \Pelican_Ajax_Adapter_Jquery());
});
}
public static function registerFilters(\Pimple $container)
{
$container['inspector.filter_listener'] = $container->share($container->extend('inspector.filter_listener', function ($listener, $c) {
$listener->addAvailableFilter('gitignore', function () {
return new Filter\GitIgnoreFilter();
});
return $listener;
}));
}
/**
* @param \Exception $e
*/
public function handle(\Exception $e)
{
$code = $e->getCode();
// if there is no handler for this do nothing
if (!$this->_handlers->offsetExists($code)) {
return;
}
return $this->_handlers[$code]($e);
}
/**
* Registers services on the given container.
*
* This method should only be used to configure services and parameters.
* It should not get services.
*
* @param \Pimple $mainContainer An Container instance
*/
public function register(\Pimple $mainContainer)
{
$container = new \Pimple();
$container['dispatcher'] = $mainContainer->share(function () {
$dispatcher = new EventDispatcher();
// Add listeners
return $dispatcher;
});
$mainContainer['core'] = $container;
}
/**
* {@inheritDoc}
*/
public static function register(\Pimple $container)
{
$container['event_dispatcher.class'] = 'Zend\\EventManager\\EventManager';
if (class_exists($container['event_dispatcher.class'])) {
$container['event_dispatcher'] = $container->share(function ($c) {
return new $c['event_dispatcher.class']();
});
} else {
throw new Exception\Provider\ClassNotFoundException('Event Dispatcher', $container['event_dispatcher.class']);
}
}
public function it_creates_a_array_parameter_and_merges_existing_data(Parameter $parameterConf, \Pimple $container)
{
$parameterConf->getParameterName()->willReturn('db.options');
$parameterConf->getParameterValue()->willReturn(array('host' => 'example.org'));
$parameterConf->getMergeStrategy(Argument::type('array'))->willReturn('array_replace_recursive');
$parameterConf->mergeExisting()->willReturn(true);
$container->offsetExists('db.options')->willReturn(true);
$container->offsetGet('db.options')->willReturn(array('host' => 'localhost', 'user' => 'root', 'password' => 'test'));
$container->offsetSet('db.options', array('host' => 'example.org', 'user' => 'root', 'password' => 'test'))->shouldBeCalled();
$container = $this->create($parameterConf, $container);
}
public function register(\Pimple $container)
{
$container['knp_menu.route.voter'] = $container->share(function (\Pimple $container) {
$voter = new RouteVoter();
$voter->setRequest($container['request_stack']->getCurrentRequest());
return $voter;
});
$container['knp_menu.matcher.configure'] = $container->protect(function (Matcher $matcher) use($container) {
$matcher->addVoter($container['knp_menu.route.voter']);
});
}
/**
* Registers services on the given container.
*
* This method should only be used to configure services and parameters.
* It should not get services.
*
* @param \Pimple $container An Container instance
*/
public function register(\Pimple $container)
{
$services = new \Pimple();
$services['factory'] = $container->share(function () use($container) {
return new \Itkg\Core\Cache\Factory($container['cache']['adapters']);
});
$services['listener'] = $container->share(function () use($services, $container) {
return new CacheListener($services['factory']->create($container['config']['cache']['adapter'], $container['config']['cache']), $container['core']['dispatcher']);
});
$container['cache'] = $services;
}
public function createApplication()
{
$pimple = new \Pimple();
$dependencies = array('beforeTokenChecker' => $pimple->protect(function () {
}));
require SPIKA_ROOT . '/etc/app.php';
$mailer = $this->getMockBuilder('\\Silex\\Provider\\SwiftmailerServiceProvider')->setMethods(array('send'))->disableOriginalConstructor()->getMock();
$mailer->expects(once())->method('send')->with(isInstanceOf('Swift_Message'));
$app['mailer'] = $mailer;
return $app;
}
public static function registerApplication(\Pimple $container)
{
$container['console.application'] = $container->share(function ($c) {
$app = new $c['console.application.class']($c);
foreach ($c['console.command'] as $command) {
$app->add($command());
}
return $app;
});
$container['console.command'] = new \ArrayObject();
self::registerCommands($container);
}
public function testGetMenuAsClosure()
{
$pimple = new \Pimple();
$menu = $this->getMock('Knp\\Menu\\ItemInterface');
$pimple['menu'] = $pimple->protect(function ($options, $c) use($menu) {
$c['options'] = $options;
return $menu;
});
$provider = new PimpleProvider($pimple, array('default' => 'menu'));
$this->assertSame($menu, $provider->get('default', array('foo' => 'bar')));
$this->assertEquals(array('foo' => 'bar'), $pimple['options']);
}
/**
* Initialize the user.
*
* @param \Pimple $container The dependency container.
*
* @return void
*/
public function startup(\Pimple $container)
{
$container['workflow.security.user'] = $container->share(function () use($container) {
$user = $this->createUser($container['event-dispatcher']);
try {
$contaoUser = $container['user'];
$this->initializeContaoUser($user, $contaoUser);
} catch (\Exception $e) {
// Ignore error. Fetching user from container could throw an error for a unknown TL_MODE.
}
return $user;
});
}
/**
* Generate a mapping of the container's values
*
* @param Container $container
*
* @return array
*/
protected function parseContainer(Container $container)
{
$map = array();
foreach ($container->keys() as $name) {
if ($name === 'dump.path') {
continue;
}
if ($item = $this->parseItem($container, $name)) {
$map[] = $item;
}
}
return $map;
}
/**
* Generate a mapping of the container's values
*
* @param Container $container
*
* @return array
*/
protected function parseContainer(Container $container)
{
$map = array();
foreach ($container->keys() as $name) {
if (strpos($name, self::DIC_PREFIX) === 0) {
continue;
}
if ($item = $this->parseItem($container, $name)) {
$map[] = $item;
}
}
return $map;
}
/**
* Registers services on the given container.
*
* This method should only be used to configure services and parameters.
* It should not get services.
*
* @param \Pimple $mainContainer An Container instance
*/
public function register(\Pimple $mainContainer)
{
$mainContainer['router'] = $mainContainer->share(function () {
return new Router();
});
$mainContainer['request_matcher'] = $mainContainer->share(function ($mainContainer) {
return new RequestMatcher($mainContainer['router']);
});
// listeners
$mainContainer['listener.request_matcher'] = $mainContainer->share(function ($mainContainer) {
return new RequestMatcherListener($mainContainer['request_matcher']);
});
$mainContainer['dispatcher']->addSubscriber($mainContainer['listener.request_matcher']);
}
public function register(\Pimple $pimple)
{
$pimple['issue'] = $pimple->share(function ($pimple) {
return new IssueService($pimple['session']);
});
$pimple['issue.email'] = $pimple->share(function ($pimple) {
return new IssueEmailService($pimple['session'], $pimple['workflow']);
});
$pimple['workflow'] = $pimple->share(function ($pimple) {
return new WorkflowService($pimple['session']);
});
$pimple['project'] = $pimple->share(function ($pimple) {
return new ProjectService($pimple['session']);
});
}
/**
* {@inheritdoc}
*/
public function register(\Pimple $container)
{
foreach ($this->getDefaults() as $key => $value) {
if (!isset($container[$key])) {
$container[$key] = $value;
}
}
$container['console'] = $container->share(function () use($container) {
$class = $container['console.class'];
$instance = new $class(isset($container['console.name']) ? $container['console.name'] : '', isset($container['console.version']) ? $container['console.version'] : null);
if ($instance instanceof ContainerAwareApplication) {
$instance->setContainer($container);
}
return $instance;
});
}
/**
* Constructs the container and set up default services and properties
*/
public function __construct()
{
parent::__construct();
//Shared services
$this['twig'] = $this->share(function ($c) {
$envOptions = array_merge(array('cache' => $c['twig.compilation_cache']), $c['twig.environment_options']);
$twig = new Twig_Environment($c['twig.loader'], $envOptions);
if (isset($envOptions['debug']) && $envOptions['debug']) {
$twig->addExtension(new Twig_Extension_Debug());
}
return $twig;
});
$this['twig.loader'] = $this->share(function ($c) {
return new $c['twig.loader_class']($c['twig.template_paths']);
});
//Dynamic props
$this['twig.compilation_cache'] = BASE_PATH . '/twig-cache';
$this['twig.template_paths'] = THEMES_PATH . '/' . SSViewer::current_theme() . '/twig';
//Default config
foreach (self::$config as $key => $value) {
$this[$key] = $value;
}
//Extensions
if (is_array(self::$extensions)) {
foreach (self::$extensions as $value) {
$this->extend($value[0], $value[1]);
}
}
//Shared
if (is_array(self::$shared)) {
foreach (self::$shared as $value) {
$this[$value[0]] = $this->share($value[1]);
}
}
}
public function __construct()
{
parent::__construct();
$this->initializeFilesystem();
$this->initializeServices();
$this->initializeSubscribers();
}
/**
* Registers services on the given container.
*
* This method should only be used to configure services and parameters.
* It should not get services.
*
* @param \Pimple $mainContainer An Container instance
*/
public function register(\Pimple $mainContainer)
{
$mainContainer['listener.response_exception'] = $mainContainer->share(function () {
return new ResponseExceptionListener();
});
$mainContainer['listener.processor_response_render'] = $mainContainer->share(function () {
return new ResponsePostRendererListener();
});
// Response Processors
$mainContainer['response.processor.compress'] = $mainContainer->share(function () {
return new CompressProcessor();
});
$dispatcher = $mainContainer['dispatcher'];
$dispatcher->addSubscriber($mainContainer['listener.response_exception']);
$dispatcher->addSubscriber($mainContainer['listener.processor_response_render']);
}
public function __construct(Application $app, array $values = array())
{
parent::__construct();
$this->app = $app;
$this['debug'] = false;
$this['admin'] = false;
$this['admin_content'] = '';
$this['block_type_factory'] = $app->protect(function ($blockTypeData) {
return BlockType::factory($blockTypeData);
});
$this['block_types'] = $this->share(function () {
return array();
});
$this['twig_extensions'] = $this->share(function () {
return array();
});
$this['snippet_queue'] = $this->share(function () {
return new SnippetQueue();
});
$this['loader_class'] = 'NodePub\\Core\\Extension\\Loader';
$app['loader'] = $app->share(function ($app) {
return new $app['extension_loader_class']();
});
foreach ($values as $key => $value) {
$this[$key] = $value;
}
}
/**
* @param array $config The SlotMachine configuration data
* @param Request|null $request The Request object
*/
public function __construct(array $config = array(), Request $request = null)
{
parent::__construct();
$this->config = $config;
$this->request = !is_null($request) ? $request : Request::createFromGlobals();
$this->initialize();
}
/**
* The given closure is call the first time the given service is queried.
* The closure has to return the instance for the given service.
* Created instance will be cached in case $shared is true.
*
* @param string $name name of the service to register another backend for
* @param \Closure $closure the closure to be called on service creation
*/
function registerService($name, \Closure $closure, $shared = true)
{
if ($shared) {
$this[$name] = \Pimple::share($closure);
} else {
$this[$name] = $closure;
}
}
public function register(\Pimple $container)
{
$container['validator'] = $container->share(function ($container) {
$r = new \ReflectionClass('Symfony\\Component\\Validator\\Validator');
if (isset($container['translator'])) {
$container['translator']->addResource('xliff', dirname($r->getFilename()) . '/Resources/translations/validators.' . $container['locale'] . '.xlf', $container['locale'], 'validators');
}
return new Validator($container['validator.mapping.class_metadata_factory'], $container['validator.validator_factory'], isset($container['translator']) ? $container['translator'] : new DefaultTranslator());
});
$container['validator.mapping.class_metadata_factory'] = $container->share(function ($container) {
return new ClassMetadataFactory(new StaticMethodLoader());
});
$container['validator.validator_factory'] = $container->share(function () use($container) {
$validators = isset($container['validator.validator_service_ids']) ? $container['validator.validator_service_ids'] : array();
return new ConstraintValidatorFactory($container, $validators);
});
}
/**
* Constructor.
*
* @param array $values
*/
public function __construct(array $values = [])
{
parent::__construct($values);
$this['app'] = $this;
$this->register(new EventServiceProvider());
$this->register(new RoutingServiceProvider());
ApplicationTrait::setApplication($this);
}
