AbstractStructureParser - Code Metrics - appserver-io/doppelgaenger - Measure and Improve Code Quality continuously with Scrutinizer

AbstractStructureParser F
last analyzed 2019-05-14 10:21 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	366
Duplicated Lines	10.66 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
wmc	84
lcom	1
cbo	4
dl	39
loc	366
rs	2
c	0
b	0
f	0

10 Methods

Rating	Name	Duplication	Size	Complexity
B	getConstants()	0	33	10
C	getDefinition()	8	38	13
A	getDefinitionListFromFile()	0	23	4
A	getName()	0	19	6
B	getNamespace()	11	24	8
A	getStructureToken()	0	25	5
A	isStructureToken()	0	8	5
D	getStructureTokens()	8	59	18
B	getUsedStructures()	12	30	9
B	resolveUsedNamespace()	0	26	6

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 AbstractStructureParser 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 AbstractStructureParser, and based on these observations, apply Extract Interface, too.

<?php

/**
 * \AppserverIo\Doppelgaenger\Parser\AbstractStructureParser
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 *
 * PHP version 5
 *
 * @author    Bernhard Wick <[email protected]>
 * @copyright 2015 TechDivision GmbH - <[email protected]>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/doppelgaenger
 * @link      http://www.appserver.io/
 */

namespace AppserverIo\Doppelgaenger\Parser;

use AppserverIo\Doppelgaenger\Entities\Lists\StructureDefinitionList;
use AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface;
use AppserverIo\Doppelgaenger\Interfaces\StructureParserInterface;
use AppserverIo\Doppelgaenger\Entities\Definitions\FileDefinition;

/**
 * The abstract class AbstractStructureParser which provides a basic implementation other structure parsers
 * can inherit from
 *
 * @author    Bernhard Wick <[email protected]>
 * @copyright 2015 TechDivision GmbH - <[email protected]>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/doppelgaenger
 * @link      http://www.appserver.io/
 */
abstract class AbstractStructureParser extends AbstractParser implements StructureParserInterface
{

    /**
     * Will return the constants within the main token array
     *
     * @return array
     */
    public function getConstants()
    {
        // Check the tokens
        $constants = array();
        for ($i = 0; $i < $this->tokenCount; $i++) {
            // If we got the class name
            if ($this->tokens[$i][0] === T_CONST) {
                for ($j = $i + 1; $j < $this->tokenCount; $j++) {
                    if ($this->tokens[$j] === ';') {
                        break;


                    } elseif ($this->tokens[$j][0] === T_STRING) {
                        $constants[$this->tokens[$j][1]] = '';

                        for ($k = $j + 1; $k < count($this->tokens); $k++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                            if ($this->tokens[$k] === ';') {
                                break;


                            } elseif (is_array($this->tokens[$k]) && $this->tokens[$k][0] !== '=') {
                                $constants[$this->tokens[$j][1]] .= $this->tokens[$k][1];
                            }
                        }

                        // Now trim what we got
                        $constants[$this->tokens[$j][1]] = trim($constants[$this->tokens[$j][1]]);
                    }
                }
            }
        }

        // Return what we did or did not found
        return $constants;
    }

    /**
     * Will return the definition of a specified structure
     *
     * @param null|string $name         The name of the class we are searching for
     * @param boolean     $getRecursive Do we have to get the ancestral conditions as well?
     *
     * @return boolean|\AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface
     */
    public function getDefinition($name = null, $getRecursive = true)
    {
        // Maybe we already got this structure?
        if ($this->structureDefinitionHierarchy->entryExists($name)) {
            return $this->structureDefinitionHierarchy->getEntry($name);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        // First of all we need to get the structure tokens
        $tokens = $this->getStructureTokens($this->getToken());

        // Did we get something valuable?
        if ($tokens === false) {
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}


        } elseif ($name === null && count($tokens) > 1) {
            // If we did not get a structure name and we got more than one class we can fail right here
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}


        } elseif (count($tokens) === 1) {
            // We got what we came for
            return $this->getDefinitionFromTokens($tokens[0], $getRecursive);



        } elseif (is_string($name) && count($tokens) > 1) {
            // We are still here, but got a structure name to look for

            foreach ($tokens as $key => $token) {
                // Now iterate over the array and search for the class we want
                for ($i = 0; $i < count($token); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    if (is_array($token[$i]) && $token[$i] === $this->getToken() && $token[$i + 2] === $name) {
                        return $this->getDefinitionFromTokens($tokens[$key], $getRecursive);

                    }
                }
            }
        }

        // Still here? Must be an error.
        return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Will return a list of found structures or false on error
     *
     * @param string         $file           Path of the file we are searching in
     * @param FileDefinition $fileDefinition Definition of the file the class is in
     * @param boolean        $getRecursive   Do we have to get the ancestral conditions as well?
     *
     * @return boolean|StructureDefinitionList
     */
    public function getDefinitionListFromFile($file, FileDefinition $fileDefinition, $getRecursive = true)
    {
        // Get all the token arrays for the different classes
        $tokens = $this->getStructureTokens($file, $this->getToken());


        // Did we get the right thing?
        if (!is_array($tokens)) {
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        $structureDefinitionList = new StructureDefinitionList();
        foreach ($tokens as $token) {
            try {
                $structureDefinitionList->add($this->getDefinitionFromTokens($token, $fileDefinition, $getRecursive));



            } catch (\UnexpectedValueException $e) {
                // Just try the next one
                continue;
            }
        }

        return $structureDefinitionList;
    }

    /**
     * Get the name of the structure
     *
     * @param array $tokens The token array
     *
     * @return string
     */
    protected function getName($tokens)
    {
        // Check the tokens
        $name = '';
        $targetToken = $this->getToken();
        for ($i = 0; $i < count($tokens); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
            // If we got the structure name
            if ($tokens[$i][0] === $targetToken && $tokens[$i - 1][0] !== T_PAAMAYIM_NEKUDOTAYIM) {
                for ($j = $i + 1; $j < count($tokens); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    if ($tokens[$j] === '{') {
                        $name = $tokens[$i + 2][1];
                    }
                }
            }
        }

        // Return what we did or did not found
        return $name;
    }

    /**
     * Will return the structure's namespace if found
     *
     * @return string
     */
    public function getNamespace()
    {
        // Check the tokens
        $namespace = '';
        for ($i = 0; $i < $this->tokenCount; $i++) {
            // If we got the namespace
            if ($this->tokens[$i][0] === T_NAMESPACE) {
                for ($j = $i + 1; $j < count($this->tokens); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    if ($this->tokens[$j][0] === T_STRING) {
                        $namespace .= '\\' . $this->tokens[$j][1];


                    } elseif ($this->tokens[$j] === '{' ||
                        $this->tokens[$j] === ';' ||
                        $this->tokens[$j][0] === T_CURLY_OPEN
                    ) {
                        break;
                    }
                }
            }
        }

        // Return what we did or did not found
        return substr($namespace, 1);
    }

    /**
     * Will check the main token array for the occurrence of a certain on (class, interface or trait)
     *
     * @return string|boolean
     */
    protected function getStructureToken()
    {
        for ($i = 0; $i < $this->tokenCount; $i++) {
            switch ($this->tokens[$i][0]) {
                case T_CLASS:
                    return 'class';
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

                case T_INTERFACE:
                    return 'interface';
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

                case T_TRAIT:
                    return 'trait';
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

                default:
                    continue;
                    break;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            }
        }

        // We are still here? That should not be.
        return false;
    }

    /**
     * Will check if a certain token describes a structure
     *
     * @param mixed $token The token to test
     *
     * @return boolean
     */
    protected function isStructureToken($token)
    {
        if (is_array($token) && ($token[0] === T_CLASS || $token[0] === T_INTERFACE || $token[0] === T_TRAIT)) {
            return true;
        }
        // We are still here? That should not be.
        return false;
    }

    /**
     * Will return a subset of our main token array. This subset includes all tokens belonging to a certain structure.
     * Might return false on failure
     *
     * @param integer $structureToken The structure we are after e.g. T_CLASS, use PHP tokens here
     *
     * @return array|boolean
     */
    protected function getStructureTokens($structureToken)
    {
        // Now iterate over the array and filter different classes from it
        $result = array();
        for ($i = 0; $i < $this->tokenCount; $i++) {
            // If we got a class keyword, we have to check how far the class extends,
            // then copy the array withing that bounds

            if (is_array($this->tokens[$i]) && $this->tokens[$i][0] === $structureToken && $this->tokens[$i - 1][0] !== T_PAAMAYIM_NEKUDOTAYIM) {
                // The lower bound should be the last semicolon|closing curly bracket|PHP tag before the structure
                $lowerBound = 0;
                for ($j = $i - 1; $j >= 0; $j--) {
                    if ($this->tokens[$j] === ';' || $this->tokens[$j] === '}' ||
                        is_array($this->tokens[$j]) && $this->tokens[$j][0] === T_OPEN_TAG
                    ) {
                        $lowerBound = $j;
                        break;
                    }
                }

                // The upper bound should be the first time the curly brackets are even again
                $upperBound = $this->tokenCount - 1;
                $bracketCounter = null;
                for ($j = $i + 1; $j < count($this->tokens); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    if ($this->tokens[$j] === '{' || $this->tokens[$j][0] === T_CURLY_OPEN) {
                        // If we still got null set to 0
                        if ($bracketCounter === null) {
                            $bracketCounter = 0;
                        }

                        $bracketCounter++;


                    } elseif ($this->tokens[$j] === '}') {
                        // If we still got null set to 0
                        if ($bracketCounter === null) {
                            $bracketCounter = 0;
                        }

                        $bracketCounter--;
                    }

                    // Do we have an even amount of brackets yet?
                    if ($bracketCounter === 0) {
                        $upperBound = $j;
                        break;
                    }
                }

                $result[] = array_slice($this->tokens, $lowerBound, $upperBound - $lowerBound);
            }
        }

        // Last line of defence; did we get something?
        if (empty($result)) {
            return false;
        }

        return $result;
    }

    /**
     * Will return an array of structures which this structure references by use statements
     *
     * @return array
     */
    public function getUsedStructures()
    {
        // Check the tokens
        $structures = array();
        for ($i = 0; $i < $this->tokenCount; $i++) {
            // break as soon as we pass a structure keyword as "use" imports must be globally
            if ($this->isStructureToken($this->tokens[$i])) {
                break;
            }
            // if we got a use statement
            if ($this->tokens[$i][0] === T_USE) {
                $structure = '';
                for ($j = $i + 1; $j < count($this->tokens); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    if ($this->tokens[$j][0] === T_STRING) {
                        $structure .= '\\' . $this->tokens[$j][1];


                    } elseif ($this->tokens[$j] === '{' ||
                        $this->tokens[$j] === ';' ||
                        $this->tokens[$j][0] === T_CURLY_OPEN
                    ) {
                        $structures[] = $structure;
                        break;
                    }
                }
            }
        }

        // Return what we did or did not found
        return $structures;
    }

    /**
     * Will check if a certain structure was mentioned in one(!) use statement.
     *
     * @param StructureDefinitionInterface $structureDefinition The structure $structureName is compared against
     * @param string                       $structureName       The name of the structure we have to check against the
     *                                                          use statements of the definition
     *
     * @return string
     */
    protected function resolveUsedNamespace(StructureDefinitionInterface & $structureDefinition, $structureName)
    {
        // If there was no useful name passed we can fail right here
        if (empty($structureName)) {
            return '';
        }

        // Walk over all namespaces and if we find something we will act accordingly.
        $result = $structureDefinition->getQualifiedName();
        foreach ($structureDefinition->getUsedStructures() as $key => $usedStructures) {
            // Check if the last part of the use statement is our structure
            $tmp = explode('\\', $usedStructures);
            if (array_pop($tmp) === $structureName) {
                // Tell them we succeeded
                return trim(implode('\\', $tmp) . '\\' . $structureName, '\\');
            }
        }

        // We did not seem to have found anything. Might it be that we are in our own namespace?
        if ($structureDefinition->getNamespace() !== null && strpos($structureName, '\\') !== 0) {
            return $structureDefinition->getNamespace() . '\\' . $structureName;
        }

        // Still here? Return what we got.
        return $result;
    }
}


appserver-io / doppelgaenger

AbstractStructureParser F last analyzed 2019-05-14 10:21 UTC