Behapi\Container

Complexity

Total Complexity

15

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	has()	0	15	2
C	get()	0	27	7
A	getHttpClient()	0	15	1
A	getTwigService()	0	14	2
A	resolveAlias()	0	18	2

<?php
namespace Behapi;

use Twig_Environment;
use Twig_Loader_Array;

use Psr\Http\Message\UriInterface;
use Interop\Container\ContainerInterface;

use Http\Message\UriFactory;
use Http\Message\StreamFactory;
use Http\Message\MessageFactory;

use Http\Discovery\HttpClientDiscovery;
use Http\Discovery\UriFactoryDiscovery;
use Http\Discovery\StreamFactoryDiscovery;
use Http\Discovery\MessageFactoryDiscovery;

use Http\Client\HttpClient;
use Http\Client\Common\PluginClient;
use Http\Client\Common\Plugin\BaseUriPlugin;
use Http\Client\Common\Plugin\HistoryPlugin;
use Http\Client\Common\Plugin\ContentLengthPlugin;

use Behapi\Tools\Debug;
use Behapi\Tools\HttpHistory;

use Behapi\ServiceContainer\NotFoundException;
use Behapi\ServiceContainer\ServiceNotAvailableException;

class Container implements ContainerInterface
{
    /** @var object[] Instantiated services */
    private $services = [];

    /** @var string BaseURL for api requests */
    private $baseUrl;

    /** @var mixed[] Twig configuration (if needed) */
    private $twigConfig = [];

    /** @var Debug Debug status */
    private $debug;

    /** @var HttpHistory Latest requests / responses made */
    private $history;

    public function __construct(HttpHistory $history, Debug $debug, string $baseUrl, array $twigConfig = [])
    {
        $this->debug = $debug;
        $this->history = $history;

        $this->baseUrl = $baseUrl;
        $this->twigConfig = $twigConfig;
    }

    /** {@inheritDoc} */
    public function has($id)
    {
        static $services = [
            HttpClient::class,
            HttpHistory::class,
            StreamFactory::class,
            MessageFactory::class,
        ];

        if (class_exists(Twig_Environment::class)) {
            $services[] = Twig_Environment::class;
        }

        return in_array($id, $services);
    }

    /** {@inheritDoc} */
    public function get($id)
    {
        $id = $this->resolveAlias($id);

        if (array_key_exists($id, $this->services)) {
            return $this->services[$id];
        }

        switch ($id) {
            case HttpHistory::class:
                return $this->history;

            case HttpClient::class:
                return $this->services[HttpClient::class] = $this->getHttpClient();

            case MessageFactory::class:
                return $this->services[MessageFactory::class] = MessageFactoryDiscovery::find();

            case StreamFactory::class:
                return $this->services[StreamFactory::class] = StreamFactoryDiscovery::find();

            case Twig_Environment::class:
                return $this->services[Twig_Environment::class] = $this->getTwigService();
        }

        throw new NotFoundException($id);
    }

    private function getHttpClient(): HttpClient
    {
        $uriFactory = UriFactoryDiscovery::find();
        $baseUri = $uriFactory->createUri($this->baseUrl);

        $plugins = [
            new ContentLengthPlugin,
            new BaseUriPlugin($baseUri),
            new HistoryPlugin($this->history)
        ];

        $http = HttpClientDiscovery::find();

        return new PluginClient($http, $plugins);
    }

    private function getTwigService(): ?Twig_Environment
    {
        if (!class_exists(Twig_Environment::class)) {
            return null;
        }

        $options = [
            'debug' => $this->debug->getStatus(),
            'cache' => $this->twigConfig['cache'] ?? false,
            'autoescape' => $this->twigConfig['autoescape'] ?? false,
        ];

        return new Twig_Environment(new Twig_Loader_Array, $options);
    }

    private function resolveAlias(string $id): string
    {
        static $aliases = [
            'twig' => Twig_Environment::class,
            'http.client' => HttpClient::class,
            'http.history' => HttpHistory::class,
            'http.stream_factory' => StreamFactory::class,
            'http.message_factory' => MessageFactory::class,
        ];

        if (isset($aliases[$id])) {
            @trigger_error("Using {$id} is deprecated and will be removed, use {$aliases[$id]} instead", E_USER_DEPRECATED);

            return $aliases[$id];
        }

        return $id;
    }
}