Go\Instrument\RawAnnotationReader

Complexity

Total Complexity

16

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

10.81%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setImports()	0	8	2
A	addNamespace()	0	4	1
A	getClassAnnotations()	0	6	1
A	getMethodAnnotations()	0	6	1
A	getPropertyAnnotations()	0	6	1
A	getClassAnnotation()	0	10	3
A	getMethodAnnotation()	0	10	3
A	getPropertyAnnotation()	0	10	3

<?php
/*
 * Go! AOP framework
 *
 * @copyright Copyright 2011, Lisachenko Alexander <lisachenko.it@gmail.com>
 *
 * This source file is subject to the license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Go\Instrument;

use TokenReflection\ReflectionClass as ParsedReflectionClass;
use TokenReflection\ReflectionMethod as ParsedReflectionMethod;
use TokenReflection\ReflectionProperty as ParsedReflectionProperty;
use Doctrine\Common\Annotations\DocParser;
use Doctrine\Common\Annotations\Annotation\Target;

/**
 * Simple Raw Annotation Reader.
 *
 * This annotation reader is intended to be used in projects where you have
 * full-control over all annotations that are available.
 *
 * @since  2.2
 * @author Johannes M. Schmitt <schmittjoh@gmail.com>
 * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
 */
class RawAnnotationReader
{
    /**
     * @var DocParser
     */
    private $parser;

    /**
     * Constructor.
     *
     * Initializes a new SimpleAnnotationReader.
     */
    public function __construct()
    {
        $this->parser = new DocParser();
        $this->parser->setIgnoreNotImportedAnnotations(true);
    }

    /**
     * Set imports for annotations
     *
     * @param array $imports
     */
    public function setImports(array $imports)
    {
        $convertedImports = [];
        foreach ($imports as $aliasName=>$fullName) {

Expected 1 space before "=>"; 0 found

Expected 1 space after "=>"; 0 found

            $convertedImports[strtolower($aliasName)] = $fullName;
        }
        $this->parser->setImports($convertedImports);
    }

    /**
     * Adds a namespace in which we will look for annotations.
     *
     * @param string $namespace
     */
    public function addNamespace($namespace)
    {
        $this->parser->addNamespace($namespace);

$namespace is of type string, but the function expects a array.

    }

    /**
     * Gets the annotations applied to a class.
     *
     * @param ParsedReflectionClass $class The ReflectionClass of the class from which
     *                               the class annotations should be read.
     * @return array An array of Annotations.
     */
    public function getClassAnnotations(ParsedReflectionClass $class)
    {
        $this->parser->setTarget(Target::TARGET_CLASS);

        return $this->parser->parse($class->getDocComment(), 'class '.$class->getName());
    }

    /**
     * Gets the annotations applied to a method.
     *
     * @param ParsedReflectionMethod $method The ReflectionMethod of the method from which
     *                                   the annotations should be read.
     * @return array An array of Annotations.
     */
    public function getMethodAnnotations(ParsedReflectionMethod $method)
    {
        $this->parser->setTarget(Target::TARGET_METHOD);

        return $this->parser->parse($method->getDocComment(), 'method '.$method->getDeclaringClass()->name.'::'.$method->getName().'()');
    }

    /**
     * Gets the annotations applied to a property.
     *
     * @param ParsedReflectionProperty $property The ReflectionProperty of the property
     *                                     from which the annotations should be read.
     * @return array An array of Annotations.
     */
    public function getPropertyAnnotations(ParsedReflectionProperty $property)
    {
        $this->parser->setTarget(Target::TARGET_PROPERTY);

        return $this->parser->parse($property->getDocComment(), 'property '.$property->getDeclaringClass()->name.'::$'.$property->getName());
    }

    /**
     * Gets a class annotation.
     *
     * @param ParsedReflectionClass $class The ReflectionClass of the class from which
     *                               the class annotations should be read.
     * @param string $annotationName The name of the annotation.
     * @return The Annotation or NULL, if the requested annotation does not exist.
     */
    public function getClassAnnotation(ParsedReflectionClass $class, $annotationName)
    {
        foreach ($this->getClassAnnotations($class) as $annot) {
            if ($annot instanceof $annotationName) {
                return $annot;
            }
        }

        return null;
    }

    /**
     * Gets a method annotation.
     *
     * @param ParsedReflectionMethod $method
     * @param string $annotationName The name of the annotation.
     * @return The Annotation or NULL, if the requested annotation does not exist.
     */
    public function getMethodAnnotation(ParsedReflectionMethod $method, $annotationName)
    {
        foreach ($this->getMethodAnnotations($method) as $annot) {
            if ($annot instanceof $annotationName) {
                return $annot;
            }
        }

        return null;
    }

    /**
     * Gets a property annotation.
     *
     * @param ParsedReflectionProperty $property
     * @param string $annotationName The name of the annotation.
     * @return The Annotation or NULL, if the requested annotation does not exist.
     */
    public function getPropertyAnnotation(ParsedReflectionProperty $property, $annotationName)
    {
        foreach ($this->getPropertyAnnotations($property) as $annot) {
            if ($annot instanceof $annotationName) {
                return $annot;
            }
        }

        return null;
    }
}