BaseField::title() - Code Metrics - Inspection of "minor fixes for compliancy" - OriHoch/tableschema-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 53f2a7...4c5c4c )

by Ori

created 2017-07-13 12:43 UTC

BaseField::title() A

↳ Parent: BaseField

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	2
nc	2
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php

namespace frictionlessdata\tableschema\Fields;

use frictionlessdata\tableschema\Exceptions\FieldValidationException;
use frictionlessdata\tableschema\SchemaValidationError;

abstract class BaseField
{
    public function __construct($descriptor = null)
    {
        $this->descriptor = empty($descriptor) ? (object) [] : $descriptor;
    }

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

    public function fullDescriptor()
    {
        $fullDescriptor = $this->descriptor();
        $fullDescriptor->format = $this->format();
        $fullDescriptor->type = $this->type();

        return $fullDescriptor;
    }

    public function name()
    {
        return $this->descriptor()->name;
    }

    public function title()
    {
        return isset($this->descriptor()->title) ? $this->descriptor()->title : null;
    }

    public function description()
    {
        return isset($this->descriptor()->description) ? $this->descriptor()->description : null;
    }

    public function rdfType()
    {
        return isset($this->descriptor()->rdfType) ? $this->descriptor()->rdfType : null;
    }

    public function format()
    {
        return isset($this->descriptor()->format) ? $this->descriptor()->format : 'default';
    }

    public function constraints()
    {
        if (!$this->constraintsDisabled && isset($this->descriptor()->constraints)) {
            return $this->descriptor()->constraints;
        } else {
            return (object) [];
        }
    }

    public function required()
    {
        return isset($this->constraints()->required) && $this->constraints()->required;
    }

    public function unique()
    {
        return isset($this->constraints()->unique) && $this->constraints()->unique;
    }

    public function disableConstraints()
    {
        $this->constraintsDisabled = true;

        return $this;
    }

    public function enum()
    {
        if (isset($this->constraints()->enum) && !empty($this->constraints()->enum)) {
            return $this->constraints()->enum;
        } else {
            return [];
        }
    }

    /**
     * try to create a field object based on the descriptor
     * by default uses the type attribute
     * return the created field object or false if the descriptor does not match this field.
     *
     * @param object $descriptor
     *
     * @return bool|BaseField
     */
    public static function inferDescriptor($descriptor)
    {
        if (isset($descriptor->type) && $descriptor->type == static::type()) {
            return new static($descriptor);
        } else {
            return false;
        }
    }

    /**
     * try to create a new field object based on the given value.
     *
     * @param mixed       $val
     * @param null|object $descriptor
     * @param bool @lenient
     *
     * @return bool|BaseField
     */
    public static function infer($val, $descriptor = null, $lenient = false)
    {
        $field = new static($descriptor);
        try {
            $field->castValue($val);
        } catch (FieldValidationException $e) {
            return false;
        }
        $field->inferProperties($val, $lenient);

        return $field;
    }

    public function inferProperties($val, $lenient)
    {
        // should be implemented by extending classes
        // allows adding / modfiying descriptor properties based on the given value
        $this->descriptor->type = $this->type();
    }

    /**
     * @param mixed $val
     *
     * @return mixed
     *
     * @throws \frictionlessdata\tableschema\Exceptions\FieldValidationException;
     */
    final public function castValue($val)
    {
        if ($this->isEmptyValue($val)) {
            if ($this->required()) {
                throw $this->getValidationException('field is required', $val);
            }

            return null;
        } else {
            $val = $this->validateCastValue($val);
            if (!$this->constraintsDisabled) {
                $validationErrors = $this->checkConstraints($val);
                if (count($validationErrors) > 0) {
                    throw new FieldValidationException($validationErrors);
                }
            }

            return $val;
        }
    }

    public function validateValue($val)
    {
        try {
            $this->castValue($val);

            return [];
        } catch (FieldValidationException $e) {
            return $e->validationErrors;
        }
    }

    /**
     * get a unique identifier for this field
     * used in the inferring process
     * this is usually the type, but can be modified to support more advanced inferring process.
     *
     * @param bool @lenient
     *
     * @return string
     */
    public function getInferIdentifier($lenient = false)
    {
        return $this->type();
    }

    /**
     * should be implemented by extending classes to return the table schema type of this field.
     *
     * @return string
     */
    public static function type()
    {
        throw new \Exception('must be implemented by extending classes');
    }

    protected $descriptor;
    protected $constraintsDisabled = false;

    protected function getValidationException($errorMsg = null, $val = null)
    {
        return new FieldValidationException([
            new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
                'field' => isset($this->descriptor()->name) ? $this->name() : 'unknown',
                'value' => $val,
                'error' => is_null($errorMsg) ? 'invalid value' : $errorMsg,
            ]),
        ]);
    }

    protected function isEmptyValue($val)
    {
        return is_null($val);
    }

    /**
     * @param mixed $val
     *
     * @return mixed
     *
     * @throws \frictionlessdata\tableschema\Exceptions\FieldValidationException;
     */
    // extending classes should extend this method
    // value is guaranteed not to be an empty value, that is handled elsewhere
    // should raise FieldValidationException on any validation errors
    // can use getValidationException function to get a simple exception with single validation error message
    // you can also throw an exception with multiple validation errors manually
    abstract protected function validateCastValue($val);

    protected function checkConstraints($val)
    {
        $validationErrors = [];
        $allowedValues = $this->getAllowedValues();
        if (!empty($allowedValues) && !$this->checkAllowedValues($allowedValues, $val)) {
            $validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
                'field' => $this->name(),
                'value' => $val,
                'error' => 'value not in enum',
            ]);
        }
        $constraints = $this->constraints();
        if (isset($constraints->pattern)) {

            if (!$this->checkPatternConstraint($val, $constraints->pattern)) {
                $validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
                    'field' => $this->name(),
                    'value' => $val,
                    'error' => 'value does not match pattern',
                ]);
            }
        }
        if (

            isset($constraints->minimum)
            && !$this->checkMinimumConstraint($val, $this->castValueNoConstraints($constraints->minimum))
        ) {
            $validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
                'field' => $this->name(),
                'value' => $val,
                'error' => 'value is below minimum',
            ]);
        }
        if (

            isset($constraints->maximum)
            && !$this->checkMaximumConstraint($val, $this->castValueNoConstraints($constraints->maximum))
        ) {
            $validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
                'field' => $this->name(),
                'value' => $val,
                'error' => 'value is above maximum',
            ]);
        }
        if (

            isset($constraints->minLength) && !$this->checkMinLengthConstraint($val, $constraints->minLength)
        ) {
            $validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
                'field' => $this->name(),
                'value' => $val,
                'error' => 'value is below minimum length',
            ]);
        }
        if (

            isset($constraints->maxLength) && !$this->checkMaxLengthConstraint($val, $constraints->maxLength)
        ) {
            $validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
                'field' => $this->name(),
                'value' => $val,
                'error' => 'value is above maximum length',
            ]);
        }

        return $validationErrors;
    }

    protected function checkPatternConstraint($val, $pattern)
    {
        return preg_match('/^'.$pattern.'$/', $val) === 1;
    }

    protected function checkMinimumConstraint($val, $minConstraint)
    {
        return $val >= $minConstraint;
    }

    protected function checkMaximumConstraint($val, $maxConstraint)
    {
        return $val <= $maxConstraint;
    }

    protected function getLengthForConstraint($val)
    {
        if (is_string($val)) {
            return strlen($val);
        } elseif (is_array($val)) {
            return count($val);
        } elseif (is_object($val)) {
            return count((array) $val);
        } else {
            throw $this->getValidationException('invalid value for length constraint', $val);
        }
    }

    protected function checkMinLengthConstraint($val, $minLength)
    {
        return $this->getLengthForConstraint($val) >= $minLength;
    }

    protected function checkMaxLengthConstraint($val, $maxLength)
    {
        return $this->getLengthForConstraint($val) <= $maxLength;
    }

    protected function getAllowedValues()
    {
        $allowedValues = [];
        foreach ($this->enum() as $val) {
            $allowedValues[] = $this->castValueNoConstraints($val);
        }

        return $allowedValues;
    }

    protected function checkAllowedValues($allowedValues, $val)
    {
        return in_array($val, $allowedValues, !is_object($val));
    }

    protected function castValueNoConstraints($val)
    {
        $this->disableConstraints();
        $val = $this->castValue($val);
        $this->constraintsDisabled = false;

        return $val;
    }
}


1		<?php
2
3		namespace frictionlessdata\tableschema\Fields;
4
5		use frictionlessdata\tableschema\Exceptions\FieldValidationException;
6		use frictionlessdata\tableschema\SchemaValidationError;
7
8		abstract class BaseField
9		{
10		public function __construct($descriptor = null)
11		{
12		$this->descriptor = empty($descriptor) ? (object) [] : $descriptor;
13		}
14
15		public function descriptor()
16		{
17		return $this->descriptor;
18		}
19
20		public function fullDescriptor()
21		{
22		$fullDescriptor = $this->descriptor();
23		$fullDescriptor->format = $this->format();
24		$fullDescriptor->type = $this->type();
25
26		return $fullDescriptor;
27		}
28
29		public function name()
30		{
31		return $this->descriptor()->name;
32		}
33
34		public function title()
35		{
36		return isset($this->descriptor()->title) ? $this->descriptor()->title : null;
37		}
38
39		public function description()
40		{
41		return isset($this->descriptor()->description) ? $this->descriptor()->description : null;
42		}
43
44		public function rdfType()
45		{
46		return isset($this->descriptor()->rdfType) ? $this->descriptor()->rdfType : null;
47		}
48
49		public function format()
50		{
51		return isset($this->descriptor()->format) ? $this->descriptor()->format : 'default';
52		}
53
54		public function constraints()
55		{
56		if (!$this->constraintsDisabled && isset($this->descriptor()->constraints)) {
57		return $this->descriptor()->constraints;
58		} else {
59		return (object) [];
60		}
61		}
62
63		public function required()
64		{
65		return isset($this->constraints()->required) && $this->constraints()->required;
66		}
67
68		public function unique()
69		{
70		return isset($this->constraints()->unique) && $this->constraints()->unique;
71		}
72
73		public function disableConstraints()
74		{
75		$this->constraintsDisabled = true;
76
77		return $this;
78		}
79
80		public function enum()
81		{
82		if (isset($this->constraints()->enum) && !empty($this->constraints()->enum)) {
83		return $this->constraints()->enum;
84		} else {
85		return [];
86		}
87		}
88
89		/**
90		* try to create a field object based on the descriptor
91		* by default uses the type attribute
92		* return the created field object or false if the descriptor does not match this field.
93		*
94		* @param object $descriptor
95		*
96		* @return bool\|BaseField
97		*/
98		public static function inferDescriptor($descriptor)
99		{
100		if (isset($descriptor->type) && $descriptor->type == static::type()) {
101		return new static($descriptor);
102		} else {
103		return false;
104		}
105		}
106
107		/**
108		* try to create a new field object based on the given value.
109		*
110		* @param mixed $val
111		* @param null\|object $descriptor
112		* @param bool @lenient
113		*
114		* @return bool\|BaseField
115		*/
116		public static function infer($val, $descriptor = null, $lenient = false)
117		{
118		$field = new static($descriptor);
119		try {
120		$field->castValue($val);
121		} catch (FieldValidationException $e) {
122		return false;
123		}
124		$field->inferProperties($val, $lenient);
125
126		return $field;
127		}
128
129		public function inferProperties($val, $lenient)
130		{
131		// should be implemented by extending classes
132		// allows adding / modfiying descriptor properties based on the given value
133		$this->descriptor->type = $this->type();
134		}
135
136		/**
137		* @param mixed $val
138		*
139		* @return mixed
140		*
141		* @throws \frictionlessdata\tableschema\Exceptions\FieldValidationException;
142		*/
143		final public function castValue($val)
144		{
145		if ($this->isEmptyValue($val)) {
146		if ($this->required()) {
147		throw $this->getValidationException('field is required', $val);
148		}
149
150		return null;
151		} else {
152		$val = $this->validateCastValue($val);
153		if (!$this->constraintsDisabled) {
154		$validationErrors = $this->checkConstraints($val);
155		if (count($validationErrors) > 0) {
156		throw new FieldValidationException($validationErrors);
157		}
158		}
159
160		return $val;
161		}
162		}
163
164		public function validateValue($val)
165		{
166		try {
167		$this->castValue($val);
168
169		return [];
170		} catch (FieldValidationException $e) {
171		return $e->validationErrors;
172		}
173		}
174
175		/**
176		* get a unique identifier for this field
177		* used in the inferring process
178		* this is usually the type, but can be modified to support more advanced inferring process.
179		*
180		* @param bool @lenient
181		*
182		* @return string
183		*/
184		public function getInferIdentifier($lenient = false)
185		{
186		return $this->type();
187		}
188
189		/**
190		* should be implemented by extending classes to return the table schema type of this field.
191		*
192		* @return string
193		*/
194		public static function type()
195		{
196		throw new \Exception('must be implemented by extending classes');
197		}
198
199		protected $descriptor;
200		protected $constraintsDisabled = false;
201
202		protected function getValidationException($errorMsg = null, $val = null)
203		{
204		return new FieldValidationException([
205		new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
206		'field' => isset($this->descriptor()->name) ? $this->name() : 'unknown',
207		'value' => $val,
208		'error' => is_null($errorMsg) ? 'invalid value' : $errorMsg,
209		]),
210		]);
211		}
212
213		protected function isEmptyValue($val)
214		{
215		return is_null($val);
216		}
217
218		/**
219		* @param mixed $val
220		*
221		* @return mixed
222		*
223		* @throws \frictionlessdata\tableschema\Exceptions\FieldValidationException;
224		*/
225		// extending classes should extend this method
226		// value is guaranteed not to be an empty value, that is handled elsewhere
227		// should raise FieldValidationException on any validation errors
228		// can use getValidationException function to get a simple exception with single validation error message
229		// you can also throw an exception with multiple validation errors manually
230		abstract protected function validateCastValue($val);
231
232		protected function checkConstraints($val)
233		{
234		$validationErrors = [];
235		$allowedValues = $this->getAllowedValues();
236		if (!empty($allowedValues) && !$this->checkAllowedValues($allowedValues, $val)) {
237		$validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
238		'field' => $this->name(),
239		'value' => $val,
240		'error' => 'value not in enum',
241		]);
242		}
243		$constraints = $this->constraints();
244	View Code Duplication	if (isset($constraints->pattern)) {
		0 ignored issues – show Duplication introduced 2017-05-04 13:42 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
245		if (!$this->checkPatternConstraint($val, $constraints->pattern)) {
246		$validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
247		'field' => $this->name(),
248		'value' => $val,
249		'error' => 'value does not match pattern',
250		]);
251		}
252		}
253	View Code Duplication	if (
		0 ignored issues – show Duplication introduced 2017-05-04 13:42 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
254		isset($constraints->minimum)
255		&& !$this->checkMinimumConstraint($val, $this->castValueNoConstraints($constraints->minimum))
256		) {
257		$validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
258		'field' => $this->name(),
259		'value' => $val,
260		'error' => 'value is below minimum',
261		]);
262		}
263	View Code Duplication	if (
		0 ignored issues – show Duplication introduced 2017-05-04 13:42 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
264		isset($constraints->maximum)
265		&& !$this->checkMaximumConstraint($val, $this->castValueNoConstraints($constraints->maximum))
266		) {
267		$validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
268		'field' => $this->name(),
269		'value' => $val,
270		'error' => 'value is above maximum',
271		]);
272		}
273	View Code Duplication	if (
		0 ignored issues – show Duplication introduced 2017-05-04 13:42 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
274		isset($constraints->minLength) && !$this->checkMinLengthConstraint($val, $constraints->minLength)
275		) {
276		$validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
277		'field' => $this->name(),
278		'value' => $val,
279		'error' => 'value is below minimum length',
280		]);
281		}
282	View Code Duplication	if (
		0 ignored issues – show Duplication introduced 2017-05-04 13:42 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
283		isset($constraints->maxLength) && !$this->checkMaxLengthConstraint($val, $constraints->maxLength)
284		) {
285		$validationErrors[] = new SchemaValidationError(SchemaValidationError::FIELD_VALIDATION, [
286		'field' => $this->name(),
287		'value' => $val,
288		'error' => 'value is above maximum length',
289		]);
290		}
291
292		return $validationErrors;
293		}
294
295		protected function checkPatternConstraint($val, $pattern)
296		{
297		return preg_match('/^'.$pattern.'$/', $val) === 1;
298		}
299
300		protected function checkMinimumConstraint($val, $minConstraint)
301		{
302		return $val >= $minConstraint;
303		}
304
305		protected function checkMaximumConstraint($val, $maxConstraint)
306		{
307		return $val <= $maxConstraint;
308		}
309
310		protected function getLengthForConstraint($val)
311		{
312		if (is_string($val)) {
313		return strlen($val);
314		} elseif (is_array($val)) {
315		return count($val);
316		} elseif (is_object($val)) {
317		return count((array) $val);
318		} else {
319		throw $this->getValidationException('invalid value for length constraint', $val);
320		}
321		}
322
323		protected function checkMinLengthConstraint($val, $minLength)
324		{
325		return $this->getLengthForConstraint($val) >= $minLength;
326		}
327
328		protected function checkMaxLengthConstraint($val, $maxLength)
329		{
330		return $this->getLengthForConstraint($val) <= $maxLength;
331		}
332
333		protected function getAllowedValues()
334		{
335		$allowedValues = [];
336		foreach ($this->enum() as $val) {
337		$allowedValues[] = $this->castValueNoConstraints($val);
338		}
339
340		return $allowedValues;
341		}
342
343		protected function checkAllowedValues($allowedValues, $val)
344		{
345		return in_array($val, $allowedValues, !is_object($val));
346		}
347
348		protected function castValueNoConstraints($val)
349		{
350		$this->disableConstraints();
351		$val = $this->castValue($val);
352		$this->constraintsDisabled = false;
353
354		return $val;
355		}
356		}
357

OriHoch / tableschema-php

Push — master ( 53f2a7...4c5c4c )

BaseField::title() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like