namespace update

Author: František Mazura

Makefile

@@ -1,7 +1,7 @@
 .PHONY: tests
 
 COMPOSER_IMAGE=composer
-PHP_IMAGE=php:7.3
+PHP_IMAGE=php:7.4
 
 composer:
 	docker pull $(COMPOSER_IMAGE)
@@ -14,6 +14,7 @@ composer_update:
 	make composer P=update
 
 phpunit:
+	docker pull $(PHP_IMAGE)
 	docker run --rm -it -w /app --volume `pwd`:/app $(PHP_IMAGE) ./vendor/bin/phpunit $(P)
 
 tests:

README.md

@@ -20,6 +20,8 @@ PHP Value object for storing valid data.
 # Changelog
 
 - 2021-02-26
-    - ignored attributes
-    - touch (`setTouched`, `isTouched`, `getTouchedAll`)
-    - add interface `ValueObjectInterface`
+  - ignored attributes
+  - touch (`setTouched`, `isTouched`, `getTouchedAll`)
+  - add interface `ValueObjectInterface`
+  - remove trait
+  - min request PHP 7.4

composer.json

@@ -21,7 +21,7 @@
     }
   },
   "require": {
-    "php": "^7.3|8.*",
+    "php": "7.4|8.*",
     "nesbot/carbon": "^2.42.0"
   },
   "require-dev": {

src/AbstractValueObject.php

@@ -2,15 +2,21 @@
 
 namespace OGSoft\ValueObjects;
 
+use Carbon\Carbon;
+use Exception;
 use OGSoft\ValueObjects\Exceptions\ValidatorException;
 use OGSoft\ValueObjects\Interfaces\GlobalValidatorInterface;
 use OGSoft\ValueObjects\Interfaces\ValueObjectInterface;
+use ReflectionClass;
+use ReflectionException;
+use ReflectionParameter;
+use ReflectionType;
 use Throwable;
 
 abstract class AbstractValueObject implements ValueObjectInterface
 {
-	private $touched = [];
-	private $ignoredAttrs = ["ignoredAttrs", "touched"];
+	private array $touched = [];
+	private array $ignoredAttrs = ["ignoredAttrs", "touched"];
 
 	public function isIgnoredAttr(string $attrName): bool
 	{
@@ -20,9 +26,10 @@ public function isIgnoredAttr(string $attrName): bool
 	/**
 	 * @inheritDoc
 	 */
-	public function setTouched(string $attrName): void
+	public function setTouched(string $attrName): self
 	{
 		$this->touched[$attrName] = true;
+		return $this;
 	}
 
 	/**
@@ -44,7 +51,7 @@ public function getTouchedAll(): array
 	/**
 	 * @inheritDoc
 	 */
-	public function init($data): void
+	public function init($data): self
 	{
 		if (is_object($data)) {
 			$data = get_object_vars($data);
@@ -71,6 +78,8 @@ public function init($data): void
 		if ($this instanceof GlobalValidatorInterface) {
 			$this->globalValidate();
 		}
+
+		return $this;
 	}
 
 	/**
@@ -116,4 +125,144 @@ public function toArray(): array
 		return $out;
 	}
 
+	public function setValue(string $attrName, string $attrSetter, $attrValue, object $obj): self
+	{
+		$reflectionParameter = self::getReflectionParameter($obj, $attrSetter);
+		// build-in types
+		if ($reflectionParameter->getType()->isBuiltin()) {
+			if (is_array($attrValue)) {
+				$attrValue = array_map(function ($v) use ($reflectionParameter) {
+					return self::transformBuildInType($reflectionParameter, $v);
+				}, $attrValue);
+				$obj->$attrSetter(...$attrValue);
+			} else {
+				$attrValue = self::transformBuildInType($reflectionParameter, $attrValue);
+				$obj->$attrSetter($attrValue);
+			}
+		} // custom types
+		else {
+			self::initAndValidateValueObject($obj, $attrSetter, $reflectionParameter, $attrValue);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param $obj
+	 * @param $setter
+	 * @return null|ReflectionParameter
+	 * @throws ReflectionException
+	 */
+	private static function getReflectionParameter($obj, $setter): ?ReflectionParameter
+	{
+		$reflectionClass = new ReflectionClass($obj);
+		$params = $reflectionClass->getMethod($setter)->getParameters();
+		// setter has only one param
+		$param = $params[0];
+		if ($param->getType() instanceof ReflectionType) {
+//      $name = $param->getType()->getName();
+			return $param;
+		}
+		return null;
+	}
+
+	/**
+	 * Normalize build-in type
+	 *
+	 * @param ReflectionParameter $reflectionParameter
+	 * @param $value
+	 * @return mixed
+	 */
+	private static function transformBuildInType(ReflectionParameter $reflectionParameter, $value)
+	{
+		// bool transform
+		if ($reflectionParameter->getType()->getName() == "bool") {
+			if (is_bool($value) || is_null($value)) {
+				return $value;
+			} else {
+				return filter_var($value, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE);
+			}
+		}
+
+		// int transform
+		if ($reflectionParameter->getType()->getName() == "int") {
+			if ($value === '') {
+				return null; // set null on empty string (because of Mango API and types handling)
+			}
+		}
+
+		// general
+		return $value;
+	}
+
+	/**
+	 * @param object $obj
+	 * @param string $setter
+	 * @param ReflectionParameter $parameter
+	 * @param $data
+	 * @throws Exception
+	 */
+	private static function initAndValidateValueObject(object $obj, string $setter, ReflectionParameter $parameter, $data)
+	{
+		$type = $parameter->getType()->getName();
+		if (is_subclass_of($type, AbstractValueObject::class)) {
+			if (empty($data) && !is_array($data)) {
+				if ($parameter->allowsNull()) {
+					return;
+				}
+				throw new ValidatorException(" Wrong data type of property. Data can not be null", get_class($obj), $parameter->name, $data);
+			}
+			if ($parameter->isVariadic()) {
+				if (!is_array($data)) {
+					$obj->$setter(null);
+					return;
+				}
+				$dataArr = [];
+				foreach ($data as $objData) {
+					$reqObj = self::createValueObject($type, $objData);
+					if ($reqObj) {
+						$dataArr[] = $reqObj;
+					}
+				}
+				$obj->$setter(...$dataArr);
+			} else {
+				$reqObj = self::createValueObject($type, $data);
+				$obj->$setter($reqObj);
+			}
+			return;
+		} elseif ($type == DateTime::class || $type == Carbon::class) {
+			if (!$parameter->allowsNull() && empty($data)) {
+				throw new ValidatorException(" Wrong data type of property. Date can not be null", get_class($obj), $parameter->name, $data);
+			}
+			/**
+			 * Parse date and time from data, if timezone is not part of the data string, user setting timezone is used (eg. messages from
+			 * machines come in UTC and without timezone information). If the timezone is part of the string, this one is used and has higher
+			 * priority, than user settings.
+			 * If the timezone is not specified within data string, nor in the user settings, the application default timezone is used.
+			 */
+			// TODO add timezone support
+			$dateTime = empty($data) ? null : Carbon::parse($data, /*getCustomUserTimezone()*/);
+			//$dateTime->setTimezone(new \DateTimeZone(config("app.timezone")));
+
+			$obj->$setter($dateTime);
+			return;
+		}
+		throw new Exception("Unknown array type. Type has to be build in or subclass of AbstractRequestBody - " . $setter);
+	}
+
+	/**
+	 * @param $className
+	 * @param $data
+	 * @return false|AbstractValueObject
+	 * @throws ValidatorException
+	 */
+	private static function createValueObject($className, $data)
+	{
+		$valueObject = new $className();
+		if ($valueObject instanceof AbstractValueObject) {
+			$valueObject->init($data);
+			return $valueObject;
+		}
+		return false;
+	}
 }

src/Interfaces/ValueObjectInterface.php

@@ -14,10 +14,10 @@ interface ValueObjectInterface
 	 * Init object from array or object
 	 *
 	 * @param object|array $data
-	 * @return void
+	 * @return self
 	 * @throws ValidatorException
 	 */
-	public function init($data): void;
+	public function init($data): self;
 
 	/**
 	 * setter for attribute of ValueObject
@@ -26,10 +26,10 @@ public function init($data): void;
 	 * @param string $attrSetter
 	 * @param $attrValue
 	 * @param object $valueObject
-	 * @return mixed
+	 * @return self
 	 * @throws ValidatorException
 	 */
-	public function setValue(string $attrName, string $attrSetter, $attrValue, object $valueObject): void;
+	public function setValue(string $attrName, string $attrSetter, $attrValue, object $valueObject): self;
 
 	/**
 	 * @param Throwable $throwable
@@ -74,9 +74,9 @@ public function handleUndefinedAttribute(string $attrName, string $attrSetter, $
 	 * set attribute touch
 	 *
 	 * @param string $attrName
-	 * @return void
+	 * @return self
 	 */
-	public function setTouched(string $attrName): void;
+	public function setTouched(string $attrName): self;
 
 	/**
 	 * check if attribute touched