AppserverIo\Doppelgaenger\Parser\PropertyParserTrait

Complexity

Total Complexity

35

Size/Duplication

Total Lines	181
Duplicated Lines	7.18 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
D	getAttributes()	0	87	21
C	getAttributeProperties()	13	58	13
A	getToken()	0	4	1

<?php

/**
 * \AppserverIo\Doppelgaenger\Parser\PropertyParserTrait
 *
 * 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 <bw@appserver.io>
 * @copyright 2015 TechDivision GmbH - <info@appserver.io>
 * @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\Definitions\AttributeDefinition;
use AppserverIo\Doppelgaenger\Entities\Lists\AttributeDefinitionList;
use AppserverIo\Doppelgaenger\Entities\Lists\TypedListList;

/**
 * Trait which will allow the re-usability of methods for parsing structure properties
 *
 * @author    Bernhard Wick <bw@appserver.io>
 * @copyright 2015 TechDivision GmbH - <info@appserver.io>
 * @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/
 *
 * @property \AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface $currentDefinition The current definition we are working on. Assumed to be present in parent
 */
trait PropertyParserTrait
{

    /**
     * Retrieves class attributes from token array.
     *
     * This method will search for any attributes a class might have. Just pass the token array of the class.
     * Work is done using token definitions and common sense in regards to PHP syntax.
     * To retrieve the different properties of an attribute it relies on getAttributeProperties().
     * We need the list of invariants to mark attributes wo are under surveillance.
     *
     * @param array         $tokens     Array of tokens for this class
     * @param TypedListList $invariants List of invariants so we can compare the attributes to
     *
     * @return AttributeDefinitionList
     */
    public function getAttributes(array $tokens, TypedListList $invariants = null)
    {
        // Check the tokens
        $attributes = new AttributeDefinitionList();
        for ($i = 0; $i < count($tokens); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            // If we got a variable we will check if there is any function definition above it.
            // If not, we got an attribute, if so we will check if there is an even number of closing and opening
            // brackets above it, which would mean we are not in the function.
            if (is_array($tokens[$i]) && $tokens[$i][0] === T_VARIABLE) {
                for ($j = $i - 1; $j >= 0; $j--) {
                    if (is_array($tokens[$j]) && $tokens[$j][0] === T_FUNCTION) {
                        // Initialize our counter and also the check if we even started counting
                        $bracketCounter = 0;
                        $usedCounter = false;

                        // We got something, lets count the brackets between it and our variable's position
                        for ($k = $j + 1; $k < $i; $k++) {
                            if ($tokens[$k] === '{' || $tokens[$k][0] === T_CURLY_OPEN) {
                                $usedCounter = true;
                                $bracketCounter++;

Blank line found at end of control structure

                            } elseif ($tokens[$k] === '}') {
                                $usedCounter = true;
                                $bracketCounter--;
                            }
                        }

                        // If we got an even number of brackets (the counter is 0 and got used), we got an attribute
                        if ($bracketCounter === 0 && $usedCounter === true) {
                            $attributes->set($tokens[$i][1], $this->getAttributeProperties($tokens, $i));
                        }

                        break;

Blank line found at end of control structure

                    } elseif (is_array($tokens[$j]) && $tokens[$j][0] === $this->getToken()) {
                        // If we reach the class definition without passing a function we definitely got an attribute
                        $attributes->set($tokens[$i][1], $this->getAttributeProperties($tokens, $i));
                        break;
                    }
                }
            }
        }

        // If we got invariants we will check if our attributes are used in invariants
        if ($invariants !== null) {
            // Lets iterate over all the attributes and check them against the invariants we got
            $listIterator = $invariants->getIterator();
            $listCount = $listIterator->count();
            $attributeIterator = $attributes->getIterator();
            $attributeCount = $attributeIterator->count();
            for ($i = 0; $i < $attributeCount; $i++) {
                // Do we have any of these attributes in our invariants?
                $listIterator = $invariants->getIterator();
                for ($j = 0; $j < $listCount; $j++) {
                    // Did we get anything useful?
                    if ($listIterator->current() === null) {
                        continue;
                    }

                    /** @var \AppserverIo\Doppelgaenger\Interfaces\TypedListInterface|\Iterator $invariantIterator */
                    $invariantIterator = $listIterator->current()->getIterator();

The method getIterator cannot be called on $listIterator->current() (of type null).

                    $invariantCount = $invariantIterator->count();

The method count does only exist in AppserverIo\Doppelgaenger\Interfaces\TypedListInterface, but not in Iterator.

                    for ($k = 0; $k < $invariantCount; $k++) {
                        $attributePosition = strpos(
                            $invariantIterator->current()->getString(),

The method current does only exist in Iterator, but not in AppserverIo\Doppelgaenger\Interfaces\TypedListInterface.

                            '$this->' . ltrim(
                                $attributeIterator->current()->getName(),
                                '$'
                            )
                        );

                        if ($attributePosition !== false
                        ) {
                            // Tell them we were mentioned and persist it
                            $attributeIterator->current()->setInInvariant(true);
                        }

                        $invariantIterator->next();

The method next does only exist in Iterator, but not in AppserverIo\Doppelgaenger\Interfaces\TypedListInterface.

                    }
                    $listIterator->next();
                }
                $attributeIterator->next();
            }
        }

        return $attributes;
    }

    /**
     * Will return a definition of an attribute as far as we can extract it from the token array
     *
     * @param array $tokens            Array of tokens for this class
     * @param int   $attributePosition Position of the attribute within the token array
     *
     * @return AttributeDefinition
     */
    public function getAttributeProperties(array $tokens, $attributePosition)
    {
        // We got the tokens and the position of the attribute, so look in front of it for visibility and a
        // possible static keyword
        $attribute = new AttributeDefinition();
        $attribute->setName($tokens[$attributePosition][1]);
        $attribute->setLine($tokens[$attributePosition][2]);
        $attribute->setStructureName($this->currentDefinition->getQualifiedName());

        for ($i = $attributePosition; $i > $attributePosition - 6; $i--) {
            // Search for the visibility
            if (is_array($tokens[$i]) && ($tokens[$i][0] === T_PRIVATE || $tokens[$i][0] === T_PROTECTED)) {
                // Got it!
                $attribute->setVisibility($tokens[$i][1]);
            }

            // Do we get a static keyword?
            if (is_array($tokens[$i]) && $tokens[$i][0] === T_STATIC) {
                // default is false, so set it to true
                $attribute->setIsStatic(true);
            }
        }

        // Now check if there is any default value for this attribute, if so we have to get it
        $defaultValue = null;
        for ($i = $attributePosition; $i < count($tokens); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            // If we reach the semicolon we do not have anything here.
            if ($tokens[$i] === ';') {
                break;
            }

            if ($defaultValue !== null) {
                // Do we get a static keyword?
                if (is_array($tokens[$i])) {
                    $defaultValue .= $tokens[$i][1];

Blank line found at end of control structure

                } else {
                    $defaultValue .= $tokens[$i];
                }
            }

            // If we pass a = we have to get ready to make notes
            if ($tokens[$i] === '=') {
                $defaultValue = '';
            }
        }

        // Set the default Value
        $attribute->setDefaultValue($defaultValue);

        // Last but not least we have to check if got the visibility, if not, set it public.
        // This is necessary, as missing visibility in the definition will also default to public
        if ($attribute->getVisibility() === '') {
            $attribute->setVisibility('public');
        }

        return $attribute;
    }

    /**
     * We by default assume we are used to parse classes
     *
     * @return int
     */
    public function getToken()
    {
        return T_CLASS;
    }
}