Nip\Records\Relations\Traits\HasWithTrait

Complexity

Total Complexity

16

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Test Coverage

Coverage

86.05%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getWithClass()	0	4	1
A	setWith()	0	5	1
A	generateWithPK()	0	3	1
A	initWithPK()	0	3	1
A	checkParamWithPK()	0	5	2
A	initWith()	0	4	1
A	getWith()	0	8	2
A	getWithPK()	0	6	2
A	setWithClass()	0	10	2
A	setWithPK()	0	3	1
A	checkParamWith()	0	5	2

<?php

namespace Nip\Records\Relations\Traits;

use Exception;
use Nip\Records\AbstractModels\RecordManager;
use Nip\Records\Locator\Exceptions\InvalidModelException;
use Nip\Records\Relations\Relation;
use Nip\Records\Traits\Relations\HasRelationsRecordsTrait;

/**
 * Trait HasWithTrait
 * @package Nip\Records\Relations\Traits
 */
trait HasWithTrait
{
    /**
     * @var RecordManager
     */
    protected $with = null;

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

    /** @noinspection PhpDocMissingThrowsInspection
     * @return RecordManager
     */
    public function getWith()
    {
        if ($this->with == null) {
            /** @noinspection PhpUnhandledExceptionInspection */
            $this->initWith();
        }

        return $this->with;
    }

    /**
     * @param RecordManager|HasRelationsRecordsTrait $object
     * @return $this
     */
    public function setWith($object)
    {
        $this->with = $object;

It seems like $object can also be of type Nip\Records\Traits\Relations\HasRelationsRecordsTrait. However, the property $with is declared as type Nip\Records\AbstractModels\RecordManager. Maybe add an additional type check?

        return $this;
    }

    /**
     * @throws Exception
     */
    public function initWith()
    {
        $className = $this->getWithClass();
        $this->setWithClass($className);
    }

    /** @noinspection PhpDocMissingThrowsInspection
     * @return string
     */
    public function getWithClass()
    {
        /** @noinspection PhpUnhandledExceptionInspection */
        return inflector()->pluralize($this->getName());

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

    }

    /**
     * @param $params
     */
    public function checkParamWith($params)
    {
        if (isset($params['with'])) {
            $this->setWith($params['with']);
            unset($params['with']);
        }
    }

    /**
     * @param $params
     */
    public function checkParamWithPK($params)
    {
        if (isset($params['withPK'])) {
            $this->setWithPK($params['withPK']);
            unset($params['withPK']);
        }
    }

    /** @noinspection PhpDocMissingThrowsInspection
     * @param string $name
     */
    public function setWithClass($name)
    {
        try {
            $manager = $this->getModelManagerInstance($name);

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

            $this->setWith($manager);
        } catch (InvalidModelException $exception) {
            /** @noinspection PhpUnhandledExceptionInspection */
            throw new Exception(
                'Cannot instance records [' . $name . '] in ' . $this->debugString()

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

                . '|| with message ' . $exception->getMessage()
            );
        }
    }

    /**
     * @return string
     */
    public function getWithPK()
    {
        if ($this->withPK === null) {
            $this->initWithPK();
        }
        return $this->withPK;
    }

    /**
     * @param string|null $withPK
     */
    public function setWithPK(string $withPK)
    {
        $this->withPK = $withPK;
    }

    protected function initWithPK()
    {
        $this->withPK = $this->generateWithPK();
    }

    /**
     * @return string
     */
    protected function generateWithPK()
    {
        return $this->getWith()->getPrimaryKey();
    }
}