Nip\Records\Traits\HasModelName\HasModelNameRecordsTrait

Complexity

Total Complexity

13

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Test Coverage

Coverage

94.87%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	initModelNamespacePath()	0	9	2
A	getModelNamespacePath()	0	7	2
A	setModel()	0	3	1
A	getModel()	0	7	2
A	generateModelClass()	0	18	4
A	generateModelNamespacePathFromClassName()	0	10	1
A	inflectModel()	0	4	1

<?php

namespace Nip\Records\Traits\HasModelName;

/**
 * Trait HasModelNameRecordsTrait
 * @package Nip\Records\Traits\HasModelName
 */
trait HasModelNameRecordsTrait
{

    /**
     * Model class name
     * @var null|string
     */
    protected $model = null;

    /**
     * @var null|string
     */
    protected $modelNamespacePath = null;

    /**
     * @return string
     */
    public function getModelNamespacePath()
    {
        if ($this->modelNamespacePath == null) {

It seems like you are loosely comparing $this->modelNamespacePath of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $this->initModelNamespacePath();
        }

        return $this->modelNamespacePath;
    }

    public function initModelNamespacePath()
    {
        if ($this->isNamespaced()) {

It seems like isNamespaced() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $path = $this->generateModelNamespacePathFromClassName() . '\\';
        } else {
            $controller = $this->generateControllerGeneric();

It seems like generateControllerGeneric() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $path = inflector()->classify($controller) . '\\';
        }
        $this->modelNamespacePath = $path;
    }

    /**
     * @return string
     */
    protected function generateModelNamespacePathFromClassName()
    {
        $className = $this->getClassName();

It seems like getClassName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $rootNamespace = $this->getRootNamespace();

It seems like getRootNamespace() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $path = str_replace($rootNamespace, '', $className);

        $nsParts = explode('\\', $path);
        array_pop($nsParts);

        return implode($nsParts, '\\');

'\' of type string is incompatible with the type array expected by parameter $pieces of implode().

    }

    /**
     * @return string
     */
    public function getModel()
    {
        if ($this->model == null) {

It seems like you are loosely comparing $this->model of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $this->inflectModel();
        }

        return $this->model;
    }

    /**
     * @param null $model

Are you sure the doc-type for parameter $model is correct as it would always require null to be passed?

     */
    public function setModel($model)
    {
        $this->model = $model;
    }

    protected function inflectModel()
    {
        $class = $this->getClassName();
        $this->model = $this->generateModelClass($class);
    }

    /**
     * @param string $class
     * @return string
     */
    public function generateModelClass($class = null)
    {
        $class = $class ? $class : get_class($this);

        if (strpos($class, '\\')) {
            $nsParts = explode('\\', $class);
            $class = array_pop($nsParts);

            if ($class == 'Table') {
                $class = 'Row';
            } else {
                $class = ucfirst(inflector()->singularize($class));
            }

            return implode($nsParts, '\\') . '\\' . $class;

'\' of type string is incompatible with the type array expected by parameter $pieces of implode().

        }

        return ucfirst(inflector()->singularize($class));
    }
}