ByTIC\Models\SmartProperties\Definitions\Builders\FolderBuilders

Complexity

Total Complexity

27

Size/Duplication

Total Lines	181
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	1

12 Methods

Rating	Name	Duplication	Size	Complexity
A	newDefinition()	0	6	1
A	buildPlaces()	0	12	4
A	getItemsNamesFromFiles()	0	15	3
A	isAbstractItemName()	0	19	6
A	generatePropertyDirectory()	0	3	1
A	create()	0	11	2
A	setItemsDirectory()	0	3	1
A	getItemsDirectory()	0	7	2
A	getItemsNamesFromManager()	0	8	2
A	generateManagerDirectory()	0	5	1
A	generateItemsDirectory()	0	13	3
A	initItemsDirectory()	0	3	1

<?php

namespace ByTIC\Models\SmartProperties\Definitions\Builders;

use ByTIC\Models\SmartProperties\Definitions\Definition;
use Nip\Records\AbstractModels\RecordManager;
use Nip\Utility\Str;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;

/**
 * Class FolderBuilders
 * @package ByTIC\Models\SmartProperties\Definitions\Builders
 */
class FolderBuilders
{
    /**
     * @var RecordManager
     */
    protected $manager;

    /**
     * @var Definition
     */
    protected $definition;

    protected $itemsDirectory = null;

    /**
     * @param RecordManager $manager
     * @param string $field
     * @param null|string $name
     */
    public static function create($manager, $field, $name = null): Definition
    {
        $builder = new static();
        $builder->manager = $manager;
        $builder->definition = $builder->newDefinition($manager);
        $builder->definition->setField($field);
        if ($name) {
            $builder->definition->setName($name);
        }
        $builder->definition->setPlaces($builder->buildPlaces());
        return $builder->definition;
    }


    /**
     * @param $manager
     * @return Definition
     */
    protected function newDefinition($manager): Definition
    {
        $definition = new Definition();
        $definition->setManager($manager);

        return $definition;
    }

    /**
     * @return array
     */
    protected function buildPlaces()
    {
        $names = $this->getItemsNamesFromManager();

        $names = $names ?: $this->getItemsNamesFromFiles();

        foreach ($names as $key => $name) {
            if ($this->isAbstractItemName($name)) {
                unset($names[$key]);
            }
        }
        return $names;

The expression return $names also could return the type true which is incompatible with the documented return type array.

    }


    /**
     * @return array
     */
    protected function getItemsNamesFromFiles(): array
    {
        $directory = $this->getItemsDirectory();
        $files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory));
        $names = [];
        foreach ($files as $file) {
            if ($file->isDir()) {
                continue;
            }
            $name = str_replace($directory, '', $file->getPathname());
            $name = str_replace('.php', '', $name);
            $names[] = trim($name, DIRECTORY_SEPARATOR . '\\');
        }

        return array_unique($names);
    }

    /**
     * @return array|boolean
     */
    protected function getItemsNamesFromManager()
    {
        $methodName = 'get' . $this->definition->getName() . 'Names';
        if (method_exists($this->manager, $methodName)) {
            return $this->manager->$methodName();
        }

        return false;
    }

    /**
     * @param string $name
     *
     * @return bool
     */
    protected function isAbstractItemName(string $name): bool
    {
        if (in_array($name, ['Abstract', 'Generic'])) {
            return true;
        }
        if (strpos($name, 'Abstract') === 0) {
            return true;
        }
        if (Str::endsWith($name, 'Trait')) {
            return true;
        }
        if (strpos($name, '\Abstract') !== false) {
            return true;
        }
        if (strpos($name, DIRECTORY_SEPARATOR . 'Abstract') !== false) {
            return true;
        }

        return false;
    }

    /**
     * @return null|string
     */
    protected function getItemsDirectory()
    {
        if ($this->itemsDirectory == null) {
            $this->initItemsDirectory();
        }

        return $this->itemsDirectory;
    }

    /**
     * @param $dir
     */
    protected function setItemsDirectory($dir)
    {
        $this->itemsDirectory = $dir;
    }

    protected function initItemsDirectory()
    {
        $this->setItemsDirectory($this->generateItemsDirectory());
    }

    /**
     * @return string
     */
    protected function generateItemsDirectory()
    {
        $methodName = 'get' . $this->definition->getName() . 'ItemsDirectory';
        if (method_exists($this->manager, $methodName)) {
            return $this->manager->$methodName();
        }

        $methodName = 'get' . Str::plural($this->definition->getName()) . 'Directory';

It seems like $this->definition->getName() can also be of type null; however, parameter $value of Nip\Utility\Str::plural() does only seem to accept string, maybe add an additional type check?

        if (method_exists($this->manager, $methodName)) {
            return $this->manager->$methodName();
        }

        return $this->generateManagerDirectory() . DIRECTORY_SEPARATOR . $this->generatePropertyDirectory();
    }

    /**
     * @return string
     */
    protected function generateManagerDirectory()
    {
        $reflector = new \ReflectionObject($this->manager);

        return dirname($reflector->getFileName());
    }

    /**
     * @return string
     */
    protected function generatePropertyDirectory()
    {
        return $this->definition->getLabel();
    }
}