PPI\Framework\ServiceManager\Config\ServiceManagerConfig

Complexity

Total Complexity

16

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

2 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	22	6
C	configureServiceManager()	0	48	10

<?php
/**
 * This file is part of the PPI Framework.
 *
 * @copyright   Copyright (c) 2012 Paul Dragoonis <paul@ppi.io>
 * @license     http://opensource.org/licenses/mit-license.php MIT
 *
 * @link        http://www.ppi.io
 */

namespace PPI\Framework\ServiceManager\Config;

use Zend\ServiceManager\ConfigInterface;
use Zend\ServiceManager\ServiceLocatorAwareInterface;
use Zend\ServiceManager\ServiceManager;
use Zend\ServiceManager\ServiceManagerAwareInterface;

/**
 * @author     Vítor Brandão <vitor@ppi.io>
 */
class ServiceManagerConfig implements ConfigInterface
{
    /**
     * Services that can be instantiated without factories.
     *
     * @var array
     */
    protected $invokables = array(
        'SharedEventManager' => 'Zend\EventManager\SharedEventManager',
    );

    /**
     * Service factories.
     *
     * @var array
     */
    protected $factories = array(
        'Config'                => 'PPI\Framework\ServiceManager\Factory\ConfigFactory',
        'EventManager'          => 'PPI\Framework\ServiceManager\Factory\EventManagerFactory',
        'ModuleDefaultListener' => 'PPI\Framework\ServiceManager\Factory\ModuleDefaultListenerFactory',
        'ModuleManager'         => 'PPI\Framework\ServiceManager\Factory\ModuleManagerFactory',
    );

    /**
     * Abstract factories.
     *
     * @var array
     */
    protected $abstractFactories = array();

    /**
     * Aliases.
     *
     * @var array
     */
    protected $aliases = array(
        'Zend\EventManager\EventManagerInterface'       => 'EventManager',
        'Zend\ServiceManager\ServiceLocatorInterface'   => 'ServiceManager',
        'Zend\ServiceManager\ServiceManager'            => 'ServiceManager',
    );

    /**
     * Shared services.
     *
     * Services are shared by default; this is primarily to indicate services
     * that should NOT be shared
     *
     * @var array
     */
    protected $shared = array(
        'EventManager' => false,
    );

    /**
     * Constructor.
     *
     * Merges internal arrays with those passed via configuration
     *
     * @param array $configuration
     */
    public function __construct(array $configuration = array())
    {
        if (isset($configuration['invokables'])) {
            $this->invokables = array_merge($this->invokables, $configuration['invokables']);
        }

        if (isset($configuration['factories'])) {
            $this->factories = array_merge($this->factories, $configuration['factories']);
        }

        if (isset($configuration['abstract_factories'])) {
            $this->abstractFactories = array_merge($this->abstractFactories, $configuration['abstract_factories']);
        }

        if (isset($configuration['aliases'])) {
            $this->aliases = array_merge($this->aliases, $configuration['aliases']);
        }

        if (isset($configuration['shared'])) {
            $this->shared = array_merge($this->shared, $configuration['shared']);
        }
    }

    /**
     * Configure the provided service manager instance with the configuration
     * in this class.
     *
     * In addition to using each of the internal properties to configure the
     * service manager, also adds an initializer to inject ServiceManagerAware
     * and ServiceLocatorAware classes with the service manager.
     *
     * @param ServiceManager $serviceManager
     */
    public function configureServiceManager(ServiceManager $serviceManager)
    {
        foreach ($this->invokables as $name => $class) {
            $serviceManager->setInvokableClass($name, $class);
        }

        foreach ($this->factories as $name => $factoryClass) {
            $serviceManager->setFactory($name, $factoryClass);
        }

        foreach ($this->abstractFactories as $factoryClass) {
            $serviceManager->addAbstractFactory($factoryClass);
        }

        foreach ($this->aliases as $name => $service) {
            $serviceManager->setAlias($name, $service);
        }

        foreach ($this->shared as $name => $value) {
            $serviceManager->setShared($name, $value);
        }

        $serviceManager->addInitializer(function ($instance) use ($serviceManager) {
            if ($instance instanceof EventManagerAwareInterface) {

The class PPI\Framework\ServiceManager\Config\EventManagerAwareInterface does not exist. Did you forget a USE statement, or did you not list all dependencies?

                if ($instance->getEventManager() instanceof EventManagerInterface) {

The class PPI\Framework\ServiceManager\Config\EventManagerInterface does not exist. Did you forget a USE statement, or did you not list all dependencies?

                    $instance->getEventManager()->setSharedManager(
                        $serviceManager->get('SharedEventManager')
                    );
                } else {
                    $instance->setEventManager($serviceManager->get('EventManager'));
                }
            }
        });

        $serviceManager->addInitializer(function ($instance) use ($serviceManager) {
            if ($instance instanceof ServiceManagerAwareInterface) {
                $instance->setServiceManager($serviceManager);
            }
        });

        $serviceManager->addInitializer(function ($instance) use ($serviceManager) {
            if ($instance instanceof ServiceLocatorAwareInterface) {
                $instance->setServiceLocator($serviceManager);
            }
        });

        $serviceManager->setService('ServiceManager', $serviceManager);
    }
}