public function addToInjector(Injector $injector)
{
foreach ($this->shares as $share) {
$injector->share($share);
}
foreach ($this->aliases as $original => $alias) {
$injector->alias($original, $alias);
}
foreach ($this->definitions as $name => $args) {
$injector->define($name, $args);
}
foreach ($this->params as $param => $value) {
$injector->defineParam($param, $value);
}
foreach ($this->delegates as $param => $callable) {
$injector->delegate($param, $callable);
}
foreach ($this->prepares as $class => $callable) {
$injector->prepare($class, $callable);
}
}
private function registerExceptionHandlerServices(Injector $injector)
{
$injector->share(Run::class);
$injector->prepare(Run::class, function (Run $run) {
$run->pushHandler(new PrettyPageHandler());
});
$injector->share(ExceptionHandlingPlugin::class);
}
/**
* @inheritDoc
*/
public function apply(Injector $injector)
{
$injector->alias('Psr\\Http\\Message\\ResponseInterface', 'Zend\\Diactoros\\Response');
$injector->share('Psr\\Http\\Message\\ResponseInterface');
$injector->delegate('Psr\\Http\\Message\\ServerRequestInterface', 'Zend\\Diactoros\\ServerRequestFactory::fromGlobals');
$injector->share('Psr\\Http\\Message\\ServerRequestInterface');
$injector->alias('Psr\\Http\\Message\\RequestInterface', 'Psr\\Http\\Message\\ServerRequestInterface');
}
/**
* Sets the templates path.
*
* @param string $path
* @param \Twig_Environment $twig
* @param array $extensions
* @return self
*/
public function setTemplatePath($path, \Twig_Environment $twig = null, $extensions = [])
{
$this->paths['templates'] = $path;
if (is_null($twig)) {
$loader = new \Twig_Loader_Filesystem($path);
$twig = new \Twig_Environment($loader);
}
$twig->setExtensions($extensions);
$this->injector->share($twig);
return $this;
}
/**
* @param array $injections Single dimensional array of shareable values from the Silex\Application (pimple) object
*
* @return void
*/
public function performInjections(array $injections)
{
foreach ($injections as $shareable) {
$this->injector->share($this->application[$shareable]);
}
/**
* This can only be done here because security / user is only read to be read after boot
*/
if (isset($this->application['twig']) && isset($this->application['security.authorization_checker'])) {
$this->application['twig']->addExtension(new SecurityExtension($this->application['security.authorization_checker']));
}
}
function createInjector()
{
$jigTemplatePath = new \Jig\JigTemplatePath(__DIR__ . "/fixtures/templates/");
$jigCompilePath = new \Jig\JigCompilePath(__DIR__ . "/var/generatedTemplates/");
// Create a JigConfig object
$jigConfig = new JigConfig($jigTemplatePath, $jigCompilePath, Jig::COMPILE_CHECK_MTIME);
$injector = new Injector();
$injector->alias('Jig\\Escaper', 'Jig\\Bridge\\ZendEscaperBridge');
$injector->delegate('FastRoute\\Dispatcher', 'TierTest\\JigBridge\\createDispatcher');
$injector->share('FastRoute\\Dispatcher');
$injector->share($jigConfig);
return $injector;
}
public function setUp()
{
parent::setUp();
$this->compileDirectory = new JigCompilePath(dirname(__DIR__) . "/./../tmp/generatedTemplates/");
$this->templateDirectory = new JigTemplatePath(dirname(__DIR__) . "/./templates/");
$jigConfig = new JigConfig($this->templateDirectory, $this->compileDirectory, Jig::COMPILE_ALWAYS, "php.tpl");
$injector = new \Auryn\Injector();
$this->injector = $injector;
$escaper = new ZendEscaperBridge(new ZendEscaper());
$this->injector->alias('Jig\\Escaper', get_class($escaper));
$this->injector->share($escaper);
$this->jigDispatcher = new JigDispatcher($jigConfig, $injector);
}
protected function setUp()
{
define('MODEL_DIR', '\\Test\\Model');
//define('DEBUG_MODE', true);
$this->injector = new Injector();
$this->injector->share(Database::class);
$this->database = $this->injector->make('Minute\\Database\\Database', [true]);
try {
$this->pdo = $this->database->getPdo();
} catch (\PDOException $e) {
$this->markTestSkipped('Database connection error: ' . $e->getMessage());
}
parent::setUp();
}
public function __invoke(Injector $injector)
{
$injector->share($injector);
foreach ($this->classes as $class) {
$injector->execute($class);
}
}
function setMedoo()
{
$injector = new Injector();
$injector->share('medoo');
$injector->define('medoo', [':options' => $this->databaseconfig]);
$this->medoodb = $injector->make('medoo');
}
/**
* Run the application
*
* @param string $runner
*
* @return \Psr\Http\Message\ResponseInterface
*/
public function run($runner = 'Relay\\Relay')
{
foreach ($this->configuration as $entry) {
$this->injector->make($entry)->apply($this->injector);
}
return $this->injector->share($this->middleware)->prepare('Spark\\Directory', $this->routing)->execute($runner);
}
/**
* Applies a configuration set to a dependency injector.
*
* @param Injector $injector
*/
public function apply(Injector $injector)
{
$paths = ["src/Users/Entity/", "src/Shifts/Entity/"];
$isDevMode = true;
// the connection configuration
$dbParams = array('host' => $_ENV['DB_HOST'], 'driver' => $_ENV['DB_DRIVER'], 'user' => $_ENV['DB_USER'], 'password' => $_ENV['DB_PASSWORD'], 'dbname' => $_ENV['DB_DATABASE_NAME']);
$config = Setup::createAnnotationMetadataConfiguration($paths, $isDevMode, null, null, false);
$injector->share(EntityManager::create($dbParams, $config));
}
/**
* Applies a configuration set to a dependency injector.
*
* @param Injector $injector
*/
public function apply(Injector $injector)
{
// Create a new Manager instance.
$manager = new Manager(new ArrayDriver());
// Managers can do everything
$manager->role('manager')->allow('all');
// $manager->role('employee')->allow('guest', 'read');
$injector->share($manager);
}
public function apply(Injector $injector)
{
//START: auth
$injector->alias(AdapterInterface::class, \trejeraos\SimpleServerMonitor\Auth\FooAdapter::class);
$injector->alias(AuthHandler::class, FooAuthHandler::class);
$injector->share(FooAuthHandler::class);
// get auth token
$injector->alias(TokenExtractorInterface::class, QueryExtractor::class);
$injector->define(QueryExtractor::class, [':parameter' => 'tok']);
// get auth credentials
$injector->alias(CredentialsExtractorInterface::class, BodyExtractor::class);
$injector->define(BodyExtractor::class, [':identifier' => 'user', ':password' => 'password']);
// share valid auth token class
$injector->share(\trejeraos\SimpleServerMonitor\Auth\ValidTokens::class);
//END: auth
// share global config class
$injector->share(\trejeraos\SimpleServerMonitor\Data\Configuration::class);
}
public function getServiceLocator()
{
if (!$this->service_locator) {
$di_container = new DiContainer(new StandardReflector());
$di_container->share($di_container);
$service_provisioner = $di_container->make(ServiceProvisioner::CLASS);
$this->service_locator = $service_provisioner->provision();
}
return $this->service_locator;
}
/**
* @inheritDoc
*/
public function apply(Injector $injector)
{
$injector->define(Loader::class, [':filepaths' => $this->envfile]);
$injector->share(Env::class);
$injector->prepare(Env::class, function (Env $env, Injector $injector) {
$loader = $injector->make(Loader::class);
$values = $loader->parse()->toArray();
return $env->withValues($values);
});
}
public function testRouting405()
{
$request = new CLIRequest("/introduction", 'example.com', 'POST');
$this->injector->alias('Psr\\Http\\Message\\ServerRequestInterface', get_class($request));
$this->injector->share($request);
$router = $this->injector->make('Tier\\Bridge\\FastRouter');
$fn404ErrorPage = function () {
return new TextBody("Route not found.", 404);
};
$fn405ErrorPage = function () {
return new TextBody("Method not allowed for route.", 405);
};
$result = $router->routeRequest($request, $fn404ErrorPage, $fn405ErrorPage);
$body = TierApp::executeExecutable($result, $this->injector);
$this->assertInstanceOf('Room11\\HTTP\\Body\\TextBody', $body);
/** @var $body \Room11\HTTP\Body\HtmlBody */
$html = $body->getData();
$this->assertContains("Method not allowed for route.", $html);
$this->assertEquals(405, $body->getStatusCode());
}
function injector(Injector $injector = null) : Injector
{
static $persistent;
if (isset($injector)) {
$persistent = $injector;
$persistent->share($persistent);
}
if (!isset($persistent)) {
$persistent = new Injector();
$persistent->share($persistent);
}
return $persistent ?? ($persistent = new Injector());
}
public function testRouting405()
{
$request = new CLIRequest("/introduction", 'example.com', 'POST');
$this->injector->alias('Psr\\Http\\Message\\ServerRequestInterface', get_class($request));
$this->injector->share($request);
$renderCallable = $this->injector->execute('Tier\\Bridge\\JigFastRouter::routeRequest');
$body = TierApp::executeExecutable($renderCallable, $this->injector);
$this->assertInstanceOf('Room11\\HTTP\\Body\\TextBody', $body);
/** @var $body \Room11\HTTP\Body\HtmlBody */
$html = $body->getData();
$this->assertContains("Method not allowed for route.", $html);
$this->assertEquals(405, $body->getStatusCode());
}
/**
*
* {@inheritDoc}
*
* @see \Spark\Configuration\ConfigurationInterface::apply()
*/
public function apply(Injector $injector)
{
$acl = new Acl();
$acl->addRole(new Role('manager'))->addRole(new Role('employee'));
$acl->addResource(new Resource('GetEmployeeShifts'));
$acl->addResource(new Resource('GetEmployeeShiftsSummary'));
$acl->addResource(new Resource('GetShiftDetail'));
$acl->addResource(new Resource('ModifyShift'));
$acl->addResource(new Resource('GetShiftsByDate'));
$acl->addResource(new Resource('GetEmployee'));
$acl->allow('employee', 'GetEmployeeShifts');
$acl->allow('employee', 'GetEmployeeShiftsSummary');
$acl->allow('employee', 'GetShiftDetail');
$acl->allow('manager', 'GetEmployee');
$acl->allow('manager', 'ModifyShift');
$acl->allow('manager', 'GetShiftsByDate');
$injector->share($acl);
}
public function testCallsBeforeAndAfterControllerOneTime()
{
$handler = ControllerStub::class . '#index';
$injector = new Injector();
$injector->share(ControllerStub::class);
$resolver = new ControllerActionResolver($injector, $this->emitter);
$cb = $resolver->resolve($this->request, $handler);
$this->emitter->emit(new BeforeControllerEvent($this->request, $cb));
$res = $cb();
$this->emitter->emit(new AfterControllerEvent($this->request, $res, $cb));
// imagine the engine gets ran again and these events are triggered again
$this->emitter->emit(new BeforeControllerEvent($this->request, function () {
}));
$this->emitter->emit(new AfterControllerEvent($this->request, $res, function () {
}));
$controller = $injector->make(ControllerStub::class);
$this->assertSame(1, $controller->beforeControllerCount(), 'beforeController not called exactly 1 time');
$this->assertSame(1, $controller->afterControllerCount(), 'afterController not called exactly 1 time');
}
public function testRendering()
{
/** @var ViewParser $view */
/** @var Dispatcher $dispatcher */
$dispatcher = (new Injector())->make('Minute\\Event\\Dispatcher');
$dispatcher->listen('one.plus.one', function (ViewEvent $event) {
$event->setContent('2');
});
$injector = new Injector();
$injector->define('Dispatcher', [$dispatcher]);
$injector->share($dispatcher);
$view = $injector->make('Minute\\View\\ViewParser', ['foo' => 'bar']);
$view->loadTemplate('A\\HasEvent');
$output = $view->render();
$this->assertEquals('<html><body>1 + 1 = 2.</body></html>', $output, 'Output is rendering correctly');
$view->setHelpers([new Helper('D/e', Helper::POSITION_BODY)]);
$output = $view->render();
$this->assertEquals('<html><body>1 + 1 = 2.[Helper 1!]</body></html>', $output, 'Output is rendering correctly');
}
/**
* @return \Auryn\Injector
* @throws \Auryn\ConfigException
*/
function createTestInjector($mocks = array(), $shares = array())
{
$injector = new \Auryn\Injector();
// Read application config params
$injectionParams = (require __DIR__ . "/./testInjectionParams.php");
/** @var $injectionParams \Tier\InjectionParams */
$injector->share(new ScriptPath(__DIR__ . "/../fixtures/"));
//$injectionParams->mergeMocks($mocks);
$injectionParams->addToInjector($injector);
foreach ($mocks as $class => $implementation) {
if (is_object($implementation) == true) {
$injector->alias($class, get_class($implementation));
$injector->share($implementation);
} else {
$injector->alias($class, $implementation);
}
}
$injector->share($injector);
return $injector;
}
/**
* @param array $implementations
* @param array $shareClasses
* @return Provider
*/
function createProvider($implementations = array(), $shareClasses = array())
{
$provider = new Injector();
$provider->define('GithubService\\GithubArtaxService\\GithubArtaxService', [':userAgent' => 'Danack_test']);
$provider->prepare('Amp\\Artax\\Client', 'prepareArtaxClient');
$standardImplementations = ['GithubService\\GithubService' => 'DebugGithub', 'Amp\\Artax\\AsyncClient' => 'Amp\\Artax\\AsyncClient', 'Amp\\Reactor' => 'Amp\\NativeReactor', 'ArtaxServiceBuilder\\ResponseCache' => 'ArtaxServiceBuilder\\ResponseCache\\NullResponseCache', 'PSR\\Cache' => 'PSR\\Cache\\APCCache', 'Amp\\Addr\\Cache' => 'Amp\\Addr\\MemoryCache'];
$standardShares = ['Amp\\Reactor' => 'Amp\\Reactor'];
$provider->delegate('Amp\\Artax\\Client', 'createClient');
foreach ($standardImplementations as $interface => $implementation) {
if (array_key_exists($interface, $implementations)) {
if (is_object($implementations[$interface]) == true) {
$provider->alias($interface, get_class($implementations[$interface]));
$provider->share($implementations[$interface]);
} else {
$provider->alias($interface, $implementations[$interface]);
}
unset($implementations[$interface]);
} else {
if (is_object($implementation)) {
$implementation = get_class($implementation);
}
$provider->alias($interface, $implementation);
}
}
foreach ($implementations as $class => $implementation) {
if (is_object($implementation) == true) {
$provider->alias($class, get_class($implementation));
$provider->share($implementation);
} else {
$provider->alias($class, $implementation);
}
}
foreach ($standardShares as $class => $share) {
if (array_key_exists($class, $shareClasses)) {
$provider->share($shareClasses[$class]);
unset($shareClasses[$class]);
} else {
$provider->share($share);
}
}
foreach ($shareClasses as $class => $share) {
$provider->share($share);
}
$provider->share($provider);
//YOLO
return $provider;
}
/**
* @inheritdoc
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
// Parse the configuration
$configFile = $input->getArgument('configFile');
$configuration = ConfigurationParser::parseConfiguration(new YamlReader($configFile));
// Configure Propel and the logger
$logger = $this->configureLogger($output, $configuration);
$this->configurePropel($configuration, $logger);
$injector = new Injector();
// Configure shared instances
$eventLoop = EventLoopFactory::create();
$eventDispatcher = new EventDispatcher();
$aliases = [':logger' => $logger, ':loop' => $eventLoop];
$injector->share($configuration)->share($logger)->share($eventDispatcher)->share($eventLoop);
// Create managers
$statusManager = $injector->make('Jalle19\\StatusManager\\Manager\\StatusManager', $aliases);
$instanceStateManager = $injector->make('Jalle19\\StatusManager\\Manager\\InstanceStateManager', $aliases);
$webSocketManager = $injector->make('Jalle19\\StatusManager\\Manager\\WebSocketManager', $aliases);
$persistenceManager = $injector->make('Jalle19\\StatusManager\\Manager\\PersistenceManager', $aliases);
$statisticsManager = $injector->make('Jalle19\\StatusManager\\Manager\\StatisticsManager', $aliases);
$inputErrorManager = $injector->make('Jalle19\\StatusManager\\Manager\\InputErrorManager', $aliases);
$httpRequestManager = $injector->make('Jalle19\\StatusManager\\Manager\\HttpRequestManager', $aliases);
// Wire the event dispatcher
$webSocketManager->registerMessageHandler($statisticsManager);
$webSocketManager->registerMessageHandler($webSocketManager);
$eventDispatcher->addSubscriber($statusManager);
$eventDispatcher->addSubscriber($instanceStateManager);
$eventDispatcher->addSubscriber($webSocketManager);
$eventDispatcher->addSubscriber($persistenceManager);
$eventDispatcher->addSubscriber($inputErrorManager);
$eventDispatcher->addSubscriber($httpRequestManager);
// Configure the event loop and start the application
$eventLoop->addPeriodicTimer($configuration->getUpdateInterval(), function () use($eventDispatcher) {
// Emit an event on each tick
$eventDispatcher->dispatch(Events::MAIN_LOOP_TICK);
});
$eventDispatcher->dispatch(Events::MAIN_LOOP_STARTING);
$eventLoop->run();
}
<?php
use Auryn\Injector;
use Jig\JigConfig;
use Jig\Jig;
// Register some directories in the autoloader - we don't do this in composer.json
// to avoid any confusion with users of the library.
$autoloader = (require_once realpath(__DIR__) . '/../vendor/autoload.php');
$autoloader->add('JigDemo', [realpath(__DIR__) . '/']);
$autoloader->add('Jig', [realpath(__DIR__) . '/compile/']);
$injector = new Injector();
// Setting the Jig config
$jigConfig = new JigConfig(__DIR__ . "/templates/", __DIR__ . "/compile/", Jig::COMPILE_ALWAYS, "php.tpl");
// Tell the DIC that every class that needs an instance of JigConfig
// should use this one.
$injector->share($jigConfig);
// Alias an interface to a concrete class so that it can be found in
// the template.
$injector->alias('JigDemo\\Model\\ColorScheme', '\\JigDemo\\Model\\PrimaryColorscheme');
// This is the template we will be compiling.
$templateName = 'onePageExample';
// Create the Jig renderer
$jig = new Jig($jigConfig);
// Tell Jig to make sure the template is compiled.
$jig->compile($templateName);
// Get the classname that the template will be called
$className = $jig->getFQCNFromTemplateName($templateName);
// Call the template
$contents = $injector->execute([$className, 'render']);
echo $contents;
<?php
use Auryn\Injector;
use function Aerys\router;
$config = (require __DIR__ . "/config/config.php");
$injector = new Injector();
$injector->share(new \Amp\Mysql\Pool(sprintf("host=%s;user=%s;pass=%s;db=%s", $config["database"]["host"], $config["database"]["user"], $config["database"]["pass"], $config["database"]["name"])));
$injector->alias("Kelunik\\Chat\\Integration\\HookRepository", "Kelunik\\Chat\\Integration\\MysqlHookRepository");
$handler = $injector->make("Kelunik\\Chat\\Integration\\Dispatcher", [":config" => $config]);
$router = router();
$router->post("{service}/{id:[0-9]+}", [$handler, "handle"]);
$host = (new Aerys\Host())->expose("*", $config["deploy"]["port"])->name($config["deploy"]["host"])->use($router);
public function getInjector()
{
$this->injector = $injector = new Injector();
$injector->share(Binding::class);
$injector->share(BootLoader::class);
$injector->share(Config::class);
$injector->share(Database::class);
$injector->share(Dispatcher::class);
$injector->share(HttpRequestEx::class);
$injector->share(HttpResponseEx::class);
$injector->share(LoggerEx::class);
$injector->share(QCache::class);
$injector->share(Router::class);
$injector->share(Session::class);
$injector->share(Connection::class);
$injector->share($injector);
return $injector;
}
/**
* Run the application
*
* @param string $runner
*
* @return \Psr\Http\Message\ResponseInterface
*/
public function run($runner = 'Relay\\Relay')
{
$this->configuration->apply($this->injector);
return $this->injector->share($this->middleware)->prepare('Equip\\Directory', $this->routing)->execute($runner);
}
/**
* @param Injector $injector
* @param Router $router
*/
public function __construct(Injector $injector, Router $router)
{
$this->injector = $injector;
$this->router = $router;
$this->injector->share($router);
}
