FromPropelSchemaXmlAssembler::validateData() - Code Metrics - bazzline/php_component_locator_generator - Measure and Improve Code Quality continuously with Scrutinizer

FromPropelSchemaXmlAssembler::validateData() A
last analyzed 2021-06-07 11:24 UTC

↳ Parent: FromPropelSchemaXmlAssembler

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	38
Ratio	100 %

Importance

Changes

Metric	Value
dl	38
loc	38
rs	9.312
c	0
b	0
f	0
cc	3
nc	3
nop	1

<?php
/**
 * @author stev leibelt <[email protected]>
 * @since 2014-05-26 
 */

namespace Net\Bazzline\Component\Locator\Configuration\Assembler;

use Net\Bazzline\Component\Locator\Configuration\Configuration;
use Net\Bazzline\Component\Locator\Configuration\Validator\ReadableFilePath;
use XMLReader;

/**
 * Class FromPropelSchemaXmlAssembler
 * @package Net\Bazzline\Component\Locator\Configuration\Assembler
 */
class FromPropelSchemaXmlAssembler extends AbstractAssembler
{
    /**
     * @param mixed $data
     * @param Configuration $configuration
     * @return Configuration
     * @throws RuntimeException
     */
    protected function map($data, Configuration $configuration)
    {
        //begin of variable definitions
        $columnClassMethodBodyBuilder =
            (isset($data['column_class_method_body_builder']))
                ? $data['column_class_method_body_builder']
                : null;

        $locatorNamespace =
            (isset($data['namespace']))
                ? $data['namespace']
                : '';

        $methodNameWithoutNamespace =
            (isset($data['method_name_without_namespace']))
                ? $data['method_name_without_namespace']
                : false;

        $pathToSchemaXml = realpath($data['path_to_schema_xml']);
        $queryClassMethodBodyBuilder =
            (isset($data['query_class_method_body_builder']))
                ? $data['query_class_method_body_builder']
                : null;
        //end of variable definitions

        //@todo inject
        $validator = new ReadableFilePath();
        $validator->validate($pathToSchemaXml);

        $configuration = $this->mapBooleanProperties(
            $data,
            $configuration
        );
        $configuration = $this->mapStringProperties(
            $data,
            $configuration
        );
        $configuration = $this->mapSchemaXmlPropertiesToConfiguration(
            $pathToSchemaXml,
            $configuration,
            $columnClassMethodBodyBuilder,
            $locatorNamespace,
            $queryClassMethodBodyBuilder,
            $methodNameWithoutNamespace
        );
        $configuration = $this->mapArrayPropertiesToConfiguration(
            $data,
            $configuration
        );

        return $configuration;
    }

    /**
     * @param mixed $data
     * @throws InvalidArgumentException
     */
    protected function validateData($data)
    {
        if (!is_array($data)) {
            throw new InvalidArgumentException(
                'data must be an array'
            );
        }

        if (empty($data)) {
            throw new InvalidArgumentException(
                'data array must contain content'
            );
        }

        $mandatoryKeysToExpectedValueTyp = array(
            'class_name'            => 'string',
            'file_path'             => 'string'
        );

        $this->validateDataWithMandatoryKeysAndExpectedValueType(
            $data,
            $mandatoryKeysToExpectedValueTyp
        );

        $optionalKeysToExpectedValueTyp = array(
            'extends'                       => 'string',
            'implements'                    => 'array',
            'method_name_without_namespace' => 'boolean',
            'namespace'                     => 'string',
            'path_to_schema_xml'            => 'string',
            'uses'                          => 'array'
        );

        $this->validateDataWithOptionalKeysAndExpectedValueTypeOrSetExpectedValueAsDefault(
            $data,
            $optionalKeysToExpectedValueTyp
        );
    }

    /**
     * @param string $pathToSchemaXml
     * @param Configuration $configuration
     * @param string $columnClassMethodBodyBuilder
     * @param string $locatorNamespace
     * @param string $queryClassMethodBodyBuilder
     * @param boolean $methodNameWithoutNamespace
     * @return Configuration
     */
    private function mapSchemaXmlPropertiesToConfiguration(
        $pathToSchemaXml,
        Configuration $configuration,
        $columnClassMethodBodyBuilder,
        $locatorNamespace,
        $queryClassMethodBodyBuilder,
        $methodNameWithoutNamespace
    )
    {
        //begin of variable definitions
        $hasRootNamespace = false;
        //@todo inject XMLReader
        $reader = new XMLReader();
        $reader->open($pathToSchemaXml);
        $rootNamespace = '';
        //end of variable definitions

        //begin of xml parsing
        while ($reader->read()) {
            if ($reader->nodeType === XMLREADER::ELEMENT) {
                $nodeIsADatabase    = ($reader->name === 'database');
                $nodeIsATable       = ($reader->name === 'table');

                if ($nodeIsADatabase) {
                    $rootNamespace = $reader->getAttribute('namespace');
                    if(strlen($rootNamespace) > 0) {
                        $hasRootNamespace = true;
                    }
                }

                if ($nodeIsATable) {
                    $configuration = $this->addTableToConfiguration(
                        $reader,
                        $hasRootNamespace,
                        $rootNamespace,
                        $locatorNamespace,
                        $configuration,
                        $columnClassMethodBodyBuilder,
                        $queryClassMethodBodyBuilder,
                        $methodNameWithoutNamespace
                    );
                }
            }
        }
        $reader->close();
        //end of xml parsing

        return $configuration;
    }

    /**
     * @param array $data
     * @param Configuration $configuration
     * @return Configuration
     * @throws RuntimeException
     */
    private function mapArrayPropertiesToConfiguration(array $data, Configuration $configuration)
    {
        if (isset($data['implements'])) {
            foreach($data['implements'] as $interfaceName) {
                $configuration->addImplements($interfaceName);
            }
        }

        if (isset($data['uses'])) {
            foreach ($data['uses'] as $key => $uses) {
                if (!isset($uses['class_name'])) {
                    throw new RuntimeException(
                        'use entry with key "' . $key . '" needs to have a key "class_name"'
                    );
                }

                $alias      = (isset($uses['alias'])) ? $uses['alias'] : '';
                $className  = str_replace('\\\\', '\\', $uses['class_name']);
                $configuration->addUses($className, $alias);
            }
        }

        return $configuration;
    }

    /**
     * @param XMLReader $reader
     * @param boolean $hasRootNamespace
     * @param string $rootNamespace
     * @param string $locatorNamespace
     * @param Configuration $configuration
     * @param string $columnClassMethodBodyBuilder
     * @param string $queryClassMethodBodyBuilder
     * @param boolean $methodNameWithoutNamespace
     * @return Configuration
     */
    private function addTableToConfiguration(
        XMLReader $reader,
        $hasRootNamespace,
        $rootNamespace,
        $locatorNamespace,
        Configuration $configuration,
        $columnClassMethodBodyBuilder,
        $queryClassMethodBodyBuilder,
        $methodNameWithoutNamespace
    )
    {
        //begin of variable definitions
        $namespace              = $reader->getAttribute('namespace');
        $phpName                = $reader->getAttribute('phpName');
        $tableName              = $reader->getAttribute('name');
        $tableNamespace         = '';
        $hasPhpName             = (strlen($phpName) > 0);
        $hasNamespace           = (strlen($namespace) > 0);
        //end of variable definitions

        //begin of class name building
        if ($hasRootNamespace) {
            $tableNamespace .= '\\' . $rootNamespace . '\\';
        }

        if ($hasNamespace) {
            $tableNamespace .= $namespace . '\\';
        }

        $hasDifferentNamespaceThanLocator   = ($locatorNamespace !== $tableNamespace);
        $hasTableNamespace                  = (strlen($tableNamespace) > 0);
        $fullQualifiedClassName             = $this->createFullQualifiedClassName(
            $hasPhpName,
            $phpName,
            $tableName,
            $hasTableNamespace,
            $tableNamespace
        );

        $classNameAlias = ($methodNameWithoutNamespace)
            ? $this->createClassNameAlias($hasPhpName, $phpName, $tableName)
            : null;

        $queryClassNameAlias =
            (!is_null($classNameAlias))
                ? $classNameAlias . 'Query'
                : null;

        $fullQualifiedQueryClassName = $fullQualifiedClassName . 'Query';
        //end of class name building

        //begin of configuration adaptation
        $configuration->addInstance(
            $fullQualifiedClassName,
            false,
            false,
            $fullQualifiedClassName,
            $classNameAlias,
            $columnClassMethodBodyBuilder
        );
        $configuration->addInstance(
            $fullQualifiedQueryClassName,
            false,
            false,
            $fullQualifiedClassName,
            $queryClassNameAlias,
            $queryClassMethodBodyBuilder
        );

        if ($hasDifferentNamespaceThanLocator) {
            //we have to remove the first "\" if available
            $useClassName = ($this->startsWith($fullQualifiedClassName, '\\'))
                ? substr($fullQualifiedClassName, 1)
                : $fullQualifiedClassName;

            $useQueryClassName = ($this->startsWith($fullQualifiedQueryClassName, '\\'))
                ? substr($fullQualifiedQueryClassName, 1)
                : $fullQualifiedQueryClassName;

            $configuration->addUses($useClassName);
            $configuration->addUses($useQueryClassName);
        }
        //end of configuration adaptation

        return $configuration;
    }

    /**
     * @param string $haystack
     * @param string $needle
     * @return bool
     */
    private function startsWith($haystack, $needle)
    {
        return (strncmp($haystack, $needle, strlen($needle)) === 0);
    }

    /**
     * @param boolean $hasPhpName
     * @param string $phpName
     * @param string $tableName
     * @param boolean $hasTableNamespace
     * @param string $tableNamespace
     * @return mixed|string
     */
    private function createFullQualifiedClassName($hasPhpName, $phpName, $tableName, $hasTableNamespace, $tableNamespace)
    {
        $fullQualifiedClassName = '';

        if ($hasPhpName) {
            $fullQualifiedClassName = $phpName;
        } else {
            $tableNameAsArray = explode('_', $tableName);
            array_walk($tableNameAsArray, function (&$value) {
                $value = ucfirst($value);
            });
            $fullQualifiedClassName .= implode('', $tableNameAsArray);
        }

        if ($hasTableNamespace) {
            $fullQualifiedClassName = $tableNamespace . '\\' . $fullQualifiedClassName;
        }

        $fullQualifiedClassName = str_replace('\\\\', '\\', $fullQualifiedClassName);

        return $fullQualifiedClassName;
    }

    /**
     * @param boolean $hasPhpName
     * @param string $phpName
     * @param string $tableName
     * @return string
     */
    private function createClassNameAlias($hasPhpName, $phpName, $tableName)
    {
        return ($hasPhpName) ? $phpName : $tableName;
    }
}


1		<?php
2		/**
3		* @author stev leibelt <[email protected]>
4		* @since 2014-05-26
5		*/
6
7		namespace Net\Bazzline\Component\Locator\Configuration\Assembler;
8
9		use Net\Bazzline\Component\Locator\Configuration\Configuration;
10		use Net\Bazzline\Component\Locator\Configuration\Validator\ReadableFilePath;
11		use XMLReader;
12
13		/**
14		* Class FromPropelSchemaXmlAssembler
15		* @package Net\Bazzline\Component\Locator\Configuration\Assembler
16		*/
17		class FromPropelSchemaXmlAssembler extends AbstractAssembler
18		{
19		/**
20		* @param mixed $data
21		* @param Configuration $configuration
22		* @return Configuration
23		* @throws RuntimeException
24		*/
25		protected function map($data, Configuration $configuration)
26		{
27		//begin of variable definitions
28		$columnClassMethodBodyBuilder =
29		(isset($data['column_class_method_body_builder']))
30		? $data['column_class_method_body_builder']
31		: null;
32
33		$locatorNamespace =
34		(isset($data['namespace']))
35		? $data['namespace']
36		: '';
37
38		$methodNameWithoutNamespace =
39		(isset($data['method_name_without_namespace']))
40		? $data['method_name_without_namespace']
41		: false;
42
43		$pathToSchemaXml = realpath($data['path_to_schema_xml']);
44		$queryClassMethodBodyBuilder =
45		(isset($data['query_class_method_body_builder']))
46		? $data['query_class_method_body_builder']
47		: null;
48		//end of variable definitions
49
50		//@todo inject
51		$validator = new ReadableFilePath();
52		$validator->validate($pathToSchemaXml);
53
54		$configuration = $this->mapBooleanProperties(
55		$data,
56		$configuration
57		);
58		$configuration = $this->mapStringProperties(
59		$data,
60		$configuration
61		);
62		$configuration = $this->mapSchemaXmlPropertiesToConfiguration(
63		$pathToSchemaXml,
64		$configuration,
65		$columnClassMethodBodyBuilder,
66		$locatorNamespace,
67		$queryClassMethodBodyBuilder,
68		$methodNameWithoutNamespace
69		);
70		$configuration = $this->mapArrayPropertiesToConfiguration(
71		$data,
72		$configuration
73		);
74
75		return $configuration;
76		}
77
78		/**
79		* @param mixed $data
80		* @throws InvalidArgumentException
81		*/
82	View Code Duplication	protected function validateData($data)
83		{
84		if (!is_array($data)) {
85		throw new InvalidArgumentException(
86		'data must be an array'
87		);
88		}
89
90		if (empty($data)) {
91		throw new InvalidArgumentException(
92		'data array must contain content'
93		);
94		}
95
96		$mandatoryKeysToExpectedValueTyp = array(
97		'class_name' => 'string',
98		'file_path' => 'string'
99		);
100
101		$this->validateDataWithMandatoryKeysAndExpectedValueType(
102		$data,
103		$mandatoryKeysToExpectedValueTyp
104		);
105
106		$optionalKeysToExpectedValueTyp = array(
107		'extends' => 'string',
108		'implements' => 'array',
109		'method_name_without_namespace' => 'boolean',
110		'namespace' => 'string',
111		'path_to_schema_xml' => 'string',
112		'uses' => 'array'
113		);
114
115		$this->validateDataWithOptionalKeysAndExpectedValueTypeOrSetExpectedValueAsDefault(
116		$data,
117		$optionalKeysToExpectedValueTyp
118		);
119		}
120
121		/**
122		* @param string $pathToSchemaXml
123		* @param Configuration $configuration
124		* @param string $columnClassMethodBodyBuilder
125		* @param string $locatorNamespace
126		* @param string $queryClassMethodBodyBuilder
127		* @param boolean $methodNameWithoutNamespace
128		* @return Configuration
129		*/
130		private function mapSchemaXmlPropertiesToConfiguration(
131		$pathToSchemaXml,
132		Configuration $configuration,
133		$columnClassMethodBodyBuilder,
134		$locatorNamespace,
135		$queryClassMethodBodyBuilder,
136		$methodNameWithoutNamespace
137		)
138		{
139		//begin of variable definitions
140		$hasRootNamespace = false;
141		//@todo inject XMLReader
142		$reader = new XMLReader();
143		$reader->open($pathToSchemaXml);
144		$rootNamespace = '';
145		//end of variable definitions
146
147		//begin of xml parsing
148		while ($reader->read()) {
149		if ($reader->nodeType === XMLREADER::ELEMENT) {
150		$nodeIsADatabase = ($reader->name === 'database');
151		$nodeIsATable = ($reader->name === 'table');
152
153		if ($nodeIsADatabase) {
154		$rootNamespace = $reader->getAttribute('namespace');
155		if(strlen($rootNamespace) > 0) {
156		$hasRootNamespace = true;
157		}
158		}
159
160		if ($nodeIsATable) {
161		$configuration = $this->addTableToConfiguration(
162		$reader,
163		$hasRootNamespace,
164		$rootNamespace,
165		$locatorNamespace,
166		$configuration,
167		$columnClassMethodBodyBuilder,
168		$queryClassMethodBodyBuilder,
169		$methodNameWithoutNamespace
170		);
171		}
172		}
173		}
174		$reader->close();
175		//end of xml parsing
176
177		return $configuration;
178		}
179
180		/**
181		* @param array $data
182		* @param Configuration $configuration
183		* @return Configuration
184		* @throws RuntimeException
185		*/
186	View Code Duplication	private function mapArrayPropertiesToConfiguration(array $data, Configuration $configuration)
187		{
188		if (isset($data['implements'])) {
189		foreach($data['implements'] as $interfaceName) {
190		$configuration->addImplements($interfaceName);
191		}
192		}
193
194		if (isset($data['uses'])) {
195		foreach ($data['uses'] as $key => $uses) {
196		if (!isset($uses['class_name'])) {
197		throw new RuntimeException(
198		'use entry with key "' . $key . '" needs to have a key "class_name"'
199		);
200		}
201
202		$alias = (isset($uses['alias'])) ? $uses['alias'] : '';
203		$className = str_replace('\\\\', '\\', $uses['class_name']);
204		$configuration->addUses($className, $alias);
205		}
206		}
207
208		return $configuration;
209		}
210
211		/**
212		* @param XMLReader $reader
213		* @param boolean $hasRootNamespace
214		* @param string $rootNamespace
215		* @param string $locatorNamespace
216		* @param Configuration $configuration
217		* @param string $columnClassMethodBodyBuilder
218		* @param string $queryClassMethodBodyBuilder
219		* @param boolean $methodNameWithoutNamespace
220		* @return Configuration
221		*/
222		private function addTableToConfiguration(
223		XMLReader $reader,
224		$hasRootNamespace,
225		$rootNamespace,
226		$locatorNamespace,
227		Configuration $configuration,
228		$columnClassMethodBodyBuilder,
229		$queryClassMethodBodyBuilder,
230		$methodNameWithoutNamespace
231		)
232		{
233		//begin of variable definitions
234		$namespace = $reader->getAttribute('namespace');
235		$phpName = $reader->getAttribute('phpName');
236		$tableName = $reader->getAttribute('name');
237		$tableNamespace = '';
238		$hasPhpName = (strlen($phpName) > 0);
239		$hasNamespace = (strlen($namespace) > 0);
240		//end of variable definitions
241
242		//begin of class name building
243		if ($hasRootNamespace) {
244		$tableNamespace .= '\\' . $rootNamespace . '\\';
245		}
246
247		if ($hasNamespace) {
248		$tableNamespace .= $namespace . '\\';
249		}
250
251		$hasDifferentNamespaceThanLocator = ($locatorNamespace !== $tableNamespace);
252		$hasTableNamespace = (strlen($tableNamespace) > 0);
253		$fullQualifiedClassName = $this->createFullQualifiedClassName(
254		$hasPhpName,
255		$phpName,
256		$tableName,
257		$hasTableNamespace,
258		$tableNamespace
259		);
260
261		$classNameAlias = ($methodNameWithoutNamespace)
262		? $this->createClassNameAlias($hasPhpName, $phpName, $tableName)
263		: null;
264
265		$queryClassNameAlias =
266		(!is_null($classNameAlias))
267		? $classNameAlias . 'Query'
268		: null;
269
270		$fullQualifiedQueryClassName = $fullQualifiedClassName . 'Query';
271		//end of class name building
272
273		//begin of configuration adaptation
274		$configuration->addInstance(
275		$fullQualifiedClassName,
276		false,
277		false,
278		$fullQualifiedClassName,
279		$classNameAlias,
280		$columnClassMethodBodyBuilder
281		);
282		$configuration->addInstance(
283		$fullQualifiedQueryClassName,
284		false,
285		false,
286		$fullQualifiedClassName,
287		$queryClassNameAlias,
288		$queryClassMethodBodyBuilder
289		);
290
291		if ($hasDifferentNamespaceThanLocator) {
292		//we have to remove the first "\" if available
293		$useClassName = ($this->startsWith($fullQualifiedClassName, '\\'))
294		? substr($fullQualifiedClassName, 1)
295		: $fullQualifiedClassName;
296
297		$useQueryClassName = ($this->startsWith($fullQualifiedQueryClassName, '\\'))
298		? substr($fullQualifiedQueryClassName, 1)
299		: $fullQualifiedQueryClassName;
300
301		$configuration->addUses($useClassName);
302		$configuration->addUses($useQueryClassName);
303		}
304		//end of configuration adaptation
305
306		return $configuration;
307		}
308
309		/**
310		* @param string $haystack
311		* @param string $needle
312		* @return bool
313		*/
314		private function startsWith($haystack, $needle)
315		{
316		return (strncmp($haystack, $needle, strlen($needle)) === 0);
317		}
318
319		/**
320		* @param boolean $hasPhpName
321		* @param string $phpName
322		* @param string $tableName
323		* @param boolean $hasTableNamespace
324		* @param string $tableNamespace
325		* @return mixed\|string
326		*/
327		private function createFullQualifiedClassName($hasPhpName, $phpName, $tableName, $hasTableNamespace, $tableNamespace)
328		{
329		$fullQualifiedClassName = '';
330
331		if ($hasPhpName) {
332		$fullQualifiedClassName = $phpName;
333		} else {
334		$tableNameAsArray = explode('_', $tableName);
335		array_walk($tableNameAsArray, function (&$value) {
336		$value = ucfirst($value);
337		});
338		$fullQualifiedClassName .= implode('', $tableNameAsArray);
339		}
340
341		if ($hasTableNamespace) {
342		$fullQualifiedClassName = $tableNamespace . '\\' . $fullQualifiedClassName;
343		}
344
345		$fullQualifiedClassName = str_replace('\\\\', '\\', $fullQualifiedClassName);
346
347		return $fullQualifiedClassName;
348		}
349
350		/**
351		* @param boolean $hasPhpName
352		* @param string $phpName
353		* @param string $tableName
354		* @return string
355		*/
356		private function createClassNameAlias($hasPhpName, $phpName, $tableName)
357		{
358		return ($hasPhpName) ? $phpName : $tableName;
359		}
360		}
361

bazzline / php_component_locator_generator

FromPropelSchemaXmlAssembler::validateData() A last analyzed 2021-06-07 11:24 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

FromPropelSchemaXmlAssembler::validateData() A
last analyzed 2021-06-07 11:24 UTC