The first unit tests works as expected

harm-less · harm-less · commit 2251508c90d3 · 2016-05-03T21:44:39.000+02:00
diff --git a/src/PE/Encoder.php b/src/PE/Encoder.php
@@ -11,6 +11,8 @@
 use PE\Enums\ActionVariable;
 use PE\Exceptions\EncoderException;
 use PE\Options\EncoderOptions;
+use PE\Variables\Types\NodeAccessor;
+use PE\Variables\Types\ObjectAccessor;
 
 /**
  * Class Encoder
@@ -141,19 +143,20 @@ protected function _decodeNode($nodeName, $nodeData, EncoderOptions $options, En
 			}
 
 			$preNodeStaticOptions = array(
-				ActionVariable::SETTER_NODE_DATA => $nodeDataItem,
-				ActionVariable::SETTER_NODE => $type,
-				ActionVariable::SETTER_PARENT => $parentObject
+				NodeAccessor::VARIABLE_NODE => $type,
+				NodeAccessor::VARIABLE_PARENT => $parentObject
 			);
 			// call node methods. It can be useful when you want to change the outcome of the node data in the node
 			// that does not have a certain setter but is used in other ways
 			$nodeMethodVariables = $variableCollection->getPreNodeSetterVariables();
-			foreach ($nodeMethodVariables as $variableId => $nodeMethodVariable) {
-				$preNodeSetter = $nodeMethodVariable->getPreNodeSetter();
+			foreach ($nodeMethodVariables as $objectSetterVariable) {
+				$variableId = $objectSetterVariable->getId();
+				$preNodeSetter = $objectSetterVariable->getPreNodeSetter();
 				if (isset($nodeDataItem[$variableId]) || $preNodeSetter->alwaysExecute()) {
 					$setterOptions = array_merge($preNodeStaticOptions, array(
-						ActionVariable::SETTER_NAME => $variableId,
-						ActionVariable::SETTER_VALUE => $nodeDataItem[$variableId]
+						NodeAccessor::VARIABLE_NODE_DATA => $nodeDataItem,
+						NodeAccessor::VARIABLE_NAME => $variableId,
+						NodeAccessor::VARIABLE_VALUE => $nodeDataItem[$variableId]
 					));
 					if ($newNode = $preNodeSetter->apply($setterOptions)) {
 						$nodeDataItem = $newNode;
@@ -188,7 +191,8 @@ protected function _decodeNode($nodeName, $nodeData, EncoderOptions $options, En
 						throw new EncoderException(sprintf('Variable "%s" for "%s" does not exist but is required to create an object for node "%s" (Node type: "%s") at index "%s"', $processedVariable, $nodeClassName, $nodeName, $type->getNodeName(), $nodeIndex));
 					}
 					$requiredValue = $nodeDataItem[$processedVariable];
-					$processedRequiredValue = $type->processValue($processedVariable, $requiredValue);
+					$objectSetter = $variableCollection->getVariableById($processedVariable)->getObjectSetter();
+					$processedRequiredValue = $objectSetter->processValue($requiredValue);
 					if ($processedRequiredValue === null) {
 						throw new EncoderException(sprintf('Variable "%s" for "%s" cannot process its value (%s). Presumably because the NodeType does not recognize the variable', $processedVariable, $nodeClassName, $requiredValue));
 					}
@@ -208,16 +212,44 @@ protected function _decodeNode($nodeName, $nodeData, EncoderOptions $options, En
 					$parentNode->addChildrenToObject($nodeName, $parentObject, array($nodeInstance));
 				}
 
-				foreach ($nodeDataItem as $name => $value) {
-					$type->applyToVariable($name, array(
-						ActionVariable::SETTER_NODE_DATA => $nodeDataItem,
-						ActionVariable::SETTER_OBJECT => $nodeInstance,
-						ActionVariable::SETTER_PARENT => $parentObject,
-						ActionVariable::SETTER_NAME => $name,
-						ActionVariable::SETTER_VALUE => $value
-					));
+				$objectStaticOptions = array_merge($preNodeStaticOptions, array(
+					ObjectAccessor::VARIABLE_NODE_DATA => $nodeDataItem,
+					ObjectAccessor::VARIABLE_OBJECT => $nodeInstance,
+				));
+
+				$objectSetterVariables = $variableCollection->getObjectSetterVariables();
+				foreach ($objectSetterVariables as $objectSetterVariable) {
+					$variableId = $objectSetterVariable->getId();
+					$variableIsset = isset($nodeDataItem[$variableId]);
+					$objectSetter = $objectSetterVariable->getObjectSetter();
+					if ($variableIsset || $objectSetter->alwaysExecute()) {
+						$objectSetter->apply($nodeInstance, $variableIsset ? $nodeDataItem[$variableId] : null);
+					}
 				}
 
+
+				/*$setterOptionsStatic = array(
+					ActionVariable::SETTER_NODE_DATA => $nodeDataItem,
+					ActionVariable::SETTER_OBJECT => $nodeInstance,
+					ActionVariable::SETTER_PARENT => $parentObject
+				);
+
+				$nodeMethodVariables = $type->getVariables();
+				foreach ($nodeMethodVariables as $nodeMethodVariable) {
+					$variableId = $nodeMethodVariable->getId();
+					$variableIsset = isset($nodeDataItem[$variableId]);
+					if (($variableIsset || $nodeMethodVariable->alwaysExecute()) && $nodeMethodVariable->setterIsActive()) {
+						$setterOptions = array_merge($setterOptionsStatic, array(
+							ActionVariable::SETTER_NAME => $variableId,
+							ActionVariable::SETTER_VALUE => $variableIsset ? $nodeDataItem[$variableId] : null
+						));
+						$type->applyToVariable($variableId, $setterOptions);
+					}
+				}*/
+
+
+
+
 				if (!$addAfterDecode && $addAfterAttributes) {
 					$parentNode->addChildrenToObject($nodeName, $parentObject, array($nodeInstance));
 				}
diff --git a/src/PE/Variables/Types/NodeAccessor.php b/src/PE/Variables/Types/NodeAccessor.php
@@ -59,14 +59,14 @@ public function apply($options) {
 
 		if (!count($parameters)) {
 			// if there are no custom parameters at least send the value of the variable
-			$parameters = array(self::VARIABLE_VALUE);
+			$parameters = array(NodeAccessor::VARIABLE_VALUE);
 		}
 
 		// prepend the required node data as the first variable
-		array_unshift($parameters, self::VARIABLE_NODE_DATA);
+		array_unshift($parameters, NodeAccessor::VARIABLE_NODE_DATA);
 
 		// using those parameters, call the node action method
-		return $this->_callNodeAction($parameters[self::VARIABLE_NODE], $this->getMethod(), $this->_gatherAccessorParameters($options, $parameters));
+		return $this->_callNodeAction($options[NodeAccessor::VARIABLE_NODE], $this->getMethod(), $this->_gatherAccessorParameters($options, $parameters));
 	}
 
 	/**
@@ -81,7 +81,7 @@ public function apply($options) {
 	protected function _gatherAccessorParameters($options, $parameters) {
 		$actionVariables = array();
 		foreach ($parameters as $parameter) {
-			if (!isset($options[$parameter])) {
+			if (!array_key_exists($parameter, $options)) {
 				throw new VariableTypeException(sprintf('Action variable id "%s" is not known', $parameter));
 			}
 			array_push($actionVariables, $options[$parameter]);
diff --git a/src/PE/Variables/Types/ObjectAccessor.php b/src/PE/Variables/Types/ObjectAccessor.php
@@ -16,6 +16,13 @@ abstract class ObjectAccessor extends VariableType {
 
 	private $mustBeUnique;
 
+	const VARIABLE_NODE_DATA = 'node_node_data';
+	const VARIABLE_NODE = 'node_encoder_node';
+	const VARIABLE_NAME = 'node_name';
+	const VARIABLE_VALUE = 'node_value';
+	const VARIABLE_OBJECT = 'node_object';
+	const VARIABLE_PARENT = 'node_parent';
+
 	const ACCESSOR_SETTER = 'setter';
 	const ACCESSOR_GETTER = 'getter';
 
diff --git a/src/PE/Variables/Types/ObjectSetter.php b/src/PE/Variables/Types/ObjectSetter.php
@@ -6,6 +6,7 @@
 namespace PE\Variables\Types;
 
 use PE\Exceptions\VariableTypeException;
+use PE\Nodes\EncoderNodeVariable;
 use PE\Variables\Variable;
 
 /**
@@ -42,23 +43,23 @@ public function processValue($value) {
 		$type = $this->getVariable()->getType();
 		if ($type !== null) {
 			switch ($type) {
-				case Variable::TYPE_BOOL :
+				case EncoderNodeVariable::TYPE_BOOL :
 					if (is_string($value)) {
 						return ($value === 'true' || $value === '1');
 					}
 					else {
 						return (bool) $value;
 					}
 					break;
-				case Variable::TYPE_ARRAY :
+				case EncoderNodeVariable::TYPE_ARRAY :
 					if (is_string($value)) {
 						return (array) json_decode($value);
 					}
 					else {
 						throw new VariableTypeException(sprintf('The set data type is array but the value cannot be processed'));
 					}
 					break;
-				case Variable::TYPE_STRING :
+				case EncoderNodeVariable::TYPE_STRING :
 					return (string) $value;
 					break;
 				default :
diff --git a/src/PE/Variables/Types/VariableType.php b/src/PE/Variables/Types/VariableType.php
@@ -4,7 +4,7 @@
  */
 
 namespace PE\Variables\Types;
-use PE\Variables\Variable;
+use PE\Nodes\EncoderNodeVariable;
 
 /**
  * Class VariableType
@@ -17,7 +17,7 @@ abstract class VariableType {
 	private $alwaysExecute;
 
 	/**
-	 * @var Variable
+	 * @var EncoderNodeVariable
 	 */
 	private $variable;
 
@@ -32,15 +32,15 @@ public function getMethod() {
 	/**
 	 * Sets the Variable the type is connected to
 	 *
-	 * @param Variable $variable
+	 * @param EncoderNodeVariable $variable
 	 */
 	public function setVariable($variable) {
 		$this->variable = $variable;
 	}
 	/**
 	 * Gets the Variable the type is connected to
 	 *
-	 * @return Variable
+	 * @return EncoderNodeVariable
 	 */
 	public function getVariable() {
 		return $this->variable;
diff --git a/tests/PE/Nodes/Specials/VariableTypesNode.php b/tests/PE/Nodes/Specials/VariableTypesNode.php
@@ -47,22 +47,22 @@ function __construct() {
 	}
 
 	public function preNodeRequiredSetter($nodeData, VariableTypesNode $variableTypesNode, $name, $value, $parent) {
-		pr('pre required');
-		pr($nodeData);
+		print_r('pre required');
+		print_r($nodeData);
 		return $nodeData;
 	}
 	public function postNodeRequiredSetter($nodeData, VariableTypesNode $variableTypesNode, $name, $value, VariableTypes $variableTypes, $parent) {
-		pr('post required');
+		print_r('post required');
 		return $nodeData;
 	}
 
 	public function preNodeOptionalSetter($nodeData, VariableTypesNode $variableTypesNode, $name, $value, $parent) {
-		pr('pre optional');
-		pr($nodeData);
+		print_r('pre optional');
+		print_r($nodeData);
 		return $nodeData;
 	}
 	public function postNodeOptionsSetter($nodeData, VariableTypesNode $variableTypesNode, $name, $value, VariableTypes $variableTypes, $parent) {
-		pr('post optional');
+		print_r('post optional');
 		return $nodeData;
 	}
 }
diff --git a/tests/PE/Tests/EncoderTest.php b/tests/PE/Tests/EncoderTest.php
@@ -12,6 +12,7 @@
 use PE\Samples\Specials\RequiredConstructorVariables;
 use PE\Samples\Specials\AccessorMethodActionTypeNode;
 use PE\Samples\Specials\SingleChild;
+use PE\Samples\Specials\VariableTypes;
 
 class EncoderTest extends Samples {
 
@@ -241,15 +242,17 @@ public function testDecodeObjectWithOptionalVariables() {
 	public function testDecodeObjectAllVariableTypes() {
 		$this->addVariableTypesNode();
 		$decoded = $this->encoder()->decode(array(
-			'variable-types' => array(
+			'variable-type' => array(
 				'required' => 'Hello world',
 				'optional' => 'Hello other world'
 			)
 		));
-		/** @var OptionalVariables $obj */
-		$obj = $decoded['optional-variables'];
-		$this->assertEquals('Hello world', $obj->getName());
-		$this->assertEquals('other hello world', $obj->getOtherVariable());
+
+		print_r($decoded);
+		/** @var VariableTypes $obj */
+		$obj = $decoded['variable-type'];
+		$this->assertEquals('Hello world', $obj->getRequired());
+		$this->assertEquals('Hello other world', $obj->getOptional());
 	}
 
 	public function testDecodeWithSetAfterChildrenFalse() {

Original file line number	Diff line number	Diff line change
`@@ -47,22 +47,22 @@ function __construct() {`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public function preNodeRequiredSetter($nodeData, VariableTypesNode $variableTypesNode, $name, $value, $parent) {`
`50`		`- pr('pre required');`
`51`		`- pr($nodeData);`
	`50`	`+ print_r('pre required');`
	`51`	`+ print_r($nodeData);`
`52`	`52`	`return $nodeData;`
`53`	`53`	`}`
`54`	`54`	`public function postNodeRequiredSetter($nodeData, VariableTypesNode $variableTypesNode, $name, $value, VariableTypes $variableTypes, $parent) {`
`55`		`- pr('post required');`
	`55`	`+ print_r('post required');`
`56`	`56`	`return $nodeData;`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`public function preNodeOptionalSetter($nodeData, VariableTypesNode $variableTypesNode, $name, $value, $parent) {`
`60`		`- pr('pre optional');`
`61`		`- pr($nodeData);`
	`60`	`+ print_r('pre optional');`
	`61`	`+ print_r($nodeData);`
`62`	`62`	`return $nodeData;`
`63`	`63`	`}`
`64`	`64`	`public function postNodeOptionsSetter($nodeData, VariableTypesNode $variableTypesNode, $name, $value, VariableTypes $variableTypes, $parent) {`
`65`		`- pr('post optional');`
	`65`	`+ print_r('post optional');`
`66`	`66`	`return $nodeData;`
`67`	`67`	`}`
`68`	`68`	`}`