Ytake\Lom\Lom

Complexity

Total Complexity

15

Size/Duplication

Total Lines	136
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	target()	0	6	1
A	register()	0	6	1
A	parseCode()	0	12	2
A	getParsed()	0	4	1
A	parseClassAnnotations()	0	8	2
A	parsePropertyAnnotations()	0	9	3
A	callFactory()	0	11	2
A	setProperty()	0	4	1

<?php
declare(strict_types=1);

/*
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license.
 *
 * Copyright (c) 2018 Yuuki Takezawa
 */

namespace Ytake\Lom;

use Doctrine\Common\Annotations\Reader;
use ReflectionClass;
use ReflectionProperty;
use Ytake\Lom\Exception\Throwable;
use Ytake\Lom\Exception\ThrowInconsistency;
use Ytake\Lom\Factory\GeneratorFactory;

/**
 * Class Lom.
 *
 * @author  yuuki.takezawa<yuuki.takezawa@comnect.jp.net>
 * @license http://opensource.org/licenses/MIT MIT
 */
class Lom
{
    /** @var ReflectionClass */
    protected $reflection;

    /** @var Reader */
    protected $register;

    /** @var */
    protected $property;

    /** @var */
    protected $parsed;

    /** @var */
    protected $method;

    /** @var CodeParser */
    protected $parser;

    /** @var Throwable|ThrowInconsistency  */
    protected $throw;

    /**
     * @param CodeParser     $parser
     * @param Throwable|null $throw
     */
    public function __construct(CodeParser $parser, Throwable $throw = null)
    {
        $this->parser = $parser;
        $this->throw = (is_null($throw)) ? new ThrowInconsistency() : $throw;
    }

    /**
     * @param string $className
     *
     * @throws \ReflectionException
     *
     * @return Lom
     */
    final public function target(string $className): Lom
    {
        $this->reflection = new ReflectionClass($className);

        return $this;
    }

    /**
     * @param AnnotationRegister $register
     *
     * @throws \Doctrine\Common\Annotations\AnnotationException
     *
     * @return Lom
     */
    final public function register(AnnotationRegister $register): Lom
    {
        $this->register = $register->register()->getReader();

        return $this;
    }

    /**
     * @return array
     */
    public function parseCode(): array
    {
        $parsed = $this->parser->parser($this->reflection);
        $this->parseClassAnnotations($parsed);

It seems like $parsed defined by $this->parser->parser($this->reflection) on line 100 can also be of type null; however, Ytake\Lom\Lom::parseClassAnnotations() does only seem to accept array, maybe add an additional type check?

        $this->parsePropertyAnnotations($parsed);

It seems like $parsed defined by $this->parser->parser($this->reflection) on line 100 can also be of type null; however, Ytake\Lom\Lom::parsePropertyAnnotations() does only seem to accept array, maybe add an additional type check?

        if (!is_null($this->parsed)) {
            $parsed = $this->parsed;
        }

        return $parsed;
    }

    /**
     * @return array
     */
    public function getParsed(): ?array
    {
        return $this->parsed;
    }

    /**
     * @param array $parsed
     */
    protected function parseClassAnnotations(array $parsed)
    {
        $annotations = $this->register->getClassAnnotations($this->reflection);
        $this->throw->detectAnnotationErrorThrow($annotations);
        foreach ($annotations as $annotation) {
            $this->parsed = $this->callFactory($parsed, $annotation);
        }
    }

    /**
     * @param array $parsed
     */
    protected function parsePropertyAnnotations(array $parsed)
    {
        foreach ($this->reflection->getProperties() as $property) {
            foreach ($this->register->getPropertyAnnotations($property) as $propertyAnnotation) {
                $this->setProperty($property);
                $this->parsed = $this->callFactory($parsed, $propertyAnnotation);
            }
        }
    }

    /**
     * @param array $parsed
     * @param       $annotation
     *
     * @return array|null
     */
    protected function callFactory(array $parsed, $annotation): ?array
    {
        /** @var \Ytake\Lom\Factory\AbstractDriver $factory */
        $factory = (new GeneratorFactory($this->reflection, $parsed))
            ->driver($annotation);
        if (!is_null($this->property)) {
            $factory->setProperty($this->property);
        }

        return $factory->generator();
    }

    /**
     * @param ReflectionProperty $property
     */
    protected function setProperty(ReflectionProperty $property)
    {
        $this->property = $property;
    }
}