AbsractAdapter::__construct() - Code Metrics - Inspection of "Merge pull request #12 from pedro151/v1.3.x" - pedro151/orm-generator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fec112...b980e4 )

by Pedro

created 2016-08-03 00:00 UTC

AbsractAdapter::__construct() A

↳ Parent: AbsractAdapter

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
c	1
b	1
f	0
dl	0
loc	11
rs	9.4285
cc	2
eloc	8
nc	2
nop	1

<?php

namespace Classes\AdaptersDriver;

use Classes\AdapterConfig\AbstractAdapter;
use Classes\Db\Column;
use Classes\Db\Constrant;
use Classes\Db\DbTable;

/**
 * Adapter com funcoes de analise das consultas
 *
 * @author Pedro Alarcao <[email protected]>
 * @link   https://github.com/pedro151/orm-generator
 */
abstract class AbsractAdapter
{

    /**
     * @var void variavel com tipo de dados para serem convertida
     */
    protected $dataTypesToSimple;

    /**
     * @type \PDO
     */
    protected $_pdo;

    /**
     * @var int
     */
    protected $port;

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

    /**
     * @type string
     */
    protected $username;

    /**
     * @type string
     */
    protected $password;

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

    /**
     * @type string
     */
    protected $socket;

    /**
     * @type \Classes\Db\DbTable[][]
     */
    private $objDbTables = array ();

    /**
     * @var AbstractAdapter
     */
    protected $config;

    /**
     * @type int
     */
    protected $totalTables;

    /**
     * analisa e popula as Foreing keys, Primary keys e dependencias do banco nos objetos
     */
    protected function parseConstrants ()
    {
        foreach ( $this->getListConstrant () as $constrant ) {

            $schema     = $constrant[ 'table_schema' ];
            $table_name = $constrant [ 'table_name' ];
            $this->populateForeignAndPrimaryKeys ( $constrant, $table_name, $schema );
            unset( $table_name, $schema );

            if ( $constrant[ 'constraint_type' ] == "FOREIGN KEY" ) {
                $schema     = $constrant[ 'foreign_schema' ];
                $table_name = $constrant [ 'foreign_table' ];
                $this->populateDependece ( $constrant, $table_name, $schema );
                unset( $table_name, $schema );
            }
        }
    }

    /**
     * @param array  $constrant
     * @param string $table_name
     * @param int    $schema
     */
    private function populateForeignAndPrimaryKeys ( $constrant, $table_name, $schema = 0 )
    {
        if ( $this->hasTable ( $table_name, $schema ) ) {
            $table = $this->getTable ( $table_name, $schema );
            if ( $table->hasColumn ( $constrant[ "column_name" ] ) ) {
                $objConstrant = Constrant::getInstance ()
                                         ->populate (
                                             array (
                                                 'constrant' => $constrant[ 'constraint_name' ],
                                                 'schema'    => $constrant[ 'foreign_schema' ],
                                                 'table'     => $constrant[ 'foreign_table' ],
                                                 'column'    => $constrant[ 'foreign_column' ],
                                                 'database'  => $this->database
                                             )
                                         );

                switch ( $constrant[ 'constraint_type' ] ) {
                    case "FOREIGN KEY":
                        $table->getColumn ( $constrant[ "column_name" ] )
                              ->addRefFk ( $objConstrant );
                        break;
                    case"PRIMARY KEY":
switch (true) {
    case!isset($a):  //wrong
        doSomething();
        break;
    case !isset($b):  //right
        doSomething();
        break;
}
                        $table->getColumn ( $constrant[ "column_name" ] )
                              ->setPrimaryKey ( $objConstrant )
                              ->setSequence (
                                  $this->getSequence (
                                      $table_name,
                                      $constrant[ "column_name" ],
                                      $schema
                                  )
                              );
                        break;
                }
            }
        }
    }

    /**
     * @param array  $constrant
     * @param string $table_name
     * @param int    $schema
     */
    private function populateDependece ( $constrant, $table_name, $schema = 0 )
    {
        if ( $this->hasTable ( $table_name, $schema ) ) {
            $table = $this->getTable ( $table_name, $schema );
            if ( $table->hasColumn ( $constrant[ "foreign_column" ] ) ) {
                $table->getColumn ( $constrant[ "foreign_column" ] )
                      ->createDependece (
                          $constrant[ 'constraint_name' ],
                          $constrant[ 'table_name' ],
                          $constrant[ 'column_name' ],
                          $this->database,
                          $constrant[ 'table_schema' ]
                      );
            }
        }
    }

    /**
     * cria um Array com nome das tabelas
     */
    public function parseTables ()
    {
        if ( $this->hasTables () ) {
            return $this->getAllTables ();
        }

        foreach ( $this->getListColumns () as $table ) {
            $schema = $table[ 'table_schema' ];
            $key    = $table [ 'table_name' ];
            if ( !$this->hasTable ( $key, $schema ) ) {
                $this->createTable ( $key, $schema );
            }

            $column = Column::getInstance ()
                            ->populate (
                                array (
                                    'name'       => $table [ 'column_name' ],
                                    'type'       => $this->convertTypeToSimple ( $table[ 'data_type' ] ),
                                    'nullable'   => ( $table[ 'is_nullable' ] == 'YES' ),
                                    'max_length' => $table[ 'max_length' ]
                                )
                            );

            $this->getTable ( $key, $schema )
                 ->addColumn ( $column )
                 ->setNamespace (
                     $this->config->createClassNamespace ( $this->getTable ( $key, $schema ) )
                 );
        }
    }

    /**
     * retorna o numero total de tabelas
     *
     * @return int
     */
    abstract public function getTotalTables ();

    /**
     * Retorna o Nome da Sequence da tabela
     *
     * @param $table
     * @param $column
     *
     * @return string
     */
    abstract public function getSequence ( $table, $column, $schema = 0 );

    /**
     * @return array
     */
    abstract public function getListConstrant ();

    /**
     * @param string $str
     *
     * @return string
     */
    protected function convertTypeToPhp ( $str )
    {
        if ( isset( $this->dataTypesToPhp[ $str ] ) ) {
            return $this->dataTypesToPhp[ $str ];
class MyClass { }

$x = new MyClass();
$x->foo = true;
        }

        return 'string';
    }

    protected function convertTypeToSimple ( $str )
    {
        if ( isset( $this->dataTypesToSimple[ $str ] ) ) {
            return $this->dataTypesToSimple[ $str ];
        }

        return 'string';
    }

    /**
     * @return string
     */
    abstract public function getPDOString ();

    /**
     * @return string
     */
    abstract public function getPDOSocketString ();

    /**
     * @param     $nameTable
     * @param int $schema
     *
     * @return \Classes\Db\DbTable
     */
    public function createTable ( $nameTable, $schema = 0 )
    {
        $this->objDbTables[ $schema ][ trim ( $nameTable ) ] = DbTable::getInstance ()
                                                                      ->populate (
                                                                          array (
                                                                              'table'    => $nameTable,
                                                                              'schema'   => $schema,
                                                                              'database' => $this->database
                                                                          )
                                                                      );

        return $this;
    }

    /**
     * Retorna um Array Assoc com a chave com nome da tabela e o valor com objeto tables
     *
     * @return \Classes\Db\DbTable[]
     */
    public function getTables ( $schema = 0 )
    {
        if ( !isset( $this->objDbTables[ $schema ] ) ) {
            return array ();
        }

        return $this->objDbTables[ $schema ];
    }

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

    public function hasTables ()
    {
        return !empty( $this->objDbTables );
    }

    /**
     * retorna a tabela especifica
     *
     * @param string $nameTable Nome da tabela
     *
     * @return \Classes\Db\DbTable
     */
    public function getTable ( $nameTable, $schema = 0 )
    {
        return $this->objDbTables[ $schema ][ trim ( $nameTable ) ];
    }

    /**
     * @param string     $nameTable
     * @param int|string $schema
     *
     * @return bool
     */
    public function hasTable ( $nameTable, $schema = 0 )
    {
        return isset( $this->objDbTables[ $schema ][ trim ( $nameTable ) ] );
    }

    /**
     * retorna multiplos arrays com dados da column em array
     *
     * @return array[]
     */
    abstract public function getListColumns ();

    /**
     * Retorna um Array com nome das tabelas
     *
     * @return string[]
     */
    abstract public function getListNameTable ();

    /**
     * @param \Classes\AdapterConfig\AbstractAdapter $adapterConfig
     */
    public function __construct ( AbstractAdapter $adapterConfig )
    {
        $this->config   = $adapterConfig;
        $this->host     = $adapterConfig->getHost ();
        $this->database = $adapterConfig->getDatabase ();
        $this->port     = $adapterConfig->hasPort () ? $adapterConfig->getPort () : $this->port;
        $this->username = $adapterConfig->getUser ();
        $this->password = $adapterConfig->getPassword ();
        $this->socket   = $adapterConfig->getSocket ();

    }

    /**
     * Executa as consultas do banco de dados
     */
    public function runDatabase ()
    {
        $this->parseTables ();
        $this->parseConstrants ();
    }

    /**
     *
     * @return \PDO
     */
    public function getPDO ()
    {
        if ( is_null ( $this->_pdo ) ) {
            if ( !empty( $this->socket ) ) {
                $pdoString = $this->getPDOSocketString ();
            }
            else {
                $pdoString = $this->getPDOString ();
            }

            try {
                $this->_pdo = new \PDO (
                    $pdoString, $this->username, $this->password
                );
            } catch ( \Exception $e ) {
                die ( "pdo error: " . $e->getMessage () . "\n" );

            }
        }

        return $this->_pdo;
    }
}


1			<?php
2
3			namespace Classes\AdaptersDriver;
4
5			use Classes\AdapterConfig\AbstractAdapter;
6			use Classes\Db\Column;
7			use Classes\Db\Constrant;
8			use Classes\Db\DbTable;
9
10			/**
11			* Adapter com funcoes de analise das consultas
12			*
13			* @author Pedro Alarcao <[email protected]>
14			* @link https://github.com/pedro151/orm-generator
15			*/
16			abstract class AbsractAdapter
17			{
18
19			/**
20			* @var void variavel com tipo de dados para serem convertida
21			*/
22			protected $dataTypesToSimple;
23
24			/**
25			* @type \PDO
26			*/
27			protected $_pdo;
28
29			/**
30			* @var int
31			*/
32			protected $port;
33
34			/**
35			* @var string
36			*/
37			protected $host;
38
39			/**
40			* @type string
41			*/
42			protected $username;
43
44			/**
45			* @type string
46			*/
47			protected $password;
48
49			/**
50			* @var string
51			*/
52			protected $database;
53
54			/**
55			* @type string
56			*/
57			protected $socket;
58
59			/**
60			* @type \Classes\Db\DbTable[][]
61			*/
62			private $objDbTables = array ();
63
64			/**
65			* @var AbstractAdapter
66			*/
67			protected $config;
68
69			/**
70			* @type int
71			*/
72			protected $totalTables;
73
74			/**
75			* analisa e popula as Foreing keys, Primary keys e dependencias do banco nos objetos
76			*/
77			protected function parseConstrants ()
78			{
79			foreach ( $this->getListConstrant () as $constrant ) {
80
81			$schema = $constrant[ 'table_schema' ];
82			$table_name = $constrant [ 'table_name' ];
83			$this->populateForeignAndPrimaryKeys ( $constrant, $table_name, $schema );
84			unset( $table_name, $schema );
85
86			if ( $constrant[ 'constraint_type' ] == "FOREIGN KEY" ) {
87			$schema = $constrant[ 'foreign_schema' ];
88			$table_name = $constrant [ 'foreign_table' ];
89			$this->populateDependece ( $constrant, $table_name, $schema );
90			unset( $table_name, $schema );
91			}
92			}
93			}
94
95			/**
96			* @param array $constrant
97			* @param string $table_name
98			* @param int $schema
99			*/
100			private function populateForeignAndPrimaryKeys ( $constrant, $table_name, $schema = 0 )
101			{
102			if ( $this->hasTable ( $table_name, $schema ) ) {
103			$table = $this->getTable ( $table_name, $schema );
104			if ( $table->hasColumn ( $constrant[ "column_name" ] ) ) {
105			$objConstrant = Constrant::getInstance ()
106			->populate (
107			array (
108			'constrant' => $constrant[ 'constraint_name' ],
109			'schema' => $constrant[ 'foreign_schema' ],
110			'table' => $constrant[ 'foreign_table' ],
111			'column' => $constrant[ 'foreign_column' ],
112			'database' => $this->database
113			)
114			);
115
116			switch ( $constrant[ 'constraint_type' ] ) {
117			case "FOREIGN KEY":
118			$table->getColumn ( $constrant[ "column_name" ] )
119			->addRefFk ( $objConstrant );
120			break;
121			case"PRIMARY KEY":
			0 ignored issues – show Coding Style introduced 2016-04-25 21:47 UTC by Report Bug Copy Issue Report As per coding-style, `case` should be followed by a single space. As per the PSR-2 coding standard, there must be a space after the `case` keyword, instead of the test immediately following it. switch (true) { case!isset($a): //wrong doSomething(); break; case !isset($b): //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
122			$table->getColumn ( $constrant[ "column_name" ] )
123			->setPrimaryKey ( $objConstrant )
124			->setSequence (
125			$this->getSequence (
126			$table_name,
127			$constrant[ "column_name" ],
128			$schema
129			)
130			);
131			break;
132			}
133			}
134			}
135			}
136
137			/**
138			* @param array $constrant
139			* @param string $table_name
140			* @param int $schema
141			*/
142			private function populateDependece ( $constrant, $table_name, $schema = 0 )
143			{
144			if ( $this->hasTable ( $table_name, $schema ) ) {
145			$table = $this->getTable ( $table_name, $schema );
146			if ( $table->hasColumn ( $constrant[ "foreign_column" ] ) ) {
147			$table->getColumn ( $constrant[ "foreign_column" ] )
148			->createDependece (
149			$constrant[ 'constraint_name' ],
150			$constrant[ 'table_name' ],
151			$constrant[ 'column_name' ],
152			$this->database,
153			$constrant[ 'table_schema' ]
154			);
155			}
156			}
157			}
158
159			/**
160			* cria um Array com nome das tabelas
161			*/
162			public function parseTables ()
163			{
164			if ( $this->hasTables () ) {
165			return $this->getAllTables ();
166			}
167
168			foreach ( $this->getListColumns () as $table ) {
169			$schema = $table[ 'table_schema' ];
170			$key = $table [ 'table_name' ];
171			if ( !$this->hasTable ( $key, $schema ) ) {
172			$this->createTable ( $key, $schema );
173			}
174
175			$column = Column::getInstance ()
176			->populate (
177			array (
178			'name' => $table [ 'column_name' ],
179			'type' => $this->convertTypeToSimple ( $table[ 'data_type' ] ),
180			'nullable' => ( $table[ 'is_nullable' ] == 'YES' ),
181			'max_length' => $table[ 'max_length' ]
182			)
183			);
184
185			$this->getTable ( $key, $schema )
186			->addColumn ( $column )
187			->setNamespace (
188			$this->config->createClassNamespace ( $this->getTable ( $key, $schema ) )
189			);
190			}
191			}
192
193			/**
194			* retorna o numero total de tabelas
195			*
196			* @return int
197			*/
198			abstract public function getTotalTables ();
199
200			/**
201			* Retorna o Nome da Sequence da tabela
202			*
203			* @param $table
204			* @param $column
205			*
206			* @return string
207			*/
208			abstract public function getSequence ( $table, $column, $schema = 0 );
209
210			/**
211			* @return array
212			*/
213			abstract public function getListConstrant ();
214
215			/**
216			* @param string $str
217			*
218			* @return string
219			*/
220			protected function convertTypeToPhp ( $str )
221			{
222			if ( isset( $this->dataTypesToPhp[ $str ] ) ) {
223			return $this->dataTypesToPhp[ $str ];
			0 ignored issues – show Bug introduced 2016-08-03 00:03 UTC by Report Bug Copy Issue Report The property `dataTypesToPhp` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
224			}
225
226			return 'string';
227			}
228
229			protected function convertTypeToSimple ( $str )
230			{
231			if ( isset( $this->dataTypesToSimple[ $str ] ) ) {
232			return $this->dataTypesToSimple[ $str ];
233			}
234
235			return 'string';
236			}
237
238			/**
239			* @return string
240			*/
241			abstract public function getPDOString ();
242
243			/**
244			* @return string
245			*/
246			abstract public function getPDOSocketString ();
247
248			/**
249			* @param $nameTable
250			* @param int $schema
251			*
252			* @return \Classes\Db\DbTable
253			*/
254			public function createTable ( $nameTable, $schema = 0 )
255			{
256			$this->objDbTables[ $schema ][ trim ( $nameTable ) ] = DbTable::getInstance ()
257			->populate (
258			array (
259			'table' => $nameTable,
260			'schema' => $schema,
261			'database' => $this->database
262			)
263			);
264
265			return $this;
266			}
267
268			/**
269			* Retorna um Array Assoc com a chave com nome da tabela e o valor com objeto tables
270			*
271			* @return \Classes\Db\DbTable[]
272			*/
273			public function getTables ( $schema = 0 )
274			{
275			if ( !isset( $this->objDbTables[ $schema ] ) ) {
276			return array ();
277			}
278
279			return $this->objDbTables[ $schema ];
280			}
281
282			public function getAllTables ()
283			{
284			return $this->objDbTables;
285			}
286
287			public function hasTables ()
288			{
289			return !empty( $this->objDbTables );
290			}
291
292			/**
293			* retorna a tabela especifica
294			*
295			* @param string $nameTable Nome da tabela
296			*
297			* @return \Classes\Db\DbTable
298			*/
299			public function getTable ( $nameTable, $schema = 0 )
300			{
301			return $this->objDbTables[ $schema ][ trim ( $nameTable ) ];
302			}
303
304			/**
305			* @param string $nameTable
306			* @param int\|string $schema
307			*
308			* @return bool
309			*/
310			public function hasTable ( $nameTable, $schema = 0 )
311			{
312			return isset( $this->objDbTables[ $schema ][ trim ( $nameTable ) ] );
313			}
314
315			/**
316			* retorna multiplos arrays com dados da column em array
317			*
318			* @return array[]
319			*/
320			abstract public function getListColumns ();
321
322			/**
323			* Retorna um Array com nome das tabelas
324			*
325			* @return string[]
326			*/
327			abstract public function getListNameTable ();
328
329			/**
330			* @param \Classes\AdapterConfig\AbstractAdapter $adapterConfig
331			*/
332			public function __construct ( AbstractAdapter $adapterConfig )
333			{
334			$this->config = $adapterConfig;
335			$this->host = $adapterConfig->getHost ();
336			$this->database = $adapterConfig->getDatabase ();
337			$this->port = $adapterConfig->hasPort () ? $adapterConfig->getPort () : $this->port;
338			$this->username = $adapterConfig->getUser ();
339			$this->password = $adapterConfig->getPassword ();
340			$this->socket = $adapterConfig->getSocket ();
341
342			}
343
344			/**
345			* Executa as consultas do banco de dados
346			*/
347			public function runDatabase ()
348			{
349			$this->parseTables ();
350			$this->parseConstrants ();
351			}
352
353			/**
354			*
355			* @return \PDO
356			*/
357			public function getPDO ()
358			{
359			if ( is_null ( $this->_pdo ) ) {
360			if ( !empty( $this->socket ) ) {
361			$pdoString = $this->getPDOSocketString ();
362			}
363			else {
364			$pdoString = $this->getPDOString ();
365			}
366
367			try {
368			$this->_pdo = new \PDO (
369			$pdoString, $this->username, $this->password
370			);
371			} catch ( \Exception $e ) {
372			die ( "pdo error: " . $e->getMessage () . "\n" );
			0 ignored issues – show Coding Style Compatibility introduced 2016-04-25 13:41 UTC by Report Bug Copy Issue Report The method `getPDO()` contains an exit expression. An exit expression should only be used in rare cases. For example, if you write a short command line script. In most cases however, using an `exit` expression makes the code untestable and often causes incompatibilities with other libraries. Thus, unless you are absolutely sure it is required here, we recommend to refactor your code to avoid its usage. Loading history...
373			}
374			}
375
376			return $this->_pdo;
377			}
378			}
379

pedro151 / orm-generator

GitHub Access Token became invalid

Push — master ( fec112...b980e4 )

AbsractAdapter::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like