Saltwater\Salt\Module

Complexity

Total Complexity

23

Size/Duplication

Total Lines	191
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	5

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	14	3
A	ensureRequires()	0	10	3
A	registerProvides()	0	12	4
A	registerProvide()	0	6	1
A	has()	0	4	1
A	provider()	0	14	2
A	makeProvider()	0	6	2
A	doesProvide()	0	4	1
A	masterContext()	0	8	2
A	getName()	0	10	2
A	getNamespace()	0	10	2

<?php

namespace Saltwater\Salt;

use Saltwater\Server as S;
use Saltwater\Utils as U;
use Saltwater\Salt\Provider;

/**
 * Modules encapsulate salts
 *
 * @package Saltwater\Salt
 */
class Module
{
    /** @var string Can be used to override the automatically generated value */
    public static $name;

    /** @var string Can be used to override the automatically generated value */
    public static $namespace;

    /**
     * @var array Requirements that need to be in place for this module
     */
    protected $require = array();

    /**
     * @var array Salts that this module provides
     */
    protected $provide = array();

    /**
     * @var int bitmask of Salts passed to the registry
     */
    public $registry = 0;

    /**
     * @param string $name
     *
     * @return void
     */
    public function register($name)
    {
        $name = 'module.' . $name;

        if (S::$n->registry->exists($name) || $this->registry) {
            return;
        }

        $this->ensureRequires();

        $this->registry |= S::$n->registry->append($name);

        $this->registerProvides();
    }

    /**
     * Make sure all required modules are loaded
     *
     * @return void
     */
    private function ensureRequires()
    {
        if (empty($this->require['module'])) {
            return;
        }

        foreach ($this->require['module'] as $module) {
            S::$n->modules->append($module, true);
        }
    }

    /**
     * Register all salts the module provides
     *
     * @return void
     */
    private function registerProvides()
    {
        if (empty($this->provide)) {
            return;
        }

        foreach ($this->provide as $type => $content) {
            foreach ($content as $salt) {
                $this->registerProvide($type, $salt);
            }
        }
    }

    /**
     * Register a salt that this module provides
     *
     * @param $type
     * @param $salt
     *
     * @return void
     */
    private function registerProvide($type, $salt)
    {
        $this->registry |= S::$n->registry->append(
            $type . '.' . U::camelTodashed($salt)
        );
    }

    /**
     * Check whether the module contains a salt
     *
     * @param $bit
     *
     * @return bool
     */
    public function has($bit)
    {
        return ($this->registry & $bit) == $bit;
    }

    /**
     * Create a new provider instance
     *
     * @param string $type
     * @param string $caller
     *
     * @return Provider
     */
    public function provider($caller, $type)
    {
        $class = $this->makeProvider($type);

        if ($class === false) {
            return false;

The return type of return false; (false) is incompatible with the return type documented by Saltwater\Salt\Module::provider of type Saltwater\Salt\Provider.

        }

        $class::setModule($this::getName());

        $class::setCaller($caller);

        return new $class;
    }

    /**
     * @param string $type
     *
     * @return false|Provider
     */
    private function makeProvider($type)
    {
        $class = U::className($this::getNamespace(), 'provider', $type);

        return class_exists($class) ? $class : false;
    }

    /**
     * Check whether this module provides a salt
     *
     * @return bool
     */
    public function doesProvide($salt)
    {
        return !empty($this->provide[$salt]);
    }

    /**
     * Return the master context for this module
     *
     * @return null|string
     */
    public function masterContext()
    {
        if (!$this->doesProvide('context')) {
            return null;
        }

        return U::camelTodashed($this->provide['context'][0]);
    }

    /**
     * @return string
     */
    public static function getName()
    {
        $class = get_called_class();

        if (!empty($class::$name)) {
            return $class::$name;
        }

        return U::namespacedClassToDashed($class);
    }

    /**
     * @return string
     */
    public static function getNamespace()
    {
        $class = get_called_class();

        if (!empty($class::$namespace)) {
            return $class::$namespace;
        }

        return U::namespaceFromClass($class);
    }
}