AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\EntityGubbins

Complexity

Total Complexity

43

Size/Duplication

Total Lines	265
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
B	isPolymorphicAffected()	0	17	5
A	getOdataResourceType()	0	4	1
A	setOdataResourceType()	0	8	2
A	getName()	0	4	1
A	setName()	0	4	1
A	getClassName()	0	4	1
A	setClassName()	0	4	1
A	getKeyFields()	0	4	1
A	getFields()	0	4	1
B	setFields()	0	23	6
A	getStubs()	0	4	1
A	setStubs()	0	10	3
D	addAssociation()	0	32	9
A	getFieldNames()	0	8	2
A	getAssociationNames()	0	11	3
A	getAssociations()	0	4	1
A	resolveAssociation()	0	5	3
A	isOK()	0	7	1

<?php

namespace AlgoWeb\PODataLaravel\Models\ObjectMap\Entities;

use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\Association;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationMonomorphic;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationPolymorphic;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationStubBase;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationStubPolymorphic;
use POData\Providers\Metadata\ResourceEntityType;

class EntityGubbins
{
    /**
     * @var string
     */
    private $name;

    /**
     * @var string
     */
    private $className;

    /**
     * @var EntityField[]
     */
    private $keyFields;

    /**
     * @var EntityField[]
     */
    private $fields;

    /**
     * @var AssociationStubBase[]
     */
    private $stubs;

    /**
     * @var Association[]
     */
    private $associations;
    /**
     * @var ResourceEntityType
     */
    private $odataResourceType;
    /**
     * @var bool|null
     */
    private $isPolymorphicAffected = null;

    //TODO: move the checking part of this to the set stubs method.

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

    public function isPolymorphicAffected()
    {
        if (null !== $this->isPolymorphicAffected) {
            return $this->isPolymorphicAffected;
        }
        $this->isPolymorphicAffected = false;
        foreach ($this->stubs as $stub) {
            if (!$stub instanceof AssociationStubPolymorphic) {
                continue;
            }
            if (null !== $stub->getTargType()) {
                $this->isPolymorphicAffected = true;
                break;
            }
        }
        return $this->isPolymorphicAffected;
    }

    /**
     * @return ResourceEntityType
     */
    public function getOdataResourceType()
    {
        return $this->odataResourceType;
    }

    /**
     * @param ResourceEntityType $odataType
     */
    public function setOdataResourceType(ResourceEntityType $odataType)
    {
        if ($odataType->isAbstract()) {
            $msg = 'OData resource entity type must be concrete';
            throw new \InvalidArgumentException($msg);
        }
        $this->odataResourceType = $odataType;
    }

    /**
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @param string $name
     */
    public function setName($name)
    {
        $this->name = $name;
    }

    /**
     * @return string
     */
    public function getClassName()
    {
        return $this->className;
    }

    /**
     * @param string $className
     */
    public function setClassName($className)
    {
        $this->className = $className;
    }

    /**
     * @return EntityField[]
     */
    public function getKeyFields()
    {
        return $this->keyFields;
    }

    /**
     * @return EntityField[]
     */
    public function getFields()
    {
        return $this->fields;
    }

    /**
     * @param EntityField[] $fields
     */
    public function setFields(array $fields)
    {
        if (0 == count($fields)) {
            $msg = 'Fields array must not be empty';
            throw new \Exception($msg);
        }
        $keys = [];
        foreach ($fields as $propName => $field) {
            if (!$field instanceof EntityField) {
                $msg = 'Fields array must only have EntityField objects';
                throw new \Exception($msg);
            }
            if ($field->getIsKeyField()) {
                $keys[$propName] = $field;
            }
        }
        if (0 == count($keys)) {
            $msg = 'No key field supplied in fields array';
            throw new \Exception($msg);
        }
        $this->fields = $fields;
        $this->keyFields = $keys;
    }

    /**
     * @return AssociationStubBase[]
     */
    public function getStubs()
    {
        return $this->stubs;
    }

    /**
     * @param AssociationStubBase[] $stubs
     */
    public function setStubs(array $stubs)
    {
        foreach ($stubs as $field) {
            if (!$field instanceof AssociationStubBase) {
                $msg = 'Stubs array must only have AssociationStubBase objects';
                throw new \Exception($msg);
            }
        }
        $this->stubs = $stubs;
    }

    /**
     * @param Association $association
     * @param bool        $isFirst
     */
    public function addAssociation(Association $association, $isFirst = true)
    {
        if ($association instanceof AssociationMonomorphic) {
            $stub = $isFirst ? $association->getFirst() : $association->getLast();
            if (null === $stub || !in_array($stub, $this->stubs)) {
                throw new \InvalidArgumentException('Association cannot be connected to this entity');
            }
            $propertyName = $stub->getRelationName();
        } elseif ($association instanceof AssociationPolymorphic) {
            if ($isFirst) {
                $stub = $association->getFirst();
                if (!in_array($stub, $this->stubs)) {
                    throw new \InvalidArgumentException('Association cannot be connected to this entity');
                }
            } else {
                $comp = function (AssociationStubBase $one, AssociationStubBase $two) {
                    return $one->compare($two);
                };
                $stubs = $association->getLast();
                assert(is_array($stubs));
                assert(is_array($this->stubs));
                $inter = array_uintersect(array_values($stubs), array_values($this->stubs), $comp);
                if (1 !== count($inter)) {
                    throw new \InvalidArgumentException('Association cannot be connected to this entity');
                }
                $stub = array_values($inter)[0];
            }
            $propertyName = $stub->getRelationName();
        }
        assert(isset($propertyName));
        $this->associations[$propertyName] = $association;

The variable $propertyName does not seem to be defined for all execution paths leading up to this point.

    }

    /**
     * @return String[]
     */
    protected function getFieldNames()
    {
        $fieldNames = [];
        foreach ($this->fields as $field) {
            $fieldNames[] = $field->getName();
        }
        return $fieldNames;
    }

    /**
     * @return String[]
     */
    protected function getAssociationNames()
    {
        if (empty($this->stubs)) {
            return [];
        }
        $assocationNames = [];
        foreach ($this->stubs as $stub) {
            $assocationNames[] = $stub->getRelationName();
        }
        return $assocationNames;
    }

    /**
     * @return Associations\Association[]
     */
    public function getAssociations()
    {
        return $this->associations;
    }

    public function resolveAssociation($relName)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $this->associations = is_array($this->associations) ? $this->associations : [];
        return array_key_exists($relName, $this->associations) ? $this->associations[$relName] : null;
    }

    /**
     * @return bool
     */
    public function isOK()
    {
        $fieldNames = $this->getFieldNames();
        $associationNames = $this->getAssociationNames();
        $intersection = array_intersect($fieldNames, $associationNames);
        return 0 === count($intersection);
    }
}