ClassViewHelper::getPropertyResultClass() - Code Metrics - Inspection of "[FEATURE] Introduce TYPO3 8.6 support" - romm/formz - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — development (#44)

by Romain

created 2017-02-15 13:24 UTC

ClassViewHelper::getPropertyResultClass() B

↳ Parent: Project

Complexity

Conditions	5
Paths	5

Size

Total Lines	19
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	19
rs	8.8571
cc	5
eloc	12
nc	5
nop	1

<?php
/*
 * 2017 Romain CANON <[email protected]>
 *
 * This file is part of the TYPO3 Formz project.
 * It is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either
 * version 3 of the License, or any later version.
 *
 * For the full copyright and license information, see:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

namespace Romm\Formz\ViewHelpers;

use Romm\Formz\Configuration\View\Classes\ViewClass;
use Romm\Formz\Exceptions\EntryNotFoundException;
use Romm\Formz\Exceptions\InvalidEntryException;
use Romm\Formz\Exceptions\UnregisteredConfigurationException;
use Romm\Formz\ViewHelpers\Service\FieldService;
use Romm\Formz\ViewHelpers\Service\FormService;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Error\Result;
use TYPO3\CMS\Extbase\Reflection\ObjectAccess;

/**
 * This view helper is used to manage the properties set in TypoScript at the
 * path `config.tx_formz.view.classes`.
 *
 * Two groups of classes are handled: `errors` and `valid`. The classes will be
 * "activated" only when the field has been validated, and the result matches
 * the class group.
 *
 * In the option `name`, you must indicate which class from which group you want
 * to manage, for example `errors.has-error` for the class `has-error` from the
 * group `errors`.
 *
 * If the field currently being rendered with Fluid is not using the view helper
 * `FieldViewHelper` (all its skeleton is written manually), you may have to use
 * the option `field`, which should then contain the name of the field.
 *
 * Please be aware that this view helper is useful only when used at the same
 * level or under the HTML element containing the field selector (usually the
 * one with the data attribute `formz-field-container`). You may encounter
 * strange behaviours if you do not respect this requirement.
 */
class ClassViewHelper extends AbstractViewHelper
{
    const CLASS_ERRORS = 'errors';
    const CLASS_VALID = 'valid';

    /**
     * @var array
     */
    protected static $acceptedClassesNameSpace = [self::CLASS_ERRORS, self::CLASS_VALID];

    /**
     * @var FormService
     */
    protected $formService;

    /**
     * @var FieldService
     */
    protected $fieldService;

    /**
     * @var string
     */
    protected $fieldName;

    /**
     * @var string
     */
    protected $classValue;

    /**
     * @var string
     */
    protected $classNameSpace;

    /**
     * @var string
     */
    protected $className;

    /**
     * @inheritdoc
     */
    public function initializeArguments()
    {
        $this->registerArgument('name', 'string', 'Name of the class which will be managed.', true);
        $this->registerArgument('field', 'string', 'Name of the field which will be managed. By default, it is the field from the current `FieldViewHelper`.');
    }

    /**
     * @inheritdoc
     */
    public function render()
    {
        $this->initializeClassNames();
        $this->initializeClassValue();
        $this->initializeFieldName();

        $result = vsprintf(
            'formz-%s-%s',
            [
                $this->classNameSpace,
                str_replace(' ', '-', $this->classValue)
            ]
        );

        $result .= $this->getFormResultClass();

        return $result;
    }

    /**
     * Will initialize the namespace and name of the class which is given as
     * argument to this ViewHelper.
     *
     * @throws InvalidEntryException
     */
    protected function initializeClassNames()
    {
        list($this->classNameSpace, $this->className) = GeneralUtility::trimExplode('.', $this->arguments['name']);

        if (false === in_array($this->classNameSpace, self::$acceptedClassesNameSpace)) {
            throw new InvalidEntryException(
                'The class "' . $this->arguments['name'] . '" is not valid: the namespace of the error must be one of the following: ' . implode(', ', self::$acceptedClassesNameSpace) . '.',
                1467623504
            );
        }
    }

    /**
     * Fetches the name of the field which should refer to this class. It can
     * either be a given value, or be empty if the ViewHelper is used inside a
     * `FieldViewHelper`.
     *
     * @throws EntryNotFoundException
     */
    protected function initializeFieldName()
    {
        $this->fieldName = $this->arguments['field'];

        if (empty($this->fieldName)
            && $this->fieldService->fieldContextExists()
        ) {
            $this->fieldName = $this->fieldService
                ->getCurrentField()
                ->getFieldName();
        }

        if (null === $this->fieldName) {
            throw new EntryNotFoundException(
                'The field could not be fetched for the class "' . $this->arguments['name'] . '": please either use this view helper inside the view helper "' . FieldViewHelper::class . '", or fill the parameter "field" of this view helper with the field name you want.',
                1467623761
            );
        }
    }

    /**
     * Fetches the corresponding value of this class, which was defined in
     * TypoScript.
     *
     * @throws UnregisteredConfigurationException
     */
    protected function initializeClassValue()
    {
        $classesConfiguration = $this->formService
            ->getFormObject()
            ->getConfiguration()
            ->getFormzConfiguration()
            ->getView()
            ->getClasses();

        /** @var ViewClass $class */
        $class = ObjectAccess::getProperty($classesConfiguration, $this->classNameSpace);

        if (false === $class->hasItem($this->className)) {
            throw new UnregisteredConfigurationException(
                'The class "' . $this->arguments['name'] . '" is not valid: the class name "' . $this->className . '" was not found in the namespace "' . $this->classNameSpace . '".',
                1467623662
            );
        }

        $this->classValue = $class->getItem($this->className);
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
    }

    /**
     * Checks if the form was submitted, then parses its result to handle
     * classes depending on TypoScript configuration.
     *
     * @return string
     */
    protected function getFormResultClass()
    {
        $formResult = $this->formService->getFormResult();
        $propertyResult = ($formResult)
            ? $formResult->forProperty($this->fieldName)
            : null;

        return ($this->formService->formWasSubmitted() && null !== $propertyResult)
            ? $this->getPropertyResultClass($propertyResult)
            : '';
    }

    /**
     * @param Result $propertyResult
     * @return string
     */
    protected function getPropertyResultClass(Result $propertyResult)
    {
        $result = '';

        switch ($this->classNameSpace) {
            case self::CLASS_ERRORS:
                if (true === $propertyResult->hasErrors()) {
                    $result .= ' ' . $this->classValue;
                }
                break;
            case self::CLASS_VALID:
                if (false === $propertyResult->hasErrors()) {
                    $result .= ' ' . $this->classValue;
                }
                break;
        }

        return $result;
    }

    /**
     * @param FormService $service
     */
    public function injectFormService(FormService $service)
    {
        $this->formService = $service;
    }

    /**
     * @param FieldService $service
     */
    public function injectFieldService(FieldService $service)
    {
        $this->fieldService = $service;
    }
}


1			<?php
2			/*
3			* 2017 Romain CANON <[email protected]>
4			*
5			* This file is part of the TYPO3 Formz project.
6			* It is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU General Public License, either
8			* version 3 of the License, or any later version.
9			*
10			* For the full copyright and license information, see:
11			* http://www.gnu.org/licenses/gpl-3.0.html
12			*/
13
14			namespace Romm\Formz\ViewHelpers;
15
16			use Romm\Formz\Configuration\View\Classes\ViewClass;
17			use Romm\Formz\Exceptions\EntryNotFoundException;
18			use Romm\Formz\Exceptions\InvalidEntryException;
19			use Romm\Formz\Exceptions\UnregisteredConfigurationException;
20			use Romm\Formz\ViewHelpers\Service\FieldService;
21			use Romm\Formz\ViewHelpers\Service\FormService;
22			use TYPO3\CMS\Core\Utility\GeneralUtility;
23			use TYPO3\CMS\Extbase\Error\Result;
24			use TYPO3\CMS\Extbase\Reflection\ObjectAccess;
25
26			/**
27			* This view helper is used to manage the properties set in TypoScript at the
28			* path `config.tx_formz.view.classes`.
29			*
30			* Two groups of classes are handled: `errors` and `valid`. The classes will be
31			* "activated" only when the field has been validated, and the result matches
32			* the class group.
33			*
34			* In the option `name`, you must indicate which class from which group you want
35			* to manage, for example `errors.has-error` for the class `has-error` from the
36			* group `errors`.
37			*
38			* If the field currently being rendered with Fluid is not using the view helper
39			* `FieldViewHelper` (all its skeleton is written manually), you may have to use
40			* the option `field`, which should then contain the name of the field.
41			*
42			* Please be aware that this view helper is useful only when used at the same
43			* level or under the HTML element containing the field selector (usually the
44			* one with the data attribute `formz-field-container`). You may encounter
45			* strange behaviours if you do not respect this requirement.
46			*/
47			class ClassViewHelper extends AbstractViewHelper
48			{
49			const CLASS_ERRORS = 'errors';
50			const CLASS_VALID = 'valid';
51
52			/**
53			* @var array
54			*/
55			protected static $acceptedClassesNameSpace = [self::CLASS_ERRORS, self::CLASS_VALID];
56
57			/**
58			* @var FormService
59			*/
60			protected $formService;
61
62			/**
63			* @var FieldService
64			*/
65			protected $fieldService;
66
67			/**
68			* @var string
69			*/
70			protected $fieldName;
71
72			/**
73			* @var string
74			*/
75			protected $classValue;
76
77			/**
78			* @var string
79			*/
80			protected $classNameSpace;
81
82			/**
83			* @var string
84			*/
85			protected $className;
86
87			/**
88			* @inheritdoc
89			*/
90			public function initializeArguments()
91			{
92			$this->registerArgument('name', 'string', 'Name of the class which will be managed.', true);
93			$this->registerArgument('field', 'string', 'Name of the field which will be managed. By default, it is the field from the current `FieldViewHelper`.');
94			}
95
96			/**
97			* @inheritdoc
98			*/
99			public function render()
100			{
101			$this->initializeClassNames();
102			$this->initializeClassValue();
103			$this->initializeFieldName();
104
105			$result = vsprintf(
106			'formz-%s-%s',
107			[
108			$this->classNameSpace,
109			str_replace(' ', '-', $this->classValue)
110			]
111			);
112
113			$result .= $this->getFormResultClass();
114
115			return $result;
116			}
117
118			/**
119			* Will initialize the namespace and name of the class which is given as
120			* argument to this ViewHelper.
121			*
122			* @throws InvalidEntryException
123			*/
124			protected function initializeClassNames()
125			{
126			list($this->classNameSpace, $this->className) = GeneralUtility::trimExplode('.', $this->arguments['name']);
127
128			if (false === in_array($this->classNameSpace, self::$acceptedClassesNameSpace)) {
129			throw new InvalidEntryException(
130			'The class "' . $this->arguments['name'] . '" is not valid: the namespace of the error must be one of the following: ' . implode(', ', self::$acceptedClassesNameSpace) . '.',
131			1467623504
132			);
133			}
134			}
135
136			/**
137			* Fetches the name of the field which should refer to this class. It can
138			* either be a given value, or be empty if the ViewHelper is used inside a
139			* `FieldViewHelper`.
140			*
141			* @throws EntryNotFoundException
142			*/
143			protected function initializeFieldName()
144			{
145			$this->fieldName = $this->arguments['field'];
146
147			if (empty($this->fieldName)
148			&& $this->fieldService->fieldContextExists()
149			) {
150			$this->fieldName = $this->fieldService
151			->getCurrentField()
152			->getFieldName();
153			}
154
155			if (null === $this->fieldName) {
156			throw new EntryNotFoundException(
157			'The field could not be fetched for the class "' . $this->arguments['name'] . '": please either use this view helper inside the view helper "' . FieldViewHelper::class . '", or fill the parameter "field" of this view helper with the field name you want.',
158			1467623761
159			);
160			}
161			}
162
163			/**
164			* Fetches the corresponding value of this class, which was defined in
165			* TypoScript.
166			*
167			* @throws UnregisteredConfigurationException
168			*/
169			protected function initializeClassValue()
170			{
171			$classesConfiguration = $this->formService
172			->getFormObject()
173			->getConfiguration()
174			->getFormzConfiguration()
175			->getView()
176			->getClasses();
177
178			/** @var ViewClass $class */
179			$class = ObjectAccess::getProperty($classesConfiguration, $this->classNameSpace);
180
181			if (false === $class->hasItem($this->className)) {
182			throw new UnregisteredConfigurationException(
183			'The class "' . $this->arguments['name'] . '" is not valid: the class name "' . $this->className . '" was not found in the namespace "' . $this->classNameSpace . '".',
184			1467623662
185			);
186			}
187
188			$this->classValue = $class->getItem($this->className);
			0 ignored issues – show Documentation Bug introduced 2016-12-25 09:54 UTC by Report Bug Copy Issue Report It seems like `$class->getItem($this->className)` can also be of type `array`. However, the property `$classValue` is declared as type `string`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
189			}
190
191			/**
192			* Checks if the form was submitted, then parses its result to handle
193			* classes depending on TypoScript configuration.
194			*
195			* @return string
196			*/
197			protected function getFormResultClass()
198			{
199			$formResult = $this->formService->getFormResult();
200			$propertyResult = ($formResult)
201			? $formResult->forProperty($this->fieldName)
202			: null;
203
204			return ($this->formService->formWasSubmitted() && null !== $propertyResult)
205			? $this->getPropertyResultClass($propertyResult)
206			: '';
207			}
208
209			/**
210			* @param Result $propertyResult
211			* @return string
212			*/
213			protected function getPropertyResultClass(Result $propertyResult)
214			{
215			$result = '';
216
217			switch ($this->classNameSpace) {
218			case self::CLASS_ERRORS:
219			if (true === $propertyResult->hasErrors()) {
220			$result .= ' ' . $this->classValue;
221			}
222			break;
223			case self::CLASS_VALID:
224			if (false === $propertyResult->hasErrors()) {
225			$result .= ' ' . $this->classValue;
226			}
227			break;
228			}
229
230			return $result;
231			}
232
233			/**
234			* @param FormService $service
235			*/
236			public function injectFormService(FormService $service)
237			{
238			$this->formService = $service;
239			}
240
241			/**
242			* @param FieldService $service
243			*/
244			public function injectFieldService(FieldService $service)
245			{
246			$this->fieldService = $service;
247			}
248			}
249

romm / formz

Pull Request — development (#44)

ClassViewHelper::getPropertyResultClass() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like