alsvanzelf\jsonapi\objects\RelationshipObject

Complexity

Total Complexity

62

Size/Duplication

Total Lines	325
Duplicated Lines	0.92 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
A	fromAnything()	0	20	5
A	fromResource()	0	19	5
A	fromCollectionDocument()	0	16	4
A	setSelfLink()	0	3	1
A	setRelatedLink()	0	3	1
A	setPaginationLinks()	0	18	6
A	addMeta()	0	7	2
A	setResource()	0	7	2
A	addResource()	0	7	2
A	setMetaObject()	0	3	1
A	hasResource()	0	17	6
B	isEmpty()	3	19	10
B	toArray()	0	24	9
B	getNestedContainedResourceObjects()	0	26	6

<?php

namespace alsvanzelf\jsonapi\objects;

use alsvanzelf\jsonapi\CollectionDocument;
use alsvanzelf\jsonapi\exceptions\InputException;
use alsvanzelf\jsonapi\helpers\AtMemberManager;
use alsvanzelf\jsonapi\helpers\LinksManager;
use alsvanzelf\jsonapi\interfaces\ObjectInterface;
use alsvanzelf\jsonapi\interfaces\PaginableInterface;
use alsvanzelf\jsonapi\interfaces\RecursiveResourceContainerInterface;
use alsvanzelf\jsonapi\interfaces\ResourceInterface;
use alsvanzelf\jsonapi\objects\LinksObject;
use alsvanzelf\jsonapi\objects\MetaObject;
use alsvanzelf\jsonapi\objects\ResourceObject;

class RelationshipObject implements ObjectInterface, PaginableInterface, RecursiveResourceContainerInterface {

Missing doc comment for class RelationshipObject

	use AtMemberManager, LinksManager;
	
	const TO_ONE  = 'one';
	const TO_MANY = 'many';
	
	/** @var MetaObject */
	protected $meta;
	/** @var ResourceInterface */
	protected $resource;
	/** @var string one of the RelationshipObject::TO_* constants */
	protected $type;
	/** @var ResourceInterface[] */
	protected $resources = [];
	
	/**
	 * @param string $type one of the RelationshipObject::TO_* constants
	 * 
	 * @throws InputException if $type is unknown
	 */
	public function __construct($type) {
		if (in_array($type, [RelationshipObject::TO_ONE, RelationshipObject::TO_MANY], $strict=true) === false) {
			throw new InputException('unknown relationship type "'.$type.'"');
		}
		
		$this->type = $type;
	}
	
	/**
	 * human api
	 */
	
	/**
	 * create a RelationshipObject from mixed input
	 * 
	 * @param  mixed  $relation ResourceInterface | ResourceInterface[] | CollectionDocument

Expected 1 spaces after parameter type; 2 found

	 * @param  array  $links    optional

Expected 1 spaces after parameter type; 2 found

	 * @param  array  $meta     optional

Expected 1 spaces after parameter type; 2 found

	 * @return RelationshipObject
	 * 
	 * @throws InputException if $relation is not one of the supported formats
	 */
	public static function fromAnything($relation, array $links=[], array $meta=[]) {
		if (is_array($relation)) {
			$relation = CollectionDocument::fromResources(...$relation);
		}
		
		if ($relation instanceof ResourceInterface) {
			$relationshipObject = self::fromResource($relation, $links, $meta);
		}
		elseif ($relation instanceof CollectionDocument) {
			$relationshipObject = self::fromCollectionDocument($relation, $links, $meta);
		}
		elseif ($relation === null) {
			$relationshipObject = new RelationshipObject(RelationshipObject::TO_ONE);
		}
		else {
			throw new InputException('unknown format of relation "'.gettype($relation).'"');
		}
		
		return $relationshipObject;
	}
	
	/**
	 * @param  ResourceInterface $resource

Missing parameter comment

	 * @param  array             $links    optional
	 * @param  array             $meta     optional
	 * @param  string            $type     optional, one of the RelationshipObject::TO_* constants, defaults to RelationshipObject::TO_ONE
	 * @return RelationshipObject
	 */
	public static function fromResource(ResourceInterface $resource, array $links=[], array $meta=[], $type=RelationshipObject::TO_ONE) {
		$relationshipObject = new self($type);
		
		if ($type === RelationshipObject::TO_ONE) {
			$relationshipObject->setResource($resource);
		}
		elseif ($type === RelationshipObject::TO_MANY) {
			$relationshipObject->addResource($resource);
		}
		
		if ($links !== []) {
			$relationshipObject->setLinksObject(LinksObject::fromArray($links));
		}
		if ($meta !== []) {
			$relationshipObject->setMetaObject(MetaObject::fromArray($meta));
		}
		
		return $relationshipObject;
	}
	
	/**
	 * @param  CollectionDocument $collectionDocument

Missing parameter comment

	 * @param  array              $links              optional
	 * @param  array              $meta               optional
	 * @return RelationshipObject
	 */
	public static function fromCollectionDocument(CollectionDocument $collectionDocument, array $links=[], array $meta=[]) {
		$relationshipObject = new self(RelationshipObject::TO_MANY);
		
		foreach ($collectionDocument->getContainedResources() as $resource) {
			$relationshipObject->addResource($resource);
		}
		
		if ($links !== []) {
			$relationshipObject->setLinksObject(LinksObject::fromArray($links));
		}
		if ($meta !== []) {
			$relationshipObject->setMetaObject(MetaObject::fromArray($meta));
		}
		
		return $relationshipObject;
	}
	
	/**
	 * @param string $href

Missing parameter comment

	 * @param array  $meta optional, if given a LinkObject is added, otherwise a link string is added
	 */

Missing @return tag in function comment

	public function setSelfLink($href, array $meta=[]) {
		$this->addLink('self', $href, $meta);
	}
	
	/**
	 * @param string $href

Missing parameter comment

	 * @param array  $meta optional, if given a LinkObject is added, otherwise a link string is added
	 */

Missing @return tag in function comment

	public function setRelatedLink($href, array $meta=[]) {
		$this->addLink('related', $href, $meta);
	}
	
	/**

Parameter $lastHref should have a doc-comment as per coding-style.

Parameter $firstHref should have a doc-comment as per coding-style.

Parameter $nextHref should have a doc-comment as per coding-style.

Parameter $previousHref should have a doc-comment as per coding-style.

	 * @inheritDoc
	 * 
	 * @throws InputException if used on a to-one relationship
	 */

Missing @return tag in function comment

	public function setPaginationLinks($previousHref=null, $nextHref=null, $firstHref=null, $lastHref=null) {
		if ($this->type === RelationshipObject::TO_ONE) {
			throw new InputException('can not add pagination links to a to-one relationship');
		}
		
		if ($previousHref !== null) {
			$this->addLink('prev', $previousHref);
		}
		if ($nextHref !== null) {
			$this->addLink('next', $nextHref);
		}
		if ($firstHref !== null) {
			$this->addLink('first', $firstHref);
		}
		if ($lastHref !== null) {
			$this->addLink('last', $lastHref);
		}
	}
	
	/**
	 * @param string $key

Missing parameter comment

	 * @param mixed  $value

Missing parameter comment

	 */

Missing @return tag in function comment

	public function addMeta($key, $value) {
		if ($this->meta === null) {
			$this->setMetaObject(new MetaObject());
		}
		
		$this->meta->add($key, $value);
	}
	
	/**
	 * spec api
	 */
	
	/**
	 * set the resource on a to-one relationship
	 * 
	 * @param ResourceInterface $resource

Missing parameter comment

	 * 
	 * @throws InputException if used on a to-many relationship, use {@see ->addResource()} instead
	 */

Missing @return tag in function comment

	public function setResource(ResourceInterface $resource) {
		if ($this->type === RelationshipObject::TO_MANY) {
			throw new InputException('can not set a resource on a to-many relationship, use ->addResource()');
		}
		
		$this->resource = $resource;
	}
	
	/**
	 * add a resource to a to-many relationship
	 * 
	 * @param ResourceInterface $resource

Missing parameter comment

	 * 
	 * @throws InputException if used on a to-one relationship, use {@see ->setResource()} instead
	 */

Missing @return tag in function comment

	public function addResource(ResourceInterface $resource) {
		if ($this->type === RelationshipObject::TO_ONE) {
			throw new InputException('can not add a resource to a to-one relationship, use ->setResource()');
		}
		
		$this->resources[] = $resource;
	}
	
	/**
	 * @param MetaObject $metaObject

Missing parameter comment

	 */

Missing @return tag in function comment

	public function setMetaObject(MetaObject $metaObject) {
		$this->meta = $metaObject;
	}
	
	/**
	 * internal api
	 */
	
	/**
	 * whether or not the $otherResource is (one of) the resource(s) inside the relationship
	 * 
	 * @internal
	 * 
	 * @param  ResourceInterface $otherResource

Missing parameter comment

	 * @return boolean
	 */
	public function hasResource(ResourceInterface $otherResource) {
		if ($this->isEmpty()) {
			return false;
		}
		if ($this->type === RelationshipObject::TO_ONE) {
			return $this->resource->getResource()->equals($otherResource->getResource());
		}
		if ($this->type === RelationshipObject::TO_MANY) {
			foreach ($this->resources as $ownResource) {
				if ($ownResource->getResource()->equals($otherResource->getResource())) {
					return true;
				}
			}
		}
		
		return false;
	}
	
	/**
	 * ObjectInterface
	 */
	
	/**
	 * @inheritDoc
	 */

Missing @return tag in function comment

	public function isEmpty() {
		if ($this->type === RelationshipObject::TO_ONE && $this->resource !== null) {
			return false;
		}
		if ($this->type === RelationshipObject::TO_MANY && $this->resources !== []) {
			return false;
		}
		if ($this->links !== null && $this->links->isEmpty() === false) {

This code seems to be duplicated across your project.

			return false;
		}
		if ($this->meta !== null && $this->meta->isEmpty() === false) {
			return false;
		}
		if ($this->hasAtMembers()) {
			return false;
		}
		
		return true;
	}
	
	/**
	 * @inheritDoc
	 */

Missing @return tag in function comment

	public function toArray() {
		$array = $this->getAtMembers();
		
		if ($this->links !== null && $this->links->isEmpty() === false) {
			$array['links'] = $this->links->toArray();
		}
		if ($this->type === RelationshipObject::TO_ONE) {
			$array['data'] = null;
			if ($this->resource !== null) {
				$array['data'] = $this->resource->getResource($identifierOnly=true)->toArray();
			}
		}
		if ($this->type === RelationshipObject::TO_MANY) {
			$array['data'] = [];
			foreach ($this->resources as $resource) {
				$array['data'][] = $resource->getResource($identifierOnly=true)->toArray();
			}
		}
		if ($this->meta !== null && $this->meta->isEmpty() === false) {
			$array['meta'] = $this->meta->toArray();
		}
		
		return $array;
	}
	
	/**
	 * RecursiveResourceContainerInterface
	 */
	
	/**
	 * @inheritDoc
	 */

Missing @return tag in function comment

	public function getNestedContainedResourceObjects() {
		if ($this->isEmpty()) {
			return [];
		}
		
		$resources       = ($this->type === RelationshipObject::TO_ONE) ? [$this->resource] : $this->resources;
		$resourceObjects = [];
		
		foreach ($resources as $resource) {
			if ($resource->getResource() instanceof ResourceObject === false) {
				continue;
			}
			
			/** @var ResourceObject */
			$resourceObject = $resource->getResource();
			
			if ($resourceObject->hasIdentifierPropertiesOnly()) {
				continue;
			}
			
			$resourceObjects[] = $resourceObject;
			$resourceObjects   = array_merge($resourceObjects, $resourceObject->getNestedContainedResourceObjects());
		}
		
		return $resourceObjects;
	}
}