N98\Magento\Command\System\Check\Settings\CheckAbstract

Complexity

Total Complexity

9

Size/Duplication

Total Lines	96
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
	initConfigPaths()	0	1	?
A	registerStoreConfigPath()	0	4	1
A	__construct()	0	6	1
B	check()	0	38	5
A	getParamValues()	0	13	2

<?php
/*
 * @author Tom Klingenberg <mot@fsfe.org>
 */

namespace N98\Magento\Command\System\Check\Settings;

use Magento\Framework\App\Config\ScopeConfigInterface;
use Magento\Store\Api\Data\StoreInterface;
use Magento\Store\Model\ScopeInterface;
use N98\Magento\Command\System\Check\ResultCollection;
use N98\Magento\Command\System\Check\StoreCheck;

/**
 * Class CheckAbstract
 *
 * @package N98\Magento\Command\System\Check\Settings
 */
abstract class CheckAbstract implements StoreCheck
{
    /**
     * @var array
     */
    private $storeConfigPaths = array();

    /**
     * @var ScopeConfigInterface
     */
    private $scopeConfig;

    /**
     * @param ScopeConfigInterface $scopeConfig
     */
    final public function __construct(ScopeConfigInterface $scopeConfig)
    {
        $this->scopeConfig = $scopeConfig;

        $this->initConfigPaths();
    }

    abstract protected function initConfigPaths();

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    /**
     * @param string $name
     * @param string $configPath
     */
    protected function registerStoreConfigPath($name, $configPath)
    {
        $this->storeConfigPaths[$name] = $configPath;
    }

    /**
     * @param ResultCollection       $results
     * @param StoreInterface $store
     *
     */
    public function check(ResultCollection $results, StoreInterface $store)
    {
        $result = $results->createResult();

        $typedParams = array(
            'result' => $result,
            'store'  => $store,
        );

        $paramValues = $this->getParamValues($store, $typedParams);


        $name       = 'checkSettings';
        $method     = new \ReflectionMethod($this, $name);
        $parameters = $method->getParameters();

        $arguments = array();
        foreach ($parameters as $parameter) {
            $paramName  = $parameter->getName();
            $paramClass = $parameter->getClass();

            // create named parameter from type-hint if applicable
            if ($paramClass) {
                foreach ($typedParams as $object) {
                    if ($paramClass->isSubclassOf(get_class($object))) {
                        $paramValues[$paramName] = $object;
                        break;
                    }
                }
            }

            // use named parameter, otherwise null
            $paramValues += array($paramName => null);
            $arguments[] = $paramValues[$paramName];
        }

        call_user_func_array(array($this, $name), $arguments);
    }

    /**
     * @param StoreInterface $store
     * @param array $typedParams
     * @return array
     */
    private function getParamValues(StoreInterface $store, array $typedParams)
    {
        $paramValues = $this->storeConfigPaths;

        foreach ($paramValues as $name => $path) {
            $value = $this->scopeConfig->getValue($path, ScopeInterface::SCOPE_STORE, $store->getCode());
            $paramValues[$name] = $value;
        }

        $paramValues = $typedParams + $paramValues;

        return $paramValues;
    }
}