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);
}
}
/**
* {@inheritdoc}
*/
public function setClassParameters($className, $arguments)
{
foreach ($arguments as $key => $value) {
unset($arguments[$key]);
$arguments[':' . $key] = $value;
}
$this->auryn->define($className, $arguments);
}
/**
*
* {@inheritDoc}
*
* @see \Spark\Configuration\ConfigurationInterface::apply()
*/
public function apply(Injector $injector)
{
$host = $this->env['DB_HOST'];
$username = $this->env['DB_USERNAME'];
$password = $this->env['DB_PASSWORD'];
$name = $this->env['DB_DBNAME'];
$port = $this->env['DB_PORT'];
$dsn = "mysql:dbname={$name};host={$host};port={$port}";
$injector->define('PDO', [':dsn' => $dsn, ':username' => $username, ':passwd' => $password]);
$injector->define('FluentPDO', [':pdo' => $injector->make('PDO')]);
}
/**
* Applies a configuration set to a dependency injector.
*
* @param Injector $injector
*/
public function apply(Injector $injector)
{
// JWT
$injector->define('Equip\\Auth\\Jwt\\Configuration', [':publicKey' => 'uhklzsdv89ywrahu', ':ttl' => 3600, ':algorithm' => 'HS256']);
$injector->alias('Equip\\Auth\\Jwt\\GeneratorInterface', 'Equip\\Auth\\Jwt\\FirebaseGenerator');
$injector->alias('Equip\\Auth\\Jwt\\ParserInterface', 'Equip\\Auth\\Jwt\\FirebaseParser');
// Tokens
$injector->alias(TokenExtractorInterface::class, TokenHeaderExtractor::class);
$injector->define(TokenHeaderExtractor::class, [':header' => 'Bearer']);
// Credentials
$injector->alias(CredentialsExtractorInterface::class, CredentialsBodyExtractor::class);
// Adapter
$injector->alias(AdapterInterface::class, JWTAdapter::class);
}
/**
*
* {@inheritDoc}
*
* @see \Spark\Configuration\ConfigurationInterface::apply()
*/
public function apply(Injector $injector)
{
$injector->alias(ExtractorInterface::class, HeaderExtractor::class);
$injector->define(HeaderExtractor::class, [':header' => 'token']);
$injector->alias(\Spark\Auth\Credentials\ExtractorInterface::class, BodyExtractor::class);
$injector->alias(AdapterInterface::class, AuthAdapter::class);
}
/**
* @inheritDoc
*/
public function apply(Injector $injector)
{
$injector->define(RelayBuilder::class, ['resolver' => 'Spark\\Resolver\\ResolverInterface']);
$injector->delegate('Relay\\Relay', function (RelayBuilder $builder, Middleware $queue) {
return $builder->newInstance($queue);
});
}
function setMedoo()
{
$injector = new Injector();
$injector->share('medoo');
$injector->define('medoo', [':options' => $this->databaseconfig]);
$this->medoodb = $injector->make('medoo');
}
/**
* @inheritDoc
*/
public function apply(Injector $injector)
{
$injector->define(RelayBuilder::class, ['resolver' => ResolverInterface::class]);
$factory = function (RelayBuilder $builder, MiddlewareSet $queue) {
return $builder->newInstance($queue);
};
$injector->delegate(Relay::class, $factory);
}
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);
}
/**
* @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);
});
}
private function registerRouterServices(Injector $injector)
{
$injector->share(RouteCollector::class);
$injector->define(RouteCollector::class, ['routeParser' => StdRouteParser::class, 'dataGenerator' => GcbGenerator::class]);
$injector->share(Router\FastRouteRouter::class);
$injector->define(Router\FastRouteRouter::class, ['collector' => RouteCollector::class, ':dispatcherCb' => function (array $data) use($injector) {
return $injector->make(GcbDispatcher::class, [':data' => $data]);
}]);
$injector->alias(Router\Router::class, Router\FastRouteRouter::class);
$injector->share(ResolverChain::class);
$injector->prepare(ResolverChain::class, function (ResolverChain $chain, Injector $injector) {
$chain->add($injector->make(ResponseResolver::class));
$chain->add($injector->make(CallableResolver::class));
$chain->add($injector->make(ControllerActionResolver::class));
});
$injector->share(InjectorExecutableResolver::class);
$injector->define(InjectorExecutableResolver::class, ['resolver' => ResolverChain::class]);
$injector->alias(HandlerResolver::class, InjectorExecutableResolver::class);
}
private function applyProviderConfig(Injector $injector, array $env)
{
$config = [];
foreach ($env as $key => $value) {
list($provider, $key) = explode('_', strtolower($key), 2);
$key = $this->toCamelCase($key);
$config[$provider][$key] = $value;
}
$injector->define(__NAMESPACE__ . '\\ProviderConfig', [':config' => $config]);
}
/**
* @inheritDoc
*/
public function apply(Injector $injector)
{
$injector->alias('Equip\\Auth\\Token\\ExtractorInterface', 'Equip\\Auth\\Token\\QueryExtractor');
$injector->define('Equip\\Auth\\Token\\QueryExtractor', [':parameter' => 'tk']);
$injector->alias('Equip\\Auth\\Credentials\\ExtractorInterface', 'Equip\\Auth\\Credentials\\BodyExtractor');
$injector->alias('Equip\\Auth\\AdapterInterface', 'Equip\\Project\\Auth\\Adapter');
$dir = dirname(dirname(__DIR__));
$dotenv = new Dotenv($dir);
$dotenv->load();
$dotenv->required(['DB_HOST', 'DB_NAME', 'DB_USER', 'DB_PASS']);
}
/**
* Applies a configuration set to a dependency injector.
*
* @param Injector $injector
*/
public function apply(Injector $injector)
{
//Specify token parameter from query string
$injector->define(QueryExtractor::class, [':parameter' => 'al']);
//Use Query Extractor to grab auth token
$injector->alias(\Spark\Auth\Token\ExtractorInterface::class, QueryExtractor::class);
//Use Json Extractor to grab credentials
$injector->alias(\Spark\Auth\Credentials\ExtractorInterface::class, JsonExtractor::class);
//Specify custom auth adapter to use
$injector->alias(AdapterInterface::class, Adapter::class);
}
function testValidControllerActionResultsInRightCallback()
{
$handler = HandlerWithMethod::class . '#action';
$val = new \stdClass();
$val->action = null;
$injector = new Injector();
$injector->define(HandlerWithMethod::class, [':val' => $val]);
$resolver = new ControllerActionResolver($injector, $this->emitter);
$cb = $resolver->resolve($this->request, $handler);
$cb($this->getMock(ServerRequestInterface::class));
$this->assertSame('invoked', $val->action);
}
/**
* @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;
}
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');
}
public function apply(Injector $injector)
{
$injector->define(Engine::class, [':directory' => __DIR__ . '/../../templates']);
$injector->prepare(Engine::class, [$this, 'prepareTemplates']);
}
/**
* @inheritDoc
*/
public function apply(Injector $injector)
{
$injector->alias(ResolverInterface::class, AurynResolver::class);
$injector->define(AurynResolver::class, [':injector' => $injector]);
}
public function apply(Injector $injector)
{
$injector->define(Application::class, [':name' => 'Equip Console', ':version' => '0.1']);
}
use Kelunik\Template\TemplateService;
use function Aerys\root;
use function Aerys\router;
use function Aerys\session;
use function Amp\reactor;
$injector = new Injector();
$injector->alias("Kelunik\\Chat\\Storage\\MessageStorage", "Kelunik\\Chat\\Storage\\MysqlMessageStorage");
$injector->alias("Kelunik\\Chat\\Storage\\PingStorage", "Kelunik\\Chat\\Storage\\MysqlPingStorage");
$injector->alias("Kelunik\\Chat\\Storage\\RoomStorage", "Kelunik\\Chat\\Storage\\MysqlRoomStorage");
$injector->alias("Kelunik\\Chat\\Storage\\UserStorage", "Kelunik\\Chat\\Storage\\MysqlUserStorage");
$injector->alias("Kelunik\\Chat\\Events\\EventSub", "Kelunik\\Chat\\Events\\RedisEventSub");
$injector->alias("Kelunik\\Chat\\Search\\Messages\\MessageSearch", "Kelunik\\Chat\\Search\\Messages\\ElasticSearch");
$injector->prepare("Kelunik\\Template\\TemplateService", function (TemplateService $service) {
$service->setBaseDirectory(__DIR__ . "/../res/html");
});
$injector->define("Kelunik\\Chat\\Search\\Messages\\ElasticSearch", [":host" => config("elastic.host"), ":port" => config("elastic.port")]);
$injector->share($injector);
$injector->share("Kelunik\\Template\\TemplateService");
$injector->share(new Redis(config("redis.protocol") . "://" . config("redis.host") . ":" . config("redis.port")));
$injector->share(new SubscribeClient(config("redis.protocol") . "://" . config("redis.host") . ":" . config("redis.port")));
$injector->share(new MySQL(sprintf("host=%s;user=%s;pass=%s;db=%s", config("database.host"), config("database.user"), config("database.pass"), config("database.name"))));
$auth = $injector->make("Kelunik\\ChatMain\\Auth");
/** @var TemplateService $templateService */
$templateService = $injector->make("Kelunik\\Template\\TemplateService");
/** @var Chat $chat */
$chat = $injector->make("Kelunik\\Chat\\Chat");
$router = router()->get("", function (Request $req, Response $resp) use($templateService) {
$session = (yield (new Session($req))->read());
if (!$session->get("login")) {
$template = $templateService->load("main.php");
$resp->send($template->render());
/**
*
* {@inheritDoc}
*
* @see \Spark\Configuration\ConfigurationInterface::apply()
*/
public function apply(Injector $injector)
{
$injector->define('UserMapper', [':fpdo' => $injector->make('FluentPDO')]);
$injector->define('ShiftMapper', [':fpdo' => $injector->make('FluentPDO')]);
}
public function apply(Injector $injector)
{
$injector->define(Engine::class, [':directory' => $this->env['PLATES_DIRECTORY']]);
}
/**
* @expectedException \Auryn\InjectionException
* @expectedExceptionCode \Auryn\Injector::E_UNDEFINED_PARAM
*/
public function testChildWithoutConstructorMissingParam()
{
$injector = new Injector();
$injector->define('Auryn\\Test\\ParentWithConstructor', array(':foo' => 'parent'));
$injector->make('Auryn\\Test\\ChildWithoutConstructor');
}
$minifier = (new MinifineFactory())->build(__DIR__ . '/public', $production);
/**
* Setup DI
*/
$auryn = new Auryn();
$injector = new Injector($auryn);
/**
* Setup shared instances and aliases
*/
$auryn->share($request);
$auryn->share($session);
$auryn->share($user);
$auryn->share($minifier);
$auryn->share($translator);
$auryn->share($decryptor);
$auryn->define('CodeCollab\\Encryption\\Defuse\\Encryptor', [':key' => file_get_contents(__DIR__ . '/encryption.key')]);
$auryn->define('CodeCollab\\Http\\Cookie\\Factory', [':domain' => $request->server('SERVER_NAME'), ':secure' => $request->isEncrypted()]);
$auryn->define('CodeCollab\\Theme\\Theme', [':themePath' => __DIR__ . '/themes', ':theme' => 'Default']);
$auryn->define('Demo\\Presentation\\Template\\Html', [':basePage' => '/page.phtml']);
$auryn->alias('CodeCollab\\CsrfToken\\Token', 'CodeCollab\\CsrfToken\\Handler');
$auryn->alias('CodeCollab\\Authentication\\Authentication', 'CodeCollab\\Authentication\\User');
$auryn->alias('CodeCollab\\CsrfToken\\Storage\\Storage', 'Demo\\Storage\\TokenSession');
$auryn->alias('CodeCollab\\Http\\Session\\Session', 'CodeCollab\\Http\\Session\\Native');
$auryn->alias('CodeCollab\\CsrfToken\\Generator\\Generator', 'CodeCollab\\CsrfToken\\Generator\\RandomBytes32');
$auryn->alias('CodeCollab\\I18n\\Translator', 'CodeCollab\\I18n\\FileTranslator');
$auryn->alias('CodeCollab\\Theme\\Loader', 'CodeCollab\\Theme\\Theme');
$auryn->alias('CodeCollab\\Template\\Html', 'Demo\\Presentation\\Template\\Html');
$auryn->alias('CodeCollab\\Encryption\\Encryptor', 'CodeCollab\\Encryption\\Defuse\\Encryptor');
$auryn->alias('CodeCollab\\Encryption\\Decryptor', 'CodeCollab\\Encryption\\Defuse\\Decryptor');
/**
* Setup the front controller
/**
* @inheritDoc
*/
public function apply(Injector $injector)
{
$injector->alias('Relay\\ResolverInterface', 'Equip\\Resolver\\AurynResolver');
$injector->define('Equip\\Resolver\\AurynResolver', [':injector' => $injector]);
}
use function Amp\run;
require_once __DIR__ . '/../vendor/autoload.php';
require_once __DIR__ . '/../version.php';
define(__NAMESPACE__ . '\\PROCESS_START_TIME', time());
$builtInCommands = [AdminBuiltIn::class, BanBuiltIn::class, CommandBuiltIn::class, PluginBuiltIn::class, RoomPresence::class, UptimeBuiltIn::class, VersionBuiltIn::class];
$builtInEventHandlers = [Invite::class];
$config = Yaml::parse(file_get_contents(__DIR__ . '/../config/config.yml'));
$injector = new Injector();
require_once __DIR__ . '/setup-di.php';
$injector->alias(AdminStorage::class, $config['storage']['admin'] ?? FileAdminStorage::class);
$injector->alias(BanStorage::class, $config['storage']['ban'] ?? FileBanStorage::class);
$injector->alias(KeyValueStorage::class, $config['storage']['keyvalue'] ?? FileKeyValueStorage::class);
$injector->alias(KeyValueStorageFactory::class, ($config['storage']['keyvalue'] ?? FileKeyValueStorage::class) . 'Factory');
$injector->alias(PluginStorage::class, $config['storage']['plugin'] ?? FilePluginStorage::class);
$injector->alias(RoomStorage::class, $config['storage']['room'] ?? FileRoomStorage::class);
$injector->define(BitlyClient::class, [':accessToken' => $config['bitly']['accessToken']]);
$injector->define(TwitterApplicationCredentials::class, [':key' => $config['twitter']['consumerKey'], ':secret' => $config['twitter']['consumerSecret']]);
$injector->define(TranslationAPICredentials::class, [':clientId' => $config['ms-translate']['client-id'] ?? '', ':clientSecret' => $config['ms-translate']['client-secret'] ?? '']);
$injector->define(WebSocketEventDispatcher::class, [':devMode' => $config['dev-mode']['enable'] ?? false]);
$injector->delegate(Logger::class, function () use($config) {
$flags = array_map('trim', explode('|', $config['logging']['level'] ?? ''));
if (empty($flags[0])) {
$flags = LogLevel::ALL;
} else {
$flags = array_reduce($flags, function ($carry, $flag) {
return $carry | constant(LogLevel::class . "::{$flag}");
}, 0);
}
$logger = $config['logging']['handler'] ?? StdOutLogger::class;
return new $logger($flags, ...array_values($config['logging']['params'] ?? []));
});
// Check for deployment configuration
$env = __DIR__ . '/../.env';
if (!is_file($env)) {
echo 'Missing .env configuration! Please run the following:' . PHP_EOL . PHP_EOL . 'cp example.env .env && $EDITOR .env' . PHP_EOL;
exit(1);
}
// Include Composer autoloader
require __DIR__ . '/../vendor/autoload.php';
use Auryn\Injector;
use josegonzalez\Dotenv\Loader as EnvLoader;
use Spark\Configuration\DefaultConfigurationSet;
use Spark\Configuration\PlatesResponderConfiguration;
use Shadowhand\RadioTide\Configuration\MiddlewareConfiguration;
use Shadowhand\RadioTide\Configuration\ResponderConfiguration;
use Shadowhand\RadioTide\Configuration\RoutingConfiguration;
use Shadowhand\RadioTide\Configuration\PlatesSessionConfiguration;
use Shadowhand\RadioTide\Configuration\SessionConfiguration;
// Load deployment configuration
$config = (new EnvLoader($env))->parse()->toArray();
// Configure the dependency injection container
$injector = new Injector();
// Set the template directory for Plates
$injector->define('League\\Plates\\Engine', [':directory' => realpath(__DIR__ . '/../templates')]);
// Set configuration for Rdio OAuth
$injector->define('AdamPaterson\\OAuth2\\Client\\Provider\\Rdio', [':options' => ['clientId' => $config['rdio_client_id'], 'clientSecret' => $config['rdio_client_secret'], 'redirectUri' => Shadowhand\RadioTide\get_server_url() . '/login/rdio']]);
// Set configuration for Tidal API
$injector->define('Shadowhand\\RadioTide\\TidalClient', [':token' => $config['tidal_token']]);
// Apply additional configuration
(new DefaultConfigurationSet([MiddlewareConfiguration::class, ResponderConfiguration::class, RoutingConfiguration::class, PlatesResponderConfiguration::class, PlatesSessionConfiguration::class, SessionConfiguration::class]))->apply($injector);
// Bootstrap the application
call_user_func($injector->make('Relay\\Relay'), $injector->make('Psr\\Http\\Message\\ServerRequestInterface'), $injector->make('Psr\\Http\\Message\\ResponseInterface'));
/**
* @inheritDoc
*/
public function apply(Injector $injector)
{
$injector->alias(LoggerInterface::class, Logger::class);
$injector->share(Logger::class);
$injector->define(Logger::class, [':name' => $this->env->getValue('LOGGER_NAME', 'equip')]);
}
/**
* @param string $offset
* @param mixed $value
*/
public function offsetSet($offset, $value)
{
$this->injector->define($offset, (array) $value);
}
