BlockInterpreter - Code Metrics - Inspection of "0.7.0" - limoncello-php-dist/validation - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 22fd50...798002 )

by Neomerx

created 2017-08-14 16:25 UTC

BlockInterpreter B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	513
Duplicated Lines	23.2 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

Metric	Value
wmc	48
lcom	1
cbo	6
dl	119
loc	513
rs	8.4864
c	0
b	0
f	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	execute()	0	14	1
A	executeStarts()	15	15	3
A	executeEnds()	15	15	3
A	executeBlock()	0	20	2
B	executeBlockImpl()	0	30	5
A	executeProcedureBlock()	0	18	1
B	executeIfBlock()	0	24	2
A	executeAndBlock()	22	22	2
A	executeOrBlock()	23	23	2
A	getBlocks()	0	7	1
A	getBlocksWithStart()	12	12	2
A	getBlocksWithEnd()	12	12	2
A	getBlockType()	0	8	1
A	captureSuccessfulBlockResultIfEnabled()	0	14	3
A	executeProcedureStart()	10	10	1
A	executeProcedureEnd()	10	10	1
A	addBlockErrors()	0	16	2
B	debugCheckLooksLikeBlocksArray()	0	13	5
A	debugCheckBlocksExist()	0	12	4
B	debugHasKnownBlockType()	0	16	5

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like BlockInterpreter often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use BlockInterpreter, and based on these observations, apply Extract Interface, too.

<?php namespace Limoncello\Validation\Execution;

/**
 * Copyright 2015-2017 [email protected]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use Limoncello\Validation\Contracts\Captures\CaptureAggregatorInterface;
use Limoncello\Validation\Contracts\Errors\ErrorAggregatorInterface;
use Limoncello\Validation\Contracts\Execution\ContextInterface;
use Limoncello\Validation\Contracts\Execution\ContextStorageInterface;
use Limoncello\Validation\Errors\Error;
use Limoncello\Validation\Rules\BaseRule;

/**
 * @package Limoncello\Validation
 *
 * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
 */
final class BlockInterpreter
{
    /**
     * @param mixed                      $input
     * @param array                      $serializedBlocks
     * @param ContextStorageInterface    $context
     * @param CaptureAggregatorInterface $captures
     * @param ErrorAggregatorInterface   $errors
     *
     * @return void
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public static function execute(
        $input,
        array $serializedBlocks,
        ContextStorageInterface $context,
        CaptureAggregatorInterface $captures,
        ErrorAggregatorInterface $errors
    ): void {
        $blockIndex = BlockSerializer::FIRST_BLOCK_INDEX;

        $blocks = static::getBlocks($serializedBlocks);

        static::executeStarts(static::getBlocksWithStart($serializedBlocks), $blocks, $context, $errors);

        static::executeBlock($input, $blockIndex, $blocks, $context, $captures, $errors);
        static::executeEnds(static::getBlocksWithEnd($serializedBlocks), $blocks, $context, $errors);

    }

    /**
     * @param int[]                    $indexes
     * @param array                    $blocks
     * @param ContextStorageInterface  $context
     * @param ErrorAggregatorInterface $errors
     *
     * @return void
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public static function executeStarts(

        array $indexes,
        array $blocks,
        ContextStorageInterface $context,
        ErrorAggregatorInterface $errors
    ): void {
        foreach ($indexes as $index) {
            $context->setCurrentBlockId($index);
            $block      = $blocks[$index];
            $errorsInfo = static::executeProcedureStart($block, $context);

            if (empty($errorsInfo) === false) {
                static::addBlockErrors($errorsInfo, $context, $errors);

            }
        }
    }

    /**
     * @param int[]                    $indexes
     * @param array                    $blocks
     * @param ContextStorageInterface  $context
     * @param ErrorAggregatorInterface $errors
     *
     * @return void
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public static function executeEnds(

        array $indexes,
        array $blocks,
        ContextStorageInterface $context,
        ErrorAggregatorInterface $errors
    ): void {
        foreach ($indexes as $index) {
            $context->setCurrentBlockId($index);
            $block      = $blocks[$index];
            $errorsInfo = static::executeProcedureEnd($block, $context);

            if (empty($errorsInfo) === false) {
                static::addBlockErrors($errorsInfo, $context, $errors);

            }
        }
    }

    /**
     * @param mixed                      $input
     * @param int                        $blockIndex
     * @param array                      $blocks
     * @param ContextStorageInterface    $context
     * @param CaptureAggregatorInterface $captures
     * @param ErrorAggregatorInterface   $errors
     *
     * @return void
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public static function executeBlock(
        $input,
        int $blockIndex,
        array $blocks,
        ContextStorageInterface $context,
        CaptureAggregatorInterface $captures,
        ErrorAggregatorInterface $errors
    ): void {
        $result = static::executeBlockImpl(

            $input,
            $blockIndex,
            $blocks,
            $context,
            $captures
        );
        if (BlockReplies::isResultSuccessful($result) === false) {
            $errorsInfo = BlockReplies::extractResultErrorsInfo($result);
            static::addBlockErrors($errorsInfo, $context, $errors);

        }
    }

    /**
     * @param mixed                      $input
     * @param int                        $blockIndex
     * @param array                      $blocks
     * @param ContextStorageInterface    $context
     * @param CaptureAggregatorInterface $captures
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function executeBlockImpl(
        $input,
        int $blockIndex,
        array $blocks,
        ContextStorageInterface $context,
        CaptureAggregatorInterface $captures
    ): array {
        assert(array_key_exists($blockIndex, $blocks));

        $blockType = static::getBlockType($blocks[$blockIndex]);

        $context->setCurrentBlockId($blockIndex);
        switch ($blockType) {
            case BlockSerializer::TYPE__PROCEDURE:
                $result = static::executeProcedureBlock($input, $blockIndex, $blocks, $context, $captures);

                break;
            case BlockSerializer::TYPE__IF_EXPRESSION:
                $result = static::executeIfBlock($input, $blockIndex, $blocks, $context, $captures);

                break;
            case BlockSerializer::TYPE__AND_EXPRESSION:
                $result = static::executeAndBlock($input, $blockIndex, $blocks, $context, $captures);

                break;
            case BlockSerializer::TYPE__OR_EXPRESSION:
            default:
                assert($blockType === BlockSerializer::TYPE__OR_EXPRESSION);
                $result = static::executeOrBlock($input, $blockIndex, $blocks, $context, $captures);

                break;
        }

        return $result;
    }

    /**
     * @param mixed                      $input
     * @param int                        $blockIndex
     * @param array                      $blocks
     * @param ContextStorageInterface    $context
     * @param CaptureAggregatorInterface $captures
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function executeProcedureBlock(
        $input,
        int $blockIndex,
        array $blocks,
        ContextStorageInterface $context,
        CaptureAggregatorInterface $captures
    ): array {
        $block = $blocks[$blockIndex];
        assert(static::getBlockType($block) === BlockSerializer::TYPE__PROCEDURE);


        $procedure = $block[BlockSerializer::PROCEDURE_EXECUTE_CALLABLE];
        assert(is_callable($procedure));
        $result = call_user_func($procedure, $input, $context);

        static::captureSuccessfulBlockResultIfEnabled($result, $block, $captures);


        return $result;
    }

    /**
     * @param mixed                      $input
     * @param int                        $blockIndex
     * @param array                      $blocks
     * @param ContextStorageInterface    $context
     * @param CaptureAggregatorInterface $captures
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function executeIfBlock(
        $input,
        int $blockIndex,
        array $blocks,
        ContextStorageInterface $context,
        CaptureAggregatorInterface $captures
    ): array {
        $block = $blocks[$blockIndex];
        assert(static::getBlockType($block) === BlockSerializer::TYPE__IF_EXPRESSION);


        $conditionCallable = $block[BlockSerializer::IF_EXPRESSION_CONDITION_CALLABLE];
        assert(is_callable($conditionCallable));
        $conditionResult = call_user_func($conditionCallable, $input, $context);
        assert(is_bool($conditionResult));

        $index = $block[$conditionResult === true ?
            BlockSerializer::IF_EXPRESSION_ON_TRUE_BLOCK : BlockSerializer::IF_EXPRESSION_ON_FALSE_BLOCK];

        $result = static::executeBlockImpl($input, $index, $blocks, $context, $captures);


        static::captureSuccessfulBlockResultIfEnabled($result, $block, $captures);


        return $result;
    }

    /**
     * @param mixed                      $input
     * @param int                        $blockIndex
     * @param array                      $blocks
     * @param ContextStorageInterface    $context
     * @param CaptureAggregatorInterface $captures
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function executeAndBlock(

        $input,
        int $blockIndex,
        array $blocks,
        ContextStorageInterface $context,
        CaptureAggregatorInterface $captures
    ): array {
        $block = $blocks[$blockIndex];
        assert(static::getBlockType($block) === BlockSerializer::TYPE__AND_EXPRESSION);


        $primaryIndex = $block[BlockSerializer::AND_EXPRESSION_PRIMARY];
        $result       = static::executeBlockImpl($input, $primaryIndex, $blocks, $context, $captures);

        if (BlockReplies::isResultSuccessful($result) === true) {
            $nextInput      = BlockReplies::extractResultOutput($result);
            $secondaryIndex = $block[BlockSerializer::AND_EXPRESSION_SECONDARY];
            $result         = static::executeBlockImpl($nextInput, $secondaryIndex, $blocks, $context, $captures);

        }

        static::captureSuccessfulBlockResultIfEnabled($result, $block, $captures);


        return $result;
    }

    /**
     * @param mixed                      $input
     * @param int                        $blockIndex
     * @param array                      $blocks
     * @param ContextStorageInterface    $context
     * @param CaptureAggregatorInterface $captures
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     * @SuppressWarnings(PHPMD.ElseExpression)
     */
    private static function executeOrBlock(

        $input,
        int $blockIndex,
        array $blocks,
        ContextStorageInterface $context,
        CaptureAggregatorInterface $captures
    ): array {
        $block = $blocks[$blockIndex];
        assert(static::getBlockType($block) === BlockSerializer::TYPE__OR_EXPRESSION);


        $primaryIndex      = $block[BlockSerializer::OR_EXPRESSION_PRIMARY];
        $resultFromPrimary = static::executeBlockImpl($input, $primaryIndex, $blocks, $context, $captures);

        if (BlockReplies::isResultSuccessful($resultFromPrimary) === true) {
            $result = $resultFromPrimary;
        } else {
            $secondaryIndex = $block[BlockSerializer::OR_EXPRESSION_SECONDARY];
            $result         = static::executeBlockImpl($input, $secondaryIndex, $blocks, $context, $captures);

        }

        static::captureSuccessfulBlockResultIfEnabled($result, $block, $captures);


        return $result;
    }

    /**
     * @param array $serializedBlocks
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function getBlocks(array $serializedBlocks): array
    {
        $blocks = BlockSerializer::unserializeBlocks($serializedBlocks);
        assert(static::debugCheckLooksLikeBlocksArray($blocks));


        return $blocks;
    }

    /**
     * @param array $serializedBlocks
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function getBlocksWithStart(array $serializedBlocks): array

    {
        $blocksWithStart = BlockSerializer::unserializeBlocksWithStart($serializedBlocks);

        // check result contain only block indexes and the blocks are procedures
        assert(
            is_array($blocks = static::getBlocks($serializedBlocks)) &&

            static::debugCheckBlocksExist($blocksWithStart, $blocks, BlockSerializer::TYPE__PROCEDURE)

        );

        return $blocksWithStart;
    }

    /**
     * @param array $serializedBlocks
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function getBlocksWithEnd(array $serializedBlocks): array

    {
        $blocksWithEnd = BlockSerializer::unserializeBlocksWithEnd($serializedBlocks);

        // check result contain only block indexes and the blocks are procedures
        assert(
            is_array($blocks = static::getBlocks($serializedBlocks)) &&

            static::debugCheckBlocksExist($blocksWithEnd, $blocks, BlockSerializer::TYPE__PROCEDURE)

        );

        return $blocksWithEnd;
    }

    /**
     * @param array $block
     *
     * @return int
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function getBlockType(array $block): int
    {
        assert(static::debugHasKnownBlockType($block));


        $type = $block[BlockSerializer::TYPE];

        return $type;
    }

    /**
     * @param array                      $result
     * @param array                      $block
     * @param CaptureAggregatorInterface $captures
     *
     * @return void
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function captureSuccessfulBlockResultIfEnabled(
        array $result,
        array $block,
        CaptureAggregatorInterface $captures
    ): void {
        if (BlockReplies::isResultSuccessful($result) === true) {
            $isCaptureEnabled = $block[BlockSerializer::PROPERTIES][BaseRule::PROPERTY_IS_CAPTURE_ENABLED] ?? false;
            if ($isCaptureEnabled === true) {
                $name  = $block[BlockSerializer::PROPERTIES][BaseRule::PROPERTY_NAME];
                $value = BlockReplies::extractResultOutput($result);
                $captures->remember($name, $value);
            }
        }
    }

    /**
     * @param array            $procedureBlock
     * @param ContextInterface $context
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function executeProcedureStart(array $procedureBlock, ContextInterface $context): array

    {
        assert(static::getBlockType($procedureBlock) === BlockSerializer::TYPE__PROCEDURE);

        $callable = $procedureBlock[BlockSerializer::PROCEDURE_START_CALLABLE];
        assert(is_callable($callable) === true);
        $errors = call_user_func($callable, $context);
        assert(is_array($errors));

        return $errors;
    }

    /**
     * @param array            $procedureBlock
     * @param ContextInterface $context
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function executeProcedureEnd(array $procedureBlock, ContextInterface $context): array

    {
        assert(static::getBlockType($procedureBlock) === BlockSerializer::TYPE__PROCEDURE);

        $callable = $procedureBlock[BlockSerializer::PROCEDURE_END_CALLABLE];
        assert(is_callable($callable) === true);
        $errors = call_user_func($callable, $context);
        assert(is_array($errors));

        return $errors;
    }

    /**
     * @param array                    $errorsInfo
     * @param ContextStorageInterface  $context
     * @param ErrorAggregatorInterface $errors
     *
     * @return void
     */
    private static function addBlockErrors(
        array $errorsInfo,
        ContextStorageInterface $context,
        ErrorAggregatorInterface $errors
    ): void {
        foreach ($errorsInfo as $errorInfo) {
            $index        = $errorInfo[BlockReplies::ERROR_INFO_BLOCK_INDEX];
            $value        = $errorInfo[BlockReplies::ERROR_INFO_VALUE];
            $errorCode    = $errorInfo[BlockReplies::ERROR_INFO_CODE];
            $errorContext = $errorInfo[BlockReplies::ERROR_INFO_CONTEXT];

            $name = $context->setCurrentBlockId($index)->getProperties()->getProperty(BaseRule::PROPERTY_NAME);

            $errors->add(new Error($name, $value, $errorCode, $errorContext));
        }
    }

    /**
     * @param array $blocks
     *
     * @return bool
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function debugCheckLooksLikeBlocksArray(array $blocks): bool
    {
        foreach ($blocks as $index => $block) {
            if (is_int($index) === false ||
                is_array($block) === false ||
                static::debugHasKnownBlockType($block) === false

            ) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param array $blockIndexes
     * @param array $blockList
     * @param int   $blockType
     *
     * @return bool
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private static function debugCheckBlocksExist(array $blockIndexes, array $blockList, int $blockType): bool
    {
        foreach ($blockIndexes as $index) {
            if (array_key_exists($index, $blockList) === false ||
                static::getBlockType($blockList[$index]) !== $blockType

            ) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param array $block
     *
     * @return bool
     */
    private static function debugHasKnownBlockType(array $block): bool
    {
        $result = false;

        if (array_key_exists(BlockSerializer::TYPE, $block) === true) {
            $type = $block[BlockSerializer::TYPE];

            $result =
                $type === BlockSerializer::TYPE__PROCEDURE ||
                $type === BlockSerializer::TYPE__AND_EXPRESSION ||
                $type === BlockSerializer::TYPE__OR_EXPRESSION ||
                $type === BlockSerializer::TYPE__IF_EXPRESSION;
        }

        return $result;
    }
}


1			<?php namespace Limoncello\Validation\Execution;
2
3			/**
4			* Copyright 2015-2017 [email protected]
5			*
6			* Licensed under the Apache License, Version 2.0 (the "License");
7			* you may not use this file except in compliance with the License.
8			* You may obtain a copy of the License at
9			*
10			* http://www.apache.org/licenses/LICENSE-2.0
11			*
12			* Unless required by applicable law or agreed to in writing, software
13			* distributed under the License is distributed on an "AS IS" BASIS,
14			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15			* See the License for the specific language governing permissions and
16			* limitations under the License.
17			*/
18
19			use Limoncello\Validation\Contracts\Captures\CaptureAggregatorInterface;
20			use Limoncello\Validation\Contracts\Errors\ErrorAggregatorInterface;
21			use Limoncello\Validation\Contracts\Execution\ContextInterface;
22			use Limoncello\Validation\Contracts\Execution\ContextStorageInterface;
23			use Limoncello\Validation\Errors\Error;
24			use Limoncello\Validation\Rules\BaseRule;
25
26			/**
27			* @package Limoncello\Validation
28			*
29			* @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
30			*/
31			final class BlockInterpreter
32			{
33			/**
34			* @param mixed $input
35			* @param array $serializedBlocks
36			* @param ContextStorageInterface $context
37			* @param CaptureAggregatorInterface $captures
38			* @param ErrorAggregatorInterface $errors
39			*
40			* @return void

limoncello-php-dist / validation