temp evaluation work

setup/modulediscovery/ModuleFileParser.php

@@ -1,8 +1,11 @@
 <?php
 
-use PhpParser\ParserFactory;
+use evaluation\expression\PhpExpressionEvaluator;
+use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\Assign;
+use PhpParser\ParserFactory;
 
+require_once __DIR__ . "/evaluation/expression/PhpExpressionEvaluator.php";
 class ModuleFileParser {
 	private static ModuleFileParser $oInstance;
 
@@ -72,7 +75,7 @@ class ModuleFileParser {
 			throw new ModuleFileReaderException("2nd parameter to SetupWebPage::AddModule not a string: " . get_class($oModuleId->value), 0, null, $sModuleFilePath);
 		}
 
-		$sModuleId = $oModuleId->value->value;
+		$sModuleId = $this->EvaluateExpression($oModuleId->value);
 
 		$oModuleConfigInfo = $aArgs[2];
 		if (false === ($oModuleConfigInfo instanceof PhpParser\Node\Arg)) {
@@ -84,8 +87,7 @@ class ModuleFileParser {
 			throw new ModuleFileReaderException("3rd parameter to SetupWebPage::AddModule not an array: " . get_class($oModuleConfigInfo->value), 0, null, $sModuleFilePath);
 		}
 
-		$aModuleConfig=[];
-		$this->FillModuleInformationFromArray($oModuleConfigInfo->value, $aModuleConfig);
+		$aModuleConfig = $this->EvaluateExpression($oModuleConfigInfo->value);
 
 		if (! is_array($aModuleConfig)){
 			throw new ModuleFileReaderException("3rd parameter to SetupWebPage::AddModule not an array: " . get_class($oModuleConfigInfo->value), 0, null, $sModuleFilePath);
@@ -98,46 +100,6 @@ class ModuleFileParser {
 		];
 	}
 
-	public function FillModuleInformationFromArray(PhpParser\Node\Expr\Array_ $oArray, array &$aModuleInformation) : void
-	{
-		$iIndex=0;
-
-		/** @var \PhpParser\Node\Expr\ArrayItem $oValue */
-		foreach ($oArray->items as $oArrayItem){
-			if ($oArrayItem->key instanceof PhpParser\Node\Scalar\String_) {
-				//dictionnary
-				$sKey = $oArrayItem->key->value;
-			} else if ($oArrayItem->key instanceof \PhpParser\Node\Expr\ConstFetch) {
-				//dictionnary
-				$sKey = $this->EvaluateConstantExpression($oArrayItem->key);
-				if (is_null($sKey)){
-					continue;
-				}
-			} else {
-				//array
-				$sKey = $iIndex++;
-			}
-
-			$oValue = $oArrayItem->value;
-			if ($oValue instanceof PhpParser\Node\Expr\Array_) {
-				$aSubConfig=[];
-				$this->FillModuleInformationFromArray($oValue, $aSubConfig);
-				$aModuleInformation[$sKey]=$aSubConfig;
-				continue;
-			}
-
-			try {
-				$oEvaluatuedValue = $this->EvaluateExpression($oValue);
-			} catch(ModuleFileReaderException $e){
-				//required to support legacy below dump dependency
-				//'dependencies' => ['itop-config-mgmt/2.0.0'||'itop-structure/3.0.0']
-				continue;
-			}
-
-			$aModuleInformation[$sKey]=$oEvaluatuedValue;
-		}
-	}
-
 	/**
 	 * @param string $sModuleFilePath
 	 * @param \PhpParser\Node\Stmt\If_ $oNode
@@ -192,66 +154,6 @@ class ModuleFileParser {
 		return null;
 	}
 
-	public function EvaluateConstantExpression(\PhpParser\Node\Expr\ArrayItem|\PhpParser\Node\Expr\ConstFetch $oValue) : mixed
-	{
-		return $this->UnprotectedComputeBooleanExpression($oValue->name);
-	}
-
-	public function EvaluateClassConstantExpression(\PhpParser\Node\Expr\ClassConstFetch $oValue) : mixed
-	{
-		$sClassName = $oValue->class->name;
-		$sProperty = $oValue->name->name;
-		if (class_exists($sClassName)){
-			$class = new \ReflectionClass($sClassName);
-			if (array_key_exists($sProperty, $class->getConstants())) {
-				$oReflectionConstant = $class->getReflectionConstant($sProperty);
-				if ($oReflectionConstant->isPublic()){
-					return $class->getConstant($sProperty);
-				}
-			}
-		}
-
-		if ('class' === $sProperty){
-			return $sClassName;
-		}
-
-		return null;
-	}
-
-	public function EvaluateStaticPropertyExpression(\PhpParser\Node\Expr\StaticPropertyFetch $oValue) : mixed
-	{
-		$sClassName = $oValue->class->name;
-		$sProperty = $oValue->name->name;
-		if (class_exists($sClassName)){
-			$class = new \ReflectionClass($sClassName);
-			if (array_key_exists($sProperty, $class->getStaticProperties())) {
-				$oReflectionProperty = $class->getProperty($sProperty);
-				if ($oReflectionProperty->isPublic()){
-					return $class->getStaticPropertyValue($sProperty);
-				}
-			}
-		}
-
-		return null;
-	}
-
-	/**
-	 * @param string $sBooleanExpr
-	 *
-	 * @return mixed
-	 * @throws ModuleFileReaderException
-	 */
-	private function UnprotectedComputeBooleanExpression(string $sBooleanExpr) : mixed
-	{
-		try{
-			$bResult = null;
-			@eval('$bResult = '.$sBooleanExpr.';');
-			return $bResult;
-		} catch (Throwable $t) {
-			throw new ModuleFileReaderException("Eval of '$sBooleanExpr' caused an error: ".$t->getMessage());
-		}
-	}
-
 	/**
 	 * @param string $sBooleanExpr
 	 *
@@ -260,121 +162,11 @@ class ModuleFileParser {
 	 */
 	public function EvaluateBooleanExpression(string $sBooleanExpr) : bool
 	{
-		$sPhpContent = <<<PHP
-<?php
-$sBooleanExpr;
-PHP;
-		try{
-			$aNodes = $this->ParsePhpCode($sPhpContent);
-			$oExpr = $aNodes[0];
-			$oRes = $this->EvaluateExpression($oExpr->expr);
-
-			return (bool) $oRes;
-
-		} catch (Throwable $t) {
-			throw new ModuleFileReaderException("Eval of '$sBooleanExpr' caused an error:".$t->getMessage());
-		}
+		return PhpExpressionEvaluator::GetInstance()->ParseAndEvaluateBooleanExpression($sBooleanExpr);
 	}
 
-	private function GetMixedValueToString(mixed $oExpr) : string
+	private function EvaluateExpression(Expr $oExpression) : mixed
 	{
-		if (false === $oExpr){
-			return "false";
-		}
-
-		if (true === $oExpr){
-			return "true";
-		}
-
-		return $oExpr;
-	}
-
-	private function EvaluateExpression(\PhpParser\Node\Expr $oExpression) : mixed
-	{
-		if ($oExpression instanceof \PhpParser\Node\Expr\BinaryOp){
-			$sExpr = sprintf("%s %s %s",
-				$this->GetMixedValueToString($this->EvaluateExpression($oExpression->left)),
-				$oExpression->getOperatorSigil(),
-				$this->GetMixedValueToString($this->EvaluateExpression($oExpression->right))
-			);
-			//return $this->UnprotectedComputeBooleanExpression($sBooleanExpr);;
-			return $this->UnprotectedComputeBooleanExpression($sExpr);
-		}
-
-		if ($oExpression instanceof \PhpParser\Node\Expr\BooleanNot){
-			return ! $this->EvaluateExpression($oExpression->expr);
-		}
-
-		if ($oExpression instanceof \PhpParser\Node\Expr\FuncCall){
-			return $this->EvaluateCallFunction($oExpression);
-		}
-
-		if ($oExpression instanceof \PhpParser\Node\Expr\StaticCall){
-			return $this->EvaluateStaticCallFunction($oExpression);
-		}
-
-		if ($oExpression instanceof \PhpParser\Node\Expr\ConstFetch){
-			return $this->EvaluateConstantExpression($oExpression);
-		}
-
-		if ($oExpression instanceof \PhpParser\Node\Expr\ClassConstFetch) {
-			return $this->EvaluateClassConstantExpression($oExpression);
-		}
-
-		if ($oExpression instanceof \PhpParser\Node\Expr\StaticPropertyFetch) {
-			return $this->EvaluateStaticPropertyExpression($oExpression);
-		}
-
-		return $oExpression->value;
-	}
-
-	private function EvaluateCallFunction(\PhpParser\Node\Expr\FuncCall $oFunct) : mixed
-	{
-		$sFunction = $oFunct->name->name;
-		$aWhiteList = ["function_exists", "class_exists", "method_exists"];
-		if (! in_array($sFunction, $aWhiteList)){
-			throw new ModuleFileReaderException("FuncCall $sFunction not supported");
-		}
-
-		$aArgs=[];
-		foreach ($oFunct->args as $arg){
-			/** @var \PhpParser\Node\Arg $arg */
-			$aArgs[]=$arg->value->value;
-		}
-
-		$oReflectionFunction = new ReflectionFunction($sFunction);
-		return $oReflectionFunction->invoke(...$aArgs);
-	}
-
-	/**
-	 * @param \PhpParser\Node\Expr\StaticCall $oStaticCall
-	 *
-	 * @return mixed
-	 * @throws \ModuleFileReaderException
-	 * @throws \ReflectionException
-	 */
-	private function EvaluateStaticCallFunction(\PhpParser\Node\Expr\StaticCall $oStaticCall) : mixed
-	{
-		$sClassName = $oStaticCall->class->name;
-		$sMethodName = $oStaticCall->name->name;
-		$aWhiteList = ["SetupInfo::ModuleIsSelected"];
-		$sStaticCallDescription = "$sClassName::$sMethodName";
-		if (! in_array($sStaticCallDescription, $aWhiteList)){
-			throw new ModuleFileReaderException("StaticCall $sStaticCallDescription not supported");
-		}
-
-		$aArgs=[];
-		foreach ($oStaticCall->args as $arg){
-			/** @var \PhpParser\Node\Arg $arg */
-			$aArgs[]=$arg->value->value;
-		}
-
-		$class = new \ReflectionClass($sClassName);
-		$method = $class->getMethod($sMethodName);
-		if (! $method->isPublic()){
-			throw new ModuleFileReaderException("StaticCall $sStaticCallDescription not public");
-		}
-
-		return $method->invokeArgs(null, $aArgs);
+		return  PhpExpressionEvaluator::GetInstance()->EvaluateExpression($oExpression);
 	}
 }

setup/modulediscovery/evaluation/expression/ArrayEvaluator.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace evaluation\expression;
+
+use ModuleFileReaderException;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\Array_;
+use PhpParser\Node\Expr\ConstFetch;
+use PhpParser\Node\Scalar\String_;
+
+class ArrayEvaluator implements iExprEvaluator {
+	public function GetHandledExpressionType(): string {
+		return Array_::class;
+	}
+
+	public function Evaluate(Expr $oExpr): mixed {
+		/** @var Array_ $oExpr */
+		$iIndex=0;
+
+		$aModuleInformation=[];
+		/** @var \PhpParser\Node\Expr\ArrayItem $oValue */
+		foreach ($oExpr->items as $oArrayItem){
+			if ($oArrayItem->key instanceof String_||$oArrayItem->key instanceof ConstFetch) {
+				//dictionnary
+				$sKey = PhpExpressionEvaluator::GetInstance()->EvaluateExpression($oArrayItem->key);
+				if (is_null($sKey)){
+					continue;
+				}
+			} else {
+				//array
+				$sKey = $iIndex++;
+			}
+
+			try {
+				$oValue = $oArrayItem->value;
+				$oEvaluatuedValue = PhpExpressionEvaluator::GetInstance()->EvaluateExpression($oValue);
+				$aModuleInformation[$sKey]=$oEvaluatuedValue;
+			} catch(ModuleFileReaderException $e){
+				//required to support legacy below dump dependency
+				//'dependencies' => ['itop-config-mgmt/2.0.0'||'itop-structure/3.0.0']
+				continue;
+			}
+		}
+
+		return $aModuleInformation;
+	}
+}

setup/modulediscovery/evaluation/expression/BinaryOpEvaluator.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace evaluation\expression;
+
+use ModuleFileReaderException;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\BinaryOp;
+use Throwable;
+
+abstract class BinaryOpEvaluator implements iExprEvaluator {
+	abstract function EvaluateBinaryOperation(mixed $left, mixed $right) : mixed;
+
+	public function Evaluate(Expr $oExpr): mixed {
+		/** @var BinaryOp $oExpr */
+
+		return $this->EvaluateBinaryOperation(
+			PhpExpressionEvaluator::GetInstance()->EvaluateExpression($oExpr->left),
+			PhpExpressionEvaluator::GetInstance()->EvaluateExpression($oExpr->right));
+	}
+}

setup/modulediscovery/evaluation/expression/BitwiseAndEvaluator.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr\BinaryOp\BitwiseAnd;
+
+class BitwiseAndEvaluator extends BinaryOpEvaluator {
+	public function GetHandledExpressionType(): string {
+		return BitwiseAnd::class;
+	}
+
+	function EvaluateBinaryOperation(mixed $left, mixed $right) : mixed
+	{
+		return $left & $right;
+	}
+}

setup/modulediscovery/evaluation/expression/BitwiseOrEvaluator.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr\BinaryOp\BitwiseOr;
+
+class BitwiseOrEvaluator extends BinaryOpEvaluator {
+	public function GetHandledExpressionType(): string {
+		return BitwiseOr::class;
+	}
+
+	function EvaluateBinaryOperation(mixed $left, mixed $right) : mixed
+	{
+		return $left | $right;
+	}
+}

setup/modulediscovery/evaluation/expression/BooleanAndEvaluator.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr\BinaryOp\BooleanAnd;
+
+class BooleanAndEvaluator extends BinaryOpEvaluator {
+	public function GetHandledExpressionType(): string {
+		return BooleanAnd::class;
+	}
+
+	function EvaluateBinaryOperation(mixed $left, mixed $right) : mixed
+	{
+		return $left && $right;
+	}
+}

setup/modulediscovery/evaluation/expression/BooleanNotEvaluator.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\BooleanNot;
+
+class BooleanNotEvaluator implements iExprEvaluator {
+	public function GetHandledExpressionType(): string {
+		return BooleanNot::class;
+	}
+
+	public function Evaluate(Expr $oExpr): mixed {
+		/** @var BooleanNot $oExpr */
+
+		return ! PhpExpressionEvaluator::GetInstance()->EvaluateExpression($oExpr->expr);
+	}
+}

setup/modulediscovery/evaluation/expression/BooleanOrEvaluator.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr\BinaryOp\BooleanOr;
+
+class BooleanOrEvaluator extends BinaryOpEvaluator {
+	public function GetHandledExpressionType(): string {
+		return BooleanOr::class;
+	}
+
+	function EvaluateBinaryOperation(mixed $left, mixed $right) : mixed
+	{
+		return $left || $right;
+	}
+}

setup/modulediscovery/evaluation/expression/ClassConstFetchEvaluator.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\ClassConstFetch;
+
+class ClassConstFetchEvaluator implements iExprEvaluator {
+	public function GetHandledExpressionType(): string {
+		return ClassConstFetch::class;
+	}
+
+	public function Evaluate(Expr $oExpr): mixed {
+		/** @var ClassConstFetch $oExpr */
+
+		$sClassName = $oExpr->class->name;
+		$sProperty = $oExpr->name->name;
+
+		if (class_exists($sClassName)){
+			$class = new \ReflectionClass($sClassName);
+			if (array_key_exists($sProperty, $class->getConstants())) {
+				$oReflectionConstant = $class->getReflectionConstant($sProperty);
+				if ($oReflectionConstant->isPublic()){
+					return $class->getConstant($sProperty);
+				}
+			}
+		}
+
+		if ('class' === $sProperty){
+			return $sClassName;
+		}
+
+		return null;
+	}
+}

setup/modulediscovery/evaluation/expression/ConstFetchEvaluator.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\ConstFetch;
+
+class ConstFetchEvaluator implements iExprEvaluator {
+	public function GetHandledExpressionType(): string {
+		return ConstFetch::class;
+	}
+
+	public function Evaluate(Expr $oExpr): mixed {
+		/** @var ConstFetch $oExpr */
+		if (defined($oExpr->name)){
+			return constant($oExpr->name);
+		}
+
+		return null;
+	}
+}

setup/modulediscovery/evaluation/expression/FuncCallEvaluator.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace evaluation\expression;
+
+use ModuleFileReaderException;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\FuncCall;
+use ReflectionFunction;
+
+class FuncCallEvaluator implements iExprEvaluator {
+	public function GetHandledExpressionType(): string {
+		return FuncCall::class;
+	}
+
+	public function Evaluate(Expr $oExpr): mixed {
+		/** @var FuncCall $oExpr */
+
+		$sFunction = $oExpr->name->name;
+		$aWhiteList = ["function_exists", "class_exists", "method_exists"];
+		if (! in_array($sFunction, $aWhiteList)){
+			throw new ModuleFileReaderException("FuncCall $sFunction not supported");
+		}
+
+		$aArgs=[];
+		foreach ($oExpr->args as $arg){
+			/** @var \PhpParser\Node\Arg $arg */
+			$aArgs[]=$arg->value->value;
+		}
+
+		$oReflectionFunction = new ReflectionFunction($sFunction);
+		return $oReflectionFunction->invoke(...$aArgs);
+	}
+}

setup/modulediscovery/evaluation/expression/MulEvaluator.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr\BinaryOp\Mul;
+
+class MulEvaluator extends BinaryOpEvaluator {
+	public function GetHandledExpressionType(): string {
+		return Mul::class;
+	}
+
+	function EvaluateBinaryOperation(mixed $left, mixed $right) : mixed
+	{
+		return $left * $right;
+	}
+}

setup/modulediscovery/evaluation/expression/PhpExpressionEvaluator.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr;
+
+require_once __DIR__ . '/iExprEvaluator.php';
+class PhpExpressionEvaluator {
+	private static PhpExpressionEvaluator $oInstance;
+
+	/** @var iExprEvaluator[] $aPhpParserEvaluators */
+	private static array $aPhpParserEvaluators;
+
+	protected function __construct() {
+	}
+
+	final public static function GetInstance(): PhpExpressionEvaluator {
+		if (!isset(static::$oInstance)) {
+			static::$oInstance = new static();
+			static::$aPhpParserEvaluators=[];
+
+			foreach (glob(__DIR__ . "/**Evaluator.php") as $sFile){
+				require_once $sFile;
+				$sNamespace = 'evaluation\\expression\\';
+				$sClass = $sNamespace. str_replace(".php", "", basename($sFile));
+				$oReflectionClass = new \ReflectionClass($sClass);
+				if ($oReflectionClass->isInstantiable()
+					&& $oReflectionClass->implementsInterface("{$sNamespace}iExprEvaluator")){
+					$oClass = new $sClass;
+					static::$aPhpParserEvaluators[$oClass->GetHandledExpressionType()] = $oClass;
+				}
+			}
+		}
+
+		return static::$oInstance;
+	}
+
+	final public static function SetInstance(?PhpExpressionEvaluator $oInstance): void {
+		static::$oInstance = $oInstance;
+	}
+
+	public function EvaluateExpression(Expr $oExpression) : mixed
+	{
+		$sClass = get_class($oExpression);
+		$oPhpParserEvaluator = static::$aPhpParserEvaluators[$sClass] ?? null;
+		if (is_null($oPhpParserEvaluator)){
+			return $oExpression->value;
+		}
+
+		return $oPhpParserEvaluator->Evaluate($oExpression);
+	}
+
+	/**
+	 * @param string $sBooleanExpr
+	 *
+	 * @return bool
+	 * @throws \ModuleFileReaderException
+	 */
+	public function ParseAndEvaluateBooleanExpression(string $sBooleanExpr) : bool
+	{
+		return $this->ParseAndEvaluateExpression($sBooleanExpr);
+	}
+
+	public function ParseAndEvaluateExpression(string $sExpr) : bool
+	{
+		$sPhpContent = <<<PHP
+<?php
+$sExpr;
+PHP;
+		try{
+			$aNodes = \ModuleFileParser::GetInstance()->ParsePhpCode($sPhpContent);
+			$oExpr = $aNodes[0];
+			return $this->EvaluateExpression($oExpr->expr);
+
+		} catch (\Throwable $t) {
+			throw new \ModuleFileReaderException("Eval of '$sExpr' caused an error:".$t->getMessage());
+		}
+	}
+}

setup/modulediscovery/evaluation/expression/StaticCallEvaluator.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace evaluation\expression;
+
+use ModuleFileReaderException;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\StaticCall;
+use ReflectionFunction;
+
+class StaticCallEvaluator implements iExprEvaluator {
+	public function GetHandledExpressionType(): string {
+		return StaticCall::class;
+	}
+
+	public function Evaluate(Expr $oExpr): mixed {
+		/** @var StaticCall $oExpr */
+
+		$sClassName = $oExpr->class->name;
+		$sMethodName = $oExpr->name->name;
+
+		$aWhiteList = ["SetupInfo::ModuleIsSelected"];
+		$sStaticCallDescription = "$sClassName::$sMethodName";
+		if (! in_array($sStaticCallDescription, $aWhiteList)){
+			throw new ModuleFileReaderException("StaticCall $sStaticCallDescription not supported");
+		}
+
+		$aArgs=[];
+		foreach ($oExpr->args as $arg){
+			/** @var \PhpParser\Node\Arg $arg */
+			$aArgs[]=$arg->value->value;
+		}
+
+		$class = new \ReflectionClass($sClassName);
+		$method = $class->getMethod($sMethodName);
+		if (! $method->isPublic()){
+			throw new ModuleFileReaderException("StaticCall $sStaticCallDescription not public");
+		}
+
+		return $method->invokeArgs(null, $aArgs);
+	}
+}

setup/modulediscovery/evaluation/expression/StaticPropertyFetchEvaluator.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\StaticPropertyFetch;
+
+class StaticPropertyFetchEvaluator implements iExprEvaluator {
+	public function GetHandledExpressionType(): string {
+		return StaticPropertyFetch::class;
+	}
+
+	public function Evaluate(Expr $oExpr): mixed {
+		/** @var StaticPropertyFetch $oExpr */
+
+		$sClassName = $oExpr->class->name;
+		$sProperty = $oExpr->name->name;
+
+		if (class_exists($sClassName)){
+			$class = new \ReflectionClass($sClassName);
+			if (array_key_exists($sProperty, $class->getStaticProperties())) {
+				$oReflectionProperty = $class->getProperty($sProperty);
+				if ($oReflectionProperty->isPublic()){
+					return $class->getStaticPropertyValue($sProperty);
+				}
+			}
+		}
+
+		return null;
+	}
+}

setup/modulediscovery/evaluation/expression/iExprEvaluator.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace evaluation\expression;
+
+use PhpParser\Node\Expr;
+
+interface iExprEvaluator {
+	public function GetHandledExpressionType(): string;
+
+	public function Evaluate(Expr $oExpr) : mixed;
+}

tests/php-unit-tests/unitary-tests/setup/modulediscovery/ModuleFileReaderTest.php

@@ -86,10 +86,6 @@ class ModuleFileReaderTest extends ItopDataTestCase
 		$aRes = ModuleFileReader::GetInstance()->ReadModuleFileInformation($sModuleFilePath);
 		$aExpected = ModuleFileReader::GetInstance()->ReadModuleFileInformationUnsafe($sModuleFilePath);
 
-		//do not check dumb conf on dependencies
-		$aDependencies=$aRes[2]['dependencies'];
-		$aDependencies= array_merge([true], $aDependencies);
-		$aRes[2]['dependencies']=$aDependencies;
 		$this->assertEquals($aExpected, $aRes);
 	}
 

tests/php-unit-tests/unitary-tests/setup/modulediscovery/PhpExpressionEvaluatorTest.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Combodo\iTop\Test\UnitTest\Setup\ModuleDiscovery;
+
+use Combodo\iTop\Test\UnitTest\ItopDataTestCase;
+use evaluation\expression\PhpExpressionEvaluator;
+
+class PhpExpressionEvaluatorTest extends ItopDataTestCase{
+	public function testEvaluateExpression(){
+		$res = PhpExpressionEvaluator::GetInstance()->ParseAndEvaluateExpression('false');
+		$this->assertEquals(false, $res);
+	}
+}