validation example

    function validation_errors()
    {
        session();

        // Check the session to see if any were         // passed along from a redirect withErrors() request.         if (isset($_SESSION['_ci_validation_errors']) && (ENVIRONMENT === 'testing' || ! is_cli())) {
            return $_SESSION['_ci_validation_errors'];
        }

        $validation = Services::validation();

        return $validation->getErrors();
    }
}

if (! function_exists('validation_list_errors')) {
    /** * Returns the rendered HTML of the validation errors. * * See Validation::listErrors() */
    

/** * Sets validation errors in the session. * * If the validation has any errors, transmit those back * so they can be displayed when the validation is handled * within a method different than displaying the form. * * @return $this */
    private function withErrors(): self
    {
        $validation = Services::validation();

        if ($validation->getErrors()) {
            $session = Services::session();
            $session->setFlashdata('_ci_validation_errors', $validation->getErrors());
        }

        return $this;
    }

    /** * Adds a key and message to the session as Flashdata. * * @param array|string $message * * @return $this */

    protected function fillPlaceholders(array $rules, array $data): array
    {
        foreach ($rules as &$rule) {
            $ruleSet = $rule['rules'];

            foreach ($ruleSet as &$row) {
                if (is_string($row)) {
                    $placeholderFields = $this->retrievePlaceholders($row, $data);

                    foreach ($placeholderFields as $field) {
                        $validator ??= Services::validation(null, false);
                        assert($validator instanceof Validation);

                        $placeholderRules = $rules[$field]['rules'] ?? null;

                        // Check if the validation rule for the placeholder exists                         if ($placeholderRules === null) {
                            throw new LogicException(
                                'No validation rules for the placeholder: ' . $field
                            );
                        }

                        

protected bool $allowEmptyInserts = false;

    public function __construct(?ValidationInterface $validation = null)
    {
        $this->tempReturnType     = $this->returnType;
        $this->tempUseSoftDeletes = $this->useSoftDeletes;
        $this->tempAllowCallbacks = $this->allowCallbacks;

        /** * @var ValidationInterface|null $validation */
        $validation ??= Services::validation(null, false);
        $this->validation = $validation;

        $this->initialize();
    }

    /** * Initializes the instance with any additional steps. * Optionally implemented by child classes. * * @return void */
    

$routes->setHTTPVerb($method);

        // Make sure any other classes that might call the request         // instance get the right one.         Services::injectMock('request', $request);

        // Make sure filters are reset between tests         Services::injectMock('filters', Services::filters(null, false));

        // Make sure validation is reset between tests         Services::injectMock('validation', Services::validation(null, false));

        $response = $this->app
            ->setContext('web')
            ->setRequest($request)
            ->run($routes, true);

        // Reset directory if it has been set         Services::router()->setDirectory(null);

        return new TestResponse($response);
    }

    

        $this->setValidator($rules, $messages);

        return $this->validator->run($data, null, $dbGroup);
    }

    /** * @param array|string $rules */
    private function setValidator($rules, array $messages): void
    {
        $this->validator = Services::validation();

        // If you replace the $rules array with the name of the group         if (is_string($rules)) {
            $validation = config(Validation::class);

            // If the rule wasn't found in the \Config\Validation, we             // should throw an exception so the developer can find it.             if (! isset($validation->{$rules})) {
                throw ValidationException::forRuleNotFound($rules);
            }

            

final class HealthTest extends CIUnitTestCase
{
    public function testIsDefinedAppPath()
    {
        $this->assertTrue(defined('APPPATH'));
    }

    public function testBaseUrlHasBeenSet()
    {
        $validation = Services::validation();

        $env = false;

        // Check the baseURL in .env         if (is_file(HOMEPATH . '.env')) {
            $env = preg_grep('/^app\.baseURL = ./', file(HOMEPATH . '.env')) !== false;
        }

        if ($env) {
            // BaseURL in .env is a valid URL?             // phpunit.xml.dist sets app.baseURL in $_SERVER

    protected static function validate(string $field, string $value, $rules): bool
    {
        $label      = $field;
        $field      = 'temp';
        $validation = Services::validation(null, false);
        $validation->setRules([
            $field => [
                'label' => $label,
                'rules' => $rules,
            ],
        ]);
        $validation->run([$field => $value]);

        if ($validation->hasError($field)) {
            static::error($validation->getError($field));

            

    /** * Sets an expression to run for the validation. * * The expression receives the value of the node and must return it. It can * modify it. * An exception should be thrown when the node is not valid. */
    public function validate(): ExprBuilder
    {
        return $this->validation()->rule();
    }

    /** * Sets whether the node can be overwritten. * * @return $this */
    public function cannotBeOverwritten(bool $deny = true): static
    {
        $this->merge()->denyOverwrite($deny);

        

        $line = array_shift($params);

        return lang($line, $params);
    }

    /** * Wrap helper function to use as view plugin. */
    public static function ValidationErrors(array $params = []): string
    {
        $validator = Services::validation();
        if (empty($params)) {
            return $validator->listErrors();
        }

        return $validator->showError($params['field']);
    }

    /** * Wrap helper function to use as view plugin. * * @return false|string */