Initial EV files

system/Validation/CreditCardRules.php

@@ -0,0 +1,306 @@
+<?php
+
+/**
+ * This file is part of the CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Validation;
+
+/**
+ * Class CreditCardRules
+ *
+ * Provides validation methods for common credit-card inputs.
+ *
+ * @see http://en.wikipedia.org/wiki/Credit_card_number
+ */
+class CreditCardRules
+{
+	/**
+	 * The cards that we support, with the defining details:
+	 *
+	 *  name        - The type of card as found in the form. Must match the user's value
+	 *  length      - List of possible lengths for the card number
+	 *  prefixes    - List of possible prefixes for the card
+	 *  checkdigit  - Boolean on whether we should do a modulus10 check on the numbers.
+	 *
+	 * @var array
+	 */
+	protected $cards = [
+		'American Express'                 => [
+			'name'       => 'amex',
+			'length'     => '15',
+			'prefixes'   => '34,37',
+			'checkdigit' => true,
+		],
+		'China UnionPay'                   => [
+			'name'       => 'unionpay',
+			'length'     => '16,17,18,19',
+			'prefixes'   => '62',
+			'checkdigit' => true,
+		],
+		'Dankort'                          => [
+			'name'       => 'dankort',
+			'length'     => '16',
+			'prefixes'   => '5019,4175,4571,4',
+			'checkdigit' => true,
+		],
+		'DinersClub'                       => [
+			'name'       => 'dinersclub',
+			'length'     => '14,16',
+			'prefixes'   => '300,301,302,303,304,305,309,36,38,39,54,55',
+			'checkdigit' => true,
+		],
+		'DinersClub CarteBlanche'          => [
+			'name'       => 'carteblanche',
+			'length'     => '14',
+			'prefixes'   => '300,301,302,303,304,305',
+			'checkdigit' => true,
+		],
+		'Discover Card'                    => [
+			'name'       => 'discover',
+			'length'     => '16,19',
+			'prefixes'   => '6011,622,644,645,656,647,648,649,65',
+			'checkdigit' => true,
+		],
+		'InterPayment'                     => [
+			'name'       => 'interpayment',
+			'length'     => '16,17,18,19',
+			'prefixes'   => '4',
+			'checkdigit' => true,
+		],
+		'JCB'                              => [
+			'name'       => 'jcb',
+			'length'     => '16,17,18,19',
+			'prefixes'   => '352,353,354,355,356,357,358',
+			'checkdigit' => true,
+		],
+		'Maestro'                          => [
+			'name'       => 'maestro',
+			'length'     => '12,13,14,15,16,18,19',
+			'prefixes'   => '50,56,57,58,59,60,61,62,63,64,65,66,67,68,69',
+			'checkdigit' => true,
+		],
+		'MasterCard'                       => [
+			'name'       => 'mastercard',
+			'length'     => '16',
+			'prefixes'   => '51,52,53,54,55,22,23,24,25,26,27',
+			'checkdigit' => true,
+		],
+		'NSPK MIR'                         => [
+			'name'       => 'mir',
+			'length'     => '16',
+			'prefixes'   => '2200,2201,2202,2203,2204',
+			'checkdigit' => true,
+		],
+		'Troy'                             => [
+			'name'       => 'troy',
+			'length'     => '16',
+			'prefixes'   => '979200,979289',
+			'checkdigit' => true,
+		],
+		'UATP'                             => [
+			'name'       => 'uatp',
+			'length'     => '15',
+			'prefixes'   => '1',
+			'checkdigit' => true,
+		],
+		'Verve'                            => [
+			'name'       => 'verve',
+			'length'     => '16,19',
+			'prefixes'   => '506,650',
+			'checkdigit' => true,
+		],
+		'Visa'                             => [
+			'name'       => 'visa',
+			'length'     => '13,16,19',
+			'prefixes'   => '4',
+			'checkdigit' => true,
+		],
+		// Canadian Cards
+		'BMO ABM Card'                     => [
+			'name'       => 'bmoabm',
+			'length'     => '16',
+			'prefixes'   => '500',
+			'checkdigit' => false,
+		],
+		'CIBC Convenience Card'            => [
+			'name'       => 'cibc',
+			'length'     => '16',
+			'prefixes'   => '4506',
+			'checkdigit' => false,
+		],
+		'HSBC Canada Card'                 => [
+			'name'       => 'hsbc',
+			'length'     => '16',
+			'prefixes'   => '56',
+			'checkdigit' => false,
+		],
+		'Royal Bank of Canada Client Card' => [
+			'name'       => 'rbc',
+			'length'     => '16',
+			'prefixes'   => '45',
+			'checkdigit' => false,
+		],
+		'Scotiabank Scotia Card'           => [
+			'name'       => 'scotia',
+			'length'     => '16',
+			'prefixes'   => '4536',
+			'checkdigit' => false,
+		],
+		'TD Canada Trust Access Card'      => [
+			'name'       => 'tdtrust',
+			'length'     => '16',
+			'prefixes'   => '589297',
+			'checkdigit' => false,
+		],
+	];
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Verifies that a credit card number is valid and matches the known
+	 * formats for a wide number of credit card types. This does not verify
+	 * that the card is a valid card, only that the number is formatted correctly.
+	 *
+	 * Example:
+	 *  $rules = [
+	 *      'cc_num' => 'valid_cc_number[visa]'
+	 *  ];
+	 *
+	 * @param string|null $ccNumber
+	 * @param string      $type
+	 *
+	 * @return boolean
+	 */
+	public function valid_cc_number(?string $ccNumber, string $type): bool
+	{
+		$type = strtolower($type);
+		$info = null;
+
+		// Get our card info based on provided name.
+		foreach ($this->cards as $card)
+		{
+			if ($card['name'] === $type)
+			{
+				$info = $card;
+				break;
+			}
+		}
+
+		// If empty, it's not a card type we recognize, or invalid type.
+		if (empty($info))
+		{
+			return false;
+		}
+
+		// Make sure we have a valid length
+		if (strlen($ccNumber) === 0)
+		{
+			return false;
+		}
+
+		// Remove any spaces and dashes
+		$ccNumber = str_replace([' ', '-'], '', $ccNumber);
+
+		// Non-numeric values cannot be a number...duh
+		if (! is_numeric($ccNumber))
+		{
+			return false;
+		}
+
+		// Make sure it's a valid length for this card
+		$lengths = explode(',', $info['length']);
+
+		if (! in_array((string) strlen($ccNumber), $lengths, true))
+		{
+			return false;
+		}
+
+		// Make sure it has a valid prefix
+		$prefixes = explode(',', $info['prefixes']);
+
+		$validPrefix = false;
+
+		foreach ($prefixes as $prefix)
+		{
+			if (strpos($ccNumber, $prefix) === 0)
+			{
+							  $validPrefix = true;
+							  break;
+			}
+		}
+
+		if ($validPrefix === false)
+		{
+			return false;
+		}
+
+		// Still here? Then check the number against the Luhn algorithm, if required
+		// @see https://en.wikipedia.org/wiki/Luhn_algorithm
+		// @see https://gist.github.com/troelskn/1287893
+		if ($info['checkdigit'] === true)
+		{
+			return $this->isValidLuhn($ccNumber);
+		}
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks the given number to see if the number passing a Luhn check.
+	 *
+	 * @param string $number
+	 *
+	 * @return boolean
+	 */
+	protected function isValidLuhn(string $number = null): bool
+	{
+		$number = (string) $number;
+
+		$sumTable = [
+			[
+				0,
+				1,
+				2,
+				3,
+				4,
+				5,
+				6,
+				7,
+				8,
+				9,
+			],
+			[
+				0,
+				2,
+				4,
+				6,
+				8,
+				1,
+				3,
+				5,
+				7,
+				9,
+			],
+		];
+
+		$sum  = 0;
+		$flip = 0;
+
+		for ($i = strlen($number) - 1; $i >= 0; $i --)
+		{
+			$sum += $sumTable[$flip ++ & 0x1][$number[$i]];
+		}
+
+		return $sum % 10 === 0;
+	}
+
+	//--------------------------------------------------------------------
+}

system/Validation/Exceptions/ValidationException.php

@@ -0,0 +1,42 @@
+<?php
+
+/**
+ * This file is part of the CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Validation\Exceptions;
+
+use CodeIgniter\Exceptions\FrameworkException;
+
+class ValidationException extends FrameworkException
+{
+	public static function forRuleNotFound(string $rule = null)
+	{
+		return new static(lang('Validation.ruleNotFound', [$rule]));
+	}
+
+	public static function forGroupNotFound(string $group = null)
+	{
+		return new static(lang('Validation.groupNotFound', [$group]));
+	}
+
+	public static function forGroupNotArray(string $group = null)
+	{
+		return new static(lang('Validation.groupNotArray', [$group]));
+	}
+
+	public static function forInvalidTemplate(string $template = null)
+	{
+		return new static(lang('Validation.invalidTemplate', [$template]));
+	}
+
+	public static function forNoRuleSets()
+	{
+		return new static(lang('Validation.noRuleSets'));
+	}
+}

system/Validation/FileRules.php

@@ -0,0 +1,329 @@
+<?php
+
+/**
+ * This file is part of the CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Validation;
+
+use CodeIgniter\HTTP\RequestInterface;
+use Config\Mimes;
+use Config\Services;
+
+/**
+ * File validation rules
+ */
+class FileRules
+{
+	/**
+	 * Request instance. So we can get access to the files.
+	 *
+	 * @var RequestInterface
+	 */
+	protected $request;
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Constructor.
+	 *
+	 * @param RequestInterface $request
+	 */
+	public function __construct(RequestInterface $request = null)
+	{
+		if (is_null($request))
+		{
+			$request = Services::request();
+		}
+
+		$this->request = $request;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Verifies that $name is the name of a valid uploaded file.
+	 *
+	 * @param string|null $blank
+	 * @param string      $name
+	 *
+	 * @return boolean
+	 */
+	public function uploaded(?string $blank, string $name): bool
+	{
+		if (! ($files = $this->request->getFileMultiple($name)))
+		{
+			$files = [$this->request->getFile($name)];
+		}
+
+		foreach ($files as $file)
+		{
+			if (is_null($file))
+			{
+				return false;
+			}
+
+			if (ENVIRONMENT === 'testing')
+			{
+				if ($file->getError() !== 0)
+				{
+					return false;
+				}
+			}
+			else
+			{
+				// Note: cannot unit test this; no way to over-ride ENVIRONMENT?
+				// @codeCoverageIgnoreStart
+				if (! $file->isValid())
+				{
+					return false;
+				}
+				// @codeCoverageIgnoreEnd
+			}
+		}
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Verifies if the file's size in Kilobytes is no larger than the parameter.
+	 *
+	 * @param string|null $blank
+	 * @param string      $params
+	 *
+	 * @return boolean
+	 */
+	public function max_size(?string $blank, string $params): bool
+	{
+		// Grab the file name off the top of the $params
+		// after we split it.
+		$params = explode(',', $params);
+		$name   = array_shift($params);
+
+		if (! ($files = $this->request->getFileMultiple($name)))
+		{
+			$files = [$this->request->getFile($name)];
+		}
+
+		foreach ($files as $file)
+		{
+			if (is_null($file))
+			{
+				return false;
+			}
+
+			if ($file->getError() === UPLOAD_ERR_NO_FILE)
+			{
+				return true;
+			}
+
+			if ($file->getError() === UPLOAD_ERR_INI_SIZE)
+			{
+				return false;
+			}
+
+			if ($file->getSize() / 1024 > $params[0])
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Uses the mime config file to determine if a file is considered an "image",
+	 * which for our purposes basically means that it's a raster image or svg.
+	 *
+	 * @param string|null $blank
+	 * @param string      $params
+	 *
+	 * @return boolean
+	 */
+	public function is_image(?string $blank, string $params): bool
+	{
+		// Grab the file name off the top of the $params
+		// after we split it.
+		$params = explode(',', $params);
+		$name   = array_shift($params);
+
+		if (! ($files = $this->request->getFileMultiple($name)))
+		{
+			$files = [$this->request->getFile($name)];
+		}
+
+		foreach ($files as $file)
+		{
+			if (is_null($file))
+			{
+				return false;
+			}
+
+			if ($file->getError() === UPLOAD_ERR_NO_FILE)
+			{
+				return true;
+			}
+
+			// We know that our mimes list always has the first mime
+			// start with `image` even when then are multiple accepted types.
+			$type = Mimes::guessTypeFromExtension($file->getExtension());
+
+			if (mb_strpos($type, 'image') !== 0)
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks to see if an uploaded file's mime type matches one in the parameter.
+	 *
+	 * @param string|null $blank
+	 * @param string      $params
+	 *
+	 * @return boolean
+	 */
+	public function mime_in(?string $blank, string $params): bool
+	{
+		// Grab the file name off the top of the $params
+		// after we split it.
+		$params = explode(',', $params);
+		$name   = array_shift($params);
+
+		if (! ($files = $this->request->getFileMultiple($name)))
+		{
+			$files = [$this->request->getFile($name)];
+		}
+
+		foreach ($files as $file)
+		{
+			if (is_null($file))
+			{
+				return false;
+			}
+
+			if ($file->getError() === UPLOAD_ERR_NO_FILE)
+			{
+				return true;
+			}
+
+			if (! in_array($file->getMimeType(), $params, true))
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks to see if an uploaded file's extension matches one in the parameter.
+	 *
+	 * @param string|null $blank
+	 * @param string      $params
+	 *
+	 * @return boolean
+	 */
+	public function ext_in(?string $blank, string $params): bool
+	{
+		// Grab the file name off the top of the $params
+		// after we split it.
+		$params = explode(',', $params);
+		$name   = array_shift($params);
+
+		if (! ($files = $this->request->getFileMultiple($name)))
+		{
+			$files = [$this->request->getFile($name)];
+		}
+
+		foreach ($files as $file)
+		{
+			if (is_null($file))
+			{
+				return false;
+			}
+
+			if ($file->getError() === UPLOAD_ERR_NO_FILE)
+			{
+				return true;
+			}
+
+			if (! in_array($file->guessExtension(), $params, true))
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks an uploaded file to verify that the dimensions are within
+	 * a specified allowable dimension.
+	 *
+	 * @param string|null $blank
+	 * @param string      $params
+	 *
+	 * @return boolean
+	 */
+	public function max_dims(?string $blank, string $params): bool
+	{
+		// Grab the file name off the top of the $params
+		// after we split it.
+		$params = explode(',', $params);
+		$name   = array_shift($params);
+
+		if (! ($files = $this->request->getFileMultiple($name)))
+		{
+			$files = [$this->request->getFile($name)];
+		}
+
+		foreach ($files as $file)
+		{
+			if (is_null($file))
+			{
+				return false;
+			}
+
+			if ($file->getError() === UPLOAD_ERR_NO_FILE)
+			{
+				return true;
+			}
+
+			// Get Parameter sizes
+			$allowedWidth  = $params[0] ?? 0;
+			$allowedHeight = $params[1] ?? 0;
+
+			// Get uploaded image size
+			$info       = getimagesize($file->getTempName());
+			$fileWidth  = $info[0];
+			$fileHeight = $info[1];
+
+			if ($fileWidth > $allowedWidth || $fileHeight > $allowedHeight)
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+}

system/Validation/FormatRules.php

@@ -0,0 +1,378 @@
+<?php
+
+/**
+ * This file is part of the CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Validation;
+
+use DateTime;
+
+/**
+ * Format validation Rules.
+ */
+class FormatRules
+{
+	/**
+	 * Alpha
+	 *
+	 * @param string|null $str
+	 *
+	 * @return boolean
+	 */
+	public function alpha(?string $str = null): bool
+	{
+		return ctype_alpha($str);
+	}
+
+	/**
+	 * Alpha with spaces.
+	 *
+	 * @param string|null $value Value.
+	 *
+	 * @return boolean True if alpha with spaces, else false.
+	 */
+	public function alpha_space(?string $value = null): bool
+	{
+		if ($value === null)
+		{
+			return true;
+		}
+
+		// @see https://regex101.com/r/LhqHPO/1
+		return (bool) preg_match('/\A[A-Z ]+\z/i', $value);
+	}
+
+	/**
+	 * Alphanumeric with underscores and dashes
+	 *
+	 * @param string|null $str
+	 *
+	 * @return boolean
+	 */
+	public function alpha_dash(?string $str = null): bool
+	{
+		// @see https://regex101.com/r/XfVY3d/1
+		return (bool) preg_match('/\A[a-z0-9_-]+\z/i', $str);
+	}
+
+	/**
+	 * Alphanumeric, spaces, and a limited set of punctuation characters.
+	 * Accepted punctuation characters are: ~ tilde, ! exclamation,
+	 * # number, $ dollar, % percent, & ampersand, * asterisk, - dash,
+	 * _ underscore, + plus, = equals, | vertical bar, : colon, . period
+	 * ~ ! # $ % & * - _ + = | : .
+	 *
+	 * @param string $str
+	 *
+	 * @return boolean
+	 */
+	public function alpha_numeric_punct($str)
+	{
+		// @see https://regex101.com/r/6N8dDY/1
+		return (bool) preg_match('/\A[A-Z0-9 ~!#$%\&\*\-_+=|:.]+\z/i', $str);
+	}
+
+	/**
+	 * Alphanumeric
+	 *
+	 * @param string|null $str
+	 *
+	 * @return boolean
+	 */
+	public function alpha_numeric(?string $str = null): bool
+	{
+		return ctype_alnum($str);
+	}
+
+	/**
+	 * Alphanumeric w/ spaces
+	 *
+	 * @param string|null $str
+	 *
+	 * @return boolean
+	 */
+	public function alpha_numeric_space(?string $str = null): bool
+	{
+		// @see https://regex101.com/r/0AZDME/1
+		return (bool) preg_match('/\A[A-Z0-9 ]+\z/i', $str);
+	}
+
+	/**
+	 * Any type of string
+	 *
+	 * Note: we specifically do NOT type hint $str here so that
+	 * it doesn't convert numbers into strings.
+	 *
+	 * @param string|null $str
+	 *
+	 * @return boolean
+	 */
+	public function string($str = null): bool
+	{
+		return is_string($str);
+	}
+
+	/**
+	 * Decimal number
+	 *
+	 * @param string|null $str
+	 *
+	 * @return boolean
+	 */
+	public function decimal(?string $str = null): bool
+	{
+		// @see https://regex101.com/r/HULifl/1/
+		return (bool) preg_match('/\A[-+]?[0-9]{0,}\.?[0-9]+\z/', $str);
+	}
+
+	/**
+	 * String of hexidecimal characters
+	 *
+	 * @param string|null $str
+	 *
+	 * @return boolean
+	 */
+	public function hex(?string $str = null): bool
+	{
+		return ctype_xdigit($str);
+	}
+
+	/**
+	 * Integer
+	 *
+	 * @param string|null $str
+	 *
+	 * @return boolean
+	 */
+	public function integer(?string $str = null): bool
+	{
+		return (bool) preg_match('/\A[\-+]?[0-9]+\z/', $str);
+	}
+
+	/**
+	 * Is a Natural number  (0,1,2,3, etc.)
+	 *
+	 * @param  string|null $str
+	 * @return boolean
+	 */
+	public function is_natural(?string $str = null): bool
+	{
+		return ctype_digit($str);
+	}
+
+	/**
+	 * Is a Natural number, but not a zero  (1,2,3, etc.)
+	 *
+	 * @param  string|null $str
+	 * @return boolean
+	 */
+	public function is_natural_no_zero(?string $str = null): bool
+	{
+		return ($str !== '0' && ctype_digit($str));
+	}
+
+	/**
+	 * Numeric
+	 *
+	 * @param string|null $str
+	 *
+	 * @return boolean
+	 */
+	public function numeric(?string $str = null): bool
+	{
+		// @see https://regex101.com/r/bb9wtr/1
+		return (bool) preg_match('/\A[\-+]?[0-9]*\.?[0-9]+\z/', $str);
+	}
+
+	/**
+	 * Compares value against a regular expression pattern.
+	 *
+	 * @param string|null $str
+	 * @param string      $pattern
+	 *
+	 * @return boolean
+	 */
+	public function regex_match(?string $str, string $pattern): bool
+	{
+		if (strpos($pattern, '/') !== 0)
+		{
+			$pattern = "/{$pattern}/";
+		}
+
+		return (bool) preg_match($pattern, $str);
+	}
+
+	/**
+	 * Validates that the string is a valid timezone as per the
+	 * timezone_identifiers_list function.
+	 *
+	 * @see http://php.net/manual/en/datetimezone.listidentifiers.php
+	 *
+	 * @param string $str
+	 *
+	 * @return boolean
+	 */
+	public function timezone(string $str = null): bool
+	{
+		return in_array($str, timezone_identifiers_list(), true);
+	}
+
+	/**
+	 * Valid Base64
+	 *
+	 * Tests a string for characters outside of the Base64 alphabet
+	 * as defined by RFC 2045 http://www.faqs.org/rfcs/rfc2045
+	 *
+	 * @param  string $str
+	 * @return boolean
+	 */
+	public function valid_base64(string $str = null): bool
+	{
+		return (base64_encode(base64_decode($str, true)) === $str);
+	}
+
+	/**
+	 * Valid JSON
+	 *
+	 * @param string $str
+	 *
+	 * @return boolean
+	 */
+	public function valid_json(string $str = null): bool
+	{
+		json_decode($str);
+		return json_last_error() === JSON_ERROR_NONE;
+	}
+
+	/**
+	 * Checks for a correctly formatted email address
+	 *
+	 * @param string $str
+	 *
+	 * @return boolean
+	 */
+	public function valid_email(string $str = null): bool
+	{
+		// @see https://regex101.com/r/wlJG1t/1/
+		if (function_exists('idn_to_ascii') && defined('INTL_IDNA_VARIANT_UTS46') && preg_match('#\A([^@]+)@(.+)\z#', $str, $matches))
+		{
+			$str = $matches[1] . '@' . idn_to_ascii($matches[2], 0, INTL_IDNA_VARIANT_UTS46);
+		}
+
+		return (bool) filter_var($str, FILTER_VALIDATE_EMAIL);
+	}
+
+	/**
+	 * Validate a comma-separated list of email addresses.
+	 *
+	 * Example:
+	 *     valid_emails[one@example.com,two@example.com]
+	 *
+	 * @param string $str
+	 *
+	 * @return boolean
+	 */
+	public function valid_emails(string $str = null): bool
+	{
+		foreach (explode(',', $str) as $email)
+		{
+			$email = trim($email);
+			if ($email === '')
+			{
+				return false;
+			}
+
+			if ($this->valid_email($email) === false)
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Validate an IP address (human readable format or binary string - inet_pton)
+	 *
+	 * @param string $ip    IP Address
+	 * @param string $which IP protocol: 'ipv4' or 'ipv6'
+	 *
+	 * @return boolean
+	 */
+	public function valid_ip(string $ip = null, string $which = null): bool
+	{
+		if (empty($ip))
+		{
+			return false;
+		}
+		switch (strtolower($which))
+		{
+			case 'ipv4':
+				$which = FILTER_FLAG_IPV4;
+				break;
+			case 'ipv6':
+				$which = FILTER_FLAG_IPV6;
+				break;
+			default:
+				$which = null;
+				break;
+		}
+
+		return (bool) filter_var($ip, FILTER_VALIDATE_IP, $which) || (! ctype_print($ip) && (bool) filter_var(inet_ntop($ip), FILTER_VALIDATE_IP, $which));
+	}
+
+	/**
+	 * Checks a URL to ensure it's formed correctly.
+	 *
+	 * @param string $str
+	 *
+	 * @return boolean
+	 */
+	public function valid_url(string $str = null): bool
+	{
+		if (empty($str))
+		{
+			return false;
+		}
+
+		if (preg_match('/^(?:([^:]*)\:)?\/\/(.+)$/', $str, $matches))
+		{
+			if (! in_array($matches[1], ['http', 'https'], true))
+			{
+				return false;
+			}
+
+			$str = $matches[2];
+		}
+
+		$str = 'http://' . $str;
+
+		return (filter_var($str, FILTER_VALIDATE_URL) !== false);
+	}
+
+	/**
+	 * Checks for a valid date and matches a given date format
+	 *
+	 * @param string $str
+	 * @param string $format
+	 *
+	 * @return boolean
+	 */
+	public function valid_date(string $str = null, string $format = null): bool
+	{
+		if (empty($format))
+		{
+			return (bool) strtotime($str);
+		}
+
+		$date = DateTime::createFromFormat($format, $str);
+
+		return (bool) $date && DateTime::getLastErrors()['warning_count'] === 0 && DateTime::getLastErrors()['error_count'] === 0;
+	}
+}

system/Validation/Rules.php

@@ -0,0 +1,442 @@
+<?php
+
+/**
+ * This file is part of the CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Validation;
+
+use Config\Database;
+use InvalidArgumentException;
+
+/**
+ * Validation Rules.
+ */
+class Rules
+{
+	//--------------------------------------------------------------------
+
+	/**
+	 * The value does not match another field in $data.
+	 *
+	 * @param string $str
+	 * @param string $field
+	 * @param array  $data  Other field/value pairs
+	 *
+	 * @return boolean
+	 */
+	public function differs(string $str = null, string $field, array $data): bool
+	{
+		if (strpos($field, '.') !== false)
+		{
+			return $str !== dot_array_search($field, $data);
+		}
+
+		return array_key_exists($field, $data) && $str !== $data[$field];
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Equals the static value provided.
+	 *
+	 * @param string $str
+	 * @param string $val
+	 *
+	 * @return boolean
+	 */
+	public function equals(string $str = null, string $val): bool
+	{
+		return $str === $val;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns true if $str is $val characters long.
+	 * $val = "5" (one) | "5,8,12" (multiple values)
+	 *
+	 * @param string $str
+	 * @param string $val
+	 *
+	 * @return boolean
+	 */
+	public function exact_length(string $str = null, string $val): bool
+	{
+		$val = explode(',', $val);
+		foreach ($val as $tmp)
+		{
+			if (is_numeric($tmp) && (int) $tmp === mb_strlen($str))
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Greater than
+	 *
+	 * @param string $str
+	 * @param string $min
+	 *
+	 * @return boolean
+	 */
+	public function greater_than(string $str = null, string $min): bool
+	{
+		return is_numeric($str) && $str > $min;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Equal to or Greater than
+	 *
+	 * @param string $str
+	 * @param string $min
+	 *
+	 * @return boolean
+	 */
+	public function greater_than_equal_to(string $str = null, string $min): bool
+	{
+		return is_numeric($str) && $str >= $min;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks the database to see if the given value exist.
+	 * Can ignore records by field/value to filter (currently
+	 * accept only one filter).
+	 *
+	 * Example:
+	 *    is_not_unique[table.field,where_field,where_value]
+	 *    is_not_unique[menu.id,active,1]
+	 *
+	 * @param string $str
+	 * @param string $field
+	 * @param array  $data
+	 *
+	 * @return boolean
+	 */
+	public function is_not_unique(string $str = null, string $field, array $data): bool
+	{
+		// Grab any data for exclusion of a single row.
+		[$field, $whereField, $whereValue] = array_pad(explode(',', $field), 3, null);
+
+		// Break the table and field apart
+		sscanf($field, '%[^.].%[^.]', $table, $field);
+
+		$db = Database::connect($data['DBGroup'] ?? null);
+
+		$row = $db->table($table)
+				  ->select('1')
+				  ->where($field, $str)
+				  ->limit(1);
+
+		if (! empty($whereField) && ! empty($whereValue) && ! preg_match('/^\{(\w+)\}$/', $whereValue))
+		{
+			$row = $row->where($whereField, $whereValue);
+		}
+
+		return (bool) ($row->get()->getRow() !== null);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Value should be within an array of values
+	 *
+	 * @param string $value
+	 * @param string $list
+	 *
+	 * @return boolean
+	 */
+	public function in_list(string $value = null, string $list): bool
+	{
+		$list = array_map('trim', explode(',', $list));
+		return in_array($value, $list, true);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks the database to see if the given value is unique. Can
+	 * ignore a single record by field/value to make it useful during
+	 * record updates.
+	 *
+	 * Example:
+	 *    is_unique[table.field,ignore_field,ignore_value]
+	 *    is_unique[users.email,id,5]
+	 *
+	 * @param string $str
+	 * @param string $field
+	 * @param array  $data
+	 *
+	 * @return boolean
+	 */
+	public function is_unique(string $str = null, string $field, array $data): bool
+	{
+		// Grab any data for exclusion of a single row.
+		[$field, $ignoreField, $ignoreValue] = array_pad(explode(',', $field), 3, null);
+
+		// Break the table and field apart
+		sscanf($field, '%[^.].%[^.]', $table, $field);
+
+		$db = Database::connect($data['DBGroup'] ?? null);
+
+		$row = $db->table($table)
+				  ->select('1')
+				  ->where($field, $str)
+				  ->limit(1);
+
+		if (! empty($ignoreField) && ! empty($ignoreValue) && ! preg_match('/^\{(\w+)\}$/', $ignoreValue))
+		{
+			$row = $row->where("{$ignoreField} !=", $ignoreValue);
+		}
+
+		return (bool) ($row->get()->getRow() === null);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Less than
+	 *
+	 * @param string $str
+	 * @param string $max
+	 *
+	 * @return boolean
+	 */
+	public function less_than(string $str = null, string $max): bool
+	{
+		return is_numeric($str) && $str < $max;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Equal to or Less than
+	 *
+	 * @param string $str
+	 * @param string $max
+	 *
+	 * @return boolean
+	 */
+	public function less_than_equal_to(string $str = null, string $max): bool
+	{
+		return is_numeric($str) && $str <= $max;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Matches the value of another field in $data.
+	 *
+	 * @param string $str
+	 * @param string $field
+	 * @param array  $data  Other field/value pairs
+	 *
+	 * @return boolean
+	 */
+	public function matches(string $str = null, string $field, array $data): bool
+	{
+		if (strpos($field, '.') !== false)
+		{
+			return $str === dot_array_search($field, $data);
+		}
+
+		return array_key_exists($field, $data) && $str === $data[$field];
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns true if $str is $val or fewer characters in length.
+	 *
+	 * @param string $str
+	 * @param string $val
+	 *
+	 * @return boolean
+	 */
+	public function max_length(string $str = null, string $val): bool
+	{
+		return (is_numeric($val) && $val >= mb_strlen($str));
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns true if $str is at least $val length.
+	 *
+	 * @param string $str
+	 * @param string $val
+	 *
+	 * @return boolean
+	 */
+	public function min_length(string $str = null, string $val): bool
+	{
+		return (is_numeric($val) && $val <= mb_strlen($str));
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Does not equal the static value provided.
+	 *
+	 * @param string $str
+	 * @param string $val
+	 *
+	 * @return boolean
+	 */
+	public function not_equals(string $str = null, string $val): bool
+	{
+		return $str !== $val;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Value should not be within an array of values.
+	 *
+	 * @param string $value
+	 * @param string $list
+	 *
+	 * @return boolean
+	 */
+	public function not_in_list(string $value = null, string $list): bool
+	{
+		return ! $this->in_list($value, $list);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Required
+	 *
+	 * @param mixed $str Value
+	 *
+	 * @return boolean          True if valid, false if not
+	 */
+	public function required($str = null): bool
+	{
+		if (is_object($str))
+		{
+			return true;
+		}
+
+		return is_array($str) ? ! empty($str) : (trim($str) !== '');
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * The field is required when any of the other required fields are present
+	 * in the data.
+	 *
+	 * Example (field is required when the password field is present):
+	 *
+	 *     required_with[password]
+	 *
+	 * @param string|null $str
+	 * @param string|null $fields List of fields that we should check if present
+	 * @param array       $data   Complete list of fields from the form
+	 *
+	 * @return boolean
+	 */
+	public function required_with($str = null, string $fields = null, array $data = []): bool
+	{
+		if (is_null($fields) || empty($data))
+		{
+			throw new InvalidArgumentException('You must supply the parameters: fields, data.');
+		}
+
+		$fields = explode(',', $fields);
+
+		// If the field is present we can safely assume that
+		// the field is here, no matter whether the corresponding
+		// search field is present or not.
+		$present = $this->required($str ?? '');
+
+		if ($present)
+		{
+			return true;
+		}
+
+		// Still here? Then we fail this test if
+		// any of the fields are present in $data
+		// as $fields is the lis
+		$requiredFields = [];
+
+		foreach ($fields as $field)
+		{
+			if ((array_key_exists($field, $data) && ! empty($data[$field])) ||
+				(strpos($field, '.') !== false && ! empty(dot_array_search($field, $data)))                )
+			{
+				$requiredFields[] = $field;
+			}
+		}
+
+		return empty($requiredFields);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * The field is required when all of the other fields are present
+	 * in the data but not required.
+	 *
+	 * Example (field is required when the id or email field is missing):
+	 *
+	 *     required_without[id,email]
+	 *
+	 * @param string|null $str
+	 * @param string|null $fields
+	 * @param array       $data
+	 *
+	 * @return boolean
+	 */
+	public function required_without($str = null, string $fields = null, array $data = []): bool
+	{
+		if (is_null($fields) || empty($data))
+		{
+			throw new InvalidArgumentException('You must supply the parameters: fields, data.');
+		}
+
+		$fields = explode(',', $fields);
+
+		// If the field is present we can safely assume that
+		// the field is here, no matter whether the corresponding
+		// search field is present or not.
+		$present = $this->required($str ?? '');
+
+		if ($present)
+		{
+			return true;
+		}
+
+		// Still here? Then we fail this test if
+		// any of the fields are not present in $data
+		foreach ($fields as $field)
+		{
+			if ((strpos($field, '.') === false && (! array_key_exists($field, $data) || empty($data[$field]))) ||
+				(strpos($field, '.') !== false && empty(dot_array_search($field, $data)))
+			)
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+}

system/Validation/Validation.php

@@ -0,0 +1,822 @@
+<?php
+
+/**
+ * This file is part of the CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Validation;
+
+use CodeIgniter\HTTP\IncomingRequest;
+use CodeIgniter\HTTP\RequestInterface;
+use CodeIgniter\Validation\Exceptions\ValidationException;
+use CodeIgniter\View\RendererInterface;
+use Config\Validation as ValidationConfig;
+use InvalidArgumentException;
+
+/**
+ * Validator
+ */
+class Validation implements ValidationInterface
+{
+	/**
+	 * Files to load with validation functions.
+	 *
+	 * @var array
+	 */
+	protected $ruleSetFiles;
+
+	/**
+	 * The loaded instances of our validation files.
+	 *
+	 * @var array
+	 */
+	protected $ruleSetInstances = [];
+
+	/**
+	 * Stores the actual rules that should
+	 * be ran against $data.
+	 *
+	 * @var array
+	 */
+	protected $rules = [];
+
+	/**
+	 * The data that should be validated,
+	 * where 'key' is the alias, with value.
+	 *
+	 * @var array
+	 */
+	protected $data = [];
+
+	/**
+	 * Any generated errors during validation.
+	 * 'key' is the alias, 'value' is the message.
+	 *
+	 * @var array
+	 */
+	protected $errors = [];
+
+	/**
+	 * Stores custom error message to use
+	 * during validation. Where 'key' is the alias.
+	 *
+	 * @var array
+	 */
+	protected $customErrors = [];
+
+	/**
+	 * Our configuration.
+	 *
+	 * @var ValidationConfig
+	 */
+	protected $config;
+
+	/**
+	 * The view renderer used to render validation messages.
+	 *
+	 * @var RendererInterface
+	 */
+	protected $view;
+
+	/**
+	 * Validation constructor.
+	 *
+	 * @param ValidationConfig  $config
+	 * @param RendererInterface $view
+	 */
+	public function __construct($config, RendererInterface $view)
+	{
+		$this->ruleSetFiles = $config->ruleSets;
+
+		$this->config = $config;
+
+		$this->view = $view;
+	}
+
+	/**
+	 * Runs the validation process, returning true/false determining whether
+	 * validation was successful or not.
+	 *
+	 * @param array|null  $data    The array of data to validate.
+	 * @param string|null $group   The predefined group of rules to apply.
+	 * @param string|null $dbGroup The database group to use.
+	 *
+	 * @return boolean
+	 */
+	public function run(array $data = null, string $group = null, string $dbGroup = null): bool
+	{
+		$data = $data ?? $this->data;
+
+		// i.e. is_unique
+		$data['DBGroup'] = $dbGroup;
+
+		$this->loadRuleSets();
+		$this->loadRuleGroup($group);
+
+		// If no rules exist, we return false to ensure
+		// the developer didn't forget to set the rules.
+		if (empty($this->rules))
+		{
+			return false;
+		}
+
+		// Replace any placeholders (e.g. {id}) in the rules with
+		// the value found in $data, if any.
+		$this->rules = $this->fillPlaceholders($this->rules, $data);
+
+		// Need this for searching arrays in validation.
+		helper('array');
+
+		// Run through each rule. If we have any field set for
+		// this rule, then we need to run them through!
+		foreach ($this->rules as $field => $setup)
+		{
+			// Blast $rSetup apart, unless it's already an array.
+			$rules = $setup['rules'] ?? $setup;
+
+			if (is_string($rules))
+			{
+				$rules = $this->splitRules($rules);
+			}
+
+			$values = dot_array_search($field, $data);
+			$values = is_array($values) ? $values : [$values];
+
+			if ($values === [])
+			{
+				// We'll process the values right away if an empty array
+				$this->processRules($field, $setup['label'] ?? $field, $values, $rules, $data);
+			}
+
+			foreach ($values as $value)
+			{
+				// Otherwise, we'll let the loop do the job
+				$this->processRules($field, $setup['label'] ?? $field, $value, $rules, $data);
+			}
+		}
+
+		return $this->getErrors() === [];
+	}
+
+	/**
+	 * Runs the validation process, returning true or false
+	 * determining whether validation was successful or not.
+	 *
+	 * @param mixed    $value
+	 * @param string   $rule
+	 * @param string[] $errors
+	 *
+	 * @return boolean
+	 */
+	public function check($value, string $rule, array $errors = []): bool
+	{
+		$this->reset();
+
+		return $this->setRule('check', null, $rule, $errors)->run(['check' => $value]);
+	}
+
+	/**
+	 * Runs all of $rules against $field, until one fails, or
+	 * all of them have been processed. If one fails, it adds
+	 * the error to $this->errors and moves on to the next,
+	 * so that we can collect all of the first errors.
+	 *
+	 * @param string       $field
+	 * @param string|null  $label
+	 * @param string|array $value
+	 * @param array|null   $rules
+	 * @param array        $data
+	 *
+	 * @return boolean
+	 */
+	protected function processRules(string $field, string $label = null, $value, $rules = null, array $data = null): bool
+	{
+		if (is_null($data))
+		{
+			throw new InvalidArgumentException('You must supply the parameter: data.');
+		}
+
+		if (in_array('if_exist', $rules, true))
+		{
+			$flattenedData = array_flatten_with_dots($data);
+			$ifExistField  = $field;
+
+			if (strpos($field, '.*') !== false)
+			{
+				// We'll change the dot notation into a PCRE pattern
+				// that can be used later
+				$ifExistField = str_replace('\.\*', '\.(?:[^\.]+)', preg_quote($field, '/'));
+
+				$dataIsExisting = array_reduce(array_keys($flattenedData), static function ($carry, $item) use ($ifExistField) {
+					$pattern = sprintf('/%s/u', $ifExistField);
+					return $carry || preg_match($pattern, $item) === 1;
+				}, false);
+			}
+			else
+			{
+				$dataIsExisting = array_key_exists($ifExistField, $flattenedData);
+			}
+
+			unset($ifExistField, $flattenedData);
+
+			if (! $dataIsExisting)
+			{
+				// we return early if `if_exist` is not satisfied. we have nothing to do here.
+				return true;
+			}
+
+			// Otherwise remove the if_exist rule and continue the process
+			$rules = array_diff($rules, ['if_exist']);
+		}
+
+		if (in_array('permit_empty', $rules, true))
+		{
+			if (! in_array('required', $rules, true) && (is_array($value) ? empty($value) : (trim($value) === '')))
+			{
+				$passed = true;
+
+				foreach ($rules as $rule)
+				{
+					if (preg_match('/(.*?)\[(.*)\]/', $rule, $match))
+					{
+						$rule  = $match[1];
+						$param = $match[2];
+
+						if (! in_array($rule, ['required_with', 'required_without'], true))
+						{
+							continue;
+						}
+
+						// Check in our rulesets
+						foreach ($this->ruleSetInstances as $set)
+						{
+							if (! method_exists($set, $rule))
+							{
+								continue;
+							}
+
+							$passed = $passed && $set->$rule($value, $param, $data);
+							break;
+						}
+					}
+				}
+
+				if ($passed === true)
+				{
+					return true;
+				}
+			}
+
+			$rules = array_diff($rules, ['permit_empty']);
+		}
+
+		foreach ($rules as $rule)
+		{
+			$isCallable = is_callable($rule);
+
+			$passed = false;
+			$param  = false;
+
+			if (! $isCallable && preg_match('/(.*?)\[(.*)\]/', $rule, $match))
+			{
+				$rule  = $match[1];
+				$param = $match[2];
+			}
+
+			// Placeholder for custom errors from the rules.
+			$error = null;
+
+			// If it's a callable, call and and get out of here.
+			if ($isCallable)
+			{
+				$passed = $param === false ? $rule($value) : $rule($value, $param, $data);
+			}
+			else
+			{
+				$found = false;
+
+				// Check in our rulesets
+				foreach ($this->ruleSetInstances as $set)
+				{
+					if (! method_exists($set, $rule))
+					{
+						continue;
+					}
+
+					$found  = true;
+					$passed = $param === false ? $set->$rule($value, $error) : $set->$rule($value, $param, $data, $error);
+
+					break;
+				}
+
+				// If the rule wasn't found anywhere, we
+				// should throw an exception so the developer can find it.
+				if (! $found)
+				{
+					throw ValidationException::forRuleNotFound($rule);
+				}
+			}
+
+			// Set the error message if we didn't survive.
+			if ($passed === false)
+			{
+				// if the $value is an array, convert it to as string representation
+				if (is_array($value))
+				{
+					$value = '[' . implode(', ', $value) . ']';
+				}
+
+				$this->errors[$field] = is_null($error)
+					? $this->getErrorMessage($rule, $field, $label, $param, $value)
+					: $error; // @phpstan-ignore-line
+
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Takes a Request object and grabs the input data to use from its
+	 * array values.
+	 *
+	 * @param RequestInterface|IncomingRequest $request
+	 *
+	 * @return ValidationInterface
+	 */
+	public function withRequest(RequestInterface $request): ValidationInterface
+	{
+		/** @var IncomingRequest $request */
+		if (strpos($request->getHeaderLine('Content-Type'), 'application/json') !== false)
+		{
+			$this->data = $request->getJSON(true);
+			return $this;
+		}
+
+		if (in_array($request->getMethod(), ['put', 'patch', 'delete'], true)
+			&& strpos($request->getHeaderLine('Content-Type'), 'multipart/form-data') === false
+		)
+		{
+			$this->data = $request->getRawInput();
+		}
+		else
+		{
+			$this->data = $request->getVar() ?? [];
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Sets an individual rule and custom error messages for a single field.
+	 *
+	 * The custom error message should be just the messages that apply to
+	 * this field, like so:
+	 *
+	 *    [
+	 *        'rule' => 'message',
+	 *        'rule' => 'message'
+	 *    ]
+	 *
+	 * @param string      $field
+	 * @param string|null $label
+	 * @param string      $rules
+	 * @param array       $errors
+	 *
+	 * @return $this
+	 */
+	public function setRule(string $field, string $label = null, string $rules, array $errors = [])
+	{
+		$this->rules[$field] = [
+			'label' => $label,
+			'rules' => $rules,
+		];
+
+		$this->customErrors = array_merge($this->customErrors, [
+			$field => $errors,
+		]);
+
+		return $this;
+	}
+
+	/**
+	 * Stores the rules that should be used to validate the items.
+	 * Rules should be an array formatted like:
+	 *
+	 *    [
+	 *        'field' => 'rule1|rule2'
+	 *    ]
+	 *
+	 * The $errors array should be formatted like:
+	 *    [
+	 *        'field' => [
+	 *            'rule' => 'message',
+	 *            'rule' => 'message
+	 *        ],
+	 *    ]
+	 *
+	 * @param array $rules
+	 * @param array $errors // An array of custom error messages
+	 *
+	 * @return ValidationInterface
+	 */
+	public function setRules(array $rules, array $errors = []): ValidationInterface
+	{
+		$this->customErrors = $errors;
+
+		foreach ($rules as $field => &$rule)
+		{
+			if (! is_array($rule))
+			{
+				continue;
+			}
+
+			if (! array_key_exists('errors', $rule))
+			{
+				continue;
+			}
+
+			$this->customErrors[$field] = $rule['errors'];
+			unset($rule['errors']);
+		}
+
+		$this->rules = $rules;
+
+		return $this;
+	}
+
+	/**
+	 * Returns all of the rules currently defined.
+	 *
+	 * @return array
+	 */
+	public function getRules(): array
+	{
+		return $this->rules;
+	}
+
+	/**
+	 * Checks to see if the rule for key $field has been set or not.
+	 *
+	 * @param string $field
+	 *
+	 * @return boolean
+	 */
+	public function hasRule(string $field): bool
+	{
+		return array_key_exists($field, $this->rules);
+	}
+
+	/**
+	 * Get rule group.
+	 *
+	 * @param string $group Group.
+	 *
+	 * @return string[] Rule group.
+	 *
+	 * @throws InvalidArgumentException If group not found.
+	 */
+	public function getRuleGroup(string $group): array
+	{
+		if (! isset($this->config->$group))
+		{
+			throw ValidationException::forGroupNotFound($group);
+		}
+
+		if (! is_array($this->config->$group))
+		{
+			throw ValidationException::forGroupNotArray($group);
+		}
+
+		return $this->config->$group;
+	}
+
+	/**
+	 * Set rule group.
+	 *
+	 * @param string $group Group.
+	 *
+	 * @throws InvalidArgumentException If group not found.
+	 */
+	public function setRuleGroup(string $group)
+	{
+		$rules = $this->getRuleGroup($group);
+		$this->setRules($rules);
+
+		$errorName = $group . '_errors';
+		if (isset($this->config->$errorName))
+		{
+			$this->customErrors = $this->config->$errorName;
+		}
+	}
+
+	/**
+	 * Returns the rendered HTML of the errors as defined in $template.
+	 *
+	 * @param string $template
+	 *
+	 * @return string
+	 */
+	public function listErrors(string $template = 'list'): string
+	{
+		if (! array_key_exists($template, $this->config->templates))
+		{
+			throw ValidationException::forInvalidTemplate($template);
+		}
+
+		return $this->view
+			->setVar('errors', $this->getErrors())
+			->render($this->config->templates[$template]);
+	}
+
+	/**
+	 * Displays a single error in formatted HTML as defined in the $template view.
+	 *
+	 * @param string $field
+	 * @param string $template
+	 *
+	 * @return string
+	 */
+	public function showError(string $field, string $template = 'single'): string
+	{
+		if (! array_key_exists($field, $this->getErrors()))
+		{
+			return '';
+		}
+
+		if (! array_key_exists($template, $this->config->templates))
+		{
+			throw ValidationException::forInvalidTemplate($template);
+		}
+
+		return $this->view
+			->setVar('error', $this->getError($field))
+			->render($this->config->templates[$template]);
+	}
+
+	/**
+	 * Loads all of the rulesets classes that have been defined in the
+	 * Config\Validation and stores them locally so we can use them.
+	 */
+	protected function loadRuleSets()
+	{
+		if (empty($this->ruleSetFiles))
+		{
+			throw ValidationException::forNoRuleSets();
+		}
+
+		foreach ($this->ruleSetFiles as $file)
+		{
+			$this->ruleSetInstances[] = new $file();
+		}
+	}
+
+	/**
+	 * Loads custom rule groups (if set) into the current rules.
+	 *
+	 * Rules can be pre-defined in Config\Validation and can
+	 * be any name, but must all still be an array of the
+	 * same format used with setRules(). Additionally, check
+	 * for {group}_errors for an array of custom error messages.
+	 *
+	 * @param string|null $group
+	 *
+	 * @return array|ValidationException|null
+	 */
+	public function loadRuleGroup(string $group = null)
+	{
+		if (empty($group))
+		{
+			return null;
+		}
+
+		if (! isset($this->config->$group))
+		{
+			throw ValidationException::forGroupNotFound($group);
+		}
+
+		if (! is_array($this->config->$group))
+		{
+			throw ValidationException::forGroupNotArray($group);
+		}
+
+		$this->setRules($this->config->$group);
+
+		// If {group}_errors exists in the config file,
+		// then override our custom errors with them.
+		$errorName = $group . '_errors';
+
+		if (isset($this->config->$errorName))
+		{
+			$this->customErrors = $this->config->$errorName;
+		}
+
+		return $this->rules;
+	}
+
+	/**
+	 * Replace any placeholders within the rules with the values that
+	 * match the 'key' of any properties being set. For example, if
+	 * we had the following $data array:
+	 *
+	 * [ 'id' => 13 ]
+	 *
+	 * and the following rule:
+	 *
+	 *  'required|is_unique[users,email,id,{id}]'
+	 *
+	 * The value of {id} would be replaced with the actual id in the form data:
+	 *
+	 *  'required|is_unique[users,email,id,13]'
+	 *
+	 * @param array $rules
+	 * @param array $data
+	 *
+	 * @return array
+	 */
+	protected function fillPlaceholders(array $rules, array $data): array
+	{
+		$replacements = [];
+
+		foreach ($data as $key => $value)
+		{
+			$replacements["{{$key}}"] = $value;
+		}
+
+		if (! empty($replacements))
+		{
+			foreach ($rules as &$rule)
+			{
+				if (is_array($rule))
+				{
+					foreach ($rule as &$row)
+					{
+						// Should only be an `errors` array
+						// which doesn't take placeholders.
+						if (is_array($row))
+						{
+							continue;
+						}
+
+						$row = strtr($row, $replacements);
+					}
+					continue;
+				}
+
+				$rule = strtr($rule, $replacements);
+			}
+		}
+
+		return $rules;
+	}
+
+	/**
+	 * Checks to see if an error exists for the given field.
+	 *
+	 * @param string $field
+	 *
+	 * @return boolean
+	 */
+	public function hasError(string $field): bool
+	{
+		return array_key_exists($field, $this->getErrors());
+	}
+
+	/**
+	 * Returns the error(s) for a specified $field (or empty string if not
+	 * set).
+	 *
+	 * @param string $field Field.
+	 *
+	 * @return string Error(s).
+	 */
+	public function getError(string $field = null): string
+	{
+		if ($field === null && count($this->rules) === 1)
+		{
+			$field = array_key_first($this->rules);
+		}
+
+		return array_key_exists($field, $this->getErrors()) ? $this->errors[$field] : '';
+	}
+
+	/**
+	 * Returns the array of errors that were encountered during
+	 * a run() call. The array should be in the following format:
+	 *
+	 *    [
+	 *        'field1' => 'error message',
+	 *        'field2' => 'error message',
+	 *    ]
+	 *
+	 * @return array<string,string>
+	 *
+	 * Excluded from code coverage because that it always run as cli
+	 *
+	 * @codeCoverageIgnore
+	 */
+	public function getErrors(): array
+	{
+		// If we already have errors, we'll use those.
+		// If we don't, check the session to see if any were
+		// passed along from a redirect_with_input request.
+		if (empty($this->errors) && ! is_cli() && isset($_SESSION, $_SESSION['_ci_validation_errors']))
+		{
+			$this->errors = unserialize($_SESSION['_ci_validation_errors']);
+		}
+
+		return $this->errors ?? [];
+	}
+
+	/**
+	 * Sets the error for a specific field. Used by custom validation methods.
+	 *
+	 * @param string $field
+	 * @param string $error
+	 *
+	 * @return ValidationInterface
+	 */
+	public function setError(string $field, string $error): ValidationInterface
+	{
+		$this->errors[$field] = $error;
+
+		return $this;
+	}
+
+	/**
+	 * Attempts to find the appropriate error message
+	 *
+	 * @param string      $rule
+	 * @param string      $field
+	 * @param string|null $label
+	 * @param string      $param
+	 * @param string      $value The value that caused the validation to fail.
+	 *
+	 * @return string
+	 */
+	protected function getErrorMessage(string $rule, string $field, string $label = null, string $param = null, string $value = null): string
+	{
+		// Check if custom message has been defined by user
+		if (isset($this->customErrors[$field][$rule]))
+		{
+			$message = lang($this->customErrors[$field][$rule]);
+		}
+		else
+		{
+			// Try to grab a localized version of the message...
+			// lang() will return the rule name back if not found,
+			// so there will always be a string being returned.
+			$message = lang('Validation.' . $rule);
+		}
+
+		$message = str_replace('{field}', empty($label) ? $field : lang($label), $message);
+		$message = str_replace('{param}', empty($this->rules[$param]['label']) ? $param : lang($this->rules[$param]['label']), $message);
+
+		return str_replace('{value}', $value, $message);
+	}
+
+	/**
+	 * Split rules string by pipe operator.
+	 *
+	 * @param string $rules
+	 *
+	 * @return array
+	 */
+	protected function splitRules(string $rules): array
+	{
+		$nonEscapeBracket = '((?<!\\\\)(?:\\\\\\\\)*[\[\]])';
+		$pipeNotInBracket = sprintf(
+			'/\|(?=(?:[^\[\]]*%s[^\[\]]*%s)*(?![^\[\]]*%s))/',
+			$nonEscapeBracket,
+			$nonEscapeBracket,
+			$nonEscapeBracket
+		);
+
+		$_rules = preg_split($pipeNotInBracket, $rules);
+
+		return array_unique($_rules);
+	}
+
+	// Misc
+	/**
+	 * Resets the class to a blank slate. Should be called whenever
+	 * you need to process more than one array.
+	 *
+	 * @return ValidationInterface
+	 */
+	public function reset(): ValidationInterface
+	{
+		$this->data         = [];
+		$this->rules        = [];
+		$this->errors       = [];
+		$this->customErrors = [];
+
+		return $this;
+	}
+}

system/Validation/ValidationInterface.php

@@ -0,0 +1,137 @@
+<?php
+
+/**
+ * This file is part of the CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Validation;
+
+use CodeIgniter\HTTP\RequestInterface;
+
+/**
+ * Expected behavior of a validator
+ */
+interface ValidationInterface
+{
+	/**
+	 * Runs the validation process, returning true/false determining whether
+	 * or not validation was successful.
+	 *
+	 * @param array  $data  The array of data to validate.
+	 * @param string $group The pre-defined group of rules to apply.
+	 *
+	 * @return boolean
+	 */
+	public function run(array $data = null, string $group = null): bool;
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Check; runs the validation process, returning true or false
+	 * determining whether or not validation was successful.
+	 *
+	 * @param mixed    $value  Value to validation.
+	 * @param string   $rule   Rule.
+	 * @param string[] $errors Errors.
+	 *
+	 * @return boolean True if valid, else false.
+	 */
+	public function check($value, string $rule, array $errors = []): bool;
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Takes a Request object and grabs the input data to use from its
+	 * array values.
+	 *
+	 * @param RequestInterface $request
+	 *
+	 * @return ValidationInterface
+	 */
+	public function withRequest(RequestInterface $request): ValidationInterface;
+
+	//--------------------------------------------------------------------
+	// Rules
+	//--------------------------------------------------------------------
+
+	/**
+	 * Stores the rules that should be used to validate the items.
+	 *
+	 * @param array $rules
+	 * @param array $messages
+	 *
+	 * @return ValidationInterface
+	 */
+	public function setRules(array $rules, array $messages = []): ValidationInterface;
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks to see if the rule for key $field has been set or not.
+	 *
+	 * @param string $field
+	 *
+	 * @return boolean
+	 */
+	public function hasRule(string $field): bool;
+
+	//--------------------------------------------------------------------
+	//--------------------------------------------------------------------
+	// Errors
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns the error for a specified $field (or empty string if not set).
+	 *
+	 * @param string $field
+	 *
+	 * @return string
+	 */
+	public function getError(string $field): string;
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns the array of errors that were encountered during
+	 * a run() call. The array should be in the following format:
+	 *
+	 *    [
+	 *        'field1' => 'error message',
+	 *        'field2' => 'error message',
+	 *    ]
+	 *
+	 * @return array<string,string>
+	 */
+	public function getErrors(): array;
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sets the error for a specific field. Used by custom validation methods.
+	 *
+	 * @param string $alias
+	 * @param string $error
+	 *
+	 * @return ValidationInterface
+	 */
+	public function setError(string $alias, string $error): ValidationInterface;
+
+	//--------------------------------------------------------------------
+	// Misc
+	//--------------------------------------------------------------------
+
+	/**
+	 * Resets the class to a blank slate. Should be called whenever
+	 * you need to process more than one array.
+	 *
+	 * @return ValidationInterface
+	 */
+	public function reset(): ValidationInterface;
+
+	//--------------------------------------------------------------------
+}

system/Validation/Views/list.php

@@ -0,0 +1,9 @@
+<?php if (! empty($errors)) : ?>
+	<div class="errors" role="alert">
+		<ul>
+		<?php foreach ($errors as $error) : ?>
+			<li><?= esc($error) ?></li>
+		<?php endforeach ?>
+		</ul>
+	</div>
+<?php endif ?>

system/Validation/Views/single.php

@@ -0,0 +1 @@
+<span class="help-block"><?= esc($error) ?></span>