Ytake\Lom\Factory\AbstractDriver

Complexity

Total Complexity

13

Size/Duplication

Total Lines	110
Duplicated Lines	6.36 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setReflector()	0	6	1
A	setAnnotationInstance()	0	6	1
A	setProperty()	0	6	1
A	removeConstructor()	0	6	2
A	removeMethod()	7	10	4
A	setAccessLevel()	0	11	3

<?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\Factory;

use PhpParser\BuilderFactory;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassMethod;
use ReflectionClass;
use ReflectionMethod;
use ReflectionProperty;
use Ytake\Lom\Access;

/**
 * Class AbstractDriver.
 *
 * @author  yuuki.takezawa<yuuki.takezawa@comnect.jp.net>
 * @license http://opensource.org/licenses/MIT MIT
 */
abstract class AbstractDriver implements FactoryInterface
{
    /** @var ReflectionClass */
    protected $reflector;

    /** @var array */
    protected $parsed = [];

    /** @var BuilderFactory */
    protected $builder;

    /** @var */
    protected $annotation;

    /** @var ReflectionProperty */
    protected $property;

    /** @var ReflectionMethod */
    protected $method;

    /**
     * @param array          $parsed
     * @param BuilderFactory $builder
     */
    public function __construct(array $parsed, BuilderFactory $builder)
    {
        $this->parsed = $parsed;
        $this->builder = $builder;
    }

    /**
     * set ReflectionClass.
     *
     * @param ReflectionClass $reflection
     *
     * @return $this
     */
    public function setReflector(ReflectionClass $reflection): AbstractDriver
    {
        $this->reflector = $reflection;

        return $this;
    }

    /**
     * @param $annotation
     *
     * @return $this
     */
    public function setAnnotationInstance($annotation): AbstractDriver
    {
        $this->annotation = $annotation;

        return $this;
    }

    /**
     * @param ReflectionProperty $name
     *
     * @return $this
     */
    public function setProperty(ReflectionProperty $name): AbstractDriver
    {
        $this->property = $name;

        return $this;
    }

    /**
     * @param Class_ $part
     */
    protected function removeConstructor(Class_ $part)
    {
        if (!is_null($this->reflector->getConstructor())) {
            $this->removeMethod($part, '__construct');
        }
    }

    /**
     * @param Class_ $part
     * @param string $name
     */
    protected function removeMethod(Class_ $part, string $name)
    {
        foreach ($part->stmts as $key => $statement) {

This code seems to be duplicated across your project.

            if ($statement instanceof ClassMethod) {
                if ($statement->name === $name) {
                    unset($part->stmts[$key]);
                }
            }
        }
    }

    /**
     * detect constructor access level.
     *
     * @return string
     */
    protected function setAccessLevel(): string
    {
        switch ($this->annotation->access) {
            case Access::LEVEL_PRIVATE:
                return 'makePrivate';
            case Access::LEVEL_PROTECTED:
                return 'makeProtected';
            default:
                return 'makePublic';
        }
    }
}