League\JsonReference\LoaderManager

Complexity

Total Complexity

14

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

93.55%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	hasLoader()	0	4	1
A	__construct()	0	15	4
A	registerLoader()	0	4	1
A	getLoaders()	0	4	1
A	getLoader()	0	8	2
A	registerDefaultFileLoader()	0	4	1
A	registerDefaultWebLoaders()	0	10	2
A	getDecoderManager()	0	4	1
A	setDecoderManager()	0	6	1

<?php

namespace League\JsonReference;

use League\JsonReference\DecoderManager;
use League\JsonReference\Loader\CurlWebLoader;
use League\JsonReference\Loader\FileGetContentsWebLoader;
use League\JsonReference\Loader\FileLoader;

final class LoaderManager
{
    /**
     * @var LoaderInterface[]
     */
    private $loaders = [];
    
    /**
     * @var DecoderManager
     */
    private $decoderManager = [];

    /**
     * @param LoaderInterface[] $loaders
     */
    public function __construct(array $loaders = [], DecoderManager $decoderManager = null)
    {
        if (empty($loaders)) {
            $this->registerDefaultFileLoader();
            $this->registerDefaultWebLoaders();
        }
        
        if (empty($decoderManager)) {
            $this->decoderManager = new DecoderManager();
        }

        foreach ($loaders as $prefix => $loader) {
            $this->registerLoader($prefix, $loader);
        }
    }

    /**
     * Register a LoaderInterface for the given prefix.
     *
     * @param string          $prefix
     * @param LoaderInterface $loader
     */
    public function registerLoader($prefix, LoaderInterface $loader)
    {
        $this->loaders[$prefix] = $loader;
    }

    /**
     * Get all registered loaders, keyed by the prefix they are registered to load schemas for.
     *
     * @return LoaderInterface[]
     */
    public function getLoaders()
    {
        return $this->loaders;
    }

    /**
     * Get the loader for the given prefix.
     *
     * @param string $prefix
     *
     * @return LoaderInterface
     * @throws \InvalidArgumentException
     */
    public function getLoader($prefix)
    {
        if (!$this->hasLoader($prefix)) {
            throw new \InvalidArgumentException(sprintf('A loader is not registered for the prefix "%s"', $prefix));
        }

        return $this->loaders[$prefix];
    }

    /**
     * @param string $prefix
     *
     * @return bool
     */
    public function hasLoader($prefix)
    {
        return isset($this->loaders[$prefix]);
    }

    /**
     * Register the default file loader.
     */
    private function registerDefaultFileLoader()
    {
        $this->loaders['file'] = new FileLoader();
    }
    
    /**
     * Register the default web loaders.  If the curl extension is loaded,
     * the CurlWebLoader will be used.  Otherwise the FileGetContentsWebLoader
     * will be used.  You can override this by registering your own loader
     * for the 'http' and 'https' protocols.
     */
    private function registerDefaultWebLoaders()
    {
        if (function_exists('curl_init')) {
            $this->loaders['https'] = new CurlWebLoader('https://');
            $this->loaders['http']  = new CurlWebLoader('http://');
        } else {
            $this->loaders['https'] = new FileGetContentsWebLoader('https://');
            $this->loaders['http']  = new FileGetContentsWebLoader('http://');
        }
    }

    /**
     * @return DecoderManager
     */
    public function getDecoderManager()
    {
        return $this->decoderManager;
    }

    /**
     * @param \League\JsonReference\DecoderManager $decoderManager
     *
     * @return \League\JsonReference\LoaderManager
     */
    public function setDecoderManager(DecoderManager $decoderManager)
    {
        $this->decoderManager = $decoderManager;

        return $this;
    }
}