<form method="POST">
    <h3>Editing: Helpers.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/**
 * This file is part of the Nette Framework (https://nette.org)
 * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
 */

declare(strict_types=1);

namespace Nette\Schema;

use Nette;
use Nette\Utils\Reflection;


/**
 * @internal
 */
final class Helpers
{
	use Nette\StaticClass;

	public const PreventMerging = '_prevent_merging';
	public const PREVENT_MERGING = self::PreventMerging;


	/**
	 * Merges dataset. Left has higher priority than right one.
	 * @return array|string
	 */
	public static function merge($value, $base)
	{
		if (is_array($value) &amp;&amp; isset($value[self::PreventMerging])) {
			unset($value[self::PreventMerging]);
			return $value;
		}

		if (is_array($value) &amp;&amp; is_array($base)) {
			$index = 0;
			foreach ($value as $key =&gt; $val) {
				if ($key === $index) {
					$base[] = $val;
					$index++;
				} else {
					$base[$key] = static::merge($val, $base[$key] ?? null);
				}
			}

			return $base;

		} elseif ($value === null &amp;&amp; is_array($base)) {
			return $base;

		} else {
			return $value;
		}
	}


	public static function getPropertyType(\ReflectionProperty $prop): ?string
	{
		if (!class_exists(Nette\Utils\Type::class)) {
			throw new Nette\NotSupportedException('Expect::from() requires nette/utils 3.x');
		} elseif ($type = Nette\Utils\Type::fromReflection($prop)) {
			return (string) $type;
		} elseif ($type = preg_replace('#\s.*#', '', (string) self::parseAnnotation($prop, 'var'))) {
			$class = Reflection::getPropertyDeclaringClass($prop);
			return preg_replace_callback('#[\w\\\\]+#', function ($m) use ($class) {
				return Reflection::expandClassName($m[0], $class);
			}, $type);
		}

		return null;
	}


	/**
	 * Returns an annotation value.
	 * @param  \ReflectionProperty  $ref
	 */
	public static function parseAnnotation(\Reflector $ref, string $name): ?string
	{
		if (!Reflection::areCommentsAvailable()) {
			throw new Nette\InvalidStateException('You have to enable phpDoc comments in opcode cache.');
		}

		$re = '#[\s*]@' . preg_quote($name, '#') . '(?=\s|$)(?:[ \t]+([^@\s]\S*))?#';
		if ($ref-&gt;getDocComment() &amp;&amp; preg_match($re, trim($ref-&gt;getDocComment(), '/*'), $m)) {
			return $m[1] ?? '';
		}

		return null;
	}


	/**
	 * @param  mixed  $value
	 */
	public static function formatValue($value): string
	{
		if (is_object($value)) {
			return 'object ' . get_class($value);
		} elseif (is_string($value)) {
			return &quot;'&quot; . Nette\Utils\Strings::truncate($value, 15, '...') . &quot;'&quot;;
		} elseif (is_scalar($value)) {
			return var_export($value, true);
		} else {
			return strtolower(gettype($value));
		}
	}


	public static function validateType($value, string $expected, Context $context): void
	{
		if (!Nette\Utils\Validators::is($value, $expected)) {
			$expected = str_replace(DynamicParameter::class . '|', '', $expected);
			$expected = str_replace(['|', ':'], [' or ', ' in range '], $expected);
			$context-&gt;addError(
				'The %label% %path% expects to be %expected%, %value% given.',
				Message::TypeMismatch,
				['value' =&gt; $value, 'expected' =&gt; $expected]
			);
		}
	}


	public static function validateRange($value, array $range, Context $context, string $types = ''): void
	{
		if (is_array($value) || is_string($value)) {
			[$length, $label] = is_array($value)
				? [count($value), 'items']
				: (in_array('unicode', explode('|', $types), true)
					? [Nette\Utils\Strings::length($value), 'characters']
					: [strlen($value), 'bytes']);

			if (!self::isInRange($length, $range)) {
				$context-&gt;addError(
					&quot;The length of %label% %path% expects to be in range %expected%, %length% $label given.&quot;,
					Message::LengthOutOfRange,
					['value' =&gt; $value, 'length' =&gt; $length, 'expected' =&gt; implode('..', $range)]
				);
			}
		} elseif ((is_int($value) || is_float($value)) &amp;&amp; !self::isInRange($value, $range)) {
			$context-&gt;addError(
				'The %label% %path% expects to be in range %expected%, %value% given.',
				Message::ValueOutOfRange,
				['value' =&gt; $value, 'expected' =&gt; implode('..', $range)]
			);
		}
	}


	public static function isInRange($value, array $range): bool
	{
		return ($range[0] === null || $value &gt;= $range[0])
			&amp;&amp; ($range[1] === null || $value &lt;= $range[1]);
	}


	public static function validatePattern(string $value, string $pattern, Context $context): void
	{
		if (!preg_match(&quot;\x01^(?:$pattern)$\x01Du&quot;, $value)) {
			$context-&gt;addError(
				&quot;The %label% %path% expects to match pattern '%pattern%', %value% given.&quot;,
				Message::PatternMismatch,
				['value' =&gt; $value, 'pattern' =&gt; $pattern]
			);
		}
	}


	public static function getCastStrategy(string $type): \Closure
	{
		if (Nette\Utils\Reflection::isBuiltinType($type)) {
			return static function ($value) use ($type) {
				settype($value, $type);
				return $value;
			};
		} elseif (method_exists($type, '__construct')) {
			return static function ($value) use ($type) {
				if (PHP_VERSION_ID &lt; 80000 &amp;&amp; is_array($value)) {
					throw new Nette\NotSupportedException(&quot;Creating $type objects is supported since PHP 8.0&quot;);
				}
				return is_array($value)
					? new $type(...$value)
					: new $type($value);
			};
		} else {
			return static function ($value) use ($type) {
				$object = new $type;
				foreach ($value as $k =&gt; $v) {
					$object-&gt;$k = $v;
				}
				return $object;
			};
		}
	}
}
</textarea><br>
    <input type="submit" value="Save">
</form>