EventEspresso\core\services\loaders\CoreLoader

Complexity

Total Complexity

12

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	2
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	3
A	reset()	0	6	2
C	load()	0	40	7

<?php

namespace EventEspresso\core\services\loaders;

use EE_Error;
use EE_Registry;
use EventEspresso\core\exceptions\InvalidClassException;
use EventEspresso\core\exceptions\InvalidDataTypeException;
use EventEspresso\core\exceptions\InvalidIdentifierException;
use EventEspresso\core\services\container\CoffeeMaker;
use EventEspresso\core\services\container\CoffeeShop;
use EventEspresso\core\services\container\exceptions\InstantiationException;
use EventEspresso\core\services\container\exceptions\ServiceExistsException;
use EventEspresso\core\services\container\exceptions\ServiceNotFoundException;
use InvalidArgumentException;
use OutOfBoundsException;
use ReflectionException;

defined('EVENT_ESPRESSO_VERSION') || exit;



/**
 * Class CoreLoader
 * Currently uses EE_Registry for instantiating classes,
 * but will later be replaced by the CoffeeShop DI container
 *
 * @package       Event Espresso
 * @author        Brent Christensen
 * @since         $VID:$
 */
class CoreLoader implements LoaderDecoratorInterface
{

    /**
     * @var EE_Registry|CoffeeShop $generator
     */
    private $generator;



    /**
     * CoreLoader constructor.
     *
     * @param EE_Registry|CoffeeShop $generator
     * @throws InvalidArgumentException
     */
    public function __construct($generator)
    {
        if(!($generator instanceof EE_Registry || $generator instanceof CoffeeShop)) {
            throw new InvalidArgumentException(
                esc_html__(
                    'The CoreLoader class must receive an instance of EE_Registry or the CoffeeShop DI container.',
                    'event_espresso'
                )
            );
        }
        $this->generator = $generator;
    }



    /**
     * Calls the appropriate loading method from the installed generator;
     * If EE_Registry is being used, then the additional parameters for the EE_Registry::create() method
     * can be added to the $arguments array and they will be extracted and passed to EE_Registry::create(),
     * but NOT to the class being instantiated.
     * This is done by adding the parameters to the $arguments array as follows:
     *  array(
     *      'EE_Registry::create(from_db)'   => true, // boolean value, default = false
     *      'EE_Registry::create(load_only)' => true, // boolean value, default = false
     *      'EE_Registry::create(addon)'     => true, // boolean value, default = false
     *  )
     *
     * @param string $fqcn
     * @param array  $arguments
     * @param bool   $shared
     * @return mixed
     * @throws OutOfBoundsException
     * @throws ServiceExistsException
     * @throws InstantiationException
     * @throws InvalidIdentifierException
     * @throws InvalidDataTypeException
     * @throws InvalidClassException
     * @throws EE_Error
     * @throws ServiceNotFoundException
     * @throws ReflectionException
     */
    public function load($fqcn, $arguments = array(), $shared = true)
    {
        $shared = filter_var($shared, FILTER_VALIDATE_BOOLEAN);
        if($this->generator instanceof EE_Registry) {
            // check if additional EE_Registry::create() arguments have been passed
            // from_db
            $from_db = isset($arguments['EE_Registry::create(from_db)'])
                ? filter_var($arguments['EE_Registry::create(from_db)'], FILTER_VALIDATE_BOOLEAN)
                : false;
            // load_only
            $load_only = isset($arguments['EE_Registry::create(load_only)'])
                ? filter_var($arguments['EE_Registry::create(load_only)'], FILTER_VALIDATE_BOOLEAN)
                : false;
            // addon
            $addon = isset($arguments['EE_Registry::create(addon)'])
                ? filter_var($arguments['EE_Registry::create(addon)'], FILTER_VALIDATE_BOOLEAN)
                : false;
            unset(
                $arguments['EE_Registry::create(from_db)'],
                $arguments['EE_Registry::create(load_only)'],
                $arguments['EE_Registry::create(addon)']
            );
            // addons need to be cached on EE_Registry
            $shared = $addon ? true : $shared;
            return $this->generator->create(
                $fqcn,
                $arguments,
                $shared,
                $from_db,
                $load_only,
                $addon
            );
        }
        return $this->generator->brew(
            $fqcn,
            $arguments,
            $shared ? CoffeeMaker::BREW_SHARED : CoffeeMaker::BREW_NEW
        );

    }



    /**
     * calls reset() on generator if method exists
     *
     * @throws EE_Error
     * @throws ReflectionException
     */
    public function reset()
    {
        if (method_exists($this->generator, 'reset')) {
            $this->generator->reset();

The method reset does only exist in EE_Registry, but not in EventEspresso\core\services\container\CoffeeShop.

        }
    }

}
// End of file CoreLoader.php
// Location: core/services/loaders/CoreLoader.php