blitze\sitemaker\model\base_entity

Complexity

Total Complexity

22

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	1	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	get_attributes()	0	4	1
A	attribute_exists()	0	8	2
A	check_required()	0	10	3
A	validate_attribute()	0	17	4
A	get_property_type()	0	10	1
A	__construct()	0	8	2
A	__call()	0	19	4
A	to_array()	0	14	2
A	to_db()	0	16	3

<?php
/**
 *
 * @package sitemaker
 * @copyright (c) 2015 Daniel A. (blitze)
 * @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License v2
 *
 */

namespace blitze\sitemaker\model;

abstract class base_entity implements entity_interface
{
	/** @var array */
	protected $db_fields = array();

	/** @var array */
	protected $required_fields = array();

	/**
	 * Populate the entity with data
	 * @param array $data
	 */
	public function __construct(array $data)
	{
		foreach ($data as $name => $value)
		{
			$mutator = 'set_' . $name;
			$this->$mutator($value);
		}
	}

	/**
	 * @param $name
	 * @param $args
	 * @return $this
	 * @throws \blitze\sitemaker\exception\unexpected_value
	 */
	public function __call($name, $args)
	{
		if (preg_match('/^(get|set)_(\w+)/', strtolower($name), $match) && $attribute = $this->attribute_exists($match[2]))
		{
			if ('get' == $match[1])
			{
				return $this->$attribute;
			}
			else
			{
				$this->$attribute = $this->validate_attribute($match[2], $args[0]);
				return $this;
			}
		}
		else
		{
			throw new \blitze\sitemaker\exception\unexpected_value(array($name, 'UNDEFINED_METHOD'));
		}
	}

	/**
	* {@inheritdoc}
	*/
	public function to_array()
	{
		$attributes = $this->get_attributes();

		$data = array();
		foreach ($attributes as $attribute)
		{
			$accessor = 'get_' . $attribute;
			$data[$attribute] = $this->$accessor();
		}
		unset($data['db_fields'], $data['required_fields']);

		return $data;
	}

	/**
	* {@inheritdoc}
	*/
	public function to_db()
	{
		$this->check_required();

		$db_data = array();
		foreach ($this->db_fields as $attribute)
		{
			$type = $this->get_property_type($attribute);
			if (in_array($type, array('boolean', 'integer', 'string')))
			{
				$db_data[$attribute] = $this->$attribute;
			}
		}

		return $db_data;
	}

	/**
	 * @return array
	 */
	protected function get_attributes()
	{
		return array_keys(get_class_vars(get_class($this)));
	}

	/**
	 * @param string $name
	 * @return string|null
	 */
	protected function attribute_exists($name)
	{
		if (in_array(strtolower($name), $this->get_attributes()))
		{
			return strtolower($name);
		}
		return null;
	}

	/**
	 * @throws \blitze\sitemaker\exception\invalid_argument
	 */
	protected function check_required()
	{
		foreach ($this->required_fields as $field)
		{
			if (!$this->$field)
			{
				throw new \blitze\sitemaker\exception\invalid_argument(array($field, 'FIELD_MISSING'));
			}
		}
	}

	/**
	 * @param string $name
	 * @param mixed $value
	 * @return mixed
	 * @throws \blitze\sitemaker\exception\unexpected_value
	 */
	protected function validate_attribute($name, $value)
	{
		$type = $this->get_property_type($name);

		if (in_array($type, array('array', 'boolean', 'float', 'integer', 'string')))
		{
			settype($value, $type);
			return $value;
		}

		if ($type === false || !$value instanceof $type)
		{
			throw new \blitze\sitemaker\exception\unexpected_value(array($name, 'INVALID_TYPE'));
		}

		return $value;
	}

	/**
	 * @param string $name
	 * @return mixed
	 */
	protected function get_property_type($name)
	{
		$reflection = new \ReflectionObject($this);
		$reflectionProperty = $reflection->getProperty($name);
		$doc = $reflectionProperty->getDocComment();

		preg_match_all('#\/\*\*\s@var\s(.*?)\s\*\/#s', $doc, $annotations);

		return current($annotations[1]);
	}
}