Field::addValidator() - Code Metrics - jmversteeg/fieldwork - Measure and Improve Code Quality continuously with Scrutinizer

Field::addValidator() A
last analyzed 2016-05-22 21:49 UTC

↳ Parent: Field

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	9
rs	9.6666
cc	2
eloc	7
nc	2
nop	2

<?php

namespace fieldwork\components;

use fieldwork\Form;
use fieldwork\methods\Method;
use fieldwork\sanitizers\FieldSanitizer;
use fieldwork\validators\FieldValidator;

abstract class Field extends Component
{

    protected
        $label,
        $visible = true,
        $enabled = true,
        $restored = false,
        $value,
        $initialValue,
        $latestErrorMsg = "",
        $forceInvalid = false,
        $validators = array(),
        $sanitizers = array(),
        $collectData = true,
        $storeValueLocally;

    /**
     * Creates a new form field component
     *
     * @param string          $slug              internal slug to use
     * @param string          $label             label to display
     * @param string|string[] $value             initial value
     * @param int             $storeValueLocally how long to store last used value in cookie (set to 0 for no cookie)
     */
    public function __construct ($slug, $label = '', $value = '', $storeValueLocally = 0)
    {
        parent::__construct($slug);
        $this->label             = $label;
        $this->initialValue      = $this->value = $value;
        $this->storeValueLocally = $storeValueLocally;
    }

    public function reset ()
    {
        $this->value = $this->initialValue;
        parent::reset();
    }

    public function setCollectData ($collectData)
    {
        $this->collectData = $collectData;
    }

    public function getCollectData ()
    {
        return $this->collectData;
    }

    /**
     * Treats the value that was fetched from the request variables. If the control uses a non-scalar to represent its
     * value, it should be instantiated here
     * @param string $value
     * @return string
     */
    public function importValue ($value)
    {
        return stripslashes($value);
    }

    /**
     * Restores the value from the provided method
     * @param Method $method
     * @param bool   $sanitize Whether to sanitize the fetched value
     */
    public function restoreValue (Method $method, $sanitize = true)
    {
        $v = $method->getValue($this->getName(), $this->getRestoreDefault());
        if ($this->isMultiple() && is_array($v)) {
            foreach ($v as &$value)
                $value = $this->importValue($value);
        } else {
            $v = $this->importValue($v);
        }
        if ($sanitize)
            foreach ($this->sanitizers as $s)
                /* @var $s FieldSanitizer */
                $v = $s->sanitize($v);
        $this->value    = $v;
        $this->restored = true;
    }

    /**
     * Condenses multiple values (e.g. from a multiple select box) into a single string
     *
     * @param string[] $values
     *
     * @return string
     */
    public function condenseMultiple ($values = [])
    {
        return implode(',', $values);
    }

    /**
     * Extracts multiple values from a single string
     *
     * @param string $value
     *
     * @return string[]
     */
    public function extractMultiple ($value)
    {
        return explode(',', $value);
    }

    /**
     * Determines whether this field allows selection of multiple values
     * @return bool
     */
    public function isMultiple ()
    {
        return false;
    }

    public function submit ()
    {
        if ($this->storeValueLocally)
            setcookie($this->getCookieName(), $this->value, time() + $this->storeValueLocally, '/');
    }

    public function preprocess ()
    {
        if ($this->storeValueLocally && isset($_COOKIE[$this->getCookieName()]))
            $this->value = $_COOKIE[$this->getCookieName()];
    }

    private function getCookieName ()
    {
        return $this->getGlobalSlug() . '-vc';
    }

    /**
     * Gets the value of the name attribute for this field
     *
     * @param bool $asMarkup Whether to retrieve the value used in the markup (if true, [] will by default be appended
     *                       to fields that allow multiple values)
     *
     * @return string
     */
    public function getName ($asMarkup = false)
    {
        return $this->getGlobalSlug() . (($this->isMultiple() && $asMarkup) ? '[]' : '');
    }

    public function getLabel ()
    {
        return $this->label;
    }

    /**
     * Whether to condense multiple values into a single string
     *
     * @param bool $condense
     *
     * @return string|string[]
     */
    public function getValue ($condense = true)
    {
        $v = $this->value;
        if ($condense && $this->isMultiple() && is_array($v))
            $v = $this->condenseMultiple($v);
        return $v;
    }

    public function setValue ($value)
    {
        $this->value = $value;
        return $this;
    }

    /**
     * Sets whether the component is visible
     *
     * @param boolean $visible
     *
     * @return $this
     */
    public function setVisible ($visible = true)
    {
        $this->visible = $visible;
        return $this;
    }

    /**
     * Checks whether the component is visible
     * @return boolean
     */
    public function isVisible ()
    {
        return $this->visible;
    }

    /**
     * @return array
     */
    public function getJsonData ()
    {
        $v = array();
        $s = array();
        foreach ($this->validators as $validator)
            /* @var $validator FieldValidator */
            array_push($v, $validator->getJsonData());
        foreach ($this->sanitizers as $sanitizer)
            /* @var $sanitizer FieldSanitizer */
            $s[] = $sanitizer->getJsonData();
        $valid = $this->restored ? $this->isValid() : true;
        return array(
            'valid'       => $valid,
            'error'       => $this->latestErrorMsg,
            'validators'  => $v,
            'sanitizers'  => $s,
            'id'          => $this->getID(),
            'name'        => $this->getName(),
            'collectData' => $this->collectData
        );
    }

    public function getId ()
    {
        return "field-" . $this->getGlobalSlug();
    }

    public function getAttributes ()
    {
        $attributes = array(
            "name"  => $this->getName(true),
            "value" => $this->getValue(),
            "id"    => $this->getId()
        );
        if (!$this->enabled)
            $attributes['disabled'] = 'disabled';
        return array_merge(parent::getAttributes(), $attributes);
    }

    public function getClasses ()
    {
        $form = $this->getRoot();
        /* @var $form Form */
        $formClass = ($form instanceof Form) && $form->isRequested() ? ($this->isValid() ? "valid" : "invalid") : "";
        return array_merge(parent::getClasses(), array(
            "fieldwork-field",
            $formClass
        ));
    }

    /**
     * Adds validator
     *
     * @param FieldValidator $v
     * @param boolean        $unshift Whether to add the validator to the front of the array
     *
     * @return Field
     */
    public function addValidator (FieldValidator $v, $unshift = false)
    {
        if ($unshift)
            array_unshift($this->validators, $v);
        else
            $this->validators[] = $v;
        $v->setField($this);
        return $this;
    }

    /**
     * Adds sanitizer
     *
     * @param FieldSanitizer $s
     *
     * @return Field
     */
    public function addSanitizer (FieldSanitizer $s)
    {
        $this->sanitizers[] = $s;
        return $this;
    }

    public function forceInvalid ()
    {
        $this->forceInvalid = true;
    }

    public function isValid ()
    {
        // TODO cache
        if ($this->forceInvalid)
            return false;
        foreach ($this->validators as $validator) {
            /* @var $validator FieldValidator */
            if (!$validator->isValid($this->value)) {
                $this->latestErrorMsg = $validator->getErrorMsg();
                return false;
            } else if ($validator->skipValidation($this->value)) {
                return true;
            }
        }
        return true;
    }

    public function sanitize ()
    {
        foreach ($this->sanitizers as $sanitizer)
            /* @var $sanitizer FieldSanitizer */
            $this->value = $sanitizer->sanitize($this->value);
    }

    public function getLatestErrorMsg ()
    {
        return $this->latestErrorMsg;
    }

    /**
     * Returns the default value used if the POST var is not set
     * @return string
     */
    protected function getRestoreDefault ()
    {
        return $this->value;
    }

    /**
     * Sets whether the control is enabled
     * @param boolean $enabled
     * @return $this
     */
    public function setEnabled ($enabled)
    {
        $this->enabled = $enabled;
        return $this;
    }

    /**
     * Gets the script that will instantiate ONLY this field in an anonymous form
     * @return string
     */
    public function getScript ()
    {
        return "jQuery(function($){ $('#" . $this->getID() . "').fieldwork(" . json_encode($this->getJsonData(), JSON_PRETTY_PRINT) . "); });";
    }

    /**
     * Gets the script tag that will instantiate ONLY this field in an anonymous form
     * @return string
     */
    public function getScriptHTML ()
    {
        $openingTag = "<script type='text/javascript'>";
        $closingTag = "</script>";
        return $openingTag . $this->getScript() . $closingTag;
    }
}


1			<?php
2
3			namespace fieldwork\components;
4
5			use fieldwork\Form;
6			use fieldwork\methods\Method;
7			use fieldwork\sanitizers\FieldSanitizer;
8			use fieldwork\validators\FieldValidator;
9
10			abstract class Field extends Component
11			{
12
13			protected
14			$label,
15			$visible = true,
16			$enabled = true,
17			$restored = false,
18			$value,
19			$initialValue,
20			$latestErrorMsg = "",
21			$forceInvalid = false,
22			$validators = array(),
23			$sanitizers = array(),
24			$collectData = true,
25			$storeValueLocally;
26
27			/**
28			* Creates a new form field component
29			*
30			* @param string $slug internal slug to use
31			* @param string $label label to display
32			* @param string\|string[] $value initial value
33			* @param int $storeValueLocally how long to store last used value in cookie (set to 0 for no cookie)
34			*/
35			public function __construct ($slug, $label = '', $value = '', $storeValueLocally = 0)
36			{
37			parent::__construct($slug);
38			$this->label = $label;
39			$this->initialValue = $this->value = $value;
40			$this->storeValueLocally = $storeValueLocally;
41			}
42
43			public function reset ()
44			{
45			$this->value = $this->initialValue;
46			parent::reset();
47			}
48
49			public function setCollectData ($collectData)
50			{
51			$this->collectData = $collectData;
52			}
53
54			public function getCollectData ()
55			{
56			return $this->collectData;
57			}
58
59			/**
60			* Treats the value that was fetched from the request variables. If the control uses a non-scalar to represent its
61			* value, it should be instantiated here
62			* @param string $value
63			* @return string
64			*/
65			public function importValue ($value)
66			{
67			return stripslashes($value);
68			}
69
70			/**
71			* Restores the value from the provided method
72			* @param Method $method
73			* @param bool $sanitize Whether to sanitize the fetched value
74			*/
75			public function restoreValue (Method $method, $sanitize = true)
76			{
77			$v = $method->getValue($this->getName(), $this->getRestoreDefault());
78			if ($this->isMultiple() && is_array($v)) {
79			foreach ($v as &$value)
80			$value = $this->importValue($value);
81			} else {
82			$v = $this->importValue($v);
83			}
84			if ($sanitize)
85			foreach ($this->sanitizers as $s)
86			/* @var $s FieldSanitizer */
87			$v = $s->sanitize($v);
88			$this->value = $v;
89			$this->restored = true;
90			}
91
92			/**
93			* Condenses multiple values (e.g. from a multiple select box) into a single string
94			*
95			* @param string[] $values
96			*
97			* @return string
98			*/
99			public function condenseMultiple ($values = [])
100			{
101			return implode(',', $values);
102			}
103
104			/**
105			* Extracts multiple values from a single string
106			*
107			* @param string $value
108			*
109			* @return string[]
110			*/
111			public function extractMultiple ($value)
112			{
113			return explode(',', $value);
114			}
115
116			/**
117			* Determines whether this field allows selection of multiple values
118			* @return bool
119			*/
120			public function isMultiple ()
121			{
122			return false;
123			}
124
125			public function submit ()
126			{
127			if ($this->storeValueLocally)
128			setcookie($this->getCookieName(), $this->value, time() + $this->storeValueLocally, '/');
129			}
130
131			public function preprocess ()
132			{
133			if ($this->storeValueLocally && isset($_COOKIE[$this->getCookieName()]))
134			$this->value = $_COOKIE[$this->getCookieName()];
135			}
136
137			private function getCookieName ()
138			{
139			return $this->getGlobalSlug() . '-vc';
140			}
141
142			/**
143			* Gets the value of the name attribute for this field
144			*
145			* @param bool $asMarkup Whether to retrieve the value used in the markup (if true, [] will by default be appended
146			* to fields that allow multiple values)
147			*
148			* @return string
149			*/
150			public function getName ($asMarkup = false)
151			{
152			return $this->getGlobalSlug() . (($this->isMultiple() && $asMarkup) ? '[]' : '');
153			}
154
155			public function getLabel ()
156			{
157			return $this->label;
158			}
159
160			/**
161			* Whether to condense multiple values into a single string
162			*
163			* @param bool $condense
164			*
165			* @return string\|string[]
166			*/
167			public function getValue ($condense = true)
168			{
169			$v = $this->value;
170			if ($condense && $this->isMultiple() && is_array($v))
171			$v = $this->condenseMultiple($v);
172			return $v;
173			}
174
175			public function setValue ($value)
176			{
177			$this->value = $value;
178			return $this;
179			}
180
181			/**
182			* Sets whether the component is visible
183			*
184			* @param boolean $visible
185			*
186			* @return $this
187			*/
188			public function setVisible ($visible = true)
189			{
190			$this->visible = $visible;
191			return $this;
192			}
193
194			/**
195			* Checks whether the component is visible
196			* @return boolean
197			*/
198			public function isVisible ()
199			{
200			return $this->visible;
201			}
202
203			/**
204			* @return array
205			*/
206			public function getJsonData ()
207			{
208			$v = array();
209			$s = array();
210			foreach ($this->validators as $validator)
211			/* @var $validator FieldValidator */
212			array_push($v, $validator->getJsonData());
213			foreach ($this->sanitizers as $sanitizer)
214			/* @var $sanitizer FieldSanitizer */
215			$s[] = $sanitizer->getJsonData();
216			$valid = $this->restored ? $this->isValid() : true;
217			return array(
218			'valid' => $valid,
219			'error' => $this->latestErrorMsg,
220			'validators' => $v,
221			'sanitizers' => $s,
222			'id' => $this->getID(),
223			'name' => $this->getName(),
224			'collectData' => $this->collectData
225			);
226			}
227
228			public function getId ()
229			{
230			return "field-" . $this->getGlobalSlug();
231			}
232
233			public function getAttributes ()
234			{
235			$attributes = array(
236			"name" => $this->getName(true),
237			"value" => $this->getValue(),
238			"id" => $this->getId()
239			);
240			if (!$this->enabled)
241			$attributes['disabled'] = 'disabled';
242			return array_merge(parent::getAttributes(), $attributes);
243			}
244
245			public function getClasses ()
246			{
247			$form = $this->getRoot();
248			/* @var $form Form */
249			$formClass = ($form instanceof Form) && $form->isRequested() ? ($this->isValid() ? "valid" : "invalid") : "";
250			return array_merge(parent::getClasses(), array(
251			"fieldwork-field",
252			$formClass
253			));
254			}
255
256			/**
257			* Adds validator
258			*
259			* @param FieldValidator $v
260			* @param boolean $unshift Whether to add the validator to the front of the array
261			*
262			* @return Field
263			*/
264			public function addValidator (FieldValidator $v, $unshift = false)
265			{
266			if ($unshift)
267			array_unshift($this->validators, $v);
268			else
269			$this->validators[] = $v;
270			$v->setField($this);
271			return $this;
272			}
273
274			/**
275			* Adds sanitizer
276			*
277			* @param FieldSanitizer $s
278			*
279			* @return Field
280			*/
281			public function addSanitizer (FieldSanitizer $s)
282			{
283			$this->sanitizers[] = $s;
284			return $this;
285			}
286
287			public function forceInvalid ()
288			{
289			$this->forceInvalid = true;
290			}
291
292			public function isValid ()
293			{
294			// TODO cache
295			if ($this->forceInvalid)
296			return false;
297			foreach ($this->validators as $validator) {
298			/* @var $validator FieldValidator */
299			if (!$validator->isValid($this->value)) {
300			$this->latestErrorMsg = $validator->getErrorMsg();
301			return false;
302			} else if ($validator->skipValidation($this->value)) {
303			return true;
304			}
305			}
306			return true;
307			}
308
309			public function sanitize ()
310			{
311			foreach ($this->sanitizers as $sanitizer)
312			/* @var $sanitizer FieldSanitizer */
313			$this->value = $sanitizer->sanitize($this->value);
314			}
315
316			public function getLatestErrorMsg ()
317			{
318			return $this->latestErrorMsg;
319			}
320
321			/**
322			* Returns the default value used if the POST var is not set
323			* @return string
324			*/
325			protected function getRestoreDefault ()
326			{
327			return $this->value;
328			}
329
330			/**
331			* Sets whether the control is enabled
332			* @param boolean $enabled
333			* @return $this
334			*/
335			public function setEnabled ($enabled)
336			{
337			$this->enabled = $enabled;
338			return $this;
339			}
340
341			/**
342			* Gets the script that will instantiate ONLY this field in an anonymous form
343			* @return string
344			*/
345			public function getScript ()
346			{
347			return "jQuery(function($){ $('#" . $this->getID() . "').fieldwork(" . json_encode($this->getJsonData(), JSON_PRETTY_PRINT) . "); });";
348			}
349
350			/**
351			* Gets the script tag that will instantiate ONLY this field in an anonymous form
352			* @return string
353			*/
354			public function getScriptHTML ()
355			{
356			$openingTag = "<script type='text/javascript'>";
357			$closingTag = "</script>";
358			return $openingTag . $this->getScript() . $closingTag;
359			}
360			}
361

jmversteeg / fieldwork

Field::addValidator() A last analyzed 2016-05-22 21:49 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Field::addValidator() A
last analyzed 2016-05-22 21:49 UTC