PHP Injector::alias方法代碼示例

 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}
  *
  * @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->alias(RequestInterface::class, ServerRequest::class);
     $injector->alias(ResponseInterface::class, Response::class);
     $injector->alias(ServerRequestInterface::class, ServerRequest::class);
     $injector->delegate(ServerRequest::class, [ServerRequestFactory::class, 'fromGlobals']);
 }

 /**
  * @inheritDoc
  */
 public function apply(Injector $injector)
 {
     $injector->alias('Psr\\Http\\Message\\RequestInterface', 'Zend\\Diactoros\\ServerRequest');
     $injector->alias('Psr\\Http\\Message\\ResponseInterface', 'Zend\\Diactoros\\Response');
     $injector->alias('Psr\\Http\\Message\\ServerRequestInterface', 'Zend\\Diactoros\\ServerRequest');
     $injector->delegate('Zend\\Diactoros\\ServerRequest', 'Zend\\Diactoros\\ServerRequestFactory::fromGlobals');
 }

 /**
  * 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);
 }

 /**
  * @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']);
 }

 public function __construct(JigConfig $jigConfig, Injector $injector, JigConverter $jigConverter = null, Escaper $escaper = null)
 {
     parent::__construct($jigConfig, $jigConverter);
     $this->injector = $injector;
     $this->injector->alias('Jig\\Jig', get_class($this));
     $this->injector->share($this);
     if ($escaper === null) {
         $escaper = new ZendEscaperBridge(new ZendEscaper());
     }
     $this->injector->alias('Jig\\Escaper', get_class($escaper));
     $this->injector->share($escaper);
     $this->escaper = $escaper;
 }

 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);
 }

 /**
  * 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);
 }

/**
 * @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 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 apply(Injector $injector)
 {
     $injector->alias(Collection::class, DefaultCollection::class);
     $injector->prepare(Collection::class, function (Collection $collection) {
         $middleware = $collection->getArrayCopy();
         // Do session checking before routing
         array_splice($middleware, array_search(RouteHandler::class, $middleware), 0, CheckSessionMiddleware::class);
         $collection->exchangeArray($middleware);
     });
 }

 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());
 }

 /**
  * Applies a configuration set to a dependency injector.
  *
  * @param Injector $injector
  */
 public function apply(Injector $injector)
 {
     foreach (self::$commandHandlerMapping as $command => $handler) {
         $injector->alias($command, $handler);
     }
     $injector->delegate(CommandBus::class, function () use($injector) {
         $handlerMiddleware = new CommandHandlerMiddleware(new ClassNameExtractor(), new CallableLocator([$injector, 'make']), new HandleInflector());
         $lockingMiddleware = new LockingMiddleware();
         $transactionMiddleware = new TransactionMiddleware($injector->make(EntityManager::class));
         return new CommandBus([$transactionMiddleware, $lockingMiddleware, $handlerMiddleware]);
     });
 }

 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());
 }