SimpleCrud\FieldFactory

Complexity

Total Complexity

14

Size/Duplication

Total Lines	147
Duplicated Lines	4.76 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes	19
Bugs	3	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	addNamespace()	0	6	1
A	mapNames()	0	6	1
A	mapRegex()	0	6	1
A	mapTypes()	0	6	1
B	get()	7	21	5
B	getClassName()	0	16	5

<?php

namespace SimpleCrud;

/**
 * Class to create instances of fields.
 */
class FieldFactory implements FieldFactoryInterface
{
    protected $namespaces = ['SimpleCrud\\Fields\\'];
    protected $defaultType = 'Field';

    protected $nameMap = [
        'id' => 'Integer',
        'active' => 'Boolean',
        'pubdate' => 'Datetime',
        'file' => 'File',
    ];

    protected $regexMap = [
        //relation fields (post_id)
        '/_id$/' => 'Integer',

        //flags (isActive, inHome)

38% of this comment could be valid code. Did you maybe forget this after debugging?

        '/^(is|has)[A-Z]/' => 'Boolean',

        //time related (createdAt, publishedAt)
        '/[a-z]At$/' => 'Datetime',

        //time related (createdAt, publishedAt)
        '/[a-z]File$/' => 'File',
    ];

    protected $typeMap = [
        'bigint' => 'Integer',
        'boolean' => 'Boolean',
        'date' => 'Date',
        'datetime' => 'Datetime',
        'float' => 'Decimal',
        'mediumint' => 'Integer',
        'set' => 'Set',
        'smallint' => 'Integer',
        'tinyint' => 'Integer',
        'year' => 'Integer',
    ];

    /**
     * Set the namespace for the fields classes.
     *
     * @param string $namespace
     *
     * @return self
     */
    public function addNamespace($namespace)
    {
        array_unshift($this->namespaces, $namespace);

        return $this;
    }

    /**
     * Map names with field types.
     *
     * @param array $map
     *
     * @return self
     */
    public function mapNames(array $map)
    {
        $this->nameMap = $map + $this->nameMap;

        return $this;
    }

    /**
     * Map names with field types using regexp.
     *
     * @param array $map
     *
     * @return self
     */
    public function mapRegex(array $map)
    {
        $this->regexMap = $map + $this->regexMap;

        return $this;
    }

    /**
     * Map db field types with classes.
     *
     * @param array $map
     *
     * @return self
     */
    public function mapTypes(array $map)
    {
        $this->mapTypes = $map + $this->mapTypes;

The property mapTypes does not exist. Did you maybe forget to declare it?

        return $this;
    }

    /**
     * @see FieldFactoryInterface
     *
     * {@inheritdoc}
     */
    public function get(Table $table, $name)
    {
        $scheme = $table->getScheme()['fields'];

        if (!isset($scheme[$name])) {
            throw new SimpleCrudException("The field '{$name}' does not exist in the table {$table->name}");
        }


        $className = $this->getClassName($name, $scheme[$name]['type']) ?: $this->defaultType;

        foreach ($this->namespaces as $namespace) {

This code seems to be duplicated across your project.

            $class = $namespace.$className;

            if (class_exists($class)) {
                return new $class($table, $name);
            }
        }

        throw new SimpleCrudException("No field class found for '{$className}'");
    }

    /**
     * Get the field class name.
     *
     * @param string $name
     * @param string $type
     *
     * @return string|null
     */
    protected function getClassName($name, $type)
    {
        if (isset($this->nameMap[$name])) {
            return $this->nameMap[$name];
        }

        foreach ($this->regexMap as $regex => $class) {
            if (preg_match($regex, $name)) {
                return $class;
            }
        }

        if (isset($this->typeMap[$type])) {
            return $this->typeMap[$type];
        }
    }
}