Registry::hasValue() - Code Metrics - Inspection of "Worked on extracting and parsing the configuration..." - Mediadevs/Validator - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Branch — 1.0 (4bdad9)

by Mike
created 2019-12-09 15:32 UTC
Registry::hasValue() A

↳ Parent: Registry
Complexity

Conditions	3
Paths	3
Size

Total Lines	10
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	12
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	4
c	1
b	0
f	0
dl	0
loc	10
ccs	0
cts	7
cp	0
rs	10
cc	3
nc	3
nop	2
crap	12
<?php

namespace Mediadevs\Validator\Helpers;

use ReflectionException;
use Mediadevs\Validator\Services\FilterProvider;

class Registry
{
    /**
     * The registry types for this library, these are de default properties for each filter class.
     */
    public const REGISTRY_TYPES = array('filters', 'aliases', 'messages');

    /**
     * All the registered classes will be stored in here.
     *
     * @var array
     */
    private $registry = array(
        'filters'   => array(),
        'messages'  => array(),
    );

    /**
     * Loading all the classes from \Services\FilterProvider and parsing the filters to collect the configuration
     * Using te previously collected configuration to generate a registry which can be used for validation.
     *
     * @return bool
     * @throws ReflectionException
     */
    public function load(): bool
    {
        // Parsing through all the providers
       foreach (FilterProvider::collect() as $provider) {
           $filter = new ExtractFilters($provider);

           // Registering the properties
           $this->registry['filters'] += $filter->getFilters();
           $this->registry['messages'] += $filter->getMessages();
       }

       return true;
    }

    /**
     * Collecting the registry based upon the given target.
     *
     * @param string $type
     * @param string $index
     *
     * @return string|void
     */
    public function getRegistry(string $type, string $index): string
    {
        $targetIndex = null;

        // Whether the type exists inside the $data array
        if (self::hasType($type)) {
        if (self::/** @scrutinizer ignore-call */ hasType($type)) {

            // Whether the $data array has the given index
            if (self::hasIndex($type, $index)) {
            if (self::/** @scrutinizer ignore-call */ hasIndex($type, $index)) {
                $targetIndex = $index;
            }

            // In this case the $data array has no index of $index, now we'll try to reverse search by value
            if (self::hasValue($type, $index)) {
            if (self::/** @scrutinizer ignore-call */ hasValue($type, $index)) {
                $targetIndex = self::getIndexByValue($type, $index);
                $targetIndex = self::getIndexByValue($type, $index);
            }
        }

        return self::getValuesByIndex($type, $targetIndex);
        return self::/** @scrutinizer ignore-call */ getValuesByIndex($type, $targetIndex);
    }

    /**
     * Whether the given type is a valid one.
     *
     * @param string $type
     *
     * @return bool
     */
    public function isValidType(string $type): bool
    {
        return (bool) in_array($type, self::REGISTRY_TYPES) ? true : false;
    }

    /**
     * Validating whether registry contains the given type.
     *
     * @param string $type
     *
     * @return bool
     */
    public function hasType(string $type): bool
    {
        // Whether the given type is a valid one.
        if (self::isValidType($type)) {
        if (self::/** @scrutinizer ignore-call */ isValidType($type)) {
            return (bool) array_key_exists($type, $this->registry) ? true : false;
        }

        return (bool) false;
    }

    /**
     * Validating whether the data contains the given index.
     *
     * @param string $type
     * @param string $index
     *
     * @return bool
     */
    public function hasIndex(string $type, string $index): bool
    {
        if (self::hasType($type)) {
        if (self::/** @scrutinizer ignore-call */ hasType($type)) {
            return (bool) array_key_exists($index, $this->registry[$type]) ? true : false;
        }

        return (bool) false;
    }

    /**
     * Validating whether the data contains the given value.
     *
     * @param string $type
     * @param string $value
     *
     * @return bool
     */
    public function hasValue(string $type, string $value): bool
    {
        if (self::hasType($type)) {
        if (self::/** @scrutinizer ignore-call */ hasType($type)) {
            // Reversing the data array; ['key' => 'value'] will now be ['value' => 'key']
            $reverseData = array_flip($this->registry[$type]);

            return (bool) (isset($reverseData[$value])) ? true : false;
        }

        return (bool) false;
    }

    /**
     * Validating whether the given index has a value.
     *
     * @param string $type
     * @param string $index
     *
     * @return bool
     */
    public function indexHasValue(string $type, string $index): bool
    {
        if (self::hasType($type) && self::hasIndex($type, $index)) {
        if (self::hasType($type) && self::/** @scrutinizer ignore-call */ hasIndex($type, $index)) {
            return (bool) !empty($this->registry[$type][$index]) ? true : false;
        }

        return (bool) false;
    }

    /**
     * Collecting the index by the given value.
     *
     * @param string $type
     * @param string $value
     *
     * @return string|void
     */
    public function getIndexByValue(string $type, string $value)
    {
        if (self::hasType($type) && self::hasValue($type, $value)) {
        if (self::hasType($type) && self::/** @scrutinizer ignore-call */ hasValue($type, $value)) {
            // Reversing the data array; ['key' => 'value'] will now be ['value' => 'key']
            $reverseData = array_flip($this->registry[$type]);

            return $reverseData[$type][$value];
        }
    }

    /**
     * Collecting multiple values based on the given index.
     *
     * @param string $type
     * @param string $index
     *
     * @return array|void
     */
    public function getValuesByIndex(string $type, string $index)
    {
        if (self::hasType($type) && self::hasIndex($type, $index) && self::indexHasValue($type, $index)) {
        if (self::hasType($type) && self::hasIndex($type, $index) && self::/** @scrutinizer ignore-call */ indexHasValue($type, $index)) {
            return $this->registry[$type][$index];
        }
    }
}

Mediadevs / Validator

Branch — 1.0 (4bdad9)

Registry::hasValue() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
