Compare commits
13 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
6c6b33cacc | ||
|
|
5509d1c92e | ||
|
|
16d789f061 | ||
|
|
3450b6263b | ||
|
|
bcc1e833c1 | ||
|
|
fea4c315f3 | ||
|
|
3ac57e05b0 | ||
|
|
b0230e7050 | ||
|
|
70f78a5f9c | ||
|
|
814ec50d3d | ||
|
|
e60ce3f0dc | ||
|
|
6140bd8671 | ||
|
|
e318a4fb9a |
@@ -20,7 +20,9 @@
|
||||
"psr/log": "^3.0@dev"
|
||||
},
|
||||
"require-dev": {
|
||||
"phpstan/phpstan": "^1.12",
|
||||
"phpstan/phpstan": "^2.0",
|
||||
"phpstan/phpdoc-parser": "^2.0",
|
||||
"phpstan/phpstan-deprecation-rules": "^2.0",
|
||||
"phan/phan": "^5.4",
|
||||
"egrajp/smarty-extended": "^4.3",
|
||||
"gullevek/dotenv": "dev-master",
|
||||
|
||||
@@ -1 +1 @@
|
||||
9.18.0
|
||||
9.20.1
|
||||
|
||||
@@ -960,10 +960,7 @@ class Login
|
||||
. "AND ear.edit_access_right_id = epa.edit_access_right_id "
|
||||
. "AND epa.enabled = 1 AND epa.edit_group_id = " . $res["edit_group_id"] . " "
|
||||
. "ORDER BY ep.order_number";
|
||||
while ($res = $this->db->dbReturn($q)) {
|
||||
if (!is_array($res)) {
|
||||
break;
|
||||
}
|
||||
while (is_array($res = $this->db->dbReturn($q))) {
|
||||
// page id array for sub data readout
|
||||
$edit_page_ids[$res['edit_page_id']] = $res['cuid'];
|
||||
// create the array for pages
|
||||
@@ -1303,11 +1300,9 @@ class Login
|
||||
{
|
||||
$is_valid_password = true;
|
||||
// check for valid in regex arrays in list
|
||||
if (is_array($this->password_valid_chars)) {
|
||||
foreach ($this->password_valid_chars as $password_valid_chars) {
|
||||
if (!preg_match("/$password_valid_chars/", $password)) {
|
||||
$is_valid_password = false;
|
||||
}
|
||||
foreach ($this->password_valid_chars as $password_valid_chars) {
|
||||
if (!preg_match("/$password_valid_chars/", $password)) {
|
||||
$is_valid_password = false;
|
||||
}
|
||||
}
|
||||
// check for min length
|
||||
|
||||
@@ -425,10 +425,7 @@ class Backend
|
||||
?string $set_content_path = null,
|
||||
int $flag = 0,
|
||||
): array {
|
||||
if (
|
||||
$set_content_path === null ||
|
||||
!is_string($set_content_path)
|
||||
) {
|
||||
if ($set_content_path === null) {
|
||||
/** @deprecated adbTopMenu missing set_content_path parameter */
|
||||
trigger_error(
|
||||
'Calling adbTopMenu without set_content_path parameter is deprecated',
|
||||
|
||||
112
src/Basic.php
112
src/Basic.php
@@ -1139,118 +1139,6 @@ class Basic
|
||||
|
||||
// *** BETTER PASSWORD OPTIONS END ***
|
||||
|
||||
// *** COLORS ***
|
||||
// [!!! DEPRECATED !!!]
|
||||
// moved to \CoreLibs\Convert\Colors
|
||||
|
||||
/**
|
||||
* converts a hex RGB color to the int numbers
|
||||
* @param string $hexStr RGB hexstring
|
||||
* @param bool $returnAsString flag to return as string
|
||||
* @param string $seperator string seperator: default: ","
|
||||
* @return string|array<mixed>|bool false on error or array with RGB or
|
||||
* a string with the seperator
|
||||
* @deprecated use \CoreLibs\Convert\Colors::hex2rgb() instead
|
||||
*/
|
||||
public static function hex2rgb(string $hexStr, bool $returnAsString = false, string $seperator = ',')
|
||||
{
|
||||
trigger_error('Method ' . __METHOD__ . ' is deprecated, use \CoreLibs\Convert\Colors::hex2rgb()', E_USER_DEPRECATED);
|
||||
return \CoreLibs\Convert\Colors::hex2rgb($hexStr, $returnAsString, $seperator);
|
||||
}
|
||||
|
||||
/**
|
||||
* converts the rgb values from int data to the valid rgb html hex string
|
||||
* optional can turn of leading #
|
||||
* @param int $red red 0-255
|
||||
* @param int $green green 0-255
|
||||
* @param int $blue blue 0-255
|
||||
* @param bool $hex_prefix default true, prefix with "#"
|
||||
* @return string|bool rgb in hex values with leading # if set
|
||||
* @deprecated use \CoreLibs\Convert\Colors::rgb2hex() instead
|
||||
*/
|
||||
public static function rgb2hex(int $red, int $green, int $blue, bool $hex_prefix = true)
|
||||
{
|
||||
trigger_error('Method ' . __METHOD__ . ' is deprecated, use \CoreLibs\Convert\Colors::rgb2hex()', E_USER_DEPRECATED);
|
||||
return \CoreLibs\Convert\Colors::rgb2hex($red, $green, $blue, $hex_prefix);
|
||||
}
|
||||
|
||||
/**
|
||||
* converts and int RGB to the HTML color string in hex format
|
||||
* @param int $red red 0-255
|
||||
* @param int $green green 0-255
|
||||
* @param int $blue blue 0-255
|
||||
* @return string|bool hex rgb string
|
||||
* @deprecated use rgb2hex instead
|
||||
*/
|
||||
public static function rgb2html(int $red, int $green, int $blue)
|
||||
{
|
||||
trigger_error('Method ' . __METHOD__ . ' is deprecated, use \CoreLibs\Convert\Colors::rgb2hex()', E_USER_DEPRECATED);
|
||||
// check that each color is between 0 and 255
|
||||
return \CoreLibs\Convert\Colors::rgb2hex($red, $green, $blue, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* converts RGB to HSB/V values
|
||||
* returns:
|
||||
* array with hue (0-360), sat (0-100%), brightness/value (0-100%)
|
||||
* @param int $red red 0-255
|
||||
* @param int $green green 0-255
|
||||
* @param int $blue blue 0-255
|
||||
* @return array<mixed>|bool Hue, Sat, Brightness/Value
|
||||
* @deprecated use \CoreLibs\Convert\Colors::rgb2hsb() instead
|
||||
*/
|
||||
public static function rgb2hsb(int $red, int $green, int $blue)
|
||||
{
|
||||
trigger_error('Method ' . __METHOD__ . ' is deprecated, use \CoreLibs\Convert\Colors::rgb2hsb()', E_USER_DEPRECATED);
|
||||
return \CoreLibs\Convert\Colors::rgb2hsb($red, $green, $blue);
|
||||
}
|
||||
|
||||
/**
|
||||
* converts HSB/V to RGB values RGB is full INT
|
||||
* @param int $H hue 0-360
|
||||
* @param float $S saturation 0-1 (float)
|
||||
* @param float $V brightness/value 0-1 (float)
|
||||
* @return array<mixed>|bool 0 red/1 green/2 blue array
|
||||
* @deprecated use \CoreLibs\Convert\Colors::hsb2rgb() instead
|
||||
*/
|
||||
public static function hsb2rgb(int $H, float $S, float $V)
|
||||
{
|
||||
trigger_error('Method ' . __METHOD__ . ' is deprecated, use \CoreLibs\Convert\Colors::hsb2rgb()', E_USER_DEPRECATED);
|
||||
return \CoreLibs\Convert\Colors::hsb2rgb($H, (int)round($S * 100), (int)round($V * 100));
|
||||
}
|
||||
|
||||
/**
|
||||
* converts a RGB (0-255) to HSL
|
||||
* return:
|
||||
* array with hue (0-360), saturation (0-100%) and luminance (0-100%)
|
||||
* @param int $r red 0-255
|
||||
* @param int $g green 0-255
|
||||
* @param int $b blue 0-255
|
||||
* @return array<mixed>|bool hue/sat/luminance
|
||||
* @deprecated use \CoreLibs\Convert\Colors::rgb2hsl() instead
|
||||
*/
|
||||
public static function rgb2hsl(int $r, int $g, int $b)
|
||||
{
|
||||
trigger_error('Method ' . __METHOD__ . ' is deprecated, use \CoreLibs\Convert\Colors::rgb2hsl()', E_USER_DEPRECATED);
|
||||
return \CoreLibs\Convert\Colors::rgb2hsb($r, $g, $b);
|
||||
}
|
||||
|
||||
/**
|
||||
* converts an HSL to RGB
|
||||
* @param int $h hue: 0-360 (degrees)
|
||||
* @param float $s saturation: 0-1
|
||||
* @param float $l luminance: 0-1
|
||||
* @return array<mixed>|bool red/blue/green 0-255 each
|
||||
* @deprecated use \CoreLibs\Convert\Colors::hsl2rgb() instead
|
||||
*/
|
||||
public static function hsl2rgb(int $h, float $s, float $l)
|
||||
{
|
||||
trigger_error('Method ' . __METHOD__ . ' is deprecated, use \CoreLibs\Convert\Colors::hsl2rgb()', E_USER_DEPRECATED);
|
||||
return \CoreLibs\Convert\Colors::hsl2rgb($h, $s * 100, $l * 100);
|
||||
}
|
||||
|
||||
// *** COLORS END ***
|
||||
|
||||
// *** EMAIL FUNCTIONS ***
|
||||
// [!!! DEPRECATED !!!]
|
||||
// Moved to \CoreLibs\Check\Email
|
||||
|
||||
@@ -119,6 +119,13 @@ class Colors
|
||||
|
||||
/**
|
||||
* check if html/css color string is valid
|
||||
*
|
||||
* TODO: update check for correct validate values
|
||||
* - space instead of ","
|
||||
* - / opcatiy checks
|
||||
* - loose numeric values
|
||||
* - lab/lch,oklab/oklch validation too
|
||||
*
|
||||
* @param string $color A color string of any format
|
||||
* @param int $flags defaults to ALL, else use | to combined from
|
||||
* HEX_RGB, HEX_RGBA, RGB, RGBA, HSL, HSLA
|
||||
@@ -168,9 +175,9 @@ class Colors
|
||||
if (preg_match("/$regex/", $color)) {
|
||||
// if valid regex, we now need to check if the content is actually valid
|
||||
// only for rgb/hsl type
|
||||
/** @var int|false */
|
||||
/** @var int<0, max>|false */
|
||||
$rgb_flag = strpos($color, 'rgb');
|
||||
/** @var int|false */
|
||||
/** @var int<0, max>|false */
|
||||
$hsl_flag = strpos($color, 'hsl');
|
||||
// if both not match, return true
|
||||
if (
|
||||
|
||||
359
src/Convert/Color/CieXyz.php
Normal file
359
src/Convert/Color/CieXyz.php
Normal file
@@ -0,0 +1,359 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: 2024/11/12
|
||||
* DESCRIPTION:
|
||||
* CIE XYZ color space conversion
|
||||
* This for various interims work
|
||||
* none public
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color;
|
||||
|
||||
use CoreLibs\Convert\Math;
|
||||
use CoreLibs\Convert\Color\Coordinates\RGB;
|
||||
use CoreLibs\Convert\Color\Coordinates\Lab;
|
||||
use CoreLibs\Convert\Color\Coordinates\XYZ;
|
||||
|
||||
class CieXyz
|
||||
{
|
||||
// MARK: public wrapper functions
|
||||
|
||||
/**
|
||||
* Convert from RGB to OkLab
|
||||
* via xyz D65
|
||||
*
|
||||
* @param RGB $rgb
|
||||
* @return Lab
|
||||
*/
|
||||
public static function rgbViaXyzD65ToOkLab(RGB $rgb): Lab
|
||||
{
|
||||
return self::xyzD65ToOkLab(
|
||||
self::linRgbToXyzD65($rgb)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convet from OkLab to RGB
|
||||
* via xyz D65
|
||||
*
|
||||
* @param Lab $lab
|
||||
* @return RGB
|
||||
*/
|
||||
public static function okLabViaXyzD65ToRgb(Lab $lab): RGB
|
||||
{
|
||||
return self::xyzD65ToLinRgb(
|
||||
self::okLabToXyzD65($lab)
|
||||
)->fromLinear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert RGB to CIE Lab
|
||||
* via xyz D65 to xyz D50
|
||||
*
|
||||
* @param RGB $rgb
|
||||
* @return Lab
|
||||
*/
|
||||
public static function rgbViaXyzD65ViaXyzD50ToLab(RGB $rgb): Lab
|
||||
{
|
||||
return self::xyzD50ToLab(
|
||||
self::xyzD65ToXyzD50(
|
||||
self::linRgbToXyzD65($rgb)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert CIE Lab to RGB
|
||||
* via xyz D50 to xyz D65
|
||||
*
|
||||
* @param Lab $lab
|
||||
* @return RGB
|
||||
*/
|
||||
public static function labViaXyzD50ViaXyzD65ToRgb(Lab $lab): RGB
|
||||
{
|
||||
return self::xyzD65ToLinRgb(
|
||||
self::xyzD50ToXyxD65(
|
||||
self::labToXyzD50($lab)
|
||||
)
|
||||
)->fromLinear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert from oklab to cie lab
|
||||
*
|
||||
* @param Lab $lab
|
||||
* @return Lab
|
||||
*/
|
||||
public static function okLabViaXyzD65ViaXyzD50ToLab(Lab $lab): Lab
|
||||
{
|
||||
return self::xyzD50ToLab(
|
||||
self::xyzD65ToXyzD50(
|
||||
self::okLabToXyzD65($lab)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert from cie lab to oklab
|
||||
*
|
||||
* @param Lab $lab
|
||||
* @return Lab
|
||||
*/
|
||||
public static function labViaXyzD50ViaXyzD65ToOkLab(Lab $lab): Lab
|
||||
{
|
||||
return self::xyzD65ToOkLab(
|
||||
self::xyzD50ToXyxD65(
|
||||
self::labToXyzD50($lab)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// MARK: helper convert any array to array{float, float, float}
|
||||
|
||||
/**
|
||||
* This is a hack for phpstan until we write a proper matrix to class
|
||||
* conversion wrapper function
|
||||
*
|
||||
* @param array<array<float|int>|float|int> $_array
|
||||
* @return array{0:float,1:float,2:float}
|
||||
*/
|
||||
private static function convertArray(array $_array): array
|
||||
{
|
||||
/** @var array{0:float,1:float,2:float} */
|
||||
return [$_array[0], $_array[1], $_array[2]];
|
||||
}
|
||||
|
||||
// MARK: xyzD65 <-> xyzD50
|
||||
|
||||
/**
|
||||
* xyzD65 to xyzD50 whitepoint
|
||||
*
|
||||
* @param XYZ $xyz
|
||||
* @return XYZ
|
||||
*/
|
||||
private static function xyzD65ToXyzD50(XYZ $xyz): XYZ
|
||||
{
|
||||
return new XYZ(self::convertArray(Math::multiplyMatrices(
|
||||
a: [
|
||||
[1.0479298208405488, 0.022946793341019088, -0.05019222954313557],
|
||||
[0.029627815688159344, 0.990434484573249, -0.01707382502938514],
|
||||
[-0.009243058152591178, 0.015055144896577895, 0.7518742899580008],
|
||||
],
|
||||
b: $xyz->returnAsArray(),
|
||||
)), options: ["whitepoint" => 'D50']);
|
||||
}
|
||||
|
||||
/**
|
||||
* xyzD50 to xyzD65 whitepoint
|
||||
*
|
||||
* @param XYZ $xyz
|
||||
* @return XYZ
|
||||
*/
|
||||
private static function xyzD50ToXyxD65(XYZ $xyz): XYZ
|
||||
{
|
||||
return new XYZ(self::convertArray(Math::multiplyMatrices(
|
||||
a: [
|
||||
[0.9554734527042182, -0.023098536874261423, 0.0632593086610217],
|
||||
[-0.028369706963208136, 1.0099954580058226, 0.021041398966943008],
|
||||
[0.012314001688319899, -0.020507696433477912, 1.3303659366080753],
|
||||
],
|
||||
b: $xyz->returnAsArray()
|
||||
)), options: ["whitepoint" => 'D65']);
|
||||
}
|
||||
|
||||
// MARK: xyzD50 <-> Lab
|
||||
|
||||
/**
|
||||
* Convert xyzD50 to Lab (Cie)
|
||||
*
|
||||
* @param XYZ $xyz
|
||||
* @return Lab
|
||||
*/
|
||||
private static function xyzD50ToLab(XYZ $xyz): Lab
|
||||
{
|
||||
$_xyz = $xyz->returnAsArray();
|
||||
$d50 = [
|
||||
0.3457 / 0.3585,
|
||||
1.00000,
|
||||
(1.0 - 0.3457 - 0.3585) / 0.3585,
|
||||
];
|
||||
|
||||
$a = 216 / 24389;
|
||||
$b = 24389 / 27;
|
||||
|
||||
$_xyz = array_map(
|
||||
fn ($k, $v) => $v / $d50[$k],
|
||||
array_keys($_xyz),
|
||||
array_values($_xyz),
|
||||
);
|
||||
|
||||
$f = array_map(
|
||||
fn ($v) => (($v > $a) ?
|
||||
pow($v, 1 / 3) :
|
||||
(($b * $v + 16) / 116)
|
||||
),
|
||||
$_xyz,
|
||||
);
|
||||
|
||||
return new Lab([
|
||||
(116 * $f[1]) - 16,
|
||||
500 * ($f[0] - $f[1]),
|
||||
200 * ($f[1] - $f[2]),
|
||||
], colorspace: 'CIELab');
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert Lab (Cie) to xyz D50
|
||||
*
|
||||
* @param Lab $lab
|
||||
* @return XYZ
|
||||
*/
|
||||
private static function labToXyzD50(Lab $lab): XYZ
|
||||
{
|
||||
$_lab = $lab->returnAsArray();
|
||||
$a = 24389 / 27;
|
||||
$b = 216 / 24389;
|
||||
$f = [];
|
||||
$f[1] = ($_lab[0] + 16) / 116;
|
||||
$f[0] = $_lab[1] / 500 + $f[1];
|
||||
$f[2] = $f[1] - $_lab[2] / 200;
|
||||
$xyz = [
|
||||
// x
|
||||
pow($f[0], 3) > $b ?
|
||||
pow($f[0], 3) :
|
||||
(116 * $f[0] - 16) / $a,
|
||||
// y
|
||||
$_lab[0] > $a * $b ?
|
||||
pow(($_lab[0] + 16) / 116, 3) :
|
||||
$_lab[0] / $a,
|
||||
// z
|
||||
pow($f[2], 3) > $b ?
|
||||
pow($f[2], 3) :
|
||||
(116 * $f[2] - 16) / $a,
|
||||
];
|
||||
|
||||
$d50 = [
|
||||
0.3457 / 0.3585,
|
||||
1.00000,
|
||||
(1.0 - 0.3457 - 0.3585) / 0.3585,
|
||||
];
|
||||
|
||||
return new XYZ(
|
||||
self::convertArray(array_map(
|
||||
fn ($k, $v) => $v * $d50[$k],
|
||||
array_keys($xyz),
|
||||
$xyz,
|
||||
)),
|
||||
options: ["whitepoint" => 'D50']
|
||||
);
|
||||
}
|
||||
|
||||
// MARK: xyzD65 <-> (linear)RGB
|
||||
|
||||
/**
|
||||
* convert linear RGB to xyz D65
|
||||
* if rgb is not flagged linear, it will be auto converted
|
||||
*
|
||||
* @param RGB $rgb
|
||||
* @return XYZ
|
||||
*/
|
||||
private static function linRgbToXyzD65(RGB $rgb): XYZ
|
||||
{
|
||||
// if not linear, convert to linear
|
||||
if (!(bool)$rgb->get('linear')) {
|
||||
$rgb = (new RGB($rgb->returnAsArray()))->toLinear();
|
||||
}
|
||||
return new XYZ(self::convertArray(Math::multiplyMatrices(
|
||||
[
|
||||
[0.41239079926595934, 0.357584339383878, 0.1804807884018343],
|
||||
[0.21263900587151027, 0.715168678767756, 0.07219231536073371],
|
||||
[0.01933081871559182, 0.11919477979462598, 0.9505321522496607],
|
||||
],
|
||||
$rgb->returnAsArray()
|
||||
)), options: ["whitepoint" => 'D65']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert xyz D65 to linear RGB
|
||||
*
|
||||
* @param XYZ $xyz
|
||||
* @return RGB
|
||||
*/
|
||||
private static function xyzD65ToLinRgb(XYZ $xyz): RGB
|
||||
{
|
||||
// xyz D65 to linrgb
|
||||
return new RGB(self::convertArray(Math::multiplyMatrices(
|
||||
a : [
|
||||
[ 3.2409699419045226, -1.537383177570094, -0.4986107602930034 ],
|
||||
[ -0.9692436362808796, 1.8759675015077202, 0.04155505740717559 ],
|
||||
[ 0.05563007969699366, -0.20397695888897652, 1.0569715142428786 ],
|
||||
],
|
||||
b : $xyz->returnAsArray()
|
||||
)), options: ["linear" => true]);
|
||||
}
|
||||
|
||||
// MARK: xyzD65 <-> OkLab
|
||||
|
||||
/**
|
||||
* xyz D65 to OkLab
|
||||
*
|
||||
* @param XYZ $xyz
|
||||
* @return Lab
|
||||
*/
|
||||
private static function xyzD65ToOkLab(XYZ $xyz): Lab
|
||||
{
|
||||
return new Lab(self::convertArray(Math::multiplyMatrices(
|
||||
[
|
||||
[0.2104542553, 0.7936177850, -0.0040720468],
|
||||
[1.9779984951, -2.4285922050, 0.4505937099],
|
||||
[0.0259040371, 0.7827717662, -0.8086757660],
|
||||
],
|
||||
array_map(
|
||||
callback: fn ($v) => pow((float)$v, 1 / 3),
|
||||
array: Math::multiplyMatrices(
|
||||
a: [
|
||||
[0.8190224432164319, 0.3619062562801221, -0.12887378261216414],
|
||||
[0.0329836671980271, 0.9292868468965546, 0.03614466816999844],
|
||||
[0.048177199566046255, 0.26423952494422764, 0.6335478258136937],
|
||||
],
|
||||
b: $xyz->returnAsArray(),
|
||||
),
|
||||
)
|
||||
)), colorspace: 'OkLab');
|
||||
}
|
||||
|
||||
/**
|
||||
* xyz D65 to OkLab
|
||||
*
|
||||
* @param Lab $lab
|
||||
* @return XYZ
|
||||
*/
|
||||
private static function okLabToXyzD65(Lab $lab): XYZ
|
||||
{
|
||||
return new XYZ(self::convertArray(Math::multiplyMatrices(
|
||||
a: [
|
||||
[1.2268798733741557, -0.5578149965554813, 0.28139105017721583],
|
||||
[-0.04057576262431372, 1.1122868293970594, -0.07171106666151701],
|
||||
[-0.07637294974672142, -0.4214933239627914, 1.5869240244272418],
|
||||
],
|
||||
b: array_map(
|
||||
callback: fn ($v) => is_numeric($v) ? $v ** 3 : 0,
|
||||
array: Math::multiplyMatrices(
|
||||
a: [
|
||||
[0.99999999845051981432, 0.39633779217376785678, 0.21580375806075880339],
|
||||
[1.0000000088817607767, -0.1055613423236563494, -0.063854174771705903402],
|
||||
[1.0000000546724109177, -0.089484182094965759684, -1.2914855378640917399],
|
||||
],
|
||||
// Divide $lightness by 100 to convert from CSS OkLab
|
||||
b: $lab->returnAsArray(),
|
||||
),
|
||||
),
|
||||
)), options: ["whitepoint" => 'D65']);
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
1103
src/Convert/Color/Color.php
Normal file
1103
src/Convert/Color/Color.php
Normal file
File diff suppressed because it is too large
Load Diff
190
src/Convert/Color/Coordinates/HSB.php
Normal file
190
src/Convert/Color/Coordinates/HSB.php
Normal file
@@ -0,0 +1,190 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: 2024/11/11
|
||||
* DESCRIPTION:
|
||||
* Color Coordinate: HSB/HSV
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color\Coordinates;
|
||||
|
||||
use CoreLibs\Convert\Color\Utils;
|
||||
|
||||
class HSB implements Interface\CoordinatesInterface
|
||||
{
|
||||
/** @var array<string> allowed colorspaces */
|
||||
private const COLORSPACES = ['sRGB'];
|
||||
|
||||
/** @var float hue */
|
||||
private float $H = 0.0;
|
||||
/** @var float saturation */
|
||||
private float $S = 0.0;
|
||||
/** @var float brightness / value */
|
||||
private float $B = 0.0;
|
||||
|
||||
/** @var string color space: either ok or cie */
|
||||
private string $colorspace = ''; /** @phpstan-ignore-line */
|
||||
|
||||
/**
|
||||
* HSB (HSV) color coordinates
|
||||
* Hue/Saturation/Brightness or Value
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default=sRGB]
|
||||
* @param array<string,string> $options [default=[]]
|
||||
* @throws \InvalidArgumentException only array colors allowed
|
||||
*/
|
||||
public function __construct(string|array $colors, string $colorspace = 'sRGB', array $options = [])
|
||||
{
|
||||
if (!is_array($colors)) {
|
||||
throw new \InvalidArgumentException('Only array colors allowed', 0);
|
||||
}
|
||||
$this->setColorspace($colorspace)->parseOptions($options)->setFromArray($colors);
|
||||
}
|
||||
|
||||
/**
|
||||
* set from array
|
||||
* where 0: Hue, 1: Saturation, 2: Brightness
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default=sRGB]
|
||||
* @param array<string,string> $options [default=[]]
|
||||
* @return self
|
||||
*/
|
||||
public static function create(string|array $colors, string $colorspace = 'sRGB', array $options = []): self
|
||||
{
|
||||
return new HSB($colors, $colorspace, $options);
|
||||
}
|
||||
|
||||
/**
|
||||
* parse options
|
||||
*
|
||||
* @param array<string,string> $options
|
||||
* @return self
|
||||
*/
|
||||
private function parseOptions(array $options): self
|
||||
{
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* set color
|
||||
*
|
||||
* @param string $name
|
||||
* @param float $value
|
||||
* @return void
|
||||
*/
|
||||
private function set(string $name, float $value): void
|
||||
{
|
||||
$name = strtoupper($name);
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
switch ($name) {
|
||||
case 'H':
|
||||
if ($value == 360.0) {
|
||||
$value = 0;
|
||||
}
|
||||
// if ($value < 0 || $value > 360) {
|
||||
if (Utils::compare(0.0, $value, 360.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for hue is not in the range of 0 to 360',
|
||||
1
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'S':
|
||||
// if ($value < 0 || $value > 100) {
|
||||
if (Utils::compare(0.0, $value, 100.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for saturation is not in the range of 0 to 100',
|
||||
2
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'B':
|
||||
// if ($value < 0 || $value > 100) {
|
||||
if (Utils::compare(0.0, $value, 100.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for brightness is not in the range of 0 to 100',
|
||||
3
|
||||
);
|
||||
}
|
||||
break;
|
||||
}
|
||||
$this->$name = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* get color
|
||||
*
|
||||
* @param string $name
|
||||
* @return float
|
||||
*/
|
||||
public function get(string $name): float|string|bool
|
||||
{
|
||||
$name = strtoupper($name);
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
return $this->$name;
|
||||
}
|
||||
|
||||
/**
|
||||
* set the colorspace
|
||||
*
|
||||
* @param string $colorspace
|
||||
* @return self
|
||||
*/
|
||||
private function setColorspace(string $colorspace): self
|
||||
{
|
||||
if (!in_array($colorspace, $this::COLORSPACES)) {
|
||||
throw new \InvalidArgumentException('Not allowed colorspace', 0);
|
||||
}
|
||||
$this->colorspace = $colorspace;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the color as array
|
||||
* where 0: Hue, 1: Saturation, 2: Brightness
|
||||
*
|
||||
* @return array{0:float,1:float,2:float}
|
||||
*/
|
||||
public function returnAsArray(): array
|
||||
{
|
||||
return [$this->H, $this->S, $this->B];
|
||||
}
|
||||
|
||||
/**
|
||||
* set color as array
|
||||
* where 0: Hue, 1: Saturation, 2: Brightness
|
||||
*
|
||||
* @param array{0:float,1:float,2:float} $colors
|
||||
* @return self
|
||||
*/
|
||||
private function setFromArray(array $colors): self
|
||||
{
|
||||
$this->set('H', $colors[0]);
|
||||
$this->set('S', $colors[1]);
|
||||
$this->set('B', $colors[2]);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* no hsb in css
|
||||
*
|
||||
* @param float|string|null $opacity
|
||||
* @return string
|
||||
* @throws \ErrorException
|
||||
*/
|
||||
public function toCssString(null|float|string $opacity = null): string
|
||||
{
|
||||
throw new \ErrorException('HSB is not available as CSS color string', 0);
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
195
src/Convert/Color/Coordinates/HSL.php
Normal file
195
src/Convert/Color/Coordinates/HSL.php
Normal file
@@ -0,0 +1,195 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: 2024/11/11
|
||||
* DESCRIPTION:
|
||||
* Color Coordinate: HSL
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color\Coordinates;
|
||||
|
||||
use CoreLibs\Convert\Color\Utils;
|
||||
|
||||
class HSL implements Interface\CoordinatesInterface
|
||||
{
|
||||
/** @var array<string> allowed colorspaces */
|
||||
private const COLORSPACES = ['sRGB'];
|
||||
|
||||
/** @var float hue */
|
||||
private float $H = 0.0;
|
||||
/** @var float saturation */
|
||||
private float $S = 0.0;
|
||||
/** @var float lightness (luminance) */
|
||||
private float $L = 0.0;
|
||||
|
||||
/** @var string color space: either sRGB */
|
||||
private string $colorspace = '';
|
||||
|
||||
/**
|
||||
* Color Coordinate HSL
|
||||
* Hue/Saturation/Lightness
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default=sRGB]
|
||||
* @param array<string,string> $options [default=[]]
|
||||
* @throws \InvalidArgumentException only array colors allowed
|
||||
*/
|
||||
public function __construct(string|array $colors, string $colorspace = 'sRGB', array $options = [])
|
||||
{
|
||||
if (!is_array($colors)) {
|
||||
throw new \InvalidArgumentException('Only array colors allowed', 0);
|
||||
}
|
||||
$this->setColorspace($colorspace)->parseOptions($options)->setFromArray($colors);
|
||||
}
|
||||
|
||||
/**
|
||||
* set from array
|
||||
* where 0: Hue, 1: Saturation, 2: Lightness
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default=sRGB]
|
||||
* @param array<string,string> $options [default=[]]
|
||||
* @return self
|
||||
*/
|
||||
public static function create(string|array $colors, string $colorspace = 'sRGB', array $options = []): self
|
||||
{
|
||||
return new HSL($colors, $colorspace, $options);
|
||||
}
|
||||
|
||||
/**
|
||||
* parse options
|
||||
*
|
||||
* @param array<string,string> $options
|
||||
* @return self
|
||||
*/
|
||||
private function parseOptions(array $options): self
|
||||
{
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* set color
|
||||
*
|
||||
* @param string $name
|
||||
* @param float $value
|
||||
* @return void
|
||||
*/
|
||||
private function set(string $name, float $value): void
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
switch ($name) {
|
||||
case 'H':
|
||||
if ($value == 360.0) {
|
||||
$value = 0;
|
||||
}
|
||||
// if ($value < 0 || $value > 360) {
|
||||
if (Utils::compare(0.0, $value, 360.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for hue is not in the range of 0 to 360',
|
||||
1
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'S':
|
||||
// if ($value < 0 || $value > 100) {
|
||||
if (Utils::compare(0.0, $value, 100.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for saturation is not in the range of 0 to 100',
|
||||
2
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'L':
|
||||
// if ($value < 0 || $value > 100) {
|
||||
if (Utils::compare(0.0, $value, 100.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for lightness is not in the range of 0 to 100',
|
||||
3
|
||||
);
|
||||
}
|
||||
break;
|
||||
}
|
||||
$this->$name = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* get color
|
||||
*
|
||||
* @param string $name
|
||||
* @return float
|
||||
*/
|
||||
public function get(string $name): float|string|bool
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
return $this->$name;
|
||||
}
|
||||
|
||||
/**
|
||||
* set the colorspace
|
||||
*
|
||||
* @param string $colorspace
|
||||
* @return self
|
||||
*/
|
||||
private function setColorspace(string $colorspace): self
|
||||
{
|
||||
if (!in_array($colorspace, $this::COLORSPACES)) {
|
||||
throw new \InvalidArgumentException('Not allowed colorspace', 0);
|
||||
}
|
||||
$this->colorspace = $colorspace;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the color as array
|
||||
* where 0: Hue, 1: Saturation, 2: Lightness
|
||||
*
|
||||
* @return array{0:float,1:float,2:float}
|
||||
*/
|
||||
public function returnAsArray(): array
|
||||
{
|
||||
return [$this->H, $this->S, $this->L];
|
||||
}
|
||||
|
||||
/**
|
||||
* set color as array
|
||||
* where 0: Hue, 1: Saturation, 2: Lightness
|
||||
*
|
||||
* @param array{0:float,1:float,2:float} $colors
|
||||
* @return self
|
||||
*/
|
||||
private function setFromArray(array $colors): self
|
||||
{
|
||||
$this->set('H', $colors[0]);
|
||||
$this->set('S', $colors[1]);
|
||||
$this->set('L', $colors[2]);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* convert to css string with optional opacityt
|
||||
*
|
||||
* @param float|string|null $opacity
|
||||
* @return string
|
||||
*/
|
||||
public function toCssString(null|float|string $opacity = null): string
|
||||
{
|
||||
$string = 'hsl('
|
||||
. $this->H
|
||||
. ' '
|
||||
. $this->S
|
||||
. ' '
|
||||
. $this->L
|
||||
. Utils::setOpacity($opacity)
|
||||
. ')';
|
||||
return $string;
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
195
src/Convert/Color/Coordinates/HWB.php
Normal file
195
src/Convert/Color/Coordinates/HWB.php
Normal file
@@ -0,0 +1,195 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: 2024/11/11
|
||||
* DESCRIPTION:
|
||||
* Color Coordinate: HWB
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color\Coordinates;
|
||||
|
||||
use CoreLibs\Convert\Color\Utils;
|
||||
|
||||
class HWB implements Interface\CoordinatesInterface
|
||||
{
|
||||
/** @var array<string> allowed colorspaces */
|
||||
private const COLORSPACES = ['sRGB'];
|
||||
|
||||
/** @var float Hue */
|
||||
private float $H = 0.0;
|
||||
/** @var float Whiteness */
|
||||
private float $W = 0.0;
|
||||
/** @var float Blackness */
|
||||
private float $B = 0.0;
|
||||
|
||||
/** @var string color space: either ok or cie */
|
||||
private string $colorspace = '';
|
||||
|
||||
/**
|
||||
* Color Coordinate: HWB
|
||||
* Hue/Whiteness/Blackness
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default=sRGB]
|
||||
* @param array<string,string> $options [default=[]]
|
||||
* @throws \InvalidArgumentException only array colors allowed
|
||||
*/
|
||||
public function __construct(string|array $colors, string $colorspace = 'sRGB', array $options = [])
|
||||
{
|
||||
if (!is_array($colors)) {
|
||||
throw new \InvalidArgumentException('Only array colors allowed', 0);
|
||||
}
|
||||
$this->setColorspace($colorspace)->parseOptions($options)->setFromArray($colors);
|
||||
}
|
||||
|
||||
/**
|
||||
* set from array
|
||||
* where 0: Hue, 1: Whiteness, 2: Blackness
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default=sRGB]
|
||||
* @param array<string,string> $options [default=[]]
|
||||
* @return self
|
||||
*/
|
||||
public static function create(string|array $colors, string $colorspace = 'sRGB', array $options = []): self
|
||||
{
|
||||
return new HWB($colors, $colorspace, $options);
|
||||
}
|
||||
|
||||
/**
|
||||
* parse options
|
||||
*
|
||||
* @param array<string,string> $options
|
||||
* @return self
|
||||
*/
|
||||
private function parseOptions(array $options): self
|
||||
{
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* set color
|
||||
*
|
||||
* @param string $name
|
||||
* @param float $value
|
||||
* @return void
|
||||
*/
|
||||
private function set(string $name, float $value): void
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
switch ($name) {
|
||||
case 'H':
|
||||
if ($value == 360.0) {
|
||||
$value = 0;
|
||||
}
|
||||
// if ($value < 0 || $value > 360) {
|
||||
if (Utils::compare(0.0, $value, 360.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for hue is not in the range of 0 to 360',
|
||||
1
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'W':
|
||||
// if ($value < 0 || $value > 100) {
|
||||
if (Utils::compare(0.0, $value, 100.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for whiteness is not in the range of 0 to 100',
|
||||
2
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'B':
|
||||
// if ($value < 0 || $value > 100) {
|
||||
if (Utils::compare(0.0, $value, 100.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for blackness is not in the range of 0 to 100',
|
||||
3
|
||||
);
|
||||
}
|
||||
break;
|
||||
}
|
||||
$this->$name = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* get color
|
||||
*
|
||||
* @param string $name
|
||||
* @return float
|
||||
*/
|
||||
public function get(string $name): float|string|bool
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
return $this->$name;
|
||||
}
|
||||
|
||||
/**
|
||||
* set the colorspace
|
||||
*
|
||||
* @param string $colorspace
|
||||
* @return self
|
||||
*/
|
||||
private function setColorspace(string $colorspace): self
|
||||
{
|
||||
if (!in_array($colorspace, $this::COLORSPACES)) {
|
||||
throw new \InvalidArgumentException('Not allowed colorspace', 0);
|
||||
}
|
||||
$this->colorspace = $colorspace;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the color as array
|
||||
* where 0: Hue, 1: Whiteness, 2: Blackness
|
||||
*
|
||||
* @return array{0:float,1:float,2:float}
|
||||
*/
|
||||
public function returnAsArray(): array
|
||||
{
|
||||
return [$this->H, $this->W, $this->B];
|
||||
}
|
||||
|
||||
/**
|
||||
* set color as array
|
||||
* where 0: Hue, 1: Whiteness, 2: Blackness
|
||||
*
|
||||
* @param array{0:float,1:float,2:float} $colors
|
||||
* @return self
|
||||
*/
|
||||
private function setFromArray(array $colors): self
|
||||
{
|
||||
$this->set('H', $colors[0]);
|
||||
$this->set('W', $colors[1]);
|
||||
$this->set('B', $colors[2]);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* convert to css string with optional opacityt
|
||||
*
|
||||
* @param float|string|null $opacity
|
||||
* @return string
|
||||
*/
|
||||
public function toCssString(null|float|string $opacity = null): string
|
||||
{
|
||||
$string = 'hwb('
|
||||
. $this->H
|
||||
. ' '
|
||||
. $this->W
|
||||
. ' '
|
||||
. $this->B
|
||||
. Utils::setOpacity($opacity)
|
||||
. ')';
|
||||
return $string;
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
@@ -0,0 +1,53 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: Ymd
|
||||
* DESCRIPTION:
|
||||
* DescriptionHere
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color\Coordinates\Interface;
|
||||
|
||||
interface CoordinatesInterface
|
||||
{
|
||||
/**
|
||||
* create class via "Class::create()" call
|
||||
* was used for multiple create interfaces
|
||||
* no longer needed, use "new Class()" instead
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default='']
|
||||
* @param array<string,string|bool|int> $options [default=[]]
|
||||
* @return self
|
||||
*/
|
||||
public static function create(string|array $colors, string $colorspace = '', array $options = []): self;
|
||||
|
||||
/**
|
||||
* get color
|
||||
*
|
||||
* @param string $name
|
||||
* @return float
|
||||
*/
|
||||
public function get(string $name): float|string|bool;
|
||||
|
||||
/**
|
||||
* Returns the color as array
|
||||
* where 0: Lightness, 1: a, 2: b
|
||||
*
|
||||
* @return array{0:float,1:float,2:float}
|
||||
*/
|
||||
public function returnAsArray(): array;
|
||||
|
||||
/**
|
||||
* Convert into css string with optional opacity
|
||||
*
|
||||
* @param null|float|string|null $opacity
|
||||
* @return string
|
||||
*/
|
||||
public function toCssString(null|float|string $opacity = null): string;
|
||||
}
|
||||
|
||||
// __END__
|
||||
227
src/Convert/Color/Coordinates/LCH.php
Normal file
227
src/Convert/Color/Coordinates/LCH.php
Normal file
@@ -0,0 +1,227 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: 2024/11/11
|
||||
* DESCRIPTION:
|
||||
* Color Coordinate: Lch
|
||||
* for oklch or cie
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color\Coordinates;
|
||||
|
||||
use CoreLibs\Convert\Color\Utils;
|
||||
|
||||
class LCH implements Interface\CoordinatesInterface
|
||||
{
|
||||
/** @var array<string> allowed colorspaces */
|
||||
private const COLORSPACES = ['OkLab', 'CIELab'];
|
||||
|
||||
/** @var float Lightness/Luminance
|
||||
* CIE: 0 to 100
|
||||
* OKlch: 0.0 to 1.0
|
||||
* BOTH: 0% to 100%
|
||||
*/
|
||||
private float $L = 0.0;
|
||||
/** @var float Chroma
|
||||
* CIE: 0 to 150, cannot be more than 230
|
||||
* OkLch: 0 to 0.4, does not exceed 0.5
|
||||
* BOTH: 0% to 100% (0 to 150, 0 to 0.4)
|
||||
*/
|
||||
private float $C = 0.0;
|
||||
/** @var float Hue
|
||||
* 0 to 360 deg
|
||||
*/
|
||||
private float $H = 0.0;
|
||||
|
||||
/** @var string color space: either ok or cie */
|
||||
private string $colorspace = '';
|
||||
|
||||
/**
|
||||
* Color Coordinate Lch
|
||||
* for oklch
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default='']
|
||||
* @param array<string,string> $options [default=[]]
|
||||
* @throws \InvalidArgumentException only array colors allowed
|
||||
*/
|
||||
public function __construct(string|array $colors, string $colorspace = '', array $options = [])
|
||||
{
|
||||
if (!is_array($colors)) {
|
||||
throw new \InvalidArgumentException('Only array colors allowed', 0);
|
||||
}
|
||||
$this->setColorspace($colorspace)->parseOptions($options)->setFromArray($colors);
|
||||
}
|
||||
|
||||
/**
|
||||
* set from array
|
||||
* where 0: Lightness, 1: Chroma, 2: Hue
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default='']
|
||||
* @param array<string,string> $options [default=[]]
|
||||
* @return self
|
||||
*/
|
||||
public static function create(string|array $colors, string $colorspace = '', array $options = []): self
|
||||
{
|
||||
return new LCH($colors, $colorspace, $options);
|
||||
}
|
||||
|
||||
/**
|
||||
* parse options
|
||||
*
|
||||
* @param array<string,string> $options
|
||||
* @return self
|
||||
*/
|
||||
private function parseOptions(array $options): self
|
||||
{
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* set color
|
||||
*
|
||||
* @param string $name
|
||||
* @param float $value
|
||||
* @return void
|
||||
*/
|
||||
private function set(string $name, float $value): void
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
switch ($name) {
|
||||
case 'L':
|
||||
// if ($this->colorspace == 'CIELab' && ($value < 0 || $value > 100)) {
|
||||
if ($this->colorspace == 'CIELab' && Utils::compare(0.0, $value, 100.0, Utils::ESPILON_BIG)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for lightness is not in the range of 0 to 100 for CIE Lab',
|
||||
1
|
||||
);
|
||||
// } elseif ($this->colorspace == 'OkLab' && ($value < 0 || $value > 1)) {
|
||||
} elseif ($this->colorspace == 'OkLab' && Utils::compare(0.0, $value, 1.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for lightness is not in the range of 0.0 to 1.0 for OkLab',
|
||||
1
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'C':
|
||||
// if ($this->colorspace == 'CIELab' && ($value < 0 || $value > 230)) {
|
||||
if ($this->colorspace == 'CIELab' && Utils::compare(0.0, $value, 230.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for chroma is not in the range of '
|
||||
. '0 to 150 and a maximum of 230 for CIE Lab',
|
||||
1
|
||||
);
|
||||
// } elseif ($this->colorspace == 'OkLab' && ($value < 0 || $value > 0.55)) {
|
||||
} elseif ($this->colorspace == 'OkLab' && Utils::compare(0.0, $value, 0.55, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for lightness is not in the range of '
|
||||
. '0.0 to 0.4 and a maximum of 0.5 for OkLab',
|
||||
1
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'H':
|
||||
// if ($value < 0 || $value > 360) {
|
||||
if (Utils::compare(0.0, $value, 360.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for hue is not in the range of 0.0 to 360.0',
|
||||
1
|
||||
);
|
||||
}
|
||||
break;
|
||||
}
|
||||
$this->$name = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* get color
|
||||
*
|
||||
* @param string $name
|
||||
* @return float
|
||||
*/
|
||||
public function get(string $name): float|string|bool
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
return $this->$name;
|
||||
}
|
||||
|
||||
/**
|
||||
* set the colorspace
|
||||
*
|
||||
* @param string $colorspace
|
||||
* @return self
|
||||
*/
|
||||
private function setColorspace(string $colorspace): self
|
||||
{
|
||||
if (!in_array($colorspace, $this::COLORSPACES)) {
|
||||
throw new \InvalidArgumentException('Not allowed colorspace', 0);
|
||||
}
|
||||
$this->colorspace = $colorspace;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the color as array
|
||||
* where 0: Lightness, 1: Chroma, 2: Hue
|
||||
*
|
||||
* @return array{0:float,1:float,2:float}
|
||||
*/
|
||||
public function returnAsArray(): array
|
||||
{
|
||||
return [$this->L, $this->C, $this->H];
|
||||
}
|
||||
|
||||
/**
|
||||
* set color as array
|
||||
* where 0: Lightness, 1: Chroma, 2: Hue
|
||||
*
|
||||
* @param array{0:float,1:float,2:float} $colors
|
||||
* @return self
|
||||
*/
|
||||
private function setFromArray(array $colors): self
|
||||
{
|
||||
$this->set('L', $colors[0]);
|
||||
$this->set('C', $colors[1]);
|
||||
$this->set('H', $colors[2]);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert into css string with optional opacity
|
||||
*
|
||||
* @param null|float|string|null $opacity
|
||||
* @return string
|
||||
*/
|
||||
public function toCssString(null|float|string $opacity = null): string
|
||||
{
|
||||
$string = '';
|
||||
switch ($this->colorspace) {
|
||||
case 'CIELab':
|
||||
$string = 'lch';
|
||||
break;
|
||||
case 'OkLab':
|
||||
$string = 'oklch';
|
||||
break;
|
||||
}
|
||||
$string .= '('
|
||||
. $this->L
|
||||
. ' '
|
||||
. $this->C
|
||||
. ' '
|
||||
. $this->H
|
||||
. Utils::setOpacity($opacity)
|
||||
. ');';
|
||||
|
||||
return $string;
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
233
src/Convert/Color/Coordinates/Lab.php
Normal file
233
src/Convert/Color/Coordinates/Lab.php
Normal file
@@ -0,0 +1,233 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: 2024/11/11
|
||||
* DESCRIPTION:
|
||||
* Color Coordinate: Lab
|
||||
* for oklab or cie
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color\Coordinates;
|
||||
|
||||
use CoreLibs\Convert\Color\Utils;
|
||||
|
||||
class Lab implements Interface\CoordinatesInterface
|
||||
{
|
||||
/** @var array<string> allowed colorspaces */
|
||||
private const COLORSPACES = ['OkLab', 'CIELab'];
|
||||
|
||||
/** @var float lightness/luminance
|
||||
* CIE: 0f to 100f
|
||||
* OKlab: 0.0 to 1.0
|
||||
* BOTH: 0% to 100%
|
||||
*/
|
||||
private float $L = 0.0;
|
||||
/** @var float a axis distance
|
||||
* CIE: -125 to 125, cannot be more than +/- 160
|
||||
* OKlab: -0.4 to 0.4, cannot exceed +/- 0.5
|
||||
* BOTH: -100% to 100% (+/-125 or 0.4)
|
||||
*/
|
||||
private float $a = 0.0;
|
||||
/** @var float b axis distance
|
||||
* CIE: -125 to 125, cannot be more than +/- 160
|
||||
* OKlab: -0.4 to 0.4, cannot exceed +/- 0.5
|
||||
* BOTH: -100% to 100% (+/-125 or 0.4)
|
||||
*/
|
||||
private float $b = 0.0;
|
||||
|
||||
/** @var string color space: either ok or cie */
|
||||
private string $colorspace = '';
|
||||
|
||||
/**
|
||||
* Color Coordinate: Lab
|
||||
* for oklab or cie
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default='']
|
||||
* @param array<string,string> $options [default=[]]
|
||||
* @throws \InvalidArgumentException only array colors allowed
|
||||
*/
|
||||
public function __construct(string|array $colors, string $colorspace = '', array $options = [])
|
||||
{
|
||||
if (!is_array($colors)) {
|
||||
throw new \InvalidArgumentException('Only array colors allowed', 0);
|
||||
}
|
||||
$this->setColorspace($colorspace)->parseOptions($options)->setFromArray($colors);
|
||||
}
|
||||
|
||||
/**
|
||||
* set from array
|
||||
* where 0: Lightness, 1: a, 2: b
|
||||
*
|
||||
* @param array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default='']
|
||||
* @param array<string,string> $options [default=[]]
|
||||
* @return self
|
||||
*/
|
||||
public static function create(string|array $colors, string $colorspace = '', array $options = []): self
|
||||
{
|
||||
return new Lab($colors, $colorspace, $options);
|
||||
}
|
||||
|
||||
/**
|
||||
* parse options
|
||||
*
|
||||
* @param array<string,string> $options
|
||||
* @return self
|
||||
*/
|
||||
private function parseOptions(array $options): self
|
||||
{
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* set color
|
||||
*
|
||||
* @param string $name
|
||||
* @param float $value
|
||||
* @return void
|
||||
*/
|
||||
private function set(string $name, float $value): void
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
switch ($name) {
|
||||
case 'L':
|
||||
// if ($this->colorspace == 'CIELab' && ($value < 0 || $value > 100)) {
|
||||
if ($this->colorspace == 'CIELab' && Utils::compare(0.0, $value, 100.0, Utils::ESPILON_BIG)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for lightness is not in the range of 0 to 100 for CIE Lab',
|
||||
1
|
||||
);
|
||||
// } elseif ($this->colorspace == 'OkLab' && ($value < 0 || $value > 1)) {
|
||||
} elseif ($this->colorspace == 'OkLab' && Utils::compare(0.0, $value, 1.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for lightness is not in the range of 0.0 to 1.0 for OkLab',
|
||||
1
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'a':
|
||||
// if ($this->colorspace == 'CIELab' && ($value < -125 || $value > 125)) {
|
||||
if ($this->colorspace == 'CIELab' && Utils::compare(-125.0, $value, 125.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for a is not in the range of -125 to 125 for CIE Lab',
|
||||
2
|
||||
);
|
||||
// } elseif ($this->colorspace == 'OkLab' && ($value < -0.55 || $value > 0.55)) {
|
||||
} elseif ($this->colorspace == 'OkLab' && Utils::compare(-0.55, $value, 0.55, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for a is not in the range of -0.5 to 0.5 for OkLab',
|
||||
2
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 'b':
|
||||
// if ($this->colorspace == 'CIELab' && ($value < -125 || $value > 125)) {
|
||||
if ($this->colorspace == 'CIELab' && Utils::compare(-125.0, $value, 125.0, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for b is not in the range of -125 to 125 for CIE Lab',
|
||||
3
|
||||
);
|
||||
// } elseif ($this->colorspace == 'OkLab' && ($value < -0.55 || $value > 0.55)) {
|
||||
} elseif ($this->colorspace == 'OkLab' && Utils::compare(-0.55, $value, 0.55, Utils::EPSILON_SMALL)) {
|
||||
throw new \LengthException(
|
||||
'Argument value ' . $value . ' for b is not in the range of -0.5 to 0.5 for OkLab',
|
||||
3
|
||||
);
|
||||
}
|
||||
break;
|
||||
}
|
||||
$this->$name = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* get color
|
||||
*
|
||||
* @param string $name
|
||||
* @return float
|
||||
*/
|
||||
public function get(string $name): float|string|bool
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
return $this->$name;
|
||||
}
|
||||
|
||||
/**
|
||||
* set the colorspace
|
||||
*
|
||||
* @param string $colorspace
|
||||
* @return self
|
||||
*/
|
||||
private function setColorspace(string $colorspace): self
|
||||
{
|
||||
if (!in_array($colorspace, $this::COLORSPACES)) {
|
||||
throw new \InvalidArgumentException('Not allowed colorspace', 0);
|
||||
}
|
||||
$this->colorspace = $colorspace;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the color as array
|
||||
* where 0: Lightness, 1: a, 2: b
|
||||
*
|
||||
* @return array{0:float,1:float,2:float}
|
||||
*/
|
||||
public function returnAsArray(): array
|
||||
{
|
||||
return [$this->L, $this->a, $this->b];
|
||||
}
|
||||
|
||||
/**
|
||||
* set color as array
|
||||
* where 0: Lightness, 1: a, 2: b
|
||||
*
|
||||
* @param array{0:float,1:float,2:float} $colors
|
||||
* @return self
|
||||
*/
|
||||
private function setFromArray(array $colors): self
|
||||
{
|
||||
$this->set('L', $colors[0]);
|
||||
$this->set('a', $colors[1]);
|
||||
$this->set('b', $colors[2]);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert into css string with optional opacity
|
||||
*
|
||||
* @param null|float|string|null $opacity
|
||||
* @return string
|
||||
*/
|
||||
public function toCssString(null|float|string $opacity = null): string
|
||||
{
|
||||
$string = '';
|
||||
switch ($this->colorspace) {
|
||||
case 'CIELab':
|
||||
$string = 'lab';
|
||||
break;
|
||||
case 'OkLab':
|
||||
$string = 'oklab';
|
||||
break;
|
||||
}
|
||||
$string .= '('
|
||||
. $this->L
|
||||
. ' '
|
||||
. $this->a
|
||||
. ' '
|
||||
. $this->b
|
||||
. Utils::setOpacity($opacity)
|
||||
. ');';
|
||||
|
||||
return $string;
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
329
src/Convert/Color/Coordinates/RGB.php
Normal file
329
src/Convert/Color/Coordinates/RGB.php
Normal file
@@ -0,0 +1,329 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: 2024/11/11
|
||||
* DESCRIPTION:
|
||||
* Color Coordinate: RGB
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color\Coordinates;
|
||||
|
||||
use CoreLibs\Convert\Color\Utils;
|
||||
|
||||
class RGB implements Interface\CoordinatesInterface
|
||||
{
|
||||
/** @var array<string> allowed colorspaces */
|
||||
private const COLORSPACES = ['sRGB'];
|
||||
|
||||
/** @var float red 0 to 255 or 0.0f to 1.0f for linear RGB */
|
||||
private float $R = 0.0;
|
||||
/** @var float green 0 to 255 or 0.0f to 1.0f for linear RGB */
|
||||
private float $G = 0.0;
|
||||
/** @var float blue 0 to 255 or 0.0f to 1.0f for linear RGB */
|
||||
private float $B = 0.0;
|
||||
|
||||
/** @var string color space: either ok or cie */
|
||||
private string $colorspace = '';
|
||||
|
||||
/** @var bool set if this is linear */
|
||||
private bool $linear = false;
|
||||
|
||||
/**
|
||||
* Color Coordinate RGB
|
||||
* @param array{0:float,1:float,2:float}|string $colors RGB color array or hex string
|
||||
* @param string $colorspace [default=sRGB]
|
||||
* @param array<string,bool> $options [default=[]] only "linear" allowed at the moment
|
||||
*/
|
||||
public function __construct(string|array $colors, string $colorspace = 'sRGB', array $options = [])
|
||||
{
|
||||
$this->setColorspace($colorspace)->parseOptions($options);
|
||||
if (is_array($colors)) {
|
||||
$this->setFromArray($colors);
|
||||
} else {
|
||||
$this->setFromHex($colors);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* set from array or string
|
||||
* where 0: Red, 1: Green, 2: Blue
|
||||
* OR #ffffff or ffffff
|
||||
*
|
||||
* @param array{0:float,1:float,2:float}|string $colors RGB color array or hex string
|
||||
* @param string $colorspace [default=sRGB]
|
||||
* @param array<string,bool> $options [default=[]] only "linear" allowed at the moment
|
||||
* @return self
|
||||
*/
|
||||
public static function create(string|array $colors, string $colorspace = 'sRGB', array $options = []): self
|
||||
{
|
||||
return new RGB($colors, $colorspace, $options);
|
||||
}
|
||||
|
||||
/**
|
||||
* parse options
|
||||
*
|
||||
* @param array<string,bool> $options
|
||||
* @return self
|
||||
*/
|
||||
private function parseOptions(array $options): self
|
||||
{
|
||||
$this->flagLinear($options['linear'] ?? false);
|
||||
return $this;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* set color
|
||||
*
|
||||
* @param string $name
|
||||
* @param float $value
|
||||
* @return void
|
||||
*/
|
||||
private function set(string $name, float $value): void
|
||||
{
|
||||
// do not allow setting linear from outside
|
||||
if ($name == 'linear') {
|
||||
return;
|
||||
}
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
// if not linear
|
||||
if (!$this->linear && ((int)$value < 0 || (int)$value > 255)) {
|
||||
throw new \LengthException('Argument value ' . $value . ' for color ' . $name
|
||||
. ' is not in the range of 0 to 255', 1);
|
||||
} elseif (
|
||||
// $this->linear && ($value < 0.0 || $value > 1.0)
|
||||
$this->linear && Utils::compare(0.0, $value, 1.0, 0.000001)
|
||||
) {
|
||||
throw new \LengthException('Argument value ' . $value . ' for color ' . $name
|
||||
. ' is not in the range of 0 to 1 for linear rgb', 2);
|
||||
}
|
||||
$this->$name = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* get color
|
||||
*
|
||||
* @param string $name
|
||||
* @return float|bool
|
||||
*/
|
||||
public function get(string $name): float|string|bool
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
return $this->$name;
|
||||
}
|
||||
|
||||
/**
|
||||
* set the colorspace
|
||||
*
|
||||
* @param string $colorspace
|
||||
* @return self
|
||||
*/
|
||||
private function setColorspace(string $colorspace): self
|
||||
{
|
||||
if (!in_array($colorspace, $this::COLORSPACES)) {
|
||||
throw new \InvalidArgumentException('Not allowed colorspace', 0);
|
||||
}
|
||||
$this->colorspace = $colorspace;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the color as array
|
||||
* where 0: Red, 1: Green, 2: Blue
|
||||
*
|
||||
* @return array{0:float,1:float,2:float}
|
||||
*/
|
||||
public function returnAsArray(): array
|
||||
{
|
||||
return [$this->R, $this->G, $this->B];
|
||||
}
|
||||
|
||||
/**
|
||||
* set color as array
|
||||
* where 0: Red, 1: Green, 2: Blue
|
||||
*
|
||||
* @param array{0:float,1:float,2:float} $colors
|
||||
* @return self
|
||||
*/
|
||||
private function setFromArray(array $colors): self
|
||||
{
|
||||
$this->set('R', $colors[0]);
|
||||
$this->set('G', $colors[1]);
|
||||
$this->set('B', $colors[2]);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return current set RGB as hex string. with or without # prefix
|
||||
*
|
||||
* @param bool $hex_prefix
|
||||
* @return string
|
||||
*/
|
||||
public function returnAsHex(bool $hex_prefix = true): string
|
||||
{
|
||||
// prefix
|
||||
$hex_color = '';
|
||||
if ($hex_prefix === true) {
|
||||
$hex_color = '#';
|
||||
}
|
||||
// convert if in linear
|
||||
if ($this->linear) {
|
||||
$this->fromLinear();
|
||||
}
|
||||
foreach ($this->returnAsArray() as $color) {
|
||||
$hex_color .= str_pad(dechex((int)$color), 2, '0', STR_PAD_LEFT);
|
||||
}
|
||||
return $hex_color;
|
||||
}
|
||||
|
||||
/**
|
||||
* set colors RGB from hex string
|
||||
*
|
||||
* @param string $hex_string
|
||||
* @return self
|
||||
*/
|
||||
private function setFromHex(string $hex_string): self
|
||||
{
|
||||
$hex_string = preg_replace("/[^0-9A-Fa-f]/", '', $hex_string); // Gets a proper hex string
|
||||
if (empty($hex_string) || !is_string($hex_string)) {
|
||||
throw new \InvalidArgumentException('hex_string argument cannot be empty', 3);
|
||||
}
|
||||
$rgbArray = [];
|
||||
if (strlen($hex_string) == 6) {
|
||||
// If a proper hex code, convert using bitwise operation.
|
||||
// No overhead... faster
|
||||
$colorVal = hexdec($hex_string);
|
||||
$rgbArray = [
|
||||
0xFF & ($colorVal >> 0x10),
|
||||
0xFF & ($colorVal >> 0x8),
|
||||
0xFF & $colorVal
|
||||
];
|
||||
} elseif (strlen($hex_string) == 3) {
|
||||
// If shorthand notation, need some string manipulations
|
||||
$rgbArray = [
|
||||
hexdec(str_repeat(substr($hex_string, 0, 1), 2)),
|
||||
hexdec(str_repeat(substr($hex_string, 1, 1), 2)),
|
||||
hexdec(str_repeat(substr($hex_string, 2, 1), 2))
|
||||
];
|
||||
} else {
|
||||
// Invalid hex color code
|
||||
throw new \UnexpectedValueException('Invalid hex_string: ' . $hex_string, 4);
|
||||
}
|
||||
return $this->setFromArray($rgbArray);
|
||||
}
|
||||
|
||||
/**
|
||||
* set as linear
|
||||
* can be used as chain call on create if input is linear RGB
|
||||
* RGB::__construct**(...)->flagLinear();
|
||||
* as it returns self
|
||||
*
|
||||
* @return self
|
||||
*/
|
||||
private function flagLinear(bool $linear): self
|
||||
{
|
||||
$this->linear = $linear;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Both function source:
|
||||
* https://bottosson.github.io/posts/colorwrong/#what-can-we-do%3F
|
||||
* but reverse f: fromLinear and f_inv for toLinear
|
||||
* Code copied from here:
|
||||
* https://stackoverflow.com/a/12894053
|
||||
*
|
||||
* converts RGB to linear
|
||||
* We come from 0-255 so we need to divide by 255
|
||||
*
|
||||
* @return self
|
||||
*/
|
||||
public function toLinear(): self
|
||||
{
|
||||
// if linear, as is
|
||||
if ($this->linear) {
|
||||
return $this;
|
||||
}
|
||||
$this->flagLinear(true)->setFromArray(array_map(
|
||||
callback: function (int|float $v) {
|
||||
$v = (float)($v / 255);
|
||||
$abs = abs($v);
|
||||
$sign = ($v < 0) ? -1 : 1;
|
||||
return (float)(
|
||||
$abs <= 0.04045 ?
|
||||
$v / 12.92 :
|
||||
$sign * pow(($abs + 0.055) / 1.055, 2.4)
|
||||
);
|
||||
},
|
||||
array: $this->returnAsArray(),
|
||||
));
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* convert back to normal sRGB from linear RGB
|
||||
* we go to 0-255 rgb so we multiply by 255
|
||||
*
|
||||
* @return self
|
||||
*/
|
||||
public function fromLinear(): self
|
||||
{
|
||||
// if not linear, as is
|
||||
if (!$this->linear) {
|
||||
return $this;
|
||||
}
|
||||
$this->flagLinear(false)->setFromArray(array_map(
|
||||
callback: function (int|float $v) {
|
||||
$abs = abs($v);
|
||||
$sign = ($v < 0) ? -1 : 1;
|
||||
// during reverse in some situations the values can become negative in very small ways
|
||||
// like -...E16 and ...E17
|
||||
return ($ret = (float)(255 * (
|
||||
$abs <= 0.0031308 ?
|
||||
$v * 12.92 :
|
||||
$sign * (1.055 * pow($abs, 1.0 / 2.4) - 0.055)
|
||||
))) < 0 ? 0 : $ret;
|
||||
},
|
||||
array: $this->returnAsArray(),
|
||||
));
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* convert to css string with optional opacity
|
||||
* Note: if this is a linear RGB, the data will converted during this operation and the converted back
|
||||
*
|
||||
* @param float|string|null $opacity
|
||||
* @return string
|
||||
*/
|
||||
public function toCssString(null|float|string $opacity = null): string
|
||||
{
|
||||
// if we are in linear mode, convert to normal mode temporary
|
||||
$was_linear = false;
|
||||
if ($this->linear) {
|
||||
$this->fromLinear();
|
||||
$was_linear = true;
|
||||
}
|
||||
$string = 'rgb('
|
||||
. (int)round($this->R, 0)
|
||||
. ' '
|
||||
. (int)round($this->G, 0)
|
||||
. ' '
|
||||
. (int)round($this->B, 0)
|
||||
. Utils::setOpacity($opacity)
|
||||
. ')';
|
||||
if ($was_linear) {
|
||||
$this->toLinear();
|
||||
}
|
||||
return $string;
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
202
src/Convert/Color/Coordinates/XYZ.php
Normal file
202
src/Convert/Color/Coordinates/XYZ.php
Normal file
@@ -0,0 +1,202 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: 2024/11/11
|
||||
* DESCRIPTION:
|
||||
* Color Coordinate: XYZ (Cie) (colorspace CIEXYZ)
|
||||
* Note, this is only for the D50 & D65 whitepoint conversion
|
||||
* https://en.wikipedia.org/wiki/CIE_1931_color_space#Construction_of_the_CIE_XYZ_color_space_from_the_Wright%E2%80%93Guild_data
|
||||
* https://en.wikipedia.org/wiki/Standard_illuminant#Illuminant_series_D
|
||||
* https://en.wikipedia.org/wiki/Standard_illuminant#D65_values
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color\Coordinates;
|
||||
|
||||
// use CoreLibs\Convert\Color\Utils;
|
||||
|
||||
class XYZ implements Interface\CoordinatesInterface
|
||||
{
|
||||
/** @var array<string> allowed colorspaces */
|
||||
private const COLORSPACES = ['CIEXYZ'];
|
||||
/** @var array<string> allowed whitepoints
|
||||
* D50: ICC profile PCS (horizon light) <-> CieLab
|
||||
* D65: RGB color space (noon) <-> linear RGB
|
||||
*/
|
||||
private const ILLUMINANT = ['D50', 'D65'];
|
||||
|
||||
/** @var float X coordinate */
|
||||
private float $X = 0.0;
|
||||
/** @var float Y coordinate (Luminance) */
|
||||
private float $Y = 0.0;
|
||||
/** @var float Z coordinate (blue) */
|
||||
private float $Z = 0.0;
|
||||
|
||||
/** @var string color space: either ok or cie */
|
||||
private string $colorspace = '';
|
||||
|
||||
/** @var string illuminat white point: only D50 and D65 are allowed */
|
||||
private string $whitepoint = '';
|
||||
|
||||
/**
|
||||
* Color Coordinate Lch
|
||||
* for oklch conversion
|
||||
*
|
||||
* @param string|array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default=CIEXYZ]
|
||||
* @param array<string,string> $options [default=[]] Only "whitepoint" option allowed
|
||||
* @throws \InvalidArgumentException only array colors allowed
|
||||
*/
|
||||
public function __construct(
|
||||
string|array $colors,
|
||||
string $colorspace = 'CIEXYZ',
|
||||
array $options = [],
|
||||
) {
|
||||
if (!is_array($colors)) {
|
||||
throw new \InvalidArgumentException('Only array colors allowed', 0);
|
||||
}
|
||||
$this->setColorspace($colorspace)
|
||||
->parseOptions($options)
|
||||
->setFromArray($colors);
|
||||
}
|
||||
|
||||
/**
|
||||
* set from array
|
||||
* where 0: X, 1: Y, 2: Z
|
||||
*
|
||||
* @param array{0:float,1:float,2:float} $colors
|
||||
* @param string $colorspace [default=CIEXYZ]
|
||||
* @param array<string,string> $options [default=[]] Only "whitepoint" option allowed
|
||||
* @return self
|
||||
*/
|
||||
public static function create(
|
||||
string|array $colors,
|
||||
string $colorspace = 'CIEXYZ',
|
||||
array $options = [],
|
||||
): self {
|
||||
return new XYZ($colors, $colorspace, $options);
|
||||
}
|
||||
|
||||
/**
|
||||
* parse options
|
||||
*
|
||||
* @param array<string,string> $options
|
||||
* @return self
|
||||
*/
|
||||
private function parseOptions(array $options): self
|
||||
{
|
||||
$this->setWhitepoint($options['whitepoint'] ?? '');
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* set color
|
||||
*
|
||||
* @param string $name
|
||||
* @param float $value
|
||||
* @return void
|
||||
*/
|
||||
private function set(string $name, float $value): void
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
// TODO: setup XYZ value limits
|
||||
// X: 0 to 95.047, Y: 0 to 100, Z: 0 to 108.88
|
||||
// if (Utils::compare(0.0, $value, 100.0, Utils::EPSILON_SMALL))) {
|
||||
// throw new \LengthException('Argument value ' . $value . ' for color ' . $name
|
||||
// . ' is not in the range of 0 to 100.0', 1);
|
||||
// }
|
||||
$this->$name = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* get color
|
||||
*
|
||||
* @param string $name
|
||||
* @return float
|
||||
*/
|
||||
public function get(string $name): float|string|bool
|
||||
{
|
||||
if (!property_exists($this, $name)) {
|
||||
throw new \ErrorException('Creation of dynamic property is not allowed', 0);
|
||||
}
|
||||
return $this->$name;
|
||||
}
|
||||
|
||||
/**
|
||||
* set the colorspace
|
||||
*
|
||||
* @param string $colorspace
|
||||
* @return self
|
||||
*/
|
||||
private function setColorspace(string $colorspace): self
|
||||
{
|
||||
if (!in_array($colorspace, $this::COLORSPACES)) {
|
||||
throw new \InvalidArgumentException('Not allowed colorspace', 0);
|
||||
}
|
||||
$this->colorspace = $colorspace;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* set the whitepoint flag
|
||||
*
|
||||
* @param string $whitepoint
|
||||
* @return self
|
||||
*/
|
||||
private function setWhitepoint(string $whitepoint): self
|
||||
{
|
||||
if (empty($whitepoint)) {
|
||||
$this->whitepoint = '';
|
||||
return $this;
|
||||
}
|
||||
if (!in_array($whitepoint, $this::ILLUMINANT)) {
|
||||
throw new \InvalidArgumentException('Not allowed whitepoint', 0);
|
||||
}
|
||||
$this->whitepoint = $whitepoint;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the color as array
|
||||
* where 0: X, 1: Y, 2: Z
|
||||
*
|
||||
* @return array{0:float,1:float,2:float}
|
||||
*/
|
||||
public function returnAsArray(): array
|
||||
{
|
||||
return [$this->X, $this->Y, $this->Z];
|
||||
}
|
||||
|
||||
/**
|
||||
* set color as array
|
||||
* where 0: X, 1: Y, 2: Z
|
||||
*
|
||||
* @param array{0:float,1:float,2:float} $colors
|
||||
* @return self
|
||||
*/
|
||||
private function setFromArray(array $colors): self
|
||||
{
|
||||
$this->set('X', $colors[0]);
|
||||
$this->set('Y', $colors[1]);
|
||||
$this->set('Z', $colors[2]);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* no hsb in css
|
||||
*
|
||||
* @param float|string|null $opacity
|
||||
* @return string
|
||||
* @throws \ErrorException
|
||||
*/
|
||||
public function toCssString(null|float|string $opacity = null): string
|
||||
{
|
||||
throw new \ErrorException('XYZ is not available as CSS color string', 0);
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
35
src/Convert/Color/Stringify.php
Normal file
35
src/Convert/Color/Stringify.php
Normal file
@@ -0,0 +1,35 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: 2024/11/11
|
||||
* DESCRIPTION:
|
||||
* Convert color coordinate to CSS string
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color;
|
||||
|
||||
use CoreLibs\Convert\Color\Coordinates\RGB;
|
||||
use CoreLibs\Convert\Color\Coordinates\HSL;
|
||||
use CoreLibs\Convert\Color\Coordinates\HWB;
|
||||
use CoreLibs\Convert\Color\Coordinates\Lab;
|
||||
use CoreLibs\Convert\Color\Coordinates\LCH;
|
||||
|
||||
class Stringify
|
||||
{
|
||||
/**
|
||||
* return the CSS string including optional opacity
|
||||
*
|
||||
* @param RGB|Lab|LCH|HSL|HWB $data
|
||||
* @param null|float|string $opacity
|
||||
* @return string
|
||||
*/
|
||||
public static function toCssString(RGB|Lab|LCH|HSL|HWB $data, null|float|string $opacity): string
|
||||
{
|
||||
return $data->toCssString($opacity);
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
56
src/Convert/Color/Utils.php
Normal file
56
src/Convert/Color/Utils.php
Normal file
@@ -0,0 +1,56 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* AUTHOR: Clemens Schwaighofer
|
||||
* CREATED: 2024/11/14
|
||||
* DESCRIPTION:
|
||||
* Utils for color
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert\Color;
|
||||
|
||||
use CoreLibs\Convert\Math;
|
||||
|
||||
class Utils
|
||||
{
|
||||
/** @var float deviation allowed for valid data checks, small */
|
||||
public const EPSILON_SMALL = 0.000000000001;
|
||||
/** @var float deviation allowed for valid data checks, medium */
|
||||
public const EPSILON_MEDIUM = 0.0000001;
|
||||
/** @var float deviation allowed for valid data checks, big */
|
||||
public const ESPILON_BIG = 0.0001;
|
||||
|
||||
public static function compare(float $lower, float $value, float $upper, float $epslion): bool
|
||||
{
|
||||
if (
|
||||
Math::compareWithEpsilon($value, '<', $lower, $epslion) ||
|
||||
Math::compareWithEpsilon($value, '>', $upper, $epslion)
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the opactiy sub string part and return it
|
||||
*
|
||||
* @param null|float|string|null $opacity
|
||||
* @return string
|
||||
*/
|
||||
public static function setOpacity(null|float|string $opacity = null): string
|
||||
{
|
||||
// set opacity, either a string or float
|
||||
if (is_string($opacity)) {
|
||||
$opacity = ' / ' . $opacity;
|
||||
} elseif ($opacity !== null) {
|
||||
$opacity = ' / ' . $opacity;
|
||||
} else {
|
||||
$opacity = '';
|
||||
}
|
||||
return $opacity;
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
@@ -17,6 +17,9 @@ declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\Convert;
|
||||
|
||||
use CoreLibs\Convert\Color\Color;
|
||||
use CoreLibs\Convert\Color\Coordinates;
|
||||
|
||||
class Colors
|
||||
{
|
||||
/**
|
||||
@@ -30,6 +33,7 @@ class Colors
|
||||
* @param bool $hex_prefix default true, prefix with "#"
|
||||
* @return string rgb in hex values with leading # if set,
|
||||
* @throws \LengthException If any argument is not in the range of 0~255
|
||||
* @deprecated v9.20.0 use: new Coordinates\RGB([$red, $green, $blue]))->returnAsHex(true/false for #)
|
||||
*/
|
||||
public static function rgb2hex(
|
||||
int $red,
|
||||
@@ -37,20 +41,7 @@ class Colors
|
||||
int $blue,
|
||||
bool $hex_prefix = true
|
||||
): string {
|
||||
$hex_color = '';
|
||||
if ($hex_prefix === true) {
|
||||
$hex_color = '#';
|
||||
}
|
||||
foreach (['red', 'green', 'blue'] as $color) {
|
||||
// if not valid, abort
|
||||
if ($$color < 0 || $$color > 255) {
|
||||
throw new \LengthException('Argument value ' . $$color . ' for color ' . $color
|
||||
. ' is not in the range of 0 to 255', 1);
|
||||
}
|
||||
// pad left with 0
|
||||
$hex_color .= str_pad(dechex($$color), 2, '0', STR_PAD_LEFT);
|
||||
}
|
||||
return $hex_color;
|
||||
return (new Coordinates\RGB([$red, $green, $blue]))->returnAsHex($hex_prefix);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -63,32 +54,29 @@ class Colors
|
||||
* or a string with the seperator
|
||||
* @throws \InvalidArgumentException if hex string is empty
|
||||
* @throws \UnexpectedValueException if the hex string value is not valid
|
||||
* @deprecated v9.20.0 use: new Coordinates\RGB($hex_string) (build string/array from return data)
|
||||
*/
|
||||
public static function hex2rgb(
|
||||
string $hex_string,
|
||||
bool $return_as_string = false,
|
||||
string $seperator = ','
|
||||
): string|array {
|
||||
$hex_string = preg_replace("/[^0-9A-Fa-f]/", '', $hex_string); // Gets a proper hex string
|
||||
if (!is_string($hex_string)) {
|
||||
throw new \InvalidArgumentException('hex_string argument cannot be empty', 1);
|
||||
}
|
||||
$rgbArray = [];
|
||||
if (strlen($hex_string) == 6) {
|
||||
// If a proper hex code, convert using bitwise operation.
|
||||
// No overhead... faster
|
||||
$colorVal = hexdec($hex_string);
|
||||
$rgbArray['r'] = 0xFF & ($colorVal >> 0x10);
|
||||
$rgbArray['g'] = 0xFF & ($colorVal >> 0x8);
|
||||
$rgbArray['b'] = 0xFF & $colorVal;
|
||||
} elseif (strlen($hex_string) == 3) {
|
||||
// If shorthand notation, need some string manipulations
|
||||
$rgbArray['r'] = hexdec(str_repeat(substr($hex_string, 0, 1), 2));
|
||||
$rgbArray['g'] = hexdec(str_repeat(substr($hex_string, 1, 1), 2));
|
||||
$rgbArray['b'] = hexdec(str_repeat(substr($hex_string, 2, 1), 2));
|
||||
} else {
|
||||
// Invalid hex color code
|
||||
throw new \UnexpectedValueException('Invalid hex_string: ' . $hex_string, 2);
|
||||
// rewrite to previous r/g/b key output
|
||||
foreach ((new Coordinates\RGB($hex_string))->returnAsArray() as $p => $el) {
|
||||
$k = '';
|
||||
switch ($p) {
|
||||
case 0:
|
||||
$k = 'r';
|
||||
break;
|
||||
case 1:
|
||||
$k = 'g';
|
||||
break;
|
||||
case 2:
|
||||
$k = 'b';
|
||||
break;
|
||||
}
|
||||
$rgbArray[$k] = (int)round($el);
|
||||
}
|
||||
// returns the rgb string or the associative array
|
||||
return $return_as_string ? implode($seperator, $rgbArray) : $rgbArray;
|
||||
@@ -105,42 +93,16 @@ class Colors
|
||||
* @param int $blue blue 0-255
|
||||
* @return array<int|float> Hue, Sat, Brightness/Value
|
||||
* @throws \LengthException If any argument is not in the range of 0~255
|
||||
* @deprecated v9.20.0 use: Color::rgbToHsb(...)->returnAsArray() will return float unrounded
|
||||
*/
|
||||
public static function rgb2hsb(int $red, int $green, int $blue): array
|
||||
{
|
||||
// check that rgb is from 0 to 255
|
||||
foreach (['red', 'green', 'blue'] as $color) {
|
||||
if ($$color < 0 || $$color > 255) {
|
||||
throw new \LengthException('Argument value ' . $$color . ' for color ' . $color
|
||||
. ' is not in the range of 0 to 255', 1);
|
||||
}
|
||||
$$color = $$color / 255;
|
||||
}
|
||||
|
||||
$MAX = max($red, $green, $blue);
|
||||
$MIN = min($red, $green, $blue);
|
||||
$HUE = 0;
|
||||
|
||||
if ($MAX == $MIN) {
|
||||
return [0, 0, round($MAX * 100)];
|
||||
}
|
||||
if ($red == $MAX) {
|
||||
$HUE = ($green - $blue) / ($MAX - $MIN);
|
||||
} elseif ($green == $MAX) {
|
||||
$HUE = 2 + (($blue - $red) / ($MAX - $MIN));
|
||||
} elseif ($blue == $MAX) {
|
||||
$HUE = 4 + (($red - $green) / ($MAX - $MIN));
|
||||
}
|
||||
$HUE *= 60;
|
||||
if ($HUE < 0) {
|
||||
$HUE += 360;
|
||||
}
|
||||
|
||||
return [
|
||||
(int)round($HUE),
|
||||
(int)round((($MAX - $MIN) / $MAX) * 100),
|
||||
(int)round($MAX * 100)
|
||||
];
|
||||
return array_map(
|
||||
fn ($v) => (int)round($v),
|
||||
Color::rgbToHsb(
|
||||
new Coordinates\RGB([$red, $green, $blue])
|
||||
)->returnAsArray()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -153,80 +115,16 @@ class Colors
|
||||
* @param float $V brightness/value 0-100 (int)
|
||||
* @return array<int> 0 red/1 green/2 blue array as 0-255
|
||||
* @throws \LengthException If any argument is not in the valid range
|
||||
* @deprecated v9.20.0 use: Color::hsbToRgb(...)->returnAsArray() will return float unrounded
|
||||
*/
|
||||
public static function hsb2rgb(float $H, float $S, float $V): array
|
||||
{
|
||||
// check that H is 0 to 359, 360 = 0
|
||||
// and S and V are 0 to 1
|
||||
if ($H == 360) {
|
||||
$H = 0;
|
||||
}
|
||||
if ($H < 0 || $H > 359) {
|
||||
throw new \LengthException('Argument value ' . $H . ' for hue is not in the range of 0 to 359', 1);
|
||||
}
|
||||
if ($S < 0 || $S > 100) {
|
||||
throw new \LengthException('Argument value ' . $S . ' for saturation is not in the range of 0 to 100', 2);
|
||||
}
|
||||
if ($V < 0 || $V > 100) {
|
||||
throw new \LengthException('Argument value ' . $V . ' for brightness is not in the range of 0 to 100', 3);
|
||||
}
|
||||
// convert to internal 0-1 format
|
||||
$S /= 100;
|
||||
$V /= 100;
|
||||
|
||||
if ($S == 0) {
|
||||
$V = (int)round($V * 255);
|
||||
return [$V, $V, $V];
|
||||
}
|
||||
|
||||
$Hi = floor($H / 60);
|
||||
$f = ($H / 60) - $Hi;
|
||||
$p = $V * (1 - $S);
|
||||
$q = $V * (1 - ($S * $f));
|
||||
$t = $V * (1 - ($S * (1 - $f)));
|
||||
|
||||
switch ($Hi) {
|
||||
case 0:
|
||||
$red = $V;
|
||||
$green = $t;
|
||||
$blue = $p;
|
||||
break;
|
||||
case 1:
|
||||
$red = $q;
|
||||
$green = $V;
|
||||
$blue = $p;
|
||||
break;
|
||||
case 2:
|
||||
$red = $p;
|
||||
$green = $V;
|
||||
$blue = $t;
|
||||
break;
|
||||
case 3:
|
||||
$red = $p;
|
||||
$green = $q;
|
||||
$blue = $V;
|
||||
break;
|
||||
case 4:
|
||||
$red = $t;
|
||||
$green = $p;
|
||||
$blue = $V;
|
||||
break;
|
||||
case 5:
|
||||
$red = $V;
|
||||
$green = $p;
|
||||
$blue = $q;
|
||||
break;
|
||||
default:
|
||||
$red = 0;
|
||||
$green = 0;
|
||||
$blue = 0;
|
||||
}
|
||||
|
||||
return [
|
||||
(int)round($red * 255),
|
||||
(int)round($green * 255),
|
||||
(int)round($blue * 255)
|
||||
];
|
||||
return array_map(
|
||||
fn ($v) => (int)round($v),
|
||||
Color::hsbToRgb(
|
||||
new Coordinates\HSB([$H, $S, $V])
|
||||
)->returnAsArray()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -239,50 +137,16 @@ class Colors
|
||||
* @param int $blue blue 0-255
|
||||
* @return array<float> hue/sat/luminance
|
||||
* @throws \LengthException If any argument is not in the range of 0~255
|
||||
* @deprecated v9.20.0 use: Color::rgbToHsl(...)->returnAsArray() will return float unrounded
|
||||
*/
|
||||
public static function rgb2hsl(int $red, int $green, int $blue): array
|
||||
{
|
||||
// check that rgb is from 0 to 255
|
||||
foreach (['red', 'green', 'blue'] as $color) {
|
||||
if ($$color < 0 || $$color > 255) {
|
||||
throw new \LengthException('Argument value ' . $$color . ' for color ' . $color
|
||||
. ' is not in the range of 0 to 255', 1);
|
||||
}
|
||||
$$color = $$color / 255;
|
||||
}
|
||||
|
||||
$min = min($red, $green, $blue);
|
||||
$max = max($red, $green, $blue);
|
||||
$chroma = $max - $min;
|
||||
$sat = 0;
|
||||
$hue = 0;
|
||||
// luminance
|
||||
$lum = ($max + $min) / 2;
|
||||
|
||||
// achromatic
|
||||
if ($chroma == 0) {
|
||||
// H, S, L
|
||||
return [0.0, 0.0, round($lum * 100, 1)];
|
||||
} else {
|
||||
$sat = $chroma / (1 - abs(2 * $lum - 1));
|
||||
if ($max == $red) {
|
||||
$hue = fmod((($green - $blue) / $chroma), 6);
|
||||
if ($hue < 0) {
|
||||
$hue = (6 - fmod(abs($hue), 6));
|
||||
}
|
||||
} elseif ($max == $green) {
|
||||
$hue = ($blue - $red) / $chroma + 2;
|
||||
} elseif ($max == $blue) {
|
||||
$hue = ($red - $green) / $chroma + 4;
|
||||
}
|
||||
$hue = $hue * 60;
|
||||
// $sat = 1 - abs(2 * $lum - 1);
|
||||
return [
|
||||
round($hue, 1),
|
||||
round($sat * 100, 1),
|
||||
round($lum * 100, 1)
|
||||
];
|
||||
}
|
||||
return array_map(
|
||||
fn ($v) => round($v, 1),
|
||||
Color::rgbToHsl(
|
||||
new Coordinates\RGB([$red, $green, $blue])
|
||||
)->returnAsArray()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -294,57 +158,16 @@ class Colors
|
||||
* @param float $lum luminance: 0-100
|
||||
* @return array<int,float|int> red/blue/green 0-255 each
|
||||
* @throws \LengthException If any argument is not in the valid range
|
||||
* @deprecated v9.20.0 use: Color::hslToRgb(...)->returnAsArray() will return float unrounded
|
||||
*/
|
||||
public static function hsl2rgb(float $hue, float $sat, float $lum): array
|
||||
{
|
||||
if ($hue == 360) {
|
||||
$hue = 0;
|
||||
}
|
||||
if ($hue < 0 || $hue > 359) {
|
||||
throw new \LengthException('Argument value ' . $hue . ' for hue is not in the range of 0 to 359', 1);
|
||||
}
|
||||
if ($sat < 0 || $sat > 100) {
|
||||
throw new \LengthException('Argument value ' . $sat . ' for saturation is not in the range of 0 to 100', 2);
|
||||
}
|
||||
if ($lum < 0 || $lum > 100) {
|
||||
throw new \LengthException('Argument value ' . $lum . ' for luminance is not in the range of 0 to 100', 3);
|
||||
}
|
||||
// calc to internal convert value for hue
|
||||
$hue = (1 / 360) * $hue;
|
||||
// convert to internal 0-1 format
|
||||
$sat /= 100;
|
||||
$lum /= 100;
|
||||
// if saturation is 0
|
||||
if ($sat == 0) {
|
||||
$lum = (int)round($lum * 255);
|
||||
return [$lum, $lum, $lum];
|
||||
} else {
|
||||
$m2 = $lum < 0.5 ? $lum * ($sat + 1) : ($lum + $sat) - ($lum * $sat);
|
||||
$m1 = $lum * 2 - $m2;
|
||||
$hueue = function ($base) use ($m1, $m2) {
|
||||
// base = hue, hue > 360 (1) - 360 (1), else < 0 + 360 (1)
|
||||
$base = $base < 0 ? $base + 1 : ($base > 1 ? $base - 1 : $base);
|
||||
// 6: 60, 2: 180, 3: 240
|
||||
// 2/3 = 240
|
||||
// 1/3 = 120 (all from 360)
|
||||
if ($base * 6 < 1) {
|
||||
return $m1 + ($m2 - $m1) * $base * 6;
|
||||
}
|
||||
if ($base * 2 < 1) {
|
||||
return $m2;
|
||||
}
|
||||
if ($base * 3 < 2) {
|
||||
return $m1 + ($m2 - $m1) * ((2 / 3) - $base) * 6;
|
||||
}
|
||||
return $m1;
|
||||
};
|
||||
|
||||
return [
|
||||
(int)round(255 * $hueue($hue + (1 / 3))),
|
||||
(int)round(255 * $hueue($hue)),
|
||||
(int)round(255 * $hueue($hue - (1 / 3)))
|
||||
];
|
||||
}
|
||||
return array_map(
|
||||
fn ($v) => round($v),
|
||||
Color::hslToRgb(
|
||||
new Coordinates\HSL([$hue, $sat, $lum])
|
||||
)->returnAsArray()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -56,6 +56,180 @@ class Math
|
||||
return (float)$number;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* calc cube root
|
||||
*
|
||||
* @param float $number Number to cubic root
|
||||
* @return float Calculated value
|
||||
*/
|
||||
public static function cbrt(float|int $number): float
|
||||
{
|
||||
return pow((float)$number, 1.0 / 3);
|
||||
}
|
||||
|
||||
/**
|
||||
* use PHP_FLOAT_EPSILON to compare if two float numbers are matching
|
||||
*
|
||||
* @param float $x
|
||||
* @param float $y
|
||||
* @param float $epsilon [default=PHP_FLOAT_EPSILON]
|
||||
* @return bool True equal
|
||||
*/
|
||||
public static function equalWithEpsilon(float $x, float $y, float $epsilon = PHP_FLOAT_EPSILON): bool
|
||||
{
|
||||
if (abs($x - $y) < $epsilon) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compare two value base on direction given
|
||||
* The default delta is PHP_FLOAT_EPSILON
|
||||
*
|
||||
* @param float $value
|
||||
* @param string $compare
|
||||
* @param float $limit
|
||||
* @param float $epsilon [default=PHP_FLOAT_EPSILON]
|
||||
* @return bool True on smaller/large or equal
|
||||
*/
|
||||
public static function compareWithEpsilon(
|
||||
float $value,
|
||||
string $compare,
|
||||
float $limit,
|
||||
float $epsilon = PHP_FLOAT_EPSILON
|
||||
): bool {
|
||||
switch ($compare) {
|
||||
case '<':
|
||||
if ($value < ($limit - $epsilon)) {
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case '<=':
|
||||
if ($value <= ($limit - $epsilon)) {
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case '==':
|
||||
return self::equalWithEpsilon($value, $limit, $epsilon);
|
||||
case '>':
|
||||
if ($value > ($limit + $epsilon)) {
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case '>=':
|
||||
if ($value >= ($limit + $epsilon)) {
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* This function is directly inspired by the multiplyMatrices() function in color.js
|
||||
* form Lea Verou and Chris Lilley.
|
||||
* (see https://github.com/LeaVerou/color.js/blob/main/src/multiply-matrices.js)
|
||||
* From:
|
||||
* https://github.com/matthieumastadenis/couleur/blob/3842cf51c9517e77afaa0a36ec78643a0c258e0b/src/utils/utils.php#L507
|
||||
*
|
||||
* It returns an array which is the product of the two number matrices passed as parameters.
|
||||
*
|
||||
* NOTE:
|
||||
* if the right side (B matrix) has a missing row, this row will be fillwed with 0 instead of
|
||||
* throwing an error:
|
||||
* A:
|
||||
* [
|
||||
* [1, 2, 3],
|
||||
* [4, 5, 6],
|
||||
* ]
|
||||
* B:
|
||||
* [
|
||||
* [7, 8, 9],
|
||||
* [10, 11, 12],
|
||||
* ]
|
||||
* The B will get a third row with [0, 0, 0] added to make the multiplication work as it will be
|
||||
* rewritten as
|
||||
* B-rewrite:
|
||||
* [
|
||||
* [7, 10, 0],
|
||||
* [8, 11, 12],
|
||||
* [0, 0, 0] <- automatically added
|
||||
* ]
|
||||
*
|
||||
* The same is done for unbalanced entries, they are filled with 0
|
||||
*
|
||||
* @param array<float|int|array<int|float>> $a m x n matrice
|
||||
* @param array<float|int|array<int|float>> $b n x p matrice
|
||||
*
|
||||
* @return array<float|int|array<int|float>> m x p product
|
||||
*/
|
||||
public static function multiplyMatrices(array $a, array $b): array
|
||||
{
|
||||
$m = count($a);
|
||||
|
||||
if (!is_array($a[0] ?? null)) {
|
||||
// $a is vector, convert to [[a, b, c, ...]]
|
||||
$a = [$a];
|
||||
}
|
||||
|
||||
if (!is_array($b[0])) {
|
||||
// $b is vector, convert to [[a], [b], [c], ...]]
|
||||
$b = array_map(
|
||||
callback: fn ($v) => [ $v ],
|
||||
array: $b,
|
||||
);
|
||||
}
|
||||
|
||||
$p = count($b[0]);
|
||||
|
||||
// transpose $b:
|
||||
// so that we can multiply row by row
|
||||
$bCols = array_map(
|
||||
callback: fn ($k) => array_map(
|
||||
(fn ($i) => is_array($i) ? $i[$k] ?? 0 : 0),
|
||||
$b,
|
||||
),
|
||||
array: array_keys($b[0]),
|
||||
);
|
||||
|
||||
$product = array_map(
|
||||
callback: fn ($row) => array_map(
|
||||
callback: fn ($col) => is_array($row) ?
|
||||
array_reduce(
|
||||
array: $row,
|
||||
callback: fn ($a, $v, $i = null) => $a + $v * (
|
||||
// if last entry missing for full copy add a 0 to it
|
||||
$col[$i ?? array_search($v, $row, true)] ?? 0 /** @phpstan-ignore-line */
|
||||
),
|
||||
initial: 0,
|
||||
) :
|
||||
array_reduce(
|
||||
array: $col,
|
||||
callback: fn ($a, $v) => $a + $v * $row,
|
||||
initial: 0,
|
||||
),
|
||||
array: $bCols,
|
||||
),
|
||||
array: $a,
|
||||
);
|
||||
|
||||
if ($m === 1) {
|
||||
// Avoid [[a, b, c, ...]]:
|
||||
return $product[0];
|
||||
}
|
||||
|
||||
if ($p === 1) {
|
||||
// Avoid [[a], [b], [c], ...]]:
|
||||
return array_map(
|
||||
callback: fn ($v) => $v[0] ?? 0,
|
||||
array: $product,
|
||||
);
|
||||
}
|
||||
|
||||
return $product;
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
|
||||
@@ -38,7 +38,7 @@ class Uids
|
||||
$uniqid_length++;
|
||||
}
|
||||
/** @var int<1,max> make sure that internal this is correct */
|
||||
$random_bytes_length = ($uniqid_length - ($uniqid_length % 2)) / 2;
|
||||
$random_bytes_length = (int)(($uniqid_length - ($uniqid_length % 2)) / 2);
|
||||
$uniqid = bin2hex(random_bytes($random_bytes_length));
|
||||
// if not forced shorten return next lower length
|
||||
if (!$force_length) {
|
||||
@@ -56,26 +56,6 @@ class Uids
|
||||
*/
|
||||
public static function uuidv4(): string
|
||||
{
|
||||
/* return sprintf(
|
||||
'%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
|
||||
// 32 bits for "time_low"
|
||||
mt_rand(0, 0xffff),
|
||||
mt_rand(0, 0xffff),
|
||||
// 16 bits for "time_mid"
|
||||
mt_rand(0, 0xffff),
|
||||
// 16 bits for "time_hi_and_version",
|
||||
// four most significant bits holds version number 4
|
||||
mt_rand(0, 0x0fff) | 0x4000,
|
||||
// 16 bits, 8 bits for "clk_seq_hi_res",
|
||||
// 8 bits for "clk_seq_low",
|
||||
// two most significant bits holds zero and one for variant DCE1.1
|
||||
mt_rand(0, 0x3fff) | 0x8000,
|
||||
// 48 bits for "node"
|
||||
mt_rand(0, 0xffff),
|
||||
mt_rand(0, 0xffff),
|
||||
mt_rand(0, 0xffff)
|
||||
); */
|
||||
|
||||
$data = random_bytes(16);
|
||||
assert(strlen($data) == 16);
|
||||
|
||||
@@ -93,6 +73,20 @@ class Uids
|
||||
return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
|
||||
}
|
||||
|
||||
/**
|
||||
* regex validate uuid v4
|
||||
*
|
||||
* @param string $uuidv4
|
||||
* @return bool
|
||||
*/
|
||||
public static function validateUuuidv4(string $uuidv4): bool
|
||||
{
|
||||
if (!preg_match("/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/", $uuidv4)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* creates a uniq id based on lengths
|
||||
*
|
||||
|
||||
@@ -374,7 +374,7 @@ class ArrayIO extends \CoreLibs\DB\IO
|
||||
public function dbDelete(array $table_array = [], bool $acl_limit = false): array
|
||||
{
|
||||
// is array and has values, override set and set new
|
||||
if (is_array($table_array) && count($table_array)) {
|
||||
if (count($table_array)) {
|
||||
$this->table_array = $table_array;
|
||||
}
|
||||
if (!$this->dbCheckPkSet()) {
|
||||
@@ -440,7 +440,7 @@ class ArrayIO extends \CoreLibs\DB\IO
|
||||
public function dbRead(bool $edit = false, array $table_array = []): array
|
||||
{
|
||||
// if array give, overrules internal array
|
||||
if (is_array($table_array) && count($table_array)) {
|
||||
if (count($table_array)) {
|
||||
$this->table_array = $table_array;
|
||||
}
|
||||
if (!$this->dbCheckPkSet()) {
|
||||
|
||||
@@ -284,7 +284,8 @@ class IO
|
||||
public const ERROR_HASH_TYPE = 'adler32';
|
||||
/** @var string regex to get returning with matches at position 1 */
|
||||
public const REGEX_RETURNING = '/\s+returning\s+(.+\s*(?:.+\s*)+);?$/i';
|
||||
/** @var array<string> allowed convert target for placeholder: pg or pdo (currently not available) */
|
||||
/** @var array<string> allowed convert target for placeholder:
|
||||
* pg or pdo (currently not available) */
|
||||
public const DB_CONVERT_PLACEHOLDER_TARGET = ['pg'];
|
||||
// REGEX_SELECT
|
||||
// REGEX_UPDATE
|
||||
@@ -914,7 +915,7 @@ class IO
|
||||
if ($cursor !== false) {
|
||||
[$db_prefix, $db_error_string] = $this->db_functions->__dbPrintError($cursor);
|
||||
}
|
||||
if ($cursor === false && method_exists($this->db_functions, '__dbPrintError')) {
|
||||
if ($cursor === false && method_exists($this->db_functions, '__dbPrintError')) { /** @phpstan-ignore-line */
|
||||
[$db_prefix, $db_error_string] = $this->db_functions->__dbPrintError();
|
||||
}
|
||||
// prefix the master if not the same
|
||||
@@ -1311,33 +1312,14 @@ class IO
|
||||
}
|
||||
|
||||
/**
|
||||
* count $ leading parameters only
|
||||
* count placeholder entries in the query
|
||||
*
|
||||
* @param string $query Query to check
|
||||
* @return int Number of parameters found
|
||||
*/
|
||||
private function __dbCountQueryParams(string $query): int
|
||||
{
|
||||
$match = [];
|
||||
// regex for params: only stand alone $number allowed
|
||||
// exclude all '' enclosed strings, ignore all numbers [note must start with digit]
|
||||
// can have space/tab/new line
|
||||
// must have <> = , ( [not equal, equal, comma, opening round bracket]
|
||||
// can have space/tab/new line
|
||||
// $ number with 1-9 for first and 0-9 for further digits
|
||||
// /s for matching new line in . list
|
||||
// [disabled, we don't used ^ or $] /m for multi line match
|
||||
// Matches in 1:, must be array_filtered to remove empty, count with array_unique
|
||||
$query_split = '[(=,?-]|->|->>|#>|#>>|@>|<@|\?\|\?\&|\|\||#-';
|
||||
preg_match_all(
|
||||
'/'
|
||||
. '(?:\'.*?\')?\s*(?:\?\?|<>|' . $query_split . ')\s*'
|
||||
. '(?:\d+|(?:\'.*?\')|(\$[1-9]{1}(?:[0-9]{1,})?))'
|
||||
. '/s',
|
||||
$query,
|
||||
$match
|
||||
);
|
||||
return count(array_unique(array_filter($match[1])));
|
||||
return $this->db_functions->__dbCountQueryParams($query);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -1737,7 +1719,7 @@ class IO
|
||||
{
|
||||
if (
|
||||
!empty($this->dbh) &&
|
||||
$this->dbh instanceof \PgSql\Connection
|
||||
$this->dbh instanceof \PgSql\Connection /** @phpstan-ignore-line future could be other */
|
||||
) {
|
||||
// reset any client encodings set
|
||||
$this->dbResetEncoding();
|
||||
@@ -3160,7 +3142,8 @@ class IO
|
||||
'count' => 0,
|
||||
'query' => '',
|
||||
'result' => null,
|
||||
'returning_id' => false
|
||||
'returning_id' => false,
|
||||
'placeholder_converted' => [],
|
||||
];
|
||||
// if this is an insert query, check if we can add a return
|
||||
if ($this->dbCheckQueryForInsert($query, true)) {
|
||||
@@ -3200,6 +3183,39 @@ class IO
|
||||
$this->prepare_cursor[$stm_name]['pk_name'] = $pk_name;
|
||||
}
|
||||
}
|
||||
// QUERY PARAMS: run query params check and rewrite
|
||||
if ($this->dbGetConvertPlaceholder() === true) {
|
||||
try {
|
||||
$this->placeholder_converted = ConvertPlaceholder::convertPlaceholderInQuery(
|
||||
$query,
|
||||
null,
|
||||
$this->dbGetConvertPlaceholderTarget()
|
||||
);
|
||||
// write the new queries over the old
|
||||
if (!empty($this->placeholder_converted['query'])) {
|
||||
$query = $this->placeholder_converted['query'];
|
||||
}
|
||||
$this->prepare_cursor[$stm_name]['placeholder_converted'] = $this->placeholder_converted;
|
||||
} catch (\OutOfRangeException $e) {
|
||||
$this->__dbError($e->getCode(), context:[
|
||||
'statement_name' => $stm_name,
|
||||
'query' => $query,
|
||||
'location' => 'dbPrepare',
|
||||
'error' => 'OutOfRangeException',
|
||||
'exception' => $e
|
||||
]);
|
||||
return false;
|
||||
} catch (\RuntimeException $e) {
|
||||
$this->__dbError($e->getCode(), context:[
|
||||
'statement_name' => $stm_name,
|
||||
'query' => $query,
|
||||
'location' => 'dbPrepare',
|
||||
'error' => 'RuntimeException',
|
||||
'exception' => $e
|
||||
]);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
// check prepared curser parameter count
|
||||
$this->prepare_cursor[$stm_name]['count'] = $this->__dbCountQueryParams($query);
|
||||
$this->prepare_cursor[$stm_name]['query'] = $query;
|
||||
@@ -3735,7 +3751,7 @@ class IO
|
||||
}
|
||||
|
||||
/**
|
||||
* convert db values (set)
|
||||
* convert db values (set) to php matching types
|
||||
*
|
||||
* @param Convert $convert
|
||||
* @return void
|
||||
@@ -3746,7 +3762,7 @@ class IO
|
||||
}
|
||||
|
||||
/**
|
||||
* unsert convert db values flag
|
||||
* unsert convert db values flag for converting db to php matching types
|
||||
*
|
||||
* @param Convert $convert
|
||||
* @return void
|
||||
@@ -3757,7 +3773,7 @@ class IO
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset to origincal config file set
|
||||
* Reset to original config file set for converting db to php matching type
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
@@ -3769,7 +3785,7 @@ class IO
|
||||
}
|
||||
|
||||
/**
|
||||
* check if a conert flag is set
|
||||
* check if a convert flag is set for converting db to php matching type
|
||||
*
|
||||
* @param Convert $convert
|
||||
* @return bool
|
||||
@@ -3783,7 +3799,7 @@ class IO
|
||||
}
|
||||
|
||||
/**
|
||||
* Set if we want to auto convert PDO/\Pg placeholders
|
||||
* Set if we want to auto convert to PDO/\Pg placeholders
|
||||
*
|
||||
* @param bool $flag
|
||||
* @return void
|
||||
@@ -4294,7 +4310,7 @@ class IO
|
||||
* @param string $stm_name The name of the stored statement
|
||||
* @param string $key Key field name in prepared cursor array
|
||||
* Allowed are: pk_name, count, query, returning_id
|
||||
* @return null|string|int|bool Entry from each of the valid keys
|
||||
* @return null|string|int|bool|array<string,mixed> Entry from each of the valid keys
|
||||
* Will return false on error
|
||||
* Not ethat returnin_id also can return false
|
||||
* but will not set an error entry
|
||||
@@ -4302,7 +4318,7 @@ class IO
|
||||
public function dbGetPrepareCursorValue(
|
||||
string $stm_name,
|
||||
string $key
|
||||
): null|string|int|bool {
|
||||
): null|string|int|bool|array {
|
||||
// if no statement name
|
||||
if (empty($stm_name)) {
|
||||
$this->__dbError(
|
||||
@@ -4313,7 +4329,7 @@ class IO
|
||||
return false;
|
||||
}
|
||||
// if not a valid key
|
||||
if (!in_array($key, ['pk_name', 'count', 'query', 'returning_id'])) {
|
||||
if (!in_array($key, ['pk_name', 'count', 'query', 'returning_id', 'placeholder_converted'])) {
|
||||
$this->__dbError(
|
||||
102,
|
||||
false,
|
||||
|
||||
@@ -285,6 +285,22 @@ interface SqlFunctions
|
||||
*/
|
||||
public function __dbConnectionBusySocketWait(int $timeout_seconds = 3): bool;
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @param string $parameter
|
||||
* @param bool $strip
|
||||
* @return string
|
||||
*/
|
||||
public function __dbVersionInfo(string $parameter, bool $strip = true): string;
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array<mixed>
|
||||
*/
|
||||
public function __dbVersionInfoParameterList(): array;
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
@@ -292,6 +308,13 @@ interface SqlFunctions
|
||||
*/
|
||||
public function __dbVersion(): string;
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function __dbVersionNumeric(): int;
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
@@ -306,6 +329,14 @@ interface SqlFunctions
|
||||
?int &$end = null
|
||||
): ?array;
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @param string $parameter
|
||||
* @return string|bool
|
||||
*/
|
||||
public function __dbParameter(string $parameter): string|bool;
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
@@ -343,6 +374,14 @@ interface SqlFunctions
|
||||
* @return string
|
||||
*/
|
||||
public function __dbGetEncoding(): string;
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @param string $query
|
||||
* @return int
|
||||
*/
|
||||
public function __dbCountQueryParams(string $query): int;
|
||||
}
|
||||
|
||||
// __END__
|
||||
|
||||
@@ -51,6 +51,8 @@ declare(strict_types=1);
|
||||
|
||||
namespace CoreLibs\DB\SQL;
|
||||
|
||||
use CoreLibs\DB\Support\ConvertPlaceholder;
|
||||
|
||||
// below no ignore is needed if we want to use PgSql interface checks with PHP 8.0
|
||||
// as main system. Currently all @var sets are written as object
|
||||
/** @#phan-file-suppress PhanUndeclaredTypeProperty,PhanUndeclaredTypeParameter,PhanUndeclaredTypeReturnType */
|
||||
@@ -102,7 +104,7 @@ class PgSQL implements Interface\SqlFunctions
|
||||
* SELECT foo FROM bar WHERE foobar = $1
|
||||
*
|
||||
* @param string $query Query string with placeholders $1, ..
|
||||
* @param array<mixed> $params Matching parameters for each placerhold
|
||||
* @param array<mixed> $params Matching parameters for each placeholder
|
||||
* @return \PgSql\Result|false Query result
|
||||
*/
|
||||
public function __dbQueryParams(string $query, array $params): \PgSql\Result|false
|
||||
@@ -140,7 +142,7 @@ class PgSQL implements Interface\SqlFunctions
|
||||
* sends an async query to the server with params
|
||||
*
|
||||
* @param string $query Query string with placeholders $1, ..
|
||||
* @param array<mixed> $params Matching parameters for each placerhold
|
||||
* @param array<mixed> $params Matching parameters for each placeholder
|
||||
* @return bool true/false Query sent successful status
|
||||
*/
|
||||
public function __dbSendQueryParams(string $query, array $params): bool
|
||||
@@ -405,17 +407,13 @@ class PgSQL implements Interface\SqlFunctions
|
||||
}
|
||||
// no PK name given at all
|
||||
if (empty($pk_name)) {
|
||||
// if name is plurar, make it singular
|
||||
// if (preg_match("/.*s$/i", $table))
|
||||
// $table = substr($table, 0, -1);
|
||||
// set pk_name to "id"
|
||||
$pk_name = $table . "_id";
|
||||
}
|
||||
$seq = ($schema ? $schema . '.' : '') . $table . "_" . $pk_name . "_seq";
|
||||
$q = "SELECT CURRVAL('$seq') AS insert_id";
|
||||
$q = "SELECT CURRVAL(pg_get_serial_sequence($1, $2)) AS insert_id";
|
||||
// I have to do manually or I overwrite the original insert internal vars ...
|
||||
if ($q = $this->__dbQuery($q)) {
|
||||
if (is_array($res = $this->__dbFetchArray($q))) {
|
||||
if ($cursor = $this->__dbQueryParams($q, [$table, $pk_name])) {
|
||||
if (is_array($res = $this->__dbFetchArray($cursor))) {
|
||||
list($id) = $res;
|
||||
} else {
|
||||
return false;
|
||||
@@ -449,26 +447,36 @@ class PgSQL implements Interface\SqlFunctions
|
||||
$table_prefix = $schema . '.';
|
||||
}
|
||||
}
|
||||
$params = [$table_prefix . $table];
|
||||
$replace = ['', ''];
|
||||
// read from table the PK name
|
||||
// faster primary key get
|
||||
$q = "SELECT pg_attribute.attname AS column_name, "
|
||||
. "format_type(pg_attribute.atttypid, pg_attribute.atttypmod) AS type "
|
||||
. "FROM pg_index, pg_class, pg_attribute ";
|
||||
$q = <<<SQL
|
||||
SELECT
|
||||
pg_attribute.attname AS column_name,
|
||||
format_type(pg_attribute.atttypid, pg_attribute.atttypmod) AS type
|
||||
FROM pg_index, pg_class, pg_attribute{PG_NAMESPACE}
|
||||
WHERE
|
||||
-- regclass translates the OID to the name
|
||||
pg_class.oid = $1::regclass AND
|
||||
indrelid = pg_class.oid AND
|
||||
pg_attribute.attrelid = pg_class.oid AND
|
||||
pg_attribute.attnum = any(pg_index.indkey) AND
|
||||
indisprimary
|
||||
{NSPNAME}
|
||||
SQL;
|
||||
if ($schema) {
|
||||
$q .= ", pg_namespace ";
|
||||
$params[] = $schema;
|
||||
$replace = [
|
||||
", pg_namespace",
|
||||
"AND pg_class.relnamespace = pg_namespace.oid AND nspname = $2"
|
||||
];
|
||||
}
|
||||
$q .= "WHERE "
|
||||
// regclass translates the OID to the name
|
||||
. "pg_class.oid = '" . $table_prefix . $table . "'::regclass AND "
|
||||
. "indrelid = pg_class.oid AND ";
|
||||
if ($schema) {
|
||||
$q .= "nspname = '" . $schema . "' AND "
|
||||
. "pg_class.relnamespace = pg_namespace.oid AND ";
|
||||
}
|
||||
$q .= "pg_attribute.attrelid = pg_class.oid AND "
|
||||
. "pg_attribute.attnum = any(pg_index.indkey) "
|
||||
. "AND indisprimary";
|
||||
$cursor = $this->__dbQuery($q);
|
||||
$cursor = $this->__dbQueryParams(str_replace(
|
||||
['{PG_NAMESPACE}', '{NSPNAME}'],
|
||||
$replace,
|
||||
$q
|
||||
), $params);
|
||||
if ($cursor !== false) {
|
||||
$__db_fetch_array = $this->__dbFetchArray($cursor);
|
||||
if (!is_array($__db_fetch_array)) {
|
||||
@@ -893,11 +901,13 @@ class PgSQL implements Interface\SqlFunctions
|
||||
public function __dbSetSchema(string $db_schema): int
|
||||
{
|
||||
// check if schema actually exists
|
||||
$query = "SELECT EXISTS("
|
||||
. "SELECT 1 FROM information_schema.schemata "
|
||||
. "WHERE schema_name = " . $this->__dbEscapeLiteral($db_schema)
|
||||
. ")";
|
||||
$cursor = $this->__dbQuery($query);
|
||||
$query = <<<SQL
|
||||
SELECT EXISTS (
|
||||
SELECT 1 FROM information_schema.schemata
|
||||
WHERE schema_name = $1
|
||||
)
|
||||
SQL;
|
||||
$cursor = $this->__dbQueryParams($query, [$db_schema]);
|
||||
// abort if execution fails
|
||||
if ($cursor === false) {
|
||||
return 1;
|
||||
@@ -966,6 +976,34 @@ class PgSQL implements Interface\SqlFunctions
|
||||
{
|
||||
return $this->__dbShow('client_encoding');
|
||||
}
|
||||
|
||||
/**
|
||||
* Count placeholder queries. $ only
|
||||
*
|
||||
* @param string $query
|
||||
* @return int
|
||||
*/
|
||||
public function __dbCountQueryParams(string $query): int
|
||||
{
|
||||
$matches = [];
|
||||
// regex for params: only stand alone $number allowed
|
||||
// exclude all '' enclosed strings, ignore all numbers [note must start with digit]
|
||||
// can have space/tab/new line
|
||||
// must have <> = , ( [not equal, equal, comma, opening round bracket]
|
||||
// can have space/tab/new line
|
||||
// $ number with 1-9 for first and 0-9 for further digits
|
||||
// Collects also PDO ? and :named, but they are ignored
|
||||
// /s for matching new line in . list
|
||||
// [disabled, we don't used ^ or $] /m for multi line match
|
||||
// Matches in 1:, must be array_filtered to remove empty, count with array_unique
|
||||
// Regex located in the ConvertPlaceholder class
|
||||
preg_match_all(
|
||||
ConvertPlaceholder::REGEX_LOOKUP_PLACEHOLDERS,
|
||||
$query,
|
||||
$matches
|
||||
);
|
||||
return count(array_unique(array_filter($matches[3])));
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
|
||||
@@ -14,6 +14,67 @@ namespace CoreLibs\DB\Support;
|
||||
|
||||
class ConvertPlaceholder
|
||||
{
|
||||
/** @var string split regex */
|
||||
private const PATTERN_QUERY_SPLIT = '[(<>=,?-]|->|->>|#>|#>>|@>|<@|\?\|\?\&|\|\||#-';
|
||||
/** @var string the main regex including the pattern query split */
|
||||
private const PATTERN_ELEMENT = '(?:\'.*?\')?\s*(?:\?\?|' . self::PATTERN_QUERY_SPLIT . ')\s*';
|
||||
/** @var string parts to ignore in the SQL */
|
||||
private const PATTERN_IGNORE =
|
||||
// digit -> ignore
|
||||
'\d+|'
|
||||
// other string -> ignore
|
||||
. '(?:\'.*?\')|';
|
||||
/** @var string named parameters */
|
||||
private const PATTERN_NAMED = '(:\w+)';
|
||||
/** @var string question mark parameters */
|
||||
private const PATTERN_QUESTION_MARK = '(?:(?:\?\?)?\s*(\?{1}))';
|
||||
/** @var string numbered parameters */
|
||||
private const PATTERN_NUMBERED = '(\$[1-9]{1}(?:[0-9]{1,})?)';
|
||||
// below here are full regex that will be used
|
||||
/** @var string replace regex for named (:...) entries */
|
||||
public const REGEX_REPLACE_NAMED = '/'
|
||||
. '(' . self::PATTERN_ELEMENT . ')'
|
||||
. '('
|
||||
. self::PATTERN_IGNORE
|
||||
. self::PATTERN_NAMED
|
||||
. ')'
|
||||
. '/s';
|
||||
/** @var string replace regex for question mark (?) entries */
|
||||
public const REGEX_REPLACE_QUESTION_MARK = '/'
|
||||
. '(' . self::PATTERN_ELEMENT . ')'
|
||||
. '('
|
||||
. self::PATTERN_IGNORE
|
||||
. self::PATTERN_QUESTION_MARK
|
||||
. ')'
|
||||
. '/s';
|
||||
/** @var string replace regex for numbered ($n) entries */
|
||||
public const REGEX_REPLACE_NUMBERED = '/'
|
||||
. '(' . self::PATTERN_ELEMENT . ')'
|
||||
. '('
|
||||
. self::PATTERN_IGNORE
|
||||
. self::PATTERN_NUMBERED
|
||||
. ')'
|
||||
. '/s';
|
||||
/** @var string the main lookup query for all placeholders */
|
||||
public const REGEX_LOOKUP_PLACEHOLDERS = '/'
|
||||
// prefix string part, must match towards
|
||||
// seperator for ( = , ? - [and json/jsonb in pg doc section 9.15]
|
||||
. self::PATTERN_ELEMENT
|
||||
// match for replace part
|
||||
. '(?:'
|
||||
// ignore parts
|
||||
. self::PATTERN_IGNORE
|
||||
// :name named part (PDO) [1]
|
||||
. self::PATTERN_NAMED . '|'
|
||||
// ? question mark part (PDO) [2]
|
||||
. self::PATTERN_QUESTION_MARK . '|'
|
||||
// $n numbered part (\PG php) [3]
|
||||
. self::PATTERN_NUMBERED
|
||||
// end match
|
||||
. ')'
|
||||
// single line -> add line break to matches in "."
|
||||
. '/s';
|
||||
|
||||
/**
|
||||
* Convert PDO type query with placeholders to \PG style and vica versa
|
||||
* For PDO to: ? and :named
|
||||
@@ -27,44 +88,24 @@ class ConvertPlaceholder
|
||||
* found has -1 if an error occoured in the preg_match_all call
|
||||
*
|
||||
* @param string $query Query with placeholders to convert
|
||||
* @param array<mixed> $params The parameters that are used for the query, and will be updated
|
||||
* @param ?array<mixed> $params The parameters that are used for the query, and will be updated
|
||||
* @param string $convert_to Either pdo or pg, will be converted to lower case for check
|
||||
* @return array{original:array{query:string,params:array<mixed>},type:''|'named'|'numbered'|'question_mark',found:int,matches:array<string>,params_lookup:array<mixed>,query:string,params:array<mixed>}
|
||||
* @throws \OutOfRangeException 200
|
||||
* @return array{original:array{query:string,params:array<mixed>,empty_params:bool},type:''|'named'|'numbered'|'question_mark',found:int,matches:array<string>,params_lookup:array<mixed>,query:string,params:array<mixed>}
|
||||
* @throws \OutOfRangeException 200 If mixed placeholder types
|
||||
* @throws \InvalidArgumentException 300 or 301 if wrong convert to with found placeholders
|
||||
*/
|
||||
public static function convertPlaceholderInQuery(
|
||||
string $query,
|
||||
array $params,
|
||||
?array $params,
|
||||
string $convert_to = 'pg'
|
||||
): array {
|
||||
$convert_to = strtolower($convert_to);
|
||||
$matches = [];
|
||||
$query_split = '[(=,?-]|->|->>|#>|#>>|@>|<@|\?\|\?\&|\|\||#-';
|
||||
$pattern = '/'
|
||||
// prefix string part, must match towards
|
||||
// seperator for ( = , ? - [and json/jsonb in pg doc section 9.15]
|
||||
. '(?:\'.*?\')?\s*(?:\?\?|' . $query_split . ')\s*'
|
||||
// match for replace part
|
||||
. '(?:'
|
||||
// digit -> ignore
|
||||
. '\d+|'
|
||||
// other string -> ignore
|
||||
. '(?:\'.*?\')|'
|
||||
// :name named part (PDO)
|
||||
. '(:\w+)|'
|
||||
// ? question mark part (PDO)
|
||||
. '(?:(?:\?\?)?\s*(\?{1}))|'
|
||||
// $n numbered part (\PG php)
|
||||
. '(\$[1-9]{1}(?:[0-9]{1,})?)'
|
||||
// end match
|
||||
. ')'
|
||||
// single line -> add line break to matches in "."
|
||||
. '/s';
|
||||
// matches:
|
||||
// 1: :named
|
||||
// 2: ? question mark
|
||||
// 3: $n numbered
|
||||
$found = preg_match_all($pattern, $query, $matches, PREG_UNMATCHED_AS_NULL);
|
||||
$found = preg_match_all(self::REGEX_LOOKUP_PLACEHOLDERS, $query, $matches, PREG_UNMATCHED_AS_NULL);
|
||||
// if false or null set to -1
|
||||
// || $found === null
|
||||
if ($found === false) {
|
||||
@@ -77,10 +118,10 @@ class ConvertPlaceholder
|
||||
/** @var array<string> 3: $n matches */
|
||||
$numbered_matches = array_filter($matches[3]);
|
||||
// count matches
|
||||
$count_named = count($named_matches);
|
||||
$count_named = count(array_unique($named_matches));
|
||||
$count_qmark = count($qmark_matches);
|
||||
$count_numbered = count($numbered_matches);
|
||||
// throw if mixed
|
||||
$count_numbered = count(array_unique($numbered_matches));
|
||||
// throw exception if mixed found
|
||||
if (
|
||||
($count_named && $count_qmark) ||
|
||||
($count_named && $count_numbered) ||
|
||||
@@ -88,140 +129,195 @@ class ConvertPlaceholder
|
||||
) {
|
||||
throw new \OutOfRangeException('Cannot have named, question mark and numbered in the same query', 200);
|
||||
}
|
||||
// rebuild
|
||||
$matches_return = [];
|
||||
$type = '';
|
||||
// // throw if invalid conversion
|
||||
// if (($count_named || $count_qmark) && $convert_to != 'pg') {
|
||||
// throw new \InvalidArgumentException('Cannot convert from named or question mark placeholders to PDO', 300);
|
||||
// }
|
||||
// if ($count_numbered && $convert_to != 'pdo') {
|
||||
// throw new \InvalidArgumentException('Cannot convert from numbered placeholders to Pg', 301);
|
||||
// }
|
||||
// return array
|
||||
$return_placeholders = [
|
||||
// original
|
||||
'original' => [
|
||||
'query' => $query,
|
||||
'params' => $params ?? [],
|
||||
'empty_params' => $params === null ? true : false,
|
||||
],
|
||||
// type found, empty if nothing was done
|
||||
'type' => '',
|
||||
// int: found, not found; -1: problem (set from false)
|
||||
'found' => (int)$found,
|
||||
'matches' => [],
|
||||
// old to new lookup check
|
||||
'params_lookup' => [],
|
||||
// this must match the count in params in new
|
||||
'needed' => 0,
|
||||
// new
|
||||
'query' => '',
|
||||
'params' => [],
|
||||
];
|
||||
// replace basic regex and name settings
|
||||
if ($count_named) {
|
||||
$return_placeholders['type'] = 'named';
|
||||
$return_placeholders['matches'] = $named_matches;
|
||||
$return_placeholders['needed'] = $count_named;
|
||||
} elseif ($count_qmark) {
|
||||
$return_placeholders['type'] = 'question_mark';
|
||||
$return_placeholders['matches'] = $qmark_matches;
|
||||
$return_placeholders['needed'] = $count_qmark;
|
||||
// for each ?:DTN: -> replace with $1 ... $n, any remaining :DTN: remove
|
||||
} elseif ($count_numbered) {
|
||||
$return_placeholders['type'] = 'numbered';
|
||||
$return_placeholders['matches'] = $numbered_matches;
|
||||
$return_placeholders['needed'] = $count_numbered;
|
||||
}
|
||||
// run convert only if matching type and direction
|
||||
if (
|
||||
(($count_named || $count_qmark) && $convert_to == 'pg') ||
|
||||
($count_numbered && $convert_to == 'pdo')
|
||||
) {
|
||||
$param_list = self::updateParamList($return_placeholders);
|
||||
$return_placeholders['params_lookup'] = $param_list['params_lookup'];
|
||||
$return_placeholders['query'] = $param_list['query'];
|
||||
$return_placeholders['params'] = $param_list['params'];
|
||||
}
|
||||
// return data
|
||||
return $return_placeholders;
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the params list from one style to the other to match the query output
|
||||
* if original.empty_params is set to true, no params replacement is done
|
||||
* if param replacement has been done in a dbPrepare then this has to be run
|
||||
* with the return palceholders array with params in original filled and empty_params turned off
|
||||
*
|
||||
* phpcs:disable Generic.Files.LineLength
|
||||
* @param array{original:array{query:string,params:array<mixed>,empty_params:bool},type:''|'named'|'numbered'|'question_mark',found:int,matches?:array<string>,params_lookup?:array<mixed>,query?:string,params?:array<mixed>} $converted_placeholders
|
||||
* phpcs:enable Generic.Files.LineLength
|
||||
* @return array{params_lookup:array<mixed>,query:string,params:array<mixed>}
|
||||
*/
|
||||
public static function updateParamList(array $converted_placeholders): array
|
||||
{
|
||||
// skip if nothing set
|
||||
if (!$converted_placeholders['found']) {
|
||||
return [
|
||||
'params_lookup' => [],
|
||||
'query' => '',
|
||||
'params' => []
|
||||
];
|
||||
}
|
||||
$query_new = '';
|
||||
$params_new = [];
|
||||
$params_lookup = [];
|
||||
if ($count_named && $convert_to == 'pg') {
|
||||
$type = 'named';
|
||||
$matches_return = $named_matches;
|
||||
// only check for :named
|
||||
$pattern_replace = '/'
|
||||
. '((?:\'.*?\')?\s*(?:\?\?|' . $query_split . ')\s*)'
|
||||
. '(\d+|(?:\'.*?\')|(:\w+))'
|
||||
. '/s';
|
||||
// 0: full
|
||||
// 1: pre part
|
||||
// 2: keep part UNLESS '3' is set
|
||||
// 3: replace part :named
|
||||
$pos = 0;
|
||||
$query_new = preg_replace_callback(
|
||||
$pattern_replace,
|
||||
function ($matches) use (&$pos, &$params_new, &$params_lookup, $params) {
|
||||
// only count up if $match[3] is not yet in lookup table
|
||||
if (!empty($matches[3]) && empty($params_lookup[$matches[3]])) {
|
||||
$pos++;
|
||||
$params_lookup[$matches[3]] = '$' . $pos;
|
||||
$params_new[] = $params[$matches[3]] ??
|
||||
throw new \RuntimeException(
|
||||
'Cannot lookup ' . $matches[3] . ' in params list',
|
||||
210
|
||||
);
|
||||
}
|
||||
// add the connectors back (1), and the data sets only if no replacement will be done
|
||||
return $matches[1] . (
|
||||
empty($matches[3]) ?
|
||||
$matches[2] :
|
||||
$params_lookup[$matches[3]] ??
|
||||
// set to null if params is empty
|
||||
$params = $converted_placeholders['original']['params'];
|
||||
$empty_params = $converted_placeholders['original']['empty_params'];
|
||||
switch ($converted_placeholders['type']) {
|
||||
case 'named':
|
||||
// 0: full
|
||||
// 0: full
|
||||
// 1: pre part
|
||||
// 2: keep part UNLESS '3' is set
|
||||
// 3: replace part :named
|
||||
$pos = 0;
|
||||
$query_new = preg_replace_callback(
|
||||
self::REGEX_REPLACE_NAMED,
|
||||
function ($matches) use (&$pos, &$params_new, &$params_lookup, $params, $empty_params) {
|
||||
// only count up if $match[3] is not yet in lookup table
|
||||
if (!empty($matches[3]) && empty($params_lookup[$matches[3]])) {
|
||||
$pos++;
|
||||
$params_lookup[$matches[3]] = '$' . $pos;
|
||||
// skip params setup if param list is empty
|
||||
if (!$empty_params) {
|
||||
$params_new[] = $params[$matches[3]] ??
|
||||
throw new \RuntimeException(
|
||||
'Cannot lookup ' . $matches[3] . ' in params list',
|
||||
210
|
||||
);
|
||||
}
|
||||
}
|
||||
// add the connectors back (1), and the data sets only if no replacement will be done
|
||||
return $matches[1] . (
|
||||
empty($matches[3]) ?
|
||||
$matches[2] :
|
||||
$params_lookup[$matches[3]] ??
|
||||
throw new \RuntimeException(
|
||||
'Cannot lookup ' . $matches[3] . ' in params lookup list',
|
||||
211
|
||||
)
|
||||
);
|
||||
},
|
||||
$converted_placeholders['original']['query']
|
||||
);
|
||||
break;
|
||||
case 'question_mark':
|
||||
if (!$empty_params) {
|
||||
// order and data stays the same
|
||||
$params_new = $params ?? [];
|
||||
}
|
||||
// 0: full
|
||||
// 1: pre part
|
||||
// 2: keep part UNLESS '3' is set
|
||||
// 3: replace part ?
|
||||
$pos = 0;
|
||||
$query_new = preg_replace_callback(
|
||||
self::REGEX_REPLACE_QUESTION_MARK,
|
||||
function ($matches) use (&$pos, &$params_lookup) {
|
||||
// only count pos up for actual replacements we will do
|
||||
if (!empty($matches[3])) {
|
||||
$pos++;
|
||||
$params_lookup[] = '$' . $pos;
|
||||
}
|
||||
// add the connectors back (1), and the data sets only if no replacement will be done
|
||||
return $matches[1] . (
|
||||
empty($matches[3]) ?
|
||||
$matches[2] :
|
||||
'$' . $pos
|
||||
);
|
||||
},
|
||||
$converted_placeholders['original']['query']
|
||||
);
|
||||
break;
|
||||
case 'numbered':
|
||||
// 0: full
|
||||
// 1: pre part
|
||||
// 2: keep part UNLESS '3' is set
|
||||
// 3: replace part $numbered
|
||||
$pos = 0;
|
||||
$query_new = preg_replace_callback(
|
||||
self::REGEX_REPLACE_NUMBERED,
|
||||
function ($matches) use (&$pos, &$params_new, &$params_lookup, $params, $empty_params) {
|
||||
// only count up if $match[3] is not yet in lookup table
|
||||
if (!empty($matches[3]) && empty($params_lookup[$matches[3]])) {
|
||||
$pos++;
|
||||
$params_lookup[$matches[3]] = ':' . $pos . '_named';
|
||||
// skip params setup if param list is empty
|
||||
if (!$empty_params) {
|
||||
$params_new[] = $params[($pos - 1)] ??
|
||||
throw new \RuntimeException(
|
||||
'Cannot lookup ' . ($pos - 1) . ' in params list',
|
||||
220
|
||||
);
|
||||
}
|
||||
}
|
||||
// add the connectors back (1), and the data sets only if no replacement will be done
|
||||
return $matches[1] . (
|
||||
empty($matches[3]) ?
|
||||
$matches[2] :
|
||||
$params_lookup[$matches[3]] ??
|
||||
throw new \RuntimeException(
|
||||
'Cannot lookup ' . $matches[3] . ' in params lookup list',
|
||||
211
|
||||
221
|
||||
)
|
||||
);
|
||||
},
|
||||
$query
|
||||
);
|
||||
} elseif ($count_qmark && $convert_to == 'pg') {
|
||||
$type = 'question_mark';
|
||||
$matches_return = $qmark_matches;
|
||||
// order and data stays the same
|
||||
$params_new = $params;
|
||||
// only check for ?
|
||||
$pattern_replace = '/'
|
||||
. '((?:\'.*?\')?\s*(?:\?\?|' . $query_split . ')\s*)'
|
||||
. '(\d+|(?:\'.*?\')|(?:(?:\?\?)?\s*(\?{1})))'
|
||||
. '/s';
|
||||
// 0: full
|
||||
// 1: pre part
|
||||
// 2: keep part UNLESS '3' is set
|
||||
// 3: replace part ?
|
||||
$pos = 0;
|
||||
$query_new = preg_replace_callback(
|
||||
$pattern_replace,
|
||||
function ($matches) use (&$pos, &$params_lookup) {
|
||||
// only count pos up for actual replacements we will do
|
||||
if (!empty($matches[3])) {
|
||||
$pos++;
|
||||
$params_lookup[] = '$' . $pos;
|
||||
}
|
||||
// add the connectors back (1), and the data sets only if no replacement will be done
|
||||
return $matches[1] . (
|
||||
empty($matches[3]) ?
|
||||
$matches[2] :
|
||||
'$' . $pos
|
||||
);
|
||||
},
|
||||
$query
|
||||
);
|
||||
// for each ?:DTN: -> replace with $1 ... $n, any remaining :DTN: remove
|
||||
} elseif ($count_numbered && $convert_to == 'pdo') {
|
||||
// convert numbered to named
|
||||
$type = 'numbered';
|
||||
$matches_return = $numbered_matches;
|
||||
// only check for $n
|
||||
$pattern_replace = '/'
|
||||
. '((?:\'.*?\')?\s*(?:\?\?|' . $query_split . ')\s*)'
|
||||
. '(\d+|(?:\'.*?\')|(\$[1-9]{1}(?:[0-9]{1,})?))'
|
||||
. '/s';
|
||||
// 0: full
|
||||
// 1: pre part
|
||||
// 2: keep part UNLESS '3' is set
|
||||
// 3: replace part $numbered
|
||||
$pos = 0;
|
||||
$query_new = preg_replace_callback(
|
||||
$pattern_replace,
|
||||
function ($matches) use (&$pos, &$params_new, &$params_lookup, $params) {
|
||||
// only count up if $match[3] is not yet in lookup table
|
||||
if (!empty($matches[3]) && empty($params_lookup[$matches[3]])) {
|
||||
$pos++;
|
||||
$params_lookup[$matches[3]] = ':' . $pos . '_named';
|
||||
$params_new[] = $params[($pos - 1)] ??
|
||||
throw new \RuntimeException(
|
||||
'Cannot lookup ' . ($pos - 1) . ' in params list',
|
||||
220
|
||||
);
|
||||
}
|
||||
// add the connectors back (1), and the data sets only if no replacement will be done
|
||||
return $matches[1] . (
|
||||
empty($matches[3]) ?
|
||||
$matches[2] :
|
||||
$params_lookup[$matches[3]] ??
|
||||
throw new \RuntimeException(
|
||||
'Cannot lookup ' . $matches[3] . ' in params lookup list',
|
||||
221
|
||||
)
|
||||
);
|
||||
},
|
||||
$query
|
||||
);
|
||||
);
|
||||
},
|
||||
$converted_placeholders['original']['query']
|
||||
);
|
||||
break;
|
||||
}
|
||||
// return, old query is always set
|
||||
return [
|
||||
// original
|
||||
'original' => [
|
||||
'query' => $query,
|
||||
'params' => $params,
|
||||
],
|
||||
// type found, empty if nothing was done
|
||||
'type' => $type,
|
||||
// int: found, not found; -1: problem (set from false)
|
||||
'found' => (int)$found,
|
||||
'matches' => $matches_return,
|
||||
// old to new lookup check
|
||||
'params_lookup' => $params_lookup,
|
||||
// new
|
||||
'query' => $query_new ?? '',
|
||||
'params' => $params_new,
|
||||
];
|
||||
|
||||
@@ -190,7 +190,6 @@ class GetTextReader
|
||||
private function loadTables(): void
|
||||
{
|
||||
if (
|
||||
is_array($this->cache_translations) &&
|
||||
is_array($this->table_originals) &&
|
||||
is_array($this->table_translations)
|
||||
) {
|
||||
@@ -318,10 +317,7 @@ class GetTextReader
|
||||
|
||||
if ($this->enable_cache) {
|
||||
// Caching enabled, get translated string from cache
|
||||
if (
|
||||
is_array($this->cache_translations) &&
|
||||
array_key_exists($string, $this->cache_translations)
|
||||
) {
|
||||
if (array_key_exists($string, $this->cache_translations)) {
|
||||
return $this->cache_translations[$string];
|
||||
} else {
|
||||
return $string;
|
||||
@@ -481,7 +477,7 @@ class GetTextReader
|
||||
$key = $single . chr(0) . $plural;
|
||||
|
||||
if ($this->enable_cache) {
|
||||
if (is_array($this->cache_translations) && !array_key_exists($key, $this->cache_translations)) {
|
||||
if (!array_key_exists($key, $this->cache_translations)) {
|
||||
return ($number != 1) ? $plural : $single;
|
||||
} else {
|
||||
$result = $this->cache_translations[$key];
|
||||
|
||||
@@ -474,7 +474,7 @@ class Generate
|
||||
$page_name_camel_case
|
||||
);
|
||||
try {
|
||||
/** @var TableArrays\Interface\TableArraysInterface|false $class */
|
||||
/** @var TableArrays\Interface\TableArraysInterface $class */
|
||||
$class = new $class_string($this);
|
||||
} catch (\Throwable $t) {
|
||||
$this->log->critical('CLASS LOADING: Failed loading: ' . $class_string . ' => ' . $t->getMessage());
|
||||
@@ -1757,14 +1757,9 @@ class Generate
|
||||
$this->dba->setTableArrayEntry($this->dba->getTableArray()[$key]['preset'], $key, 'value');
|
||||
}
|
||||
}
|
||||
if (is_array($this->reference_array)) {
|
||||
if (!is_array($this->reference_array)) {
|
||||
$this->reference_array = [];
|
||||
}
|
||||
reset($this->reference_array);
|
||||
foreach ($this->reference_array as $key => $value) {
|
||||
unset($this->reference_array[$key]['selected']);
|
||||
}
|
||||
reset($this->reference_array);
|
||||
foreach ($this->reference_array as $key => $value) {
|
||||
unset($this->reference_array[$key]['selected']);
|
||||
}
|
||||
$this->warning = 1;
|
||||
$this->msg = $this->l->__('Cleared for new Dataset!');
|
||||
@@ -1787,20 +1782,15 @@ class Generate
|
||||
$this->dba->unsetTableArrayEntry($key, 'input_value');
|
||||
}
|
||||
|
||||
if (is_array($this->reference_array)) {
|
||||
// load each reference_table
|
||||
if (!is_array($this->reference_array)) {
|
||||
$this->reference_array = [];
|
||||
}
|
||||
reset($this->reference_array);
|
||||
foreach ($this->reference_array as $key => $value) {
|
||||
unset($this->reference_array[$key]['selected']);
|
||||
$q = 'SELECT ' . $this->reference_array[$key]['other_table_pk']
|
||||
. ' FROM ' . $this->reference_array[$key]['table_name']
|
||||
. ' WHERE ' . $this->int_pk_name . ' = ' . $this->dba->getTableArray()[$this->int_pk_name]['value'];
|
||||
while (is_array($res = $this->dba->dbReturn($q))) {
|
||||
$this->reference_array[$key]['selected'][] = $res[$this->reference_array[$key]['other_table_pk']];
|
||||
}
|
||||
// load each reference_table
|
||||
reset($this->reference_array);
|
||||
foreach ($this->reference_array as $key => $value) {
|
||||
unset($this->reference_array[$key]['selected']);
|
||||
$q = 'SELECT ' . $this->reference_array[$key]['other_table_pk']
|
||||
. ' FROM ' . $this->reference_array[$key]['table_name']
|
||||
. ' WHERE ' . $this->int_pk_name . ' = ' . $this->dba->getTableArray()[$this->int_pk_name]['value'];
|
||||
while (is_array($res = $this->dba->dbReturn($q))) {
|
||||
$this->reference_array[$key]['selected'][] = $res[$this->reference_array[$key]['other_table_pk']];
|
||||
}
|
||||
}
|
||||
$this->warning = 1;
|
||||
@@ -1979,24 +1969,19 @@ class Generate
|
||||
// write the object
|
||||
$this->dba->dbWrite($addslashes, [], true);
|
||||
// write reference array (s) if necessary
|
||||
if (is_array($this->reference_array)) {
|
||||
if (!is_array($this->reference_array)) {
|
||||
$this->reference_array = [];
|
||||
reset($this->reference_array);
|
||||
foreach ($this->reference_array as $reference_array) {
|
||||
$q = 'DELETE FROM ' . $reference_array['table_name']
|
||||
. ' WHERE ' . $this->int_pk_name . ' = ' . $this->dba->getTableArray()[$this->int_pk_name]['value'];
|
||||
$this->dba->dbExec($q);
|
||||
$q = 'INSERT INTO ' . $reference_array['table_name']
|
||||
. ' (' . $reference_array['other_table_pk'] . ', ' . $this->int_pk_name . ') VALUES ';
|
||||
for ($i = 0, $i_max = count($reference_array['selected']); $i < $i_max; $i++) {
|
||||
$t_q = '(' . $reference_array['selected'][$i] . ', '
|
||||
. $this->dba->getTableArray()[$this->int_pk_name]['value'] . ')';
|
||||
$this->dba->dbExec($q . $t_q);
|
||||
}
|
||||
reset($this->reference_array);
|
||||
foreach ($this->reference_array as $reference_array) {
|
||||
$q = 'DELETE FROM ' . $reference_array['table_name']
|
||||
. ' WHERE ' . $this->int_pk_name . ' = ' . $this->dba->getTableArray()[$this->int_pk_name]['value'];
|
||||
$this->dba->dbExec($q);
|
||||
$q = 'INSERT INTO ' . $reference_array['table_name']
|
||||
. ' (' . $reference_array['other_table_pk'] . ', ' . $this->int_pk_name . ') VALUES ';
|
||||
for ($i = 0, $i_max = count($reference_array['selected']); $i < $i_max; $i++) {
|
||||
$t_q = '(' . $reference_array['selected'][$i] . ', '
|
||||
. $this->dba->getTableArray()[$this->int_pk_name]['value'] . ')';
|
||||
$this->dba->dbExec($q . $t_q);
|
||||
}
|
||||
} // foreach reference arrays
|
||||
} // if reference arrays
|
||||
} // foreach reference arrays
|
||||
// write element list
|
||||
if (!empty($this->element_list)) {
|
||||
$type = [];
|
||||
@@ -2230,16 +2215,11 @@ class Generate
|
||||
public function formDeleteTableArray()
|
||||
{
|
||||
// remove any reference arrays
|
||||
if (is_array($this->reference_array)) {
|
||||
if (!is_array($this->reference_array)) {
|
||||
$this->reference_array = [];
|
||||
}
|
||||
reset($this->reference_array);
|
||||
foreach ($this->reference_array as $reference_array) {
|
||||
$q = 'DELETE FROM ' . $reference_array['table_name']
|
||||
. ' WHERE ' . $this->int_pk_name . ' = ' . $this->dba->getTableArray()[$this->int_pk_name]['value'];
|
||||
$this->dba->dbExec($q);
|
||||
}
|
||||
reset($this->reference_array);
|
||||
foreach ($this->reference_array as $reference_array) {
|
||||
$q = 'DELETE FROM ' . $reference_array['table_name']
|
||||
. ' WHERE ' . $this->int_pk_name . ' = ' . $this->dba->getTableArray()[$this->int_pk_name]['value'];
|
||||
$this->dba->dbExec($q);
|
||||
}
|
||||
// remove any element list references
|
||||
if (!empty($this->element_list)) {
|
||||
|
||||
@@ -256,8 +256,8 @@ class Image
|
||||
}
|
||||
// check resize parameters
|
||||
if ($inc_width > $thumb_width || $inc_height > $thumb_height) {
|
||||
$thumb_width_r = 0;
|
||||
$thumb_height_r = 0;
|
||||
$thumb_width_r = 1;
|
||||
$thumb_height_r = 1;
|
||||
// we need to keep the aspect ration on longest side
|
||||
if (
|
||||
($inc_height > $inc_width &&
|
||||
@@ -288,6 +288,12 @@ class Image
|
||||
!file_exists($thumbnail_write_path . $thumbnail)
|
||||
) {
|
||||
// image, copy source image, offset in image, source x/y, new size, source image size
|
||||
if ($thumb_width_r < 1) {
|
||||
$thumb_width_r = 1;
|
||||
}
|
||||
if ($thumb_height_r < 1) {
|
||||
$thumb_height_r = 1;
|
||||
}
|
||||
$thumb = imagecreatetruecolor($thumb_width_r, $thumb_height_r);
|
||||
if ($thumb === false) {
|
||||
throw new \RuntimeException(
|
||||
@@ -380,9 +386,7 @@ class Image
|
||||
}
|
||||
}
|
||||
// add output path
|
||||
if ($thumbnail !== false) {
|
||||
$thumbnail = $thumbnail_web_path . $thumbnail;
|
||||
}
|
||||
$thumbnail = $thumbnail_web_path . $thumbnail;
|
||||
} elseif ($create_dummy === true) {
|
||||
// create dummy image in the thumbnail size
|
||||
// if one side is missing, use the other side to create a square
|
||||
@@ -399,10 +403,10 @@ class Image
|
||||
!file_exists($thumbnail_write_path . $thumbnail)
|
||||
) {
|
||||
// if both are unset, set to 250
|
||||
if ($thumb_height == 0) {
|
||||
if ($thumb_height < 1) {
|
||||
$thumb_height = 250;
|
||||
}
|
||||
if ($thumb_width == 0) {
|
||||
if ($thumb_width < 1) {
|
||||
$thumb_width = 250;
|
||||
}
|
||||
$thumb = imagecreatetruecolor($thumb_width, $thumb_height);
|
||||
|
||||
@@ -599,7 +599,7 @@ class Curl implements Interface\RequestsInterface
|
||||
// for post we set POST option
|
||||
if ($type == "post") {
|
||||
curl_setopt($handle, CURLOPT_POST, true);
|
||||
} elseif (in_array($type, self::CUSTOM_REQUESTS)) {
|
||||
} elseif (!empty($type) && in_array($type, self::CUSTOM_REQUESTS)) {
|
||||
curl_setopt($handle, CURLOPT_CUSTOMREQUEST, strtoupper($type));
|
||||
}
|
||||
// set body data if not null, will send empty [] for empty data
|
||||
@@ -700,12 +700,12 @@ class Curl implements Interface\RequestsInterface
|
||||
// if we have a timeout signal
|
||||
if (!empty($this->config['timeout'])) {
|
||||
$timeout_requires_no_signal = $this->config['timeout'] < 1;
|
||||
curl_setopt($handle, CURLOPT_TIMEOUT_MS, $this->config['timeout'] * 1000);
|
||||
curl_setopt($handle, CURLOPT_TIMEOUT_MS, (int)round($this->config['timeout'] * 1000));
|
||||
}
|
||||
if (!empty($this->config['connection_timeout'])) {
|
||||
$timeout_requires_no_signal = $timeout_requires_no_signal ||
|
||||
$this->config['connection_timeout'] < 1;
|
||||
curl_setopt($handle, CURLOPT_CONNECTTIMEOUT_MS, $this->config['connection_timeout'] * 1000);
|
||||
curl_setopt($handle, CURLOPT_CONNECTTIMEOUT_MS, (int)round($this->config['connection_timeout'] * 1000, 1));
|
||||
}
|
||||
if ($timeout_requires_no_signal && strtoupper(substr(PHP_OS, 0, 3)) !== 'WIN') {
|
||||
curl_setopt($handle, CURLOPT_NOSIGNAL, true);
|
||||
|
||||
1186
test/phpunit/Convert/CoreLibsConvertColorTest.php
Normal file
1186
test/phpunit/Convert/CoreLibsConvertColorTest.php
Normal file
File diff suppressed because it is too large
Load Diff
@@ -9,7 +9,7 @@ use PHPUnit\Framework\TestCase;
|
||||
/**
|
||||
* Test class for Convert\Colors
|
||||
* @coversDefaultClass \CoreLibs\Convert\Colors
|
||||
* @testdox \CoreLibs\Convert\Colors method tests
|
||||
* @testdox \CoreLibs\Convert\Colors legacy method tests
|
||||
*/
|
||||
final class CoreLibsConvertColorsTest extends TestCase
|
||||
{
|
||||
@@ -21,7 +21,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function rgb2hexColorProvider(): array
|
||||
public function providerRgb2hexColor(): array
|
||||
{
|
||||
return [
|
||||
'color' => [
|
||||
@@ -88,7 +88,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function hex2rgbColorProvider(): array
|
||||
public function providerHex2rgbColor(): array
|
||||
{
|
||||
return [
|
||||
'color' => [
|
||||
@@ -215,7 +215,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function rgb2hsbColorProvider(): array
|
||||
public function providerRgb2hsbColor(): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($this->rgb2hslAndhsbList() as $name => $values) {
|
||||
@@ -234,7 +234,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function hsb2rgbColorProvider(): array
|
||||
public function providerHsb2rgbColor(): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($this->rgb2hslAndhsbList() as $name => $values) {
|
||||
@@ -253,7 +253,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function rgb2hslColorProvider(): array
|
||||
public function providerRgb2hslColor(): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($this->rgb2hslAndhsbList() as $name => $values) {
|
||||
@@ -272,7 +272,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function hsl2rgbColorProvider(): array
|
||||
public function providerHsl2rgbColor(): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($this->rgb2hslAndhsbList() as $name => $values) {
|
||||
@@ -291,7 +291,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
* TODO: add cross convert check
|
||||
*
|
||||
* @covers ::rgb2hex
|
||||
* @dataProvider rgb2hexColorProvider
|
||||
* @dataProvider providerRgb2hexColor
|
||||
* @testdox rgb2hex $input_r,$input_g,$input_b will be $expected [$_dataName]
|
||||
*
|
||||
* @param int $input_r
|
||||
@@ -342,7 +342,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::hex2rgb
|
||||
* @dataProvider hex2rgbColorProvider
|
||||
* @dataProvider providerHex2rgbColor
|
||||
* @testdox hex2rgb $input will be $expected, $expected_str str[,], $expected_str_sep str[$separator] [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
@@ -385,7 +385,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::rgb2hsb
|
||||
* @dataProvider rgb2hsbColorProvider
|
||||
* @dataProvider providerRgb2hsbColor
|
||||
* @testdox rgb2hsb $input_r,$input_g,$input_b will be $expected [$_dataName]
|
||||
*
|
||||
* @param integer $input_r
|
||||
@@ -409,7 +409,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::hsb2rgb
|
||||
* @dataProvider hsb2rgbColorProvider
|
||||
* @dataProvider providerHsb2rgbColor
|
||||
* @testdox hsb2rgb $input_h,$input_s,$input_b will be $expected [$_dataName]
|
||||
*
|
||||
* @param float $input_h
|
||||
@@ -434,7 +434,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::rgb2hsl
|
||||
* @dataProvider rgb2hslColorProvider
|
||||
* @dataProvider providerRgb2hslColor
|
||||
* @testdox rgb2hsl $input_r,$input_g,$input_b will be $expected [$_dataName]
|
||||
*
|
||||
* @param integer $input_r
|
||||
@@ -458,7 +458,7 @@ final class CoreLibsConvertColorsTest extends TestCase
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::hsl2rgb
|
||||
* @dataProvider hsl2rgbColorProvider
|
||||
* @dataProvider providerHsl2rgbColor
|
||||
* @testdox hsl2rgb $input_h,$input_s,$input_l will be $expected [$_dataName]
|
||||
*
|
||||
* @param integer|float $input_h
|
||||
|
||||
@@ -18,7 +18,7 @@ final class CoreLibsConvertMathTest extends TestCase
|
||||
*
|
||||
* @return array<mixed>
|
||||
*/
|
||||
public function fceilProvider(): array
|
||||
public function providerFceil(): array
|
||||
{
|
||||
return [
|
||||
'5.5 must be 6' => [5.5, 6],
|
||||
@@ -31,7 +31,7 @@ final class CoreLibsConvertMathTest extends TestCase
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::fceil
|
||||
* @dataProvider fceilProvider
|
||||
* @dataProvider providerFceil
|
||||
* @testdox fceil: Input $input must be $expected
|
||||
*
|
||||
* @param float $input
|
||||
@@ -51,7 +51,7 @@ final class CoreLibsConvertMathTest extends TestCase
|
||||
*
|
||||
* @return array<mixed>
|
||||
*/
|
||||
public function floorProvider(): array
|
||||
public function providerFloor(): array
|
||||
{
|
||||
return [
|
||||
'5123456 with -3 must be 5123000' => [5123456, -3, 5123000],
|
||||
@@ -63,7 +63,7 @@ final class CoreLibsConvertMathTest extends TestCase
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::floorp
|
||||
* @dataProvider floorProvider
|
||||
* @dataProvider providerFloor
|
||||
* @testdox floor: Input $input with cutoff $cutoff must be $expected
|
||||
*
|
||||
* @param int $input
|
||||
@@ -84,7 +84,7 @@ final class CoreLibsConvertMathTest extends TestCase
|
||||
*
|
||||
* @return array<mixed>
|
||||
*/
|
||||
public function initNumericProvider(): array
|
||||
public function providerInitNumeric(): array
|
||||
{
|
||||
return [
|
||||
'5 must be 5' => [5, 5, 'int'],
|
||||
@@ -98,7 +98,7 @@ final class CoreLibsConvertMathTest extends TestCase
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::initNumeric
|
||||
* @dataProvider initNumericProvider
|
||||
* @dataProvider providerInitNumeric
|
||||
* @testdox initNumeric: Input $info $input must match $expected [$_dataName]
|
||||
*
|
||||
* @param int|float|string $input
|
||||
@@ -113,6 +113,388 @@ final class CoreLibsConvertMathTest extends TestCase
|
||||
\CoreLibs\Convert\Math::initNumeric($input)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function providerCbrt(): array
|
||||
{
|
||||
return [
|
||||
'cube root of 2' => [2, 1.25992, 5],
|
||||
'cube root of 3' => [3, 1.44225, 5],
|
||||
'cube root of -1' => [-1, 'NAN', 0],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::cbrt
|
||||
* @dataProvider providerCbrt
|
||||
* @testdox initNumeric: Input $input must match $expected [$_dataName]
|
||||
*
|
||||
* @param float|int $number
|
||||
* @param float $expected
|
||||
* @param int $round_to
|
||||
* @return void
|
||||
*/
|
||||
public function testCbrt(float|int $number, float|string $expected, int $round_to): void
|
||||
{
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
round(\CoreLibs\Convert\Math::cbrt($number), $round_to)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function providerMultiplyMatrices(): array
|
||||
{
|
||||
return [
|
||||
'[3] x [3] => [3x1]' => [
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
[14]
|
||||
],
|
||||
'[3] x [3x1]' => [
|
||||
[1, 2, 3],
|
||||
[[1], [2], [3]],
|
||||
[14]
|
||||
],
|
||||
'[3] x [3x1]' => [
|
||||
[1, 2, 3],
|
||||
[[1], [2], [3]],
|
||||
[14]
|
||||
],
|
||||
'[1x3L] x [3x1]' => [
|
||||
[[1, 2, 3]],
|
||||
[[1], [2], [3]],
|
||||
[14]
|
||||
],
|
||||
'[1x3] x [3x1]' => [
|
||||
[[1], [2], [3]],
|
||||
[[1], [2], [3]],
|
||||
[1, 2, 3]
|
||||
],
|
||||
'[2x3] x [3] => [3x1]' => [
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3]
|
||||
],
|
||||
[1, 2, 3],
|
||||
[
|
||||
14,
|
||||
14
|
||||
]
|
||||
],
|
||||
'[2x3] x [3x1]' => [
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3]
|
||||
],
|
||||
[[1], [2], [3]],
|
||||
[
|
||||
14,
|
||||
14
|
||||
]
|
||||
],
|
||||
'[2x3] x [2x3] => [3x3]' => [
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
[
|
||||
[3, 6, 9],
|
||||
[3, 6, 9]
|
||||
]
|
||||
],
|
||||
'[2x3] x [3x3]' => [
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
[0, 0, 0],
|
||||
],
|
||||
[
|
||||
[3, 6, 9],
|
||||
[3, 6, 9]
|
||||
]
|
||||
],
|
||||
'[2x3] x [3x2]' => [
|
||||
'a' => [
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
'b' => [
|
||||
[1, 1],
|
||||
[2, 2],
|
||||
[3, 3],
|
||||
],
|
||||
'prod' => [
|
||||
[14, 14],
|
||||
[14, 14],
|
||||
]
|
||||
],
|
||||
'[3x3] x [3] => [1x3]' => [
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
[1, 2, 3],
|
||||
[
|
||||
14,
|
||||
14,
|
||||
14
|
||||
]
|
||||
],
|
||||
'[3x3] x [2x3] => [3x3]' => [
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
[
|
||||
[3, 6, 9],
|
||||
[3, 6, 9],
|
||||
[3, 6, 9],
|
||||
]
|
||||
],
|
||||
'[3x3] x [3x3]' => [
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
// [0, 0, 0],
|
||||
],
|
||||
[
|
||||
[3, 6, 9],
|
||||
[3, 6, 9],
|
||||
[3, 6, 9],
|
||||
]
|
||||
],
|
||||
'[3] x [3x3]' => [
|
||||
[1, 2, 3],
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
[
|
||||
[6, 12, 18],
|
||||
]
|
||||
],
|
||||
'[2x3] x [3x3]' => [
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
[
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
[1, 2, 3],
|
||||
],
|
||||
[
|
||||
[6, 12, 18],
|
||||
[6, 12, 18],
|
||||
]
|
||||
],
|
||||
'inblanaced [2x2,3] x [3x2]' => [
|
||||
'a' => [
|
||||
[1, 2, 3],
|
||||
[4, 5]
|
||||
],
|
||||
'b' => [
|
||||
[6, 7],
|
||||
[8, 9],
|
||||
[10, 11]
|
||||
],
|
||||
'result' => [
|
||||
[52, 58],
|
||||
[64, 73],
|
||||
]
|
||||
],
|
||||
'inblanaced [2x3] x [3x1,2]' => [
|
||||
'a' => [
|
||||
[1, 2, 3],
|
||||
[4, 5, 7]
|
||||
],
|
||||
'b' => [
|
||||
[7, 8],
|
||||
[9, 10],
|
||||
[11]
|
||||
],
|
||||
'result' => [
|
||||
[58, 28],
|
||||
[150, 82],
|
||||
]
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::multiplyMatrices
|
||||
* @dataProvider providerMultiplyMatrices
|
||||
* @testdox initNumeric: Input $input_a x $input_b must match $expected [$_dataName]
|
||||
*
|
||||
* @param array $input_a
|
||||
* @param array $input_b
|
||||
* @param array $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testMultiplyMatrices(array $input_a, array $input_b, array $expected): void
|
||||
{
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Convert\Math::multiplyMatrices($input_a, $input_b)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function providerEqualWithEpsilon(): array
|
||||
{
|
||||
return [
|
||||
'equal' => [
|
||||
'a' => 0.000000000000000222,
|
||||
'b' => 0.000000000000000222,
|
||||
'epsilon' => PHP_FLOAT_EPSILON,
|
||||
'equal' => true,
|
||||
],
|
||||
'almost equal' => [
|
||||
'a' => 0.000000000000000222,
|
||||
'b' => 0.000000000000000232,
|
||||
'epsilon' => PHP_FLOAT_EPSILON,
|
||||
'equal' => true,
|
||||
],
|
||||
'not equal' => [
|
||||
'a' => 0.000000000000000222,
|
||||
'b' => 0.000000000000004222,
|
||||
'epsilon' => PHP_FLOAT_EPSILON,
|
||||
'equal' => false,
|
||||
],
|
||||
'equal, different epsilon' => [
|
||||
'a' => 0.000000000000000222,
|
||||
'b' => 0.000000000000004222,
|
||||
'epsilon' => 0.0001,
|
||||
'equal' => true,
|
||||
],
|
||||
'not equal, different epsilon' => [
|
||||
'a' => 0.0001,
|
||||
'b' => 0.0002,
|
||||
'epsilon' => 0.0001,
|
||||
'equal' => false,
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::equalWithEpsilon
|
||||
* @dataProvider providerEqualWithEpsilon
|
||||
* @testdox equalWithEpsilon with $a and $b and Epsilon: $epsilon must be equal: $equal [$_dataName]
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function testEqualWithEpsilon(float $a, float $b, float $epsilon, bool $equal): void
|
||||
{
|
||||
$this->assertEquals(
|
||||
$equal,
|
||||
\CoreLibs\Convert\Math::equalWithEpsilon($a, $b, $epsilon)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function providerCompareWithEpsilon(): array
|
||||
{
|
||||
return [
|
||||
'smaller, true' => [
|
||||
'value' => 0.0001,
|
||||
'compare' => '<',
|
||||
'limit' => 0.0002,
|
||||
'epsilon' => 0.00001,
|
||||
'match' => true,
|
||||
],
|
||||
'smaller, false' => [
|
||||
'value' => 0.0001,
|
||||
'compare' => '<',
|
||||
'limit' => 0.0001,
|
||||
'epsilon' => 0.00001,
|
||||
'match' => false,
|
||||
],
|
||||
'bigger, true' => [
|
||||
'value' => 0.0002,
|
||||
'compare' => '>',
|
||||
'limit' => 0.0001,
|
||||
'epsilon' => 0.00001,
|
||||
'match' => true,
|
||||
],
|
||||
'bigger, false' => [
|
||||
'value' => 0.0001,
|
||||
'compare' => '>',
|
||||
'limit' => 0.0001,
|
||||
'epsilon' => 0.00001,
|
||||
'match' => false,
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::compareWithEpsilon
|
||||
* @dataProvider providerCompareWithEpsilon
|
||||
* @testdox compareWithEpsilon $value $compare $limit with $epsilon must match: $match [$_dataName]
|
||||
*
|
||||
* @param float $value
|
||||
* @param string $compare
|
||||
* @param float $limit
|
||||
* @param float $epslion
|
||||
* @param bool $match
|
||||
* @return void
|
||||
*/
|
||||
public function testCompareWithEpsilon(
|
||||
float $value,
|
||||
string $compare,
|
||||
float $limit,
|
||||
float $epsilon,
|
||||
bool $match
|
||||
): void {
|
||||
$this->assertEquals(
|
||||
$match,
|
||||
\CoreLibs\Convert\Math::compareWithEpsilon($value, $compare, $limit, $epsilon)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
|
||||
@@ -121,6 +121,7 @@ final class CoreLibsCreateUidsTest extends TestCase
|
||||
* must match 7e78fe0d-59b8-4637-af7f-e88d221a7d1e
|
||||
*
|
||||
* @covers ::uuidv4
|
||||
* @covers ::validateUuidv4
|
||||
* @testdox uuidv4 check that return is matching regex [$_dataName]
|
||||
*
|
||||
* @return void
|
||||
@@ -129,13 +130,18 @@ final class CoreLibsCreateUidsTest extends TestCase
|
||||
{
|
||||
$uuid = \CoreLibs\Create\Uids::uuidv4();
|
||||
$this->assertMatchesRegularExpression(
|
||||
'/^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$/',
|
||||
$uuid
|
||||
'/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/',
|
||||
$uuid,
|
||||
'Failed regex check'
|
||||
);
|
||||
$this->assertTrue(
|
||||
\CoreLibs\Create\Uids::validateUuuidv4($uuid),
|
||||
'Failed validate regex method'
|
||||
);
|
||||
$this->assertFalse(
|
||||
\CoreLibs\Create\Uids::validateUuuidv4('not-a-uuidv4'),
|
||||
'Failed wrong uuid validated as true'
|
||||
);
|
||||
// $this->assertStringMatchesFormat(
|
||||
// '%4s%4s-%4s-%4s-%4s-%4s%4s%4s',
|
||||
// $uuid
|
||||
// );
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -37,8 +37,9 @@ namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
use PHPUnit\Framework\MockObject\MockObject;
|
||||
use CoreLibs\Logging\Logger\Level;
|
||||
use CoreLibs\Logging;
|
||||
use CoreLibs\DB\Options\Convert;
|
||||
use CoreLibs\DB\Support\ConvertPlaceholder;
|
||||
|
||||
/**
|
||||
* Test class for DB\IO + DB\SQL\PgSQL
|
||||
@@ -117,7 +118,7 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
);
|
||||
}
|
||||
// define basic connection set valid and one invalid
|
||||
self::$log = new \CoreLibs\Logging\Logging([
|
||||
self::$log = new Logging\Logging([
|
||||
// 'log_folder' => __DIR__ . DIRECTORY_SEPARATOR . 'log',
|
||||
'log_folder' => DIRECTORY_SEPARATOR . 'tmp',
|
||||
'log_file_id' => 'CoreLibs-DB-IO-Test',
|
||||
@@ -159,15 +160,12 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
// create the tables
|
||||
$db->dbExec(
|
||||
// primary key name is table + '_id'
|
||||
// table_with_primary_key_id SERIAL PRIMARY KEY,
|
||||
<<<SQL
|
||||
CREATE TABLE table_with_primary_key (
|
||||
table_with_primary_key_id SERIAL PRIMARY KEY,
|
||||
table_with_primary_key_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
|
||||
$base_table
|
||||
SQL
|
||||
/* "CREATE TABLE table_with_primary_key ("
|
||||
// primary key name is table + '_id'
|
||||
. "table_with_primary_key_id SERIAL PRIMARY KEY, "
|
||||
. $base_table */
|
||||
);
|
||||
$db->dbExec(
|
||||
<<<SQL
|
||||
@@ -570,11 +568,11 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
);
|
||||
$db->dbClose();
|
||||
// second conenction with log set NOT debug
|
||||
$log = new \CoreLibs\Logging\Logging([
|
||||
$log = new Logging\Logging([
|
||||
// 'log_folder' => __DIR__ . DIRECTORY_SEPARATOR . 'log',
|
||||
'log_folder' => DIRECTORY_SEPARATOR . 'tmp',
|
||||
'log_file_id' => 'CoreLibs-DB-IO-Test',
|
||||
'log_level' => \CoreLibs\Logging\Logger\Level::Notice,
|
||||
'log_level' => Logging\Logger\Level::Notice,
|
||||
]);
|
||||
$db = new \CoreLibs\DB\IO(
|
||||
self::$db_config[$connection],
|
||||
@@ -3293,6 +3291,7 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
'query' => 'INSERT INTO table_with_primary_key (row_int, uid) '
|
||||
. 'VALUES ($1, $2) RETURNING table_with_primary_key_id',
|
||||
'returning_id' => true,
|
||||
'placeholder_converted' => [],
|
||||
],
|
||||
],
|
||||
// update
|
||||
@@ -3327,6 +3326,7 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
'query' => 'UPDATE table_with_primary_key SET row_int = $1, '
|
||||
. 'row_varchar = $2 WHERE uid = $3',
|
||||
'returning_id' => false,
|
||||
'placeholder_converted' => [],
|
||||
],
|
||||
],
|
||||
// select
|
||||
@@ -3356,6 +3356,7 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
'count' => 1,
|
||||
'query' => 'SELECT row_int, uid FROM table_with_primary_key WHERE uid = $1',
|
||||
'returning_id' => false,
|
||||
'placeholder_converted' => [],
|
||||
],
|
||||
],
|
||||
// any query but with no parameters
|
||||
@@ -3388,6 +3389,7 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
'count' => 0,
|
||||
'query' => 'SELECT row_int, uid FROM table_with_primary_key',
|
||||
'returning_id' => false,
|
||||
'placeholder_converted' => [],
|
||||
],
|
||||
],
|
||||
// no statement name (25)
|
||||
@@ -3411,6 +3413,7 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
'count' => 0,
|
||||
'query' => '',
|
||||
'returning_id' => false,
|
||||
'placeholder_converted' => [],
|
||||
],
|
||||
],
|
||||
// no query (prepare 11)
|
||||
@@ -3435,6 +3438,7 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
'count' => 0,
|
||||
'query' => '',
|
||||
'returning_id' => false,
|
||||
'placeholder_converted' => [],
|
||||
],
|
||||
],
|
||||
// no db connection (prepare/execute 16)
|
||||
@@ -3464,6 +3468,7 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
'count' => 0,
|
||||
'query' => 'SELECT row_int, uid FROM table_with_primary_key',
|
||||
'returning_id' => false,
|
||||
'placeholder_converted' => [],
|
||||
],
|
||||
],
|
||||
// prepare with different statement name
|
||||
@@ -3489,6 +3494,7 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
'count' => 0,
|
||||
'query' => 'SELECT row_int, uid FROM table_with_primary_key',
|
||||
'returning_id' => false,
|
||||
'placeholder_converted' => [],
|
||||
],
|
||||
],
|
||||
// insert wrong data count compared to needed (execute 23)
|
||||
@@ -3514,10 +3520,12 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
'query' => 'INSERT INTO table_with_primary_key (row_int, uid) VALUES '
|
||||
. '($1, $2) RETURNING table_with_primary_key_id',
|
||||
'returning_id' => true,
|
||||
'placeholder_converted' => [],
|
||||
],
|
||||
],
|
||||
// execute does not return a result (22)
|
||||
// TODO execute does not return a result
|
||||
// TODO prepared statement with placeholder params auto convert
|
||||
];
|
||||
}
|
||||
|
||||
@@ -3662,7 +3670,7 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
}
|
||||
|
||||
// check dbGetPrepareCursorValue
|
||||
foreach (['pk_name', 'count', 'query', 'returning_id'] as $key) {
|
||||
foreach (['pk_name', 'count', 'query', 'returning_id', 'placeholder_converted'] as $key) {
|
||||
$this->assertEquals(
|
||||
$prepare_cursor[$key],
|
||||
$db->dbGetPrepareCursorValue($stm_name, $key),
|
||||
@@ -5031,8 +5039,151 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
$db->dbClose();
|
||||
}
|
||||
|
||||
// query placeholder convert
|
||||
// MARK: QUERY PLACEHOLDERS
|
||||
|
||||
// test query placeholder detection for all possible sets
|
||||
// ::dbPrepare
|
||||
|
||||
/**
|
||||
* placeholder sql
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function providerDbCountQueryParams(): array
|
||||
{
|
||||
return [
|
||||
'one place holder' => [
|
||||
'query' => 'SELECT row_varchar FROM table_with_primary_key WHERE row_varchar = $1',
|
||||
'count' => 1,
|
||||
'convert' => false,
|
||||
],
|
||||
'one place holder, json call' => [
|
||||
'query' => "SELECT row_varchar FROM table_with_primary_key WHERE row_jsonb->>'data' = $1",
|
||||
'count' => 1,
|
||||
'convert' => false,
|
||||
],
|
||||
'one place holder, <> compare' => [
|
||||
'query' => "SELECT row_varchar FROM table_with_primary_key WHERE row_varchar <> $1",
|
||||
'count' => 1,
|
||||
'convert' => false,
|
||||
],
|
||||
'one place holder, named' => [
|
||||
'query' => "SELECT row_varchar FROM table_with_primary_key WHERE row_varchar <> :row_varchar",
|
||||
'count' => 1,
|
||||
'convert' => true,
|
||||
],
|
||||
'no replacement' => [
|
||||
'query' => "SELECT row_varchar FROM table_with_primary_key WHERE row_varchar = '$1'",
|
||||
'count' => 0,
|
||||
'convert' => false,
|
||||
],
|
||||
'insert' => [
|
||||
'query' => "INSERT INTO table_with_primary_key (row_varchar, row_jsonb, row_int) VALUES ($1, $2, $3)",
|
||||
'count' => 3,
|
||||
'convert' => false,
|
||||
],
|
||||
'update' => [
|
||||
'query' => "UPDATE table_with_primary_key SET row_varchar = $1, row_jsonb = $2, row_int = $3 WHERE row_numeric = $4",
|
||||
'count' => 4,
|
||||
'convert' => false,
|
||||
],
|
||||
'multiple, multline' => [
|
||||
'query' => <<<SQL
|
||||
SELECT
|
||||
row_varchar
|
||||
FROM
|
||||
table_with_primary_key
|
||||
WHERE
|
||||
row_varchar = $1 AND row_int = $2
|
||||
AND row_numeric = ANY($3)
|
||||
SQL,
|
||||
'count' => 3,
|
||||
'convert' => false,
|
||||
],
|
||||
'two digit numbers' => [
|
||||
'query' => <<<SQL
|
||||
INSERT INTO table_with_primary_key (
|
||||
row_int, row_numeric, row_varchar, row_varchar_literal, row_json,
|
||||
row_jsonb, row_bytea, row_timestamp, row_date, row_interval
|
||||
) VALUES (
|
||||
$1, $2, $3, $4, $5,
|
||||
$6, $7, $8, $9, $10
|
||||
)
|
||||
SQL,
|
||||
'count' => 10,
|
||||
'convert' => false,
|
||||
],
|
||||
'things in brackets' => [
|
||||
'query' => <<<SQL
|
||||
SELECT row_varchar
|
||||
FROM table_with_primary_key
|
||||
WHERE
|
||||
row_varchar = $1 AND
|
||||
(row_int = ANY($2) OR row_int = $3)
|
||||
AND row_varchar_literal = $4
|
||||
SQL,
|
||||
'count' => 4,
|
||||
'convert' => false,
|
||||
],
|
||||
'number compare' => [
|
||||
'query' => <<<SQL
|
||||
SELECT row_varchar
|
||||
FROM table_with_primary_key
|
||||
WHERE
|
||||
row_int >= $1 OR row_int <= $2 OR
|
||||
row_int > $3 OR row_int < $4
|
||||
OR row_int = $5 OR row_int <> $6
|
||||
SQL,
|
||||
'count' => 6,
|
||||
'convert' => false,
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Placeholder check and convert tests
|
||||
*
|
||||
* @covers ::dbPrepare
|
||||
* @covers ::__dbCountQueryParams
|
||||
* @onvers ::convertPlaceholderInQuery
|
||||
* @dataProvider providerDbCountQueryParams
|
||||
* @testdox Query replacement count test [$_dataName]
|
||||
*
|
||||
* @param string $query
|
||||
* @param int $count
|
||||
* @return void
|
||||
*/
|
||||
public function testDbCountQueryParams(string $query, int $count, bool $convert): void
|
||||
{
|
||||
$db = new \CoreLibs\DB\IO(
|
||||
self::$db_config['valid'],
|
||||
self::$log
|
||||
);
|
||||
$id = sha1($query);
|
||||
$db->dbSetConvertPlaceholder($convert);
|
||||
$db->dbPrepare($id, $query);
|
||||
// print "\n**\n";
|
||||
// print "PCount: " . $db->dbGetPrepareCursorValue($id, 'count') . "\n";
|
||||
// print "\n**\n";
|
||||
$this->assertEquals(
|
||||
$count,
|
||||
$db->dbGetPrepareCursorValue($id, 'count'),
|
||||
'DB count params'
|
||||
);
|
||||
$placeholder = ConvertPlaceholder::convertPlaceholderInQuery($query, null, 'pg');
|
||||
// print "RES: " . print_r($placeholder, true) . "\n";
|
||||
$this->assertEquals(
|
||||
$count,
|
||||
$placeholder['needed'],
|
||||
'convert params'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* query placeholder convert
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function queryPlaceholderReplaceProvider(): array
|
||||
{
|
||||
// WHERE row_varchar = $1
|
||||
@@ -5076,7 +5227,9 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
WHERE row_varchar = $1
|
||||
SQL,
|
||||
'expected_params' => ['string a'],
|
||||
]
|
||||
],
|
||||
// TODO: test with multiple entries
|
||||
// TODO: test with same entry ($1, $1, :var, :var)
|
||||
];
|
||||
}
|
||||
|
||||
@@ -5178,6 +5331,8 @@ final class CoreLibsDBIOTest extends TestCase
|
||||
// - data debug
|
||||
// dbDumpData
|
||||
|
||||
// MARK: ASYNC
|
||||
|
||||
// ASYNC at the end because it has 1s timeout
|
||||
// - asynchronous executions
|
||||
// dbExecAsync, dbCheckAsync
|
||||
|
||||
Reference in New Issue
Block a user