ComponentHelper.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\UI\Implementation\Component;

use ILIAS\UI\Component\Signal;
use InvalidArgumentException;
use Closure;
use ILIAS\UI\Component\Component;

trait ComponentHelper
{
    public function getCanonicalName(): string
    {
        return $this->getCanonicalNameByFullyQualifiedName();
    }

    protected function getCanonicalNameByFullyQualifiedName(): string
    {
        $cls = explode("\\", get_class($this));
        $name = [];
        $cur = array_pop($cls);
        while ($cur !== "Component" && count($cls) > 0) {
            $name[] = preg_replace("%([a-z])([A-Z])%", "$1 $2", $cur);
            $cur = array_pop($cls);
        }
        return implode(" ", $name);
    }

    protected function checkArg(string $which, bool $check, string $message): void
    {
        if (!$check) {
            throw new InvalidArgumentException("Argument '$which': $message");
        }
    }

    protected function checkStringArg(string $which, $value): void
    {
        $this->checkArg($which, is_string($value), $this->wrongTypeMessage("string", $value));
    }

    protected function checkStringOrSignalArg(string $which, $value): void
    {
        $this->checkArg(
            $which,
            is_string($value) || $value instanceof Signal,
            $this->wrongTypeMessage("string or Signal", gettype($value))
        );
    }

    protected function checkBoolArg(string $which, $value): void
    {
        $this->checkArg($which, is_bool($value), $this->wrongTypeMessage("bool", $value));
    }

    protected function checkArgInstanceOf(string $which, $value, string $class): void
    {
        $this->checkArg($which, $value instanceof $class, $this->wrongTypeMessage($class, $value));
    }

    protected function checkArgIsElement(string $which, $value, array $array, string $name): void
    {
        if (!is_object($value)) {
            $message = "expected $name, got '$value'";
        } else {
            $message = "expected $name, got object.";
        }
        $this->checkArg($which, in_array($value, $array), $message);
    }

    protected function checkArgList(string $which, array &$values, Closure $check, Closure $message): void
    {
        $failed_k = null;
        $failed_v = null;
        foreach ($values as $key => $value) {
            $ok = $check($key, $value);
            if (!$ok) {
                $failed_k = $key;
                $failed_v = $value;
                break;
            }
        }

        if ($failed_k !== null) {
            $m = $message($failed_k, $failed_v);
        } else {
            $m = "";
        }

        $this->checkArg($which, $failed_k === null, $m);
    }

    protected function checkArgListElements(string $which, array &$values, $classes): void
    {
        $classes = $this->toArray($classes);
        $this->checkArgList($which, $values, function ($_, $value) use (&$classes) {
            foreach ($classes as $cls) {
                if ($cls === "string" && is_string($value)) {
                    return true;
                }
                if ($cls === "int" && is_int($value)) {
                    return true;
                } elseif ($value instanceof $cls) {
                    return true;
                }
            }
            return false;
        }, function ($_, $failed) use (&$classes) {
            return $this->wrongTypeMessage(implode(", ", $classes), $failed);
        });
    }

    protected function checkInputListElements(string $which, array $values, $classes, int $depth = 0): void
    {
        if (255 < $depth) {
            throw new \LogicException('Input nesting limit of 255 exceeded.');
        }

        $classes = $this->toArray($classes);
        foreach ($values as $value) {
            foreach ($classes as $class) {
                $this->checkArgInstanceOf($which, $value, $class);
            }

            if ($value instanceof \ILIAS\UI\Component\Input\Group) {
                $this->checkInputListElements($which, $value->getInputs(), $classes, $depth + 1);
            }
        }
    }

    protected function toArray($value): array
    {
        if (is_array($value)) {
            return $value;
        }
        return array($value);
    }

    protected function wrongTypeMessage(string $expected, $value): string
    {
        $type = gettype($value);
        if (!is_object($value) && !is_array($value)) {
            return "expected $expected, got $type '$value'";
        } else {
            if (is_object($value)) {
                $type = get_class($value);
            }
            return "expected $expected, got $type";
        }
    }

    public function reduceWith(\Closure $fn): mixed
    {
        $clone = clone $this;
        $results = [];
        foreach ($clone->getSubComponents() ?? [] as $component) {
            $results[] = $component->reduceWith($fn);
        }
        return $fn($clone, $results);
    }

    protected function getSubComponents(): ?array
    {
        return null;
    }

}