Code Coverage for /Users/gregor/PhpstormProjects/siesta/src/Siesta/Validator/DefaultEntityValidator.php

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total	0.00% covered (danger)	0.00%	0 / 1	90.00% covered (success)	90.00%	9 / 10	CRAP	95.45% covered (success)	95.45%	63 / 66
DefaultEntityValidator	0.00% covered (danger)	0.00%	0 / 1	90.00% covered (success)	90.00%	9 / 10	23	95.45% covered (success)	95.45%	63 / 66
validate				100.00% covered (success)	100.00%	1 / 1	1	100.00% covered (success)	100.00%	10 / 10
getEntityName				100.00% covered (success)	100.00%	1 / 1	1	100.00% covered (success)	100.00%	1 / 1
error				100.00% covered (success)	100.00%	1 / 1	1	100.00% covered (success)	100.00%	2 / 2
validateClassname				100.00% covered (success)	100.00%	1 / 1	2	100.00% covered (success)	100.00%	6 / 6
validateNamespace				100.00% covered (success)	100.00%	1 / 1	2	100.00% covered (success)	100.00%	6 / 6
validateTable				0.00% covered (danger)	0.00%	0 / 1	2.50	50.00% covered (warning)	50.00%	3 / 6
validateAttributeReferenceCollectionUnique				100.00% covered (success)	100.00%	1 / 1	6	100.00% covered (success)	100.00%	14 / 14
validateAttributeDBNamesUnique				100.00% covered (success)	100.00%	1 / 1	3	100.00% covered (success)	100.00%	8 / 8
validateIndexNameUnique				100.00% covered (success)	100.00%	1 / 1	3	100.00% covered (success)	100.00%	8 / 8
checkDuplicate				100.00% covered (success)	100.00%	1 / 1	2	100.00% covered (success)	100.00%	5 / 5

1	<?php
2	declare(strict_types = 1);
3
4	namespace Siesta\Validator;
5
6	use Siesta\Contract\EntityValidator;
7	use Siesta\Model\DataModel;
8	use Siesta\Model\Entity;
9	use Siesta\Model\ValidationLogger;
10	use Siesta\Util\ArrayUtil;
11
12	/**
13	* @author Gregor Müller
14	*/
15	class DefaultEntityValidator implements EntityValidator
16	{
17
18	const ERROR_INVALID_CLASS_NAME = "Entity '%s' has invalid class name '%s'";
19
20	const ERROR_INVALID_CLASS_NAME_CODE = 1100;
21
22	const ERROR_INVALID_NAMESPACE = "Entity '%s' has invalid class namespace '%s'";
23
24	const ERROR_INVALID_NAMESPACE_CODE = 1101;
25
26	const ERROR_INVALID_TABLE = "Entity '%s' has invalid table name '%s'";
27
28	const ERROR_INVALID_TABLE_CODE = 1102;
29
30	const ERROR_DUPLICATE_ATT_REF_COL = "Entity '%s' has duplicate attribute/reference/collection '%s'";
31
32	const ERROR_DUPLICATE_ATT_REF_COL_CODE = 1103;
33
34	const ERROR_DUPLICATE_DB_NAME = "Entity '%s' has duplicate database column '%s'";
35
36	const ERROR_DUPLICATE_DB_NAME_CODE = 1104;
37
38	const ERROR_DUPLICATE_INDEX = "Entity '%s' has duplicate index '%s'";
39
40	const ERROR_DUPLICATE_INDEX_CODE = 1105;
41
42	/**
43	* @var DataModel
44	*/
45	protected $datamodel;
46
47	/**
48	* @var Entity
49	*/
50	protected $entity;
51
52	/**
53	* @var ValidationLogger
54	*/
55	protected $logger;
56
57	/**
58	* @param DataModel $dataModel
59	* @param Entity $entity
60	* @param ValidationLogger $logger
61	*/
62	public function validate(DataModel $dataModel, Entity $entity, ValidationLogger $logger)
63	{
64	$this->datamodel = $dataModel;
65	$this->entity = $entity;
66	$this->logger = $logger;
67
68	$this->validateClassname();
69	$this->validateNamespace();
70	$this->validateTable();
71	$this->validateAttributeReferenceCollectionUnique();
72	$this->validateAttributeDBNamesUnique();
73	$this->validateIndexNameUnique();
74
75	}
76
77	/**
78	* @return string
79	*/
80	protected function getEntityName()
81	{
82	return $this->entity->getClassShortName();
83	}
84
85	/**
86	* @param string $text
87	* @param int $code
88	*/
89	protected function error(string $text, int $code)
90	{
91	$this->logger->error($text, $code);
92	}
93
94	/**
95	*
96	*/
97	protected function validateClassname()
98	{
99	$className = $this->getEntityName();
100	if (preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $className)) {
101	return;
102	}
103	$error = sprintf(self::ERROR_INVALID_CLASS_NAME, $className, $className);
104	$this->error($error, self::ERROR_INVALID_CLASS_NAME_CODE);
105
106	}
107
108	/**
109	*
110	*/
111	protected function validateNamespace()
112	{
113	$namespace = $this->entity->getNamespaceName();
114	if (preg_match('/^((?:\\\\{0,1}\\w+\|\\w+\\\\{1,2})(?:\\w+\\\\{0,2})+)$/', $namespace) === 1) {
115	return;
116	}
117	$error = sprintf(self::ERROR_INVALID_NAMESPACE, $this->getEntityName(), $namespace);
118	$this->error($error, self::ERROR_INVALID_NAMESPACE_CODE);
119	}
120
121	/**
122	*
123	*/
124	protected function validateTable()
125	{
126	$tableName = $this->entity->getTableName();
127	if ($tableName !== null) {
128	return;
129	}
130	$error = sprintf(self::ERROR_INVALID_TABLE, $this->getEntityName(), $tableName);
131	$this->error($error, self::ERROR_INVALID_TABLE_CODE);
132
133	}
134
135	protected function validateAttributeReferenceCollectionUnique()
136	{
137	$duplicateNameList = [];
138	$nameList = [];
139
140	foreach ($this->entity->getAttributeList() as $attribute) {
141	$this->checkDuplicate($nameList, $duplicateNameList, $attribute->getPhpName());
142	}
143
144	foreach ($this->entity->getReferenceList() as $reference) {
145	$this->checkDuplicate($nameList, $duplicateNameList, $reference->getName());
146	}
147
148	foreach ($this->entity->getCollectionList() as $collection) {
149	$this->checkDuplicate($nameList, $duplicateNameList, $collection->getName());
150	}
151
152	foreach ($this->entity->getCollectionManyList() as $collectionMany) {
153	$this->checkDuplicate($nameList, $duplicateNameList, $collectionMany->getName());
154	}
155
156	foreach ($duplicateNameList as $duplicateName) {
157	$error = sprintf(self::ERROR_DUPLICATE_ATT_REF_COL, $this->getEntityName(), $duplicateName);
158	$this->error($error, self::ERROR_DUPLICATE_ATT_REF_COL_CODE);
159	}
160	}
161
162	/**
163	*
164	*/
165	protected function validateAttributeDBNamesUnique()
166	{
167
168	$duplicateNameList = [];
169	$nameList = [];
170	foreach ($this->entity->getAttributeList() as $attribute) {
171	$this->checkDuplicate($nameList, $duplicateNameList, $attribute->getDBName());
172	}
173
174	foreach ($duplicateNameList as $duplicateName) {
175	$error = sprintf(self::ERROR_DUPLICATE_DB_NAME, $this->getEntityName(), $duplicateName);
176	$this->error($error, self::ERROR_DUPLICATE_DB_NAME_CODE);
177	}
178
179	}
180
181	/**
182	*
183	*/
184	protected function validateIndexNameUnique()
185	{
186	$duplicateNameList = [];
187	$nameList = [];
188	foreach ($this->entity->getIndexList() as $index) {
189	$this->checkDuplicate($nameList, $duplicateNameList, $index->getName());
190	}
191	foreach ($duplicateNameList as $duplicateName) {
192	$error = sprintf(self::ERROR_DUPLICATE_INDEX, $this->getEntityName(), $duplicateName);
193	$this->error($error, self::ERROR_DUPLICATE_INDEX_CODE);
194	}
195	}
196
197	/**
198	* @param array $nameList
199	* @param array $duplicateNameList
200	* @param $name
201	*/
202	protected function checkDuplicate(array &$nameList, array &$duplicateNameList, $name)
203	{
204	$existing = ArrayUtil::getFromArray($nameList, $name);
205	if ($existing) {
206	$duplicateNameList[] = $name;
207	}
208	$nameList[$name] = true;
209	}
210	}