ResourceDocument::toArray() - Code Metrics - Inspection of "Fix automated tests" - lode/jsonapi - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — main (#64)

by Lode

created 2021-05-14 08:44 UTC

ResourceDocument::toArray() A

↳ Parent: ResourceDocument

Complexity

Conditions	3
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.9332
c	0
b	0
f	0
cc	3
nc	2
nop	0

<?php

namespace alsvanzelf\jsonapi;

use alsvanzelf\jsonapi\CollectionDocument;
use alsvanzelf\jsonapi\DataDocument;
use alsvanzelf\jsonapi\Document;
use alsvanzelf\jsonapi\exceptions\Exception;
use alsvanzelf\jsonapi\exceptions\InputException;
use alsvanzelf\jsonapi\helpers\Converter;
use alsvanzelf\jsonapi\interfaces\RecursiveResourceContainerInterface;
use alsvanzelf\jsonapi\interfaces\ResourceInterface;
use alsvanzelf\jsonapi\objects\AttributesObject;
use alsvanzelf\jsonapi\objects\RelationshipObject;
use alsvanzelf\jsonapi\objects\RelationshipsObject;
use alsvanzelf\jsonapi\objects\ResourceIdentifierObject;
use alsvanzelf\jsonapi\objects\ResourceObject;

/**
 * this document represents an entity or other resource of the api
 * it can contain other Resources as relationships
 * a CollectionDocument should be used if the primary Resource is (or can be) a set
 */

class ResourceDocument extends DataDocument implements ResourceInterface {
	/** @var ResourceIdentifierObject|ResourceObject */
	protected $resource;
	/** @var array */
	protected static $defaults = [
		/**
		 * add resources inside relationships to /included when adding resources to the collection
		 */
		'includeContainedResources' => true,
	];
	
	/**
	 * @note $type and $id are optional to pass during construction
	 *       however they are required for a valid ResourceDocument
	 *       so use ->setPrimaryResource() if not passing them during construction
	 * 
	 * @param string     $type optional
	 * @param string|int $id   optional
	 */
	public function __construct($type=null, $id=null) {
		parent::__construct();
		
		$this->setPrimaryResource(new ResourceObject($type, $id));
	}
	
	/**
	 * human api
	 */
	
	/**
	 * @param  array      $attributes

	 * @param  string     $type       optional
	 * @param  string|int $id         optional
	 * @param  array      $options    optional {@see ResourceDocument::$defaults} {@see ResourceObject::$defaults}
	 * @return ResourceDocument
	 */
	public static function fromArray(array $attributes, $type=null, $id=null, array $options=[]) {
		$resourceDocument = new self();
		$resourceDocument->setPrimaryResource(ResourceObject::fromArray($attributes, $type, $id, $options), $options);
		
		return $resourceDocument;
	}
	
	/**
	 * @param  object     $attributes

	 * @param  string     $type       optional
	 * @param  string|int $id         optional
	 * @param  array      $options    optional {@see ResourceDocument::$defaults}
	 * @return ResourceDocument
	 */
	public static function fromObject($attributes, $type=null, $id=null, array $options=[]) {
		$array = Converter::objectToArray($attributes);
		
		return self::fromArray($array, $type, $id, $options);
	}
	
	/**
	 * add key-value pairs to the resource's attributes
	 * 
	 * @param string $key

	 * @param mixed  $value   objects will be converted using `get_object_vars()`
	 * @param array  $options optional {@see ResourceDocument::$defaults}
	 */

	public function add($key, $value, array $options=[]) {
		$this->ensureResourceObject();
		
		$this->resource->add($key, $value, $options);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
	}
	
	/**
	 * add a relation to the resource
	 * 
	 * adds included resources if found inside the relation, unless $options['includeContainedResources'] is set to false
	 * 
	 * @param string  $key

	 * @param mixed   $relation ResourceInterface | ResourceInterface[] | CollectionDocument

	 * @param array   $links    optional

	 * @param array   $meta     optional

	 * @param array   $options  optional {@see ResourceDocument::$defaults}

	 */

	public function addRelationship($key, $relation, array $links=[], array $meta=[], array $options=[]) {
		$this->ensureResourceObject();
		
		$options = array_merge(self::$defaults, $options);
		
		$relationshipObject = $this->resource->addRelationship($key, $relation, $links, $meta);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		
		if ($options['includeContainedResources']) {
			$this->addIncludedResourceObject(...$relationshipObject->getNestedContainedResourceObjects());
		}
	}
	
	/**
	 * @param string $key

	 * @param string $href

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

	 * @param string $level one of the Document::LEVEL_* constants, optional, defaults to Document::LEVEL_ROOT
	 */

	public function addLink($key, $href, array $meta=[], $level=Document::LEVEL_ROOT) {

		$this->ensureResourceObject();
		
		if ($level === Document::LEVEL_RESOURCE) {
			$this->resource->addLink($key, $href, $meta);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		}
		else {
			parent::addLink($key, $href, $meta, $level);
		}
	}
	
	/**

	 * set the self link on the resource
	 * 
	 * @param string $href

	 * @param array  $meta optional
	 */

	public function setSelfLink($href, array $meta=[], $level=Document::LEVEL_RESOURCE) {

		$this->ensureResourceObject();
		
		if ($level === Document::LEVEL_RESOURCE) {
			$this->resource->setSelfLink($href, $meta);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		}
		else {
			parent::setSelfLink($href, $meta, $level);
		}
	}
	
	/**
	 * @param string $key

	 * @param mixed  $value

	 * @param string $level one of the Document::LEVEL_* constants, optional, defaults to Document::LEVEL_ROOT
	 */

	public function addMeta($key, $value, $level=Document::LEVEL_ROOT) {
		if ($level === Document::LEVEL_RESOURCE) {
			$this->resource->addMeta($key, $value);
		}
		else {
			parent::addMeta($key, $value, $level);
		}
	}
	
	/**
	 * wrapping ResourceObject spec api
	 */
	
	/**
	 * @param string $type

	 */

	public function setType($type) {
		$this->resource->setType($type);
	}
	
	/**
	 * @param string|int $id will be casted to a string
	 */

	public function setId($id) {
		$this->resource->setId($id);
	}
	
	/**
	 * @param AttributesObject $attributesObject

	 * @param array            $options          optional {@see ResourceObject::$defaults}
	 */

	public function setAttributesObject(AttributesObject $attributesObject, array $options=[]) {
		$this->ensureResourceObject();
		
		$this->resource->setAttributesObject($attributesObject, $options);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
	}
	
	/**
	 * add a RelationshipObject to the resource
	 * 
	 * adds included resources if found inside the RelationshipObject, unless $options['includeContainedResources'] is set to false
	 * 
	 * @param string             $key

	 * @param RelationshipObject $relationshipObject

	 * @param array              $options            optional {@see ResourceDocument::$defaults}
	 */

	public function addRelationshipObject($key, RelationshipObject $relationshipObject, array $options=[]) {

		$this->ensureResourceObject();
		
		$options = array_merge(self::$defaults, $options);
		
		$this->resource->addRelationshipObject($key, $relationshipObject);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		
		if ($options['includeContainedResources']) {
			$this->addIncludedResourceObject(...$relationshipObject->getNestedContainedResourceObjects());
		}
	}
	
	/**
	 * set the RelationshipsObject to the resource
	 * 
	 * adds included resources if found inside the RelationshipObjects inside the RelationshipsObject, unless $options['includeContainedResources'] is set to false
	 * 
	 * @param RelationshipsObject $relationshipsObject

	 * @param array               $options             optional {@see ResourceDocument::$defaults}
	 */

	public function setRelationshipsObject(RelationshipsObject $relationshipsObject, array $options=[]) {

		$this->ensureResourceObject();
		
		$options = array_merge(self::$defaults, $options);
		
		$this->resource->setRelationshipsObject($relationshipsObject);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		
		if ($options['includeContainedResources']) {
			$this->addIncludedResourceObject(...$relationshipsObject->getNestedContainedResourceObjects());
		}
	}
	
	/**
	 * spec api
	 */
	
	/**
	 * overwrites the primary resource
	 * 
	 * adds included resources if found inside the resource's relationships, unless $options['includeContainedResources'] is set to false
	 * 
	 * @param ResourceInterface $resource

	 * @param array             $options  optional {@see ResourceDocument::$defaults}
	 * 
	 * @throws InputException if the $resource is a ResourceDocument itself
	 */

	public function setPrimaryResource(ResourceInterface $resource, array $options=[]) {
		if ($resource instanceof ResourceDocument) {
			throw new InputException('does not make sense to set a document inside a document, use ResourceObject or ResourceIdentifierObject instead');
		}
		
		$options = array_merge(self::$defaults, $options);
		
		$this->resource = $resource;

		
		if ($options['includeContainedResources'] && $this->resource instanceof RecursiveResourceContainerInterface) {
			$this->addIncludedResourceObject(...$this->resource->getNestedContainedResourceObjects());
		}
	}
	
	/**
	 * internal api
	 */
	
	/**
	 * @internal
	 * 
	 * @throws Exception
	 */

	private function ensureResourceObject() {
		if ($this->resource instanceof ResourceObject === false) {
			throw new Exception('the resource is an identifier-only object');
		}
	}
	
	/**
	 * DocumentInterface
	 */
	
	/**
	 * @inheritDoc
	 */

	public function toArray() {
		$array = parent::toArray();
		
		$array['data'] = null;
		if ($this->resource !== null && $this->resource->isEmpty() === false) {
			$array['data'] = $this->resource->toArray();
		}
		
		return $array;
	}
	
	/**
	 * ResourceInterface
	 */
	
	/**

	 * @inheritDoc
	 */

	public function getResource($identifierOnly=false) {
		return $this->resource->getResource($identifierOnly);
	}
}


Pull Request — main (#64)

ResourceDocument::toArray() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace alsvanzelf\jsonapi;
4
5			use alsvanzelf\jsonapi\CollectionDocument;
6			use alsvanzelf\jsonapi\DataDocument;
7			use alsvanzelf\jsonapi\Document;
8			use alsvanzelf\jsonapi\exceptions\Exception;
9			use alsvanzelf\jsonapi\exceptions\InputException;
10			use alsvanzelf\jsonapi\helpers\Converter;
11			use alsvanzelf\jsonapi\interfaces\RecursiveResourceContainerInterface;
12			use alsvanzelf\jsonapi\interfaces\ResourceInterface;
13			use alsvanzelf\jsonapi\objects\AttributesObject;
14			use alsvanzelf\jsonapi\objects\RelationshipObject;
15			use alsvanzelf\jsonapi\objects\RelationshipsObject;
16			use alsvanzelf\jsonapi\objects\ResourceIdentifierObject;
17			use alsvanzelf\jsonapi\objects\ResourceObject;
18
19			/**
20			* this document represents an entity or other resource of the api
21			* it can contain other Resources as relationships
22			* a CollectionDocument should be used if the primary Resource is (or can be) a set
23			*/
			0 ignored issues – show Coding Style introduced 2021-05-14 08:52 UTC by Report Bug Copy Issue Report Missing @package tag in class comment Loading history... Coding Style introduced 2021-05-14 08:52 UTC by Report Bug Copy Issue Report Missing @author tag in class comment Loading history... Coding Style introduced 2021-05-14 08:52 UTC by Report Bug Copy Issue Report Missing @license tag in class comment Loading history... Coding Style introduced 2021-05-14 08:52 UTC by Report Bug Copy Issue Report Missing @link tag in class comment Loading history... Coding Style introduced 2021-05-14 08:52 UTC by Report Bug Copy Issue Report Missing @category tag in class comment Loading history...
24			class ResourceDocument extends DataDocument implements ResourceInterface {
25			/** @var ResourceIdentifierObject\|ResourceObject */
26			protected $resource;
27			/** @var array */
28			protected static $defaults = [
29			/**
30			* add resources inside relationships to /included when adding resources to the collection
31			*/
32			'includeContainedResources' => true,
33			];
34
35			/**
36			* @note $type and $id are optional to pass during construction
37			* however they are required for a valid ResourceDocument
38			* so use ->setPrimaryResource() if not passing them during construction
39			*

lode / jsonapi

Pull Request — main (#64)

ResourceDocument::toArray() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like