prgTW / basecrm-php-api

Resource/Resource.php

<?php

namespace prgTW\BaseCRM\Resource;

use Doctrine\Common\Inflector\Inflector;
use prgTW\BaseCRM\Transport\Transport;

abstract class Resource extends BaseResource
{
	/** @var \Resource[] */
	protected $subResources = [];

	/** @var Transport */
	protected $transport;

	/** @var string */
	protected $uri;

	/**
	 * @param Transport $transport
	 * @param string    $uri
	 * @param array     $data
	 */
	public function __construct(Transport $transport, $uri, array $data = [])
	{
		$this->transport = $transport;
		$this->uri       = $uri;
		if ([] !== $data)
		{
			$this->hydrate($data);
		}

		$this->init();
	}

	/**
	 * @return string
	 */
	abstract protected function getEndpoint();

	protected function init()
	{

	}

	/**
	 * @param string $suffix
	 *
	 * @return string
	 */
	protected function getFullUri($suffix = '')
	{
		return sprintf('%s/%s/%s%s', static::getEndpoint(), static::PREFIX, $this->uri, $suffix);
	}

	/**
	 * @param string $name

Should the type for parameter $name not be string|null?

	 *
	 * @return Resource|\Resource[]

Should the return type not be \Resource|null|\Resource[]?

	 */
	public function getSubResources($name = null)
	{
		if (isset($name))
		{
			return isset($this->subResources[$name]) ? $this->subResources[$name] : null;
		}

		return $this->subResources;
	}

	/**
	 * @param string[] $resourceClassNames
	 *
	 * @throws \InvalidArgumentException when class name is not a Resource
	 */
	protected function setSubResources(array $resourceClassNames)
	{
		foreach ($resourceClassNames as $key => $value)
		{
			$resourceClassName = is_int($key) ? $value : $key;
			if (false === is_subclass_of($resourceClassName, Resource::class))

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \prgTW\BaseCRM\Resource\Resource::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

			{
				//@codeCoverageIgnoreStart
				throw new \InvalidArgumentException(sprintf('Class %s is not an instance of %s', $resourceClassName, Resource::class));

This line exceeds maximum limit of 120 characters; contains 123 characters

				//@codeCoverageIgnoreEnd
			}
			$resourceName = $this->getResourceName($resourceClassName);
			$uri          = ltrim(sprintf('%s/%s', $this->uri, $resourceName), '/');
			if (false === is_int($key))
			{
				$uri = $value;
			}

			$class = new $resourceClassName($this->transport, $uri);

			$this->subResources[lcfirst(Inflector::camelize($resourceName))] = $class;
		}
	}

	/**
	 * @param array  $params
	 * @param string $instanceClassName

Should the type for parameter $instanceClassName not be string|null?

	 * @param string $idParam
	 *
	 * @return Resource

Should the return type not be object?

	 */
	protected function getObjectFromArray(array $params, $instanceClassName = null, $idParam = 'id')
	{
		if (null === $instanceClassName)
		{
			$instanceClassName = Inflector::singularize(static::class);
		}

		if (array_key_exists($idParam, $params))
		{
			$uri = sprintf('%s/%s', $this->uri, $params[$idParam]);
		}
		else
		{
			$uri = $this->uri;
		}

		return new $instanceClassName($this->transport, $uri, $params);
	}

	/**
	 * @param $method
	 * @param $arguments
	 *
	 * @return Resource|ResourceCollection

Should the return type not be \Resource|\Resource[]?

	 * @throws \BadMethodCallException
	 */
	public function __call($method, $arguments)
	{
		if ('get' !== substr($method, 0, 3))
		{
			//@codeCoverageIgnoreStart
			throw new \BadMethodCallException('Unknown resource');
			//@codeCoverageIgnoreEnd
		}

		$key         = lcfirst(substr($method, 3));
		$subResource = $this->getSubResources($key);
		if (null === $subResource)
		{
			//@codeCoverageIgnoreStart
			throw new \BadMethodCallException(sprintf('Resource "%s" not found', $key));
			//@codeCoverageIgnoreEnd
		}

		return $subResource;
	}

	/**
	 * @return Transport
	 */
	public function getTransport()
	{
		return $this->transport;
	}
}