Composer corelibs update

Convert\VarSetType for always return type expected (eg string will be string)
or Convert\VarSetTypeNull to return string or null on failure

The return value for failure if not matching type can be set for both, but
only for Convert\VarSetTypeNull the return value can be set to null.

.gitignore

@@ -0,0 +1,2 @@
+composer.lock
+vendor/

4dev/deprecated/CoreLibs/Convert/Extends/VarSetTypeMain.php

@@ -0,0 +1,256 @@
+<?php
+
+/*
+ * Run is_<type> checks and return default value if not this type
+ * This will return default null on invalid entries
+ */
+
+declare(strict_types=1);
+
+namespace CoreLibs\Convert\Extends;
+
+class VarSetTypeMain
+{
+	/**
+	 * If input variable is string then returns it, else returns default set
+	 * if not null is true, then null as return is allowed, else return is
+	 * converted to string
+	 *
+	 * @param  mixed       $val     Input variable
+	 * @param  string|null $default Default value
+	 * @param  bool        $to_null Convert to null (default no)
+	 * @return string|null          Input var or default value
+	 */
+	protected static function setStrMain(
+		mixed $val,
+		?string $default = null,
+		bool $to_null = false
+	): ?string {
+		if (is_string($val)) {
+			return $val;
+		}
+		if ($to_null === false) {
+			return (string)$default;
+		}
+		return $default;
+	}
+
+	/**
+	 * Will convert input data to string if possible.
+	 * Runs for string/int/float/bool/null
+	 * Will skip array/object/resource/callable/etc and use default for that
+	 *
+	 * @param  mixed       $val     Input variable
+	 * @param  string|null $default Default value
+	 * @param  bool        $to_null Convert to null (default no)
+	 * @return string|null          Converted input data to string/null
+	 */
+	protected static function makeStrMain(
+		mixed $val,
+		string $default = null,
+		bool $to_null = false
+	): ?string {
+		// int/float/string/bool/null, everything else is ignored
+		// no: array/object/resource/callable
+		if (
+			is_int($val) ||
+			is_float($val) ||
+			is_string($val) ||
+			is_bool($val) ||
+			is_null($val)
+		) {
+			return (string)$val;
+		}
+		if ($to_null === false) {
+			return (string)$default;
+		}
+		return $default;
+	}
+
+
+	/**
+	 * If input variable is int, return it, else return default value. If to_null
+	 * is true then null as return is allowed, else only int is returned
+	 *
+	 * @param  mixed    $val     Input variable
+	 * @param  int|null $default Default value
+	 * @param  bool     $to_null Convert to null (default no)
+	 * @return int|null          Input var or default value
+	 */
+	protected static function setIntMain(
+		mixed $val,
+		?int $default = null,
+		bool $to_null = false
+	): ?int {
+		if (is_int($val)) {
+			return $val;
+		}
+		if ($to_null === false) {
+			return (int)$default;
+		}
+		return $default;
+	}
+
+	/**
+	 * Convert input to int via filter_var. If not convertable return default value.
+	 * If to_null is set to true null return is allowed
+	 * NOTE: this is only a drastic fallback and not recommned for special use.
+	 * It will try to check via filter_var if we can get an int value and then use
+	 * intval to convert it.
+	 * Reason is that filter_var will convert eg 1.5 to 15 instead 1
+	 * One is very wrong, the other is at least better, but not perfect
+	 *
+	 * @param  mixed    $val     Input variable
+	 * @param  int|null $default Default value
+	 * @param  bool     $to_null Convert to null (default no)
+	 * @return int|null          Converted input data to int/null
+	 */
+	protected static function makeIntMain(
+		mixed $val,
+		int $default = null,
+		bool $to_null = false
+	): ?int {
+		// if we can filter it to a valid int, we can convert it
+		// we so avoid object, array, etc
+		if (
+			filter_var(
+				$val,
+				FILTER_SANITIZE_NUMBER_INT
+			) !== false
+		) {
+			return intval($val);
+		}
+		if ($to_null === false) {
+			return (int)$default;
+		}
+		return $default;
+	}
+
+	/**
+	 * If input is float return it, else set to default value. If to_null is set
+	 * to true, allow null return
+	 *
+	 * @param  mixed      $val     Input variable
+	 * @param  float|null $default Default value
+	 * @param  bool       $to_null Convert to null (default no)
+	 * @return float|null          Input var or default value
+	 */
+	protected static function setFloatMain(
+		mixed $val,
+		?float $default = null,
+		bool $to_null = false
+	): ?float {
+		if (is_float($val)) {
+			return $val;
+		}
+		if ($to_null === false) {
+			return (float)$default;
+		}
+		return $default;
+	}
+
+	/**
+	 * Convert intput var to float via filter_var. If failed to so return default.
+	 * If to_null is set to true allow null return
+	 *
+	 * @param  mixed      $val     Input variable
+	 * @param  float|null $default Default value
+	 * @param  bool       $to_null Convert to null (default no)
+	 * @return float|null          Converted intput data to float/null
+	 */
+	protected static function makeFloatMain(
+		mixed $val,
+		float $default = null,
+		bool $to_null = false
+	): ?float {
+		if (
+			(
+				$val = filter_var(
+					$val,
+					FILTER_SANITIZE_NUMBER_FLOAT,
+					FILTER_FLAG_ALLOW_FRACTION
+				)
+			) !== false
+		) {
+			return (float)$val;
+		}
+		if ($to_null === false) {
+			return (float)$default;
+		}
+		return $default;
+	}
+
+	/**
+	 * If input var is array return it, else return default value. If to_null is
+	 * set to true, allow null return
+	 *
+	 * @param  mixed             $val     Input variable
+	 * @param  array<mixed>|null $default Default value
+	 * @param  bool              $to_null Convert to null (default no)
+	 * @return array<mixed>|null          Input var or default value
+	 */
+	protected static function setArrayMain(
+		mixed $val,
+		?array $default = null,
+		bool $to_null = false
+	): ?array {
+		if (is_array($val)) {
+			return $val;
+		}
+		if ($to_null === false) {
+			return (array)$default;
+		}
+		return $default;
+	}
+
+	/**
+	 * If input var is bool return it, else return default value. If to_null is
+	 * set to true will allow null return.
+	 *
+	 * @param  mixed     $val     Input variable
+	 * @param  bool|null $default Default value
+	 * @param  bool      $to_null Convert to null (default no)
+	 * @return bool|null          Input var or default value
+	 */
+	protected static function setBoolMain(
+		mixed $val,
+		?bool $default = null,
+		bool $to_null = false
+	): ?bool {
+		if (is_bool($val)) {
+			return $val;
+		}
+		if ($to_null === false) {
+			return (bool)$default;
+		}
+		return $default;
+	}
+
+	/**
+	 * Convert anything to bool. If it is a string it will try to use the filter_var
+	 * to convert know true/false strings.
+	 * Else it uses (bool) to convert the rest
+	 * If null is allowed, will return null
+	 *
+	 * @param  mixed     $val     Input variable
+	 * @param  bool      $default Default value if to_null if false
+	 * @param  bool      $to_null Convert to null (default no)
+	 * @return bool|null          Converted input data to bool/ null
+	 */
+	protected static function makeBoolMain(
+		mixed $val,
+		bool $default = false,
+		bool $to_null = false
+	): ?bool {
+		$boolvar = is_string($val) ?
+				filter_var(
+					$val,
+					FILTER_VALIDATE_BOOLEAN,
+					FILTER_NULL_ON_FAILURE
+				) :
+				(bool)$val;
+		return $boolvar === null && !$to_null ? $default : $boolvar;
+	}
+}
+
+// __END__

4dev/deprecated/CoreLibs/Convert/VarSetType.php

@@ -0,0 +1,136 @@
+<?php
+
+/*
+ * Run is_<type> checks and return default value if not this type
+ * This will return a default value as always what is expected and never null
+ * Use this for santize output from multi return functions where we know what
+ * will come back
+ */
+
+declare(strict_types=1);
+
+namespace CoreLibs\Convert;
+
+use CoreLibs\Convert\Extends\VarSetTypeMain;
+
+class VarSetType extends Extends\VarSetTypeMain
+{
+	/**
+	 * Check is input is string, if not return default string.
+	 * Will always return string
+	 *
+	 * @param  mixed  $val     Input value
+	 * @param  string $default Default override value
+	 * @return string          Input value or default as string
+	 */
+	public static function setStr(mixed $val, string $default = ''): string
+	{
+		return (string)VarSetTypeMain::setStrMain($val, $default, false);
+	}
+
+	/**
+	 * Convert input to string if possible.
+	 * Will only work on string/int/float/bool/null types
+	 * Will always return string
+	 *
+	 * @param  mixed  $val     Input value
+	 * @param  string $default Default override value
+	 * @return string          Input value as string or default as string
+	 */
+	public static function makeStr(mixed $val, string $default = ''): string
+	{
+		return (string)VarSetTypeMain::makeStrMain($val, $default, false);
+	}
+
+	/**
+	 * Check if input is int, if not return default int value 0.
+	 * Will always return int.
+	 *
+	 * @param  mixed $val     Input value
+	 * @param  int   $default Default override value
+	 * @return int            Input value or default as int
+	 */
+	public static function setInt(mixed $val, int $default = 0): int
+	{
+		return (int)VarSetTypeMain::setIntMain($val, $default, false);
+	}
+
+	/**
+	 * Convert intput to int if possible, if not return default value 0.
+	 * Will always return int.
+	 *
+	 * @param  mixed $val     Input value
+	 * @param  int   $default Default override value
+	 * @return int            Input value as int or default as int
+	 */
+	public static function makeInt(mixed $val, int $default = 0): int
+	{
+		return (int)VarSetTypeMain::makeIntMain($val, $default, false);
+	}
+
+	/**
+	 * Check if input is float, if not return default value value 0.0.
+	 * Will always return float
+	 *
+	 * @param  mixed $val     Input value
+	 * @param  float $default Default override value
+	 * @return float          Input value or default as float
+	 */
+	public static function setFloat(mixed $val, float $default = 0.0): float
+	{
+		return (float)VarSetTypeMain::setFloatMain($val, $default, false);
+	}
+
+	/**
+	 * Convert input to float, if not possible return default value 0.0.
+	 * Will always return float
+	 *
+	 * @param  mixed $val     Input value
+	 * @param  float $default Default override value
+	 * @return float          Input value as float or default as float
+	 */
+	public static function makeFloat(mixed $val, float $default = 0.0): float
+	{
+		return (float)VarSetTypeMain::makeFloatMain($val, $default, false);
+	}
+
+	/**
+	 * Check if input is array, if not return default empty array.
+	 * Will always return array.
+	 *
+	 * @param  mixed        $val     Input value
+	 * @param  array<mixed> $default Default override value
+	 * @return array<mixed>          Input value or default as array
+	 */
+	public static function setArray(mixed $val, array $default = []): array
+	{
+		return (array)VarSetTypeMain::setArrayMain($val, $default, false);
+	}
+
+	/**
+	 * Check if input is bool, if not will return default value false.
+	 * Will aways return bool.
+	 *
+	 * @param  mixed $val     Input value
+	 * @param  bool  $default Default override value
+	 * @return bool           Input value or default as bool
+	 */
+	public static function setBool(mixed $val, bool $default = false): bool
+	{
+		return (bool)VarSetTypeMain::setBoolMain($val, $default, false);
+	}
+
+	/**
+	 * Convert anything to bool
+	 *
+	 * @param  mixed $val     Input value
+	 * @param  bool  $default Default override value
+	 * @return bool           Input value as bool or default as bool
+	 */
+	public static function makeBool(mixed $val, bool $default = false): bool
+	{
+		return (bool)VarSetTypeMain::makeBoolMain($val, $default, false);
+	}
+}
+
+// __END__

4dev/deprecated/CoreLibs/Convert/VarSetTypeNull.php

@@ -0,0 +1,130 @@
+<?php
+
+/*
+ * Run is_<type> checks and return default value if not this type
+ * This will return default null on invalid entries
+ */
+
+declare(strict_types=1);
+
+namespace CoreLibs\Convert;
+
+use CoreLibs\Convert\Extends\VarSetTypeMain;
+
+class VarSetTypeNull extends Extends\VarSetTypeMain
+{
+	/**
+	 * Check is input is string, if not return default string.
+	 * Will return null if no string as default.
+	 *
+	 * @param  mixed       $val     Input value
+	 * @param  string|null $default Default override value
+	 * @return string|null          Input value or default as string/null
+	 */
+	public static function setStr(mixed $val, ?string $default = null): ?string
+	{
+		return VarSetTypeMain::setStrMain($val, $default, true);
+	}
+
+	/**
+	 * Convert input to string if possible.
+	 * Will only work on string/int/float/bool/null types.
+	 * Will return null if convert failed as default.
+	 *
+	 * @param  mixed       $val     Input value
+	 * @param  string|null $default Default override value
+	 * @return string|null          Input value as string or default as string/null
+	 */
+	public static function makeStr(mixed $val, string $default = null): ?string
+	{
+		return VarSetTypeMain::makeStrMain($val, $default, true);
+	}
+
+
+	/**
+	 * Check if input is int, if not return default value null.
+	 *
+	 * @param  mixed    $val     Input value
+	 * @param  int|null $default Default override value
+	 * @return int|null          Input value or default as int/null
+	 */
+	public static function setInt(mixed $val, ?int $default = null): ?int
+	{
+		return VarSetTypeMain::setIntMain($val, $default, true);
+	}
+
+	/**
+	 * Convert intput to int if possible, if not return default value value null.
+	 *
+	 * @param  mixed    $val     Input value $val
+	 * @param  int|null $default Default override value
+	 * @return int|null          Input value as int or default as int/null
+	 */
+	public static function makeInt(mixed $val, int $default = null): ?int
+	{
+		return VarSetTypeMain::makeIntMain($val, $default, true);
+	}
+
+	/**
+	 * Check if input is float, if not return default value value null.
+	 *
+	 * @param  mixed      $val     Input value $val
+	 * @param  float|null $default Default override value
+	 * @return float|null          Input value or default as float/null
+	 */
+	public static function setFloat(mixed $val, ?float $default = null): ?float
+	{
+		return VarSetTypeMain::setFloatMain($val, $default, true);
+	}
+
+	/**
+	 * Convert input to float, if not possible return default value null.
+	 *
+	 * @param  mixed      $val     Input value $val
+	 * @param  float|null $default Default override value
+	 * @return float|null          Input value as float or default as float/null
+	 */
+	public static function makeFloat(mixed $val, float $default = null): ?float
+	{
+		return VarSetTypeMain::makeFloatMain($val, $default, true);
+	}
+
+	/**
+	 * Check if input is array, if not return default value null.
+	 *
+	 * @param  mixed             $val     Input value $val
+	 * @param  array<mixed>|null $default Default override value
+	 * @return array<mixed>|null          Input value or default as array/null
+	 */
+	public static function setArray(mixed $val, ?array $default = null): ?array
+	{
+		return VarSetTypeMain::setArrayMain($val, $default, true);
+	}
+
+	/**
+	 * Check if input is bool, if not will return default value null.
+	 *
+	 * @param  mixed     $val     Input value $val
+	 * @param  bool|null $default Default override value
+	 * @return bool|null          Input value or default as bool/null
+	 */
+	public static function setBool(mixed $val, ?bool $default = null): ?bool
+	{
+		return VarSetTypeMain::setBoolMain($val, $default, true);
+	}
+
+	/**
+	 * Convert anything to bool
+	 *
+	 * @param  mixed     $val Input value $val
+	 * @return bool|null      Input value as bool or default as bool/null
+	 */
+	public static function makeBool(mixed $val): ?bool
+	{
+		// note that the default value here is irrelevant, we return null
+		// on unsetable string var
+		return VarSetTypeMain::makeBoolMain($val, false, true);
+	}
+}
+
+// __END__

4dev/deprecated/CoreLibs/DB/IO.php

@@ -266,16 +266,18 @@ class IO
 	// 1: read new, keep at end, clean before new run
 	// 2: read new, clean at the end (temporary cache)
 	// 3: never cache
-	/** @var int */
+	/** @var int use cache (default) in dbReturn */
 	public const USE_CACHE = 0;
-	/** @var int */
+	/** @var int reset cache and read new in dbReturn */
 	public const READ_NEW = 1;
-	/** @var int */
+	/** @var int clear cache after read in dbeEturn */
 	public const CLEAR_CACHE = 2;
-	/** @var int */
+	/** @var int do not use any cache in dbReturn */
 	public const NO_CACHE = 3;
-	/** @var string */
+	/** @var string default hash type */
 	public const ERROR_HASH_TYPE = 'adler32';
+	/** @var string regex to get returning with matches at position 1 */
+	public const REGEX_RETURNING = '/\s+returning\s+(.+?);?$/i';
 
 	// recommend to set private/protected and only allow setting via method
 	// can bet set from outside
@@ -573,14 +575,14 @@ class IO
 	/**
 	 * checks if query is a SELECT, SHOW or WITH, if not error, 0 return
 	 * NOTE:
-	 * Query needs to start with SELECT, SHOW or WITH. if starts with "with" it is ignored
+	 * Query needs to start with SELECT, SHOW or WITH
 	 * @param  string $query query to check
 	 * @return bool          true if matching, false if not
 	 */
 	private function __checkQueryForSelect(string $query): bool
 	{
-		// perhaps allow spaces before select ?!?
-		if (preg_match("/^(select|show|with) /i", $query)) {
+		// change to string starts with?
+		if (preg_match("/^\s*(?:SELECT|SHOW|WITH)\s/i", $query)) {
 			return true;
 		}
 		return false;
@@ -597,10 +599,10 @@ class IO
 	 */
 	private function __checkQueryForInsert(string $query, bool $pure = false): bool
 	{
-		if ($pure && preg_match("/^insert /i", $query)) {
+		if ($pure && preg_match("/^\s*INSERT\s+?INTO\s/i", $query)) {
 			return true;
 		}
-		if (!$pure && preg_match("/^(insert|update|delete) /i", $query)) {
+		if (!$pure && preg_match("/^\s*(?:INSERT\s+?INTO|DELETE\s+?FROM|UPDATE)\s/i", $query)) {
 			return true;
 		}
 		return false;
@@ -614,7 +616,7 @@ class IO
 	 */
 	private function __checkQueryForUpdate(string $query): bool
 	{
-		if (preg_match("/^update /i", $query)) {
+		if (preg_match("/^\s*UPDATE\s?(.+)/i", $query)) {
 			return true;
 		}
 		return false;
@@ -879,12 +881,33 @@ class IO
 	private function __dbReturnTable(string $query): array
 	{
 		$matches = [];
-		if (preg_match("/^SELECT /i", $query)) {
-			preg_match("/ (FROM) \"?(([\w_]+)\.)?([\w_]+)\"? /i", $query, $matches);
+		$schema_table = [];
+		if ($this->__checkQueryForSelect($query)) {
+			// only selects the first one, this is more a fallback
+			// MATCHES 1 (call), 3 (schema), 4 (table)
+			preg_match("/\s+?(FROM)\s+?([\"'])?(?:([\w_]+)\.)?([\w_]+)(?:\2)?\s?/i", $query, $matches);
+			$schema_table = [
+				$matches[3] ?? '',
+				$matches[4] ?? '',
+			];
 		} else {
-			preg_match("/(INSERT INTO|DELETE FROM|UPDATE) \"?(([\w_]+)\.)?([\w_]+)\"? /i", $query, $matches);
+			preg_match(
+				// must start with
+				// INSERT INTO (table)
+				// DELETE FROM (table)
+				// UPDATE (table) SET
+				// MATCHES 1 (call), 4 (schema), 5 (table)
+				"/^\s*(INSERT\s+?INTO|DELETE\s+?FROM|(UPDATE))\s+?"
+					. "([\"'])?(?:([\w_]+)\.)?([\w_]+)(?:\3)?\s?(?(2)\s+?SET|)/i",
+				$query,
+				$matches
+			);
+			$schema_table = [
+				$matches[4] ?? '',
+				$matches[5] ?? ''
+			];
 		}
-		return [$matches[3] ?? '', $matches[4] ?? ''];
+		return $schema_table;
 	}
 
 	/**
@@ -1007,7 +1030,7 @@ class IO
 							$this->pk_name_table[$table] : 'NULL';
 				}
 				if (
-					!preg_match("/ returning /i", $this->query) &&
+					!preg_match(self::REGEX_RETURNING, $this->query) &&
 					$this->pk_name && $this->pk_name != 'NULL'
 				) {
 					// check if this query has a ; at the end and remove it
@@ -1016,7 +1039,9 @@ class IO
 					$this->query = !is_string($__query) ? $this->query : $__query;
 					$this->query .= " RETURNING " . $this->pk_name;
 					$this->returning_id = true;
-				} elseif (preg_match("/ returning (.*)/i", $this->query, $matches)) {
+				} elseif (
+					preg_match(self::REGEX_RETURNING, $this->query, $matches)
+				) {
 					if ($this->pk_name && $this->pk_name != 'NULL') {
 						// add the primary key if it is not in the returning set
 						if (!preg_match("/$this->pk_name/", $matches[1])) {
@@ -1030,7 +1055,7 @@ class IO
 		// if we have an UPDATE and RETURNING, flag for true, but do not add anything
 		if (
 			$this->__checkQueryForUpdate($this->query) &&
-			preg_match("/ returning (.*)/i", $this->query, $matches)
+			preg_match(self::REGEX_RETURNING, $this->query, $matches)
 		) {
 			$this->returning_id = true;
 		}
@@ -2288,11 +2313,14 @@ class IO
 						$this->prepare_cursor[$stm_name]['pk_name'] = $pk_name;
 					}
 					// if no returning, then add it
-					if (!preg_match("/ returning /i", $query) && $this->prepare_cursor[$stm_name]['pk_name']) {
+					if (
+						!preg_match(self::REGEX_RETURNING, $query) &&
+						$this->prepare_cursor[$stm_name]['pk_name']
+					) {
 						$query .= " RETURNING " . $this->prepare_cursor[$stm_name]['pk_name'];
 						$this->prepare_cursor[$stm_name]['returning_id'] = true;
 					} elseif (
-						preg_match("/ returning (.*)/i", $query, $matches) &&
+						preg_match(self::REGEX_RETURNING, $query, $matches) &&
 						$this->prepare_cursor[$stm_name]['pk_name']
 					) {
 						// if returning exists but not pk_name, add it

4dev/deprecated/CoreLibs/Debug/Support.php

@@ -94,9 +94,11 @@ class Support
 	 * @param  bool   $no_html set to true to use ##HTMLPRE##or html escape
 	 * @return string
 	 */
-	public static function printToString($mixed, bool $no_html = false): string
+	public static function printToString(mixed $mixed, bool $no_html = false): string
 	{
-		if (is_bool($mixed)) {
+		if (is_null($mixed)) {
+			return (string)'NULL';
+		} elseif (is_bool($mixed)) {
 			return self::printBool($mixed, '', 'TRUE', 'FALSE');
 		} elseif (is_resource($mixed)) {
 			return (string)$mixed;