Codeburner\Annotator\Reflection\AnnotationTrait

Complexity

Total Complexity

19

Size/Duplication

Total Lines	173
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
	getDocComment()	0	1	?
	getNamespaceName()	0	1	?
A	getAnnotation()	0	14	3
A	getAnnotations()	0	14	3
A	hasAnnotation()	0	4	1
A	getMatchedAnnotations()	0	5	1
A	getAnnotationObject()	0	18	3
A	getUseStatements()	0	19	4
A	getClassFileHeader()	0	15	2
A	getAnnotationName()	0	9	2

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 31 and the first side effect is on line 22.

/**
 * Codeburner Framework.
 *
 * @author Alex Rohleder <contato@alexrohleder.com.br>
 * @copyright 2016 Alex Rohleder
 * @license http://opensource.org/licenses/MIT
 */

namespace Codeburner\Annotator\Reflection;

use Codeburner\Annotator\Annotation;
use Codeburner\Annotator\Exceptions\WildcardNotAllowedException;

/**
 * Avoid the autoload by manually including the required files.
 * This bust significantly the performance.
 */

if (!class_exists('Codeburner\Annotator\Annotation', false)) {
	include __DIR__ . '/../Annotation.php';
}

/**
 * Implements the annotation methods into a reflection.
 *
 * @author Alex Rohleder <contato@alexrohleder.com.br>
 */

trait AnnotationTrait
{

	abstract public function getDocComment();
    abstract public function getNamespaceName();

    /**
     * @var string
     */

    private $useStatementsCache;

    /**
     * Get an annotation by it literal name.
     * 
     * @param  Annotation|null
     * @throws MultipleAnnotationException
     * @return string
     */

    public function getAnnotation($name)
    {
        $annotations = $this->getMatchedAnnotations($name);

        if (empty($annotations)) {
            return null;
        }

        if (count($annotations) > 1) {
            throw new WildcardNotAllowedException("getAnnotation");
        }

        return $this->getAnnotationObject($annotations[0]);
    }

    /**
     * Get all annotations, or several of then. Note that here annotations can
     * have regex on they name.
     *
     * @param array $names if empty will return all annotations. Can have regex.
     * @return array ["AnnotationName" => Annotation]
     */

    public function getAnnotations(array $names = array())
    {
        if (empty($names)) {
               $annotations = $this->getMatchedAnnotations("[\w]+");
        } else $annotations = $this->getMatchedAnnotations(implode("|", $names));

        $bucket = [];

        foreach ($annotations as $annotation) {
            $bucket[$annotation[1]] = $this->getAnnotationObject($annotation);
        }

        return $bucket;
    }
    
    /**
     * Check if an annotation exists
     *
     * @return bool
     */

    public function hasAnnotation($name)
    {
        return (bool) preg_match("~@" . $this->getAnnotationName($name) . "~", $this->getDocComment());
    }

    /**
     * Find all annotations that the name match the $pattern
     *
     * @return array
     */

    protected function getMatchedAnnotations($pattern)
    {
        preg_match_all("~@(" . $this->getAnnotationName($pattern) . ")(\s(-f\s?)?(.*))?~i", $this->getDocComment(), $annotations, PREG_SET_ORDER);
        return (array) $annotations;
    }

    /**
     * Instantiate a new Annotation object, if the annotation has a specific object
     * then resolve the name and create it.
     *
     * @param array $annotation The getMatchedAnnotation annotation return.
     * @return Annotation
     */

    protected function getAnnotationObject($annotation)
    {
        $use = $this->getUseStatements();

$use is not used, you could remove the assignment.

        $name = $annotation[1];
        $value = $annotation[4];
        $flag = $annotation[3];

        if (trim($flag) === "-f") {
            $uses = $this->getUseStatements();

            if (!isset($uses[$name])) {
                   $class = $this->getNamespaceName() . "\\$name";
                   return new $class($name, $value);
            } else return new $uses[$name]($name, $value);
        }

        return new Annotation($name, $value);
    }

    /**
     * Get all use statements from the annotated reflection file.
     *
     * @return array
     */

    protected function getUseStatements()
    {
        if ($this->useStatementsCache) {
            return $this->useStatementsCache;
        }

        preg_match_all("~use\s([\w\\\\]+)(\sas\s(\w+))?;~i", $this->getClassFileHeader(), $matches, PREG_SET_ORDER);

        foreach ($matches as $match) {

The expression $matches of type null|array<integer,array<integer,string>> is not guaranteed to be traversable. How about adding an additional type check?

            // if an alias exists.
            if (isset($match[3])) {
                $this->useStatementsCache[$match[3]] = $match[1];
            }

            $this->useStatementsCache[$match[1]] = $match[1];
        }

        return $this->useStatementsCache;
    }

    /**
     * Get a fraction of the annotated reflection file.
     *
     * @return string
     */

    private function getClassFileHeader()
    {
        $file   = fopen($this->getFileName(), "r");

It seems like getFileName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $until  = $this->getStartLine();

It seems like getStartLine() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $line   = 0;
        $source = "";

        while ($line < $until) {
            $source .= fgets($file);
            ++$line;
        }

        fclose($file);
        return $source;
    }

    /**
     * Resolve annotation name.
     *
     * @return string
     */

    private function getAnnotationName($name)
    {
        // if it is a pattern like [\w]+
        if ($name[0] === "[") {
            return $name;
        }

        return str_replace("\\", "\\\\", $name);
    }

}