WebTheory\Saveyour\Controller\Abstracts\AbstractField

Complexity

Total Complexity

21

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Test Coverage

Coverage

65.38%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	defineMustAwait()	0	3	1
A	inspect()	0	3	1
A	compose()	0	3	1
A	validate()	0	3	1
A	getUpdatedValue()	0	3	1
A	defineDataFormatter()	0	3	1
A	mustAwait()	0	3	1
A	getPresetValue()	0	3	1
A	defineRequestVar()	0	3	1
A	getRequestVar()	0	3	1
A	requestVarPresent()	0	3	1
A	defineFormField()	0	3	1
A	defineValidator()	0	3	1
A	isPermittedToProcess()	0	3	1
A	definePermissionProcessStatus()	0	3	1
A	process()	0	3	1
A	render()	0	3	1
A	defineDataManager()	0	3	1
A	__construct()	0	7	1
A	createFormFieldController()	0	10	1
A	getFormField()	0	3	1

<?php

namespace WebTheory\Saveyour\Controller\Abstracts;

use Psr\Http\Message\ServerRequestInterface;
use WebTheory\Saveyour\Contracts\Controller\FormFieldControllerInterface;
use WebTheory\Saveyour\Contracts\Data\FieldDataManagerInterface;
use WebTheory\Saveyour\Contracts\Field\FormFieldInterface;
use WebTheory\Saveyour\Contracts\Formatting\DataFormatterInterface;
use WebTheory\Saveyour\Contracts\Report\ProcessedFieldReportInterface;
use WebTheory\Saveyour\Contracts\Report\ValidationReportInterface;
use WebTheory\Saveyour\Controller\FormFieldController;
use WebTheory\Saveyour\Validation\Validator;

abstract class AbstractField implements FormFieldControllerInterface
{
    /**
     * @var string
     */
    protected string $__requestVar;

    /**
     * @var bool
     */
    protected bool $__isPermittedToProcess = true;

    /**
     * @var array<int,string>
     */
    protected array $__mustAwait = [];

    protected FormFieldControllerInterface $__coreController;

    public function __construct(string $requestVar, array $mustAwait = [], $processingEnabled = true)
    {
        $this->__requestVar = $requestVar;
        $this->__mustAwait = $mustAwait;
        $this->__isPermittedToProcess = $processingEnabled;

        $this->__coreController = $this->createFormFieldController();
    }

    /**
     * Get the value of requestVar
     *
     * @return string
     */
    public function getRequestVar(): string
    {
        return $this->__coreController->getRequestVar();
    }

    public function getFormField(): ?FormFieldInterface
    {
        return $this->__coreController->getFormField();
    }

    public function requestVarPresent(ServerRequestInterface $request): bool
    {
        return $this->__coreController->requestVarPresent($request);
    }

    public function inspect($value): ValidationReportInterface
    {
        return $this->__coreController->inspect($value);
    }

    public function validate($value): bool
    {
        return $this->__coreController->validate($value);
    }

    public function getPresetValue(ServerRequestInterface $request)
    {
        return $this->__coreController->getPresetValue($request);
    }

    public function getUpdatedValue(ServerRequestInterface $request): ?array
    {
        return $this->__coreController->getUpdatedValue($request);
    }

    public function mustAwait(): array
    {
        return $this->__coreController->mustAwait();
    }

    public function render(ServerRequestInterface $request): string
    {
        return $this->__coreController->render($request);
    }

    public function compose(ServerRequestInterface $request): FormFieldInterface
    {
        return $this->__coreController->compose($request);
    }

    public function isPermittedToProcess(): bool
    {
        return $this->__coreController->isPermittedToProcess();
    }

    public function process(ServerRequestInterface $request): ProcessedFieldReportInterface
    {
        return $this->__coreController->process($request);
    }

    protected function createFormFieldController(): FormFieldControllerInterface
    {
        return new FormFieldController(
            $this->defineRequestVar(),
            $this->defineFormField(),

Are you sure the usage of $this->defineFormField() targeting WebTheory\Saveyour\Controller\Abstracts\AbstractField::defineFormField() seems to always return null.

            $this->defineDataManager(),

Are you sure the usage of $this->defineDataManager() targeting WebTheory\Saveyour\Controller\Abstracts\AbstractField::defineDataManager() seems to always return null.

            $this->defineValidator(),

Are you sure the usage of $this->defineValidator() targeting WebTheory\Saveyour\Controller\Abstracts\AbstractField::defineValidator() seems to always return null.

            $this->defineDataFormatter(),

Are you sure the usage of $this->defineDataFormatter() targeting WebTheory\Saveyour\Controller\Abstracts\AbstractField::defineDataFormatter() seems to always return null.

            $this->definePermissionProcessStatus(),
            $this->defineMustAwait(),
        );
    }

    protected function defineRequestVar(): string
    {
        return $this->__requestVar;
    }

    protected function defineFormField(): ?FormFieldInterface
    {
        return null;
    }

    protected function defineDataManager(): ?FieldDataManagerInterface
    {
        return null;
    }

    protected function defineDataFormatter(): ?DataFormatterInterface
    {
        return null;
    }

    protected function defineValidator(): ?Validator
    {
        return null;
    }

    protected function definePermissionProcessStatus(): ?bool
    {
        return $this->__isPermittedToProcess;
    }

    protected function defineMustAwait(): ?array
    {
        return $this->__mustAwait;
    }
}