FormFieldController::canProcessInput() - Code Metrics - Inspection of "added some missing return types" - spider-mane/saveyour - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 4c5faf...429320 )

by Chris

created 2020-08-23 09:21 UTC

FormFieldController::canProcessInput() A

↳ Parent: FormFieldController

Complexity

Conditions	2
Paths	2

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	1
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	2
rs	10

<?php

namespace WebTheory\Saveyour\Controllers;

use Psr\Http\Message\ServerRequestInterface;
use WebTheory\Saveyour\Contracts\DataFormatterInterface;
use WebTheory\Saveyour\Contracts\FieldDataManagerInterface;
use WebTheory\Saveyour\Contracts\FieldOperationCacheInterface;
use WebTheory\Saveyour\Contracts\FormFieldControllerInterface;
use WebTheory\Saveyour\Contracts\FormFieldInterface;
use WebTheory\Saveyour\InputPurifier;
use WebTheory\Saveyour\Request;
use WebTheory\Saveyour\Formatters\LazyFormatter;

class FormFieldController extends InputPurifier implements FormFieldControllerInterface
{
    /**
     * @var string
     */
    protected $requestVar;

    /**
     * formField
     *
     * @var FormFieldInterface
     */
    protected $formField;

    /**
     * dataManager
     *
     * @var FieldDataManagerInterface
     */
    protected $dataManager;

    /**
     * @var DataFormatterInterface
     */
    protected $formatter;

    /**
     * Callback to escape value on display
     *
     * @var callable|null
     */
    protected $escaper = 'htmlspecialchars';

    /**
     * @var bool
     */
    protected $processingDisabled = false;

    /**
     * @var string[]
     */
    protected $mustAwait = [];

    /**
     *
     */
    public const LAZY_ESCAPE = [self::class, 'lazyEscaper'];

    /**
     *
     */
    public function __construct(
        string $requestVar,
        ?FormFieldInterface $formField = null,
        ?FieldDataManagerInterface $dataManager = null,
        ?DataFormatterInterface $formatter = null,
        ?array $filters = null,
        ?array $rules = null,
        ?callable $escaper = null,
        ?bool $processingDisabled = null,
        ?array $await = null
    ) {
        $this->requestVar = $requestVar;

        $formField && $this->formField = $formField;
        $dataManager && $this->dataManager = $dataManager;
        $processingDisabled && $this->processingDisabled = $processingDisabled;
        $escaper && $this->escaper = $escaper;

        $this->formatter = $formatter ?? new LazyFormatter();

        $filters && $this->setFilters(...$filters);
        $rules && $this->setRules($rules);
        $await && $this->setMustAwait(...$await);
    }

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

    /**
     * Get formField
     *
     * @return FormFieldInterface|null
     */
    public function getFormField(): ?FormFieldInterface
    {
        return $this->formField;
    }

    /**
     * Get dataManager
     *
     * @return FieldDataManagerInterface|null
     */
    public function getDataManager(): ?FieldDataManagerInterface
    {
        return $this->dataManager;
    }

    /**
     * Get the value of formatter
     *
     * @return DataFormatterInterface|null
     */
    public function getFormatter(): ?DataFormatterInterface
    {
        return $this->formatter;
    }

    /**
     * Get callback to escape value on display
     *
     * @return callable|null
     */
    public function getEscaper(): ?callable
    {
        return $this->escaper;
    }

    /**
     * Get hasDataManager
     *
     * @return bool
     */
    public function hasDataManager(): bool
    {
        return isset($this->dataManager);
    }

    /**
     * Get the value of mustAwait
     *
     * @return string[]
     */
    public function mustAwait(): array
    {
        return $this->mustAwait;
    }

    /**
     * Set the value of mustAwait
     *
     * @param string[] $mustAwait
     *
     * @return self
     */
    protected function setMustAwait(string ...$fields)
    {
        $this->mustAwait = $fields;

        return $this;
    }

    /**
     * Get the value of savingDisabled
     *
     * @return bool
     */
    public function isProcessingDisabled(): bool
    {
        return $this->processingDisabled;
    }

    /**
     * {@inheritDoc}
     */
    public function process(ServerRequestInterface $request): FieldOperationCacheInterface
    {
        $results = new FieldOperationCacheBuilder();
        $this->processData($request, $results);
        $results->withRuleViolations($this->getViolations());
        $this->clearViolations();

        return $results;
    }

    /**
     *
     */
    protected function processData(ServerRequestInterface $request, FieldOperationCacheBuilder $results)
    {
        $filteredInput = $this->getSanitizedInput($request);

        $results->withSanitizedInputValue($filteredInput);

        if (false !== $filteredInput && $this->canProcessInput()) {

            $updated = $this->processInput($request, $filteredInput);

            $results->withUpdateAttempted(true)->withUpdateSuccessful($updated);
        }

        return $this;
    }

    /**
     *
     */
    protected function processInput(ServerRequestInterface $request, $input): bool
    {
        return $this->dataManager->handleSubmittedData($request, $this->formatInput($input));
    }

    /**
     *
     */
    public function getPresetValue(ServerRequestInterface $request)
    {
        $data = $this->hasDataManager() ? $this->dataManager->getCurrentData($request) : '';

        return $this->escapeValue($this->formatData($data));
    }

    /**
     *
     */
    public function requestVarExists(ServerRequestInterface $request): bool
    {
        return Request::has($request, $this->requestVar);
    }

    /**
     *
     */
    protected function getRawInput(ServerRequestInterface $request)
    {
        return Request::var($request, $this->requestVar);
    }

    /**
     *
     */
    public function getSanitizedInput(ServerRequestInterface $request)
    {
        return $this->filterInput($this->getRawInput($request));
    }

    /**
     *
     */
    public function canProcessInput(): bool
    {
        return $this->hasDataManager() && !$this->isProcessingDisabled();
    }

    /**
     *
     */
    protected function formatData($data)
    {
        return $this->formatter->formatData($data);
    }

    /**
     *
     */
    protected function formatInput($input)
    {
        return $this->formatter->formatInput($input);
    }

    /**
     *
     */
    protected function escapeValue($value)
    {
        if (!isset($this->escaper)) {
            return $value;
        }

        return !is_array($value)
            ? call_user_func($this->escaper, $value)
            : array_filter($value, $this->escaper);
    }

    /**
     *
     */
    protected function setFormFieldName()
    {
        $this->formField->setName($this->getRequestVar());

        return $this;
    }

    /**
     *
     */
    public function setFormFieldValue(ServerRequestInterface $request)
    {
        $this->formField->setValue($this->getPresetValue($request));

        return $this;
    }

    /**
     *
     */
    public function render(ServerRequestInterface $request): ?FormFieldInterface
    {
        return $this->prepareFormFieldForRendering($request)->getFormField();
    }

    /**
     *
     */
    protected function prepareFormFieldForRendering(ServerRequestInterface $request)
    {
        return $this->setFormFieldName()->setFormFieldValue($request);
    }

    /**
     *
     */
    protected static function lazyEscaper($value)
    {
        return $value;
    }
}


1		<?php
2
3		namespace WebTheory\Saveyour\Controllers;
4
5		use Psr\Http\Message\ServerRequestInterface;
6		use WebTheory\Saveyour\Contracts\DataFormatterInterface;
7		use WebTheory\Saveyour\Contracts\FieldDataManagerInterface;
8		use WebTheory\Saveyour\Contracts\FieldOperationCacheInterface;
9		use WebTheory\Saveyour\Contracts\FormFieldControllerInterface;
10		use WebTheory\Saveyour\Contracts\FormFieldInterface;
11		use WebTheory\Saveyour\InputPurifier;
12		use WebTheory\Saveyour\Request;
13		use WebTheory\Saveyour\Formatters\LazyFormatter;
14
15		class FormFieldController extends InputPurifier implements FormFieldControllerInterface
16		{
17		/**
18		* @var string
19		*/
20		protected $requestVar;
21
22		/**
23		* formField
24		*
25		* @var FormFieldInterface
26		*/
27		protected $formField;
28
29		/**
30		* dataManager
31		*
32		* @var FieldDataManagerInterface
33		*/
34		protected $dataManager;
35
36		/**
37		* @var DataFormatterInterface
38		*/
39		protected $formatter;
40
41		/**
42		* Callback to escape value on display
43		*
44		* @var callable\|null
45		*/
46		protected $escaper = 'htmlspecialchars';
47
48		/**
49		* @var bool
50		*/
51		protected $processingDisabled = false;
52
53		/**
54		* @var string[]
55		*/
56		protected $mustAwait = [];
57
58		/**
59		*
60		*/
61		public const LAZY_ESCAPE = [self::class, 'lazyEscaper'];
62
63		/**
64		*
65		*/
66	57	public function __construct(
67		string $requestVar,
68		?FormFieldInterface $formField = null,
69		?FieldDataManagerInterface $dataManager = null,
70		?DataFormatterInterface $formatter = null,
71		?array $filters = null,
72		?array $rules = null,
73		?callable $escaper = null,
74		?bool $processingDisabled = null,
75		?array $await = null
76		) {
77	57	$this->requestVar = $requestVar;
78
79	57	$formField && $this->formField = $formField;
80	57	$dataManager && $this->dataManager = $dataManager;
81	57	$processingDisabled && $this->processingDisabled = $processingDisabled;
82	57	$escaper && $this->escaper = $escaper;
83
84	57	$this->formatter = $formatter ?? new LazyFormatter();
85
86	57	$filters && $this->setFilters(...$filters);
87	57	$rules && $this->setRules($rules);
88	57	$await && $this->setMustAwait(...$await);
89	57	}
90
91		/**
92		* Get the value of requestVar
93		*
94		* @return string
95		*/
96	21	public function getRequestVar(): string
97		{
98	21	return $this->requestVar;
99		}
100
101		/**
102		* Get formField
103		*
104		* @return FormFieldInterface\|null
105		*/
106	9	public function getFormField(): ?FormFieldInterface
107		{
108	9	return $this->formField;
109		}
110
111		/**
112		* Get dataManager
113		*
114		* @return FieldDataManagerInterface\|null
115		*/
116	3	public function getDataManager(): ?FieldDataManagerInterface
117		{
118	3	return $this->dataManager;
119		}
120
121		/**
122		* Get the value of formatter
123		*
124		* @return DataFormatterInterface\|null
125		*/
126	3	public function getFormatter(): ?DataFormatterInterface
127		{
128	3	return $this->formatter;
129		}
130
131		/**
132		* Get callback to escape value on display
133		*
134		* @return callable\|null
135		*/
136	3	public function getEscaper(): ?callable
137		{
138	3	return $this->escaper;
139		}
140
141		/**
142		* Get hasDataManager
143		*
144		* @return bool
145		*/
146	21	public function hasDataManager(): bool
147		{
148	21	return isset($this->dataManager);
149		}
150
151		/**
152		* Get the value of mustAwait
153		*
154		* @return string[]
155		*/
156	6	public function mustAwait(): array
157		{
158	6	return $this->mustAwait;
159		}
160
161		/**
162		* Set the value of mustAwait
163		*
164		* @param string[] $mustAwait
165		*
166		* @return self
167		*/
168	3	protected function setMustAwait(string ...$fields)
169		{
170	3	$this->mustAwait = $fields;
171
172	3	return $this;
173		}
174
175		/**
176		* Get the value of savingDisabled
177		*
178		* @return bool
179		*/
180	9	public function isProcessingDisabled(): bool
181		{
182	9	return $this->processingDisabled;
183		}
184
185		/**
186		* {@inheritDoc}
187		*/
188	15	public function process(ServerRequestInterface $request): FieldOperationCacheInterface
189		{
190	15	$results = new FieldOperationCacheBuilder();
191	15	$this->processData($request, $results);
192	15	$results->withRuleViolations($this->getViolations());
193	15	$this->clearViolations();
194
195	15	return $results;
196		}
197
198		/**
199		*
200		*/
201	15	protected function processData(ServerRequestInterface $request, FieldOperationCacheBuilder $results)
202		{
203	15	$filteredInput = $this->getSanitizedInput($request);
204
205	15	$results->withSanitizedInputValue($filteredInput);
206
207	15	if (false !== $filteredInput && $this->canProcessInput()) {
208
209	6	$updated = $this->processInput($request, $filteredInput);
210
211	6	$results->withUpdateAttempted(true)->withUpdateSuccessful($updated);
212		}
213
214	15	return $this;
215		}
216
217		/**
218		*
219		*/
220	6	protected function processInput(ServerRequestInterface $request, $input): bool
221		{
222	6	return $this->dataManager->handleSubmittedData($request, $this->formatInput($input));
223		}
224
225		/**
226		*
227		*/
228	6	public function getPresetValue(ServerRequestInterface $request)
229		{
230	6	$data = $this->hasDataManager() ? $this->dataManager->getCurrentData($request) : '';
231
232	6	return $this->escapeValue($this->formatData($data));
233		}
234
235		/**
236		*
237		*/
238		public function requestVarExists(ServerRequestInterface $request): bool
239		{
240		return Request::has($request, $this->requestVar);
241		}
242
243		/**
244		*
245		*/
246	15	protected function getRawInput(ServerRequestInterface $request)
247		{
248	15	return Request::var($request, $this->requestVar);
249		}
250
251		/**
252		*
253		*/
254	15	public function getSanitizedInput(ServerRequestInterface $request)
255		{
256	15	return $this->filterInput($this->getRawInput($request));
257		}
258
259		/**
260		*
261		*/
262	12	public function canProcessInput(): bool
263		{
264	12	return $this->hasDataManager() && !$this->isProcessingDisabled();
265		}
266
267		/**
268		*
269		*/
270	6	protected function formatData($data)
271		{
272	6	return $this->formatter->formatData($data);
273		}
274
275		/**
276		*
277		*/
278	6	protected function formatInput($input)
279		{
280	6	return $this->formatter->formatInput($input);
281		}
282
283		/**
284		*
285		*/
286	6	protected function escapeValue($value)
287		{
288	6	if (!isset($this->escaper)) {
289		return $value;
290		}
291
292	6	return !is_array($value)
293	6	? call_user_func($this->escaper, $value)
294	6	: array_filter($value, $this->escaper);
295		}
296
297		/**
298		*
299		*/
300	6	protected function setFormFieldName()
301		{
302	6	$this->formField->setName($this->getRequestVar());
303
304	6	return $this;
305		}
306
307		/**
308		*
309		*/
310	6	public function setFormFieldValue(ServerRequestInterface $request)
311		{
312	6	$this->formField->setValue($this->getPresetValue($request));
313
314	6	return $this;
315		}
316
317		/**
318		*
319		*/
320	6	public function render(ServerRequestInterface $request): ?FormFieldInterface
321		{
322	6	return $this->prepareFormFieldForRendering($request)->getFormField();
323		}
324
325		/**
326		*
327		*/
328	6	protected function prepareFormFieldForRendering(ServerRequestInterface $request)
329		{
330	6	return $this->setFormFieldName()->setFormFieldValue($request);
331		}
332
333		/**
334		*
335		*/
336	3	protected static function lazyEscaper($value)
337		{
338	3	return $value;
339		}
340		}
341

spider-mane / saveyour

Push — master ( 4c5faf...429320 )

FormFieldController::canProcessInput() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like