Classes\AdapterConfig\AbstractAdapter

Complexity

Total Complexity

53

Size/Duplication

Total Lines	491
Duplicated Lines	0 %

Coupling/Cohesion

Components	4
Dependencies	3

Importance

Changes

0

36 Methods

Rating	Name	Duplication	Size	Complexity
A	checkConfig()	0	9	2
	getParams()	0	1	?
	parseFrameworkConfig()	0	1	?
	getMakeFileInstances()	0	1	?
	init()	0	1	?
A	getBaseNamespace()	0	7	1
B	createClassNamespace()	0	28	6
A	__construct()	0	21	2
A	setFrameworkFiles()	0	12	4
B	isValidFrameworkFiles()	0	30	5
A	getFrameworkIni()	0	4	1
A	getEnvironment()	0	4	1
A	isValid()	0	4	1
A	setParams()	0	7	2
A	getDatabase()	0	4	1
A	hasSchemas()	0	4	1
A	getSchemas()	0	9	2
A	setSchema()	0	4	1
A	getHost()	0	4	1
A	getPort()	0	4	1
A	hasPort()	0	4	1
A	isCleanTrash()	0	3	1
A	getSocket()	0	4	1
A	getUser()	0	4	1
A	getPassword()	0	4	1
A	replaceReservedWord()	0	9	2
A	isStatusEnabled()	0	4	1
A	validTableNames()	0	8	2
A	hasTablesName()	0	3	1
A	getTablesName()	0	9	2
A	getListTablesName()	0	4	1
A	hasOptionalClasses()	0	3	1
A	getOptionalClasses()	0	9	2
A	__get()	0	23	2
A	convertTypeToPHP()	0	4	1
A	convertTypeToTypeFramework()	0	4	1

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 16 and the first side effect is on line 8.

namespace Classes\AdapterConfig;

use Classes\Config;
use Classes\Maker\AbstractMaker;

require_once "Classes/Maker/AbstractMaker.php";
require_once "Classes/Config.php";
require_once 'Exception.php';

/**
 * @author Pedro Alarcao <phacl151@gmail.com>
 * @link   https://github.com/pedro151/orm-generator
 */
abstract class AbstractAdapter
{

    protected $arrConfig = array (
        ############################# DATABASE
        //Driver do banco de dados
        'driver'          => null ,
        //Nome do banco de dados
        'database'        => null ,
        //Host do banco
        'host'            => 'localhost' ,
        //Port do banco
        'port'            => '' ,
        //usuario do banco
        'username'        => null ,
        //senha do banco
        'password'        => null ,
        // lista de schemas do banco de dados
        'schema'          => array () ,
        'version'         => '' ,
        'socket'          => null ,

        ########################### DOCS
        // autor que gerou o script
        'author'          => "Pedro" ,
        'license'         => "New BSD License" ,
        'copyright'       => "ORM Generator - Pedro151" ,
        'link'            => 'https://github.com/pedro151/orm-generator' ,
        'version'         => '' ,
        // data que foi gerado o script
        'last_modify'     => null ,

        ########################## Ambiente/Arquivos

        // Nome do framework para o adapter
        'framework'       => null ,
        // namespace das classes
        'namespace'       => "" ,
        // caminho onde os arquivos devem ser criados
        'path'            => 'models' ,
        // flag para gerar pasta com o nome do driver do banco de dados
        'folder-database' => 0 ,
        // string com o nome da pastar personalizada
        'folder-name'     => '' ,

        'clean-trash'     => false,

        ############################## Comandos adicionais
        //flag para mostrar o status da execução ao termino do processo
        'status'          => false ,
        // flags para criar todas as tabelas ou nao
        'tables'          => array () ,
        // lista de Classes opcionais pre-definidas para serem criadas
        'optional-classes'=> array (),
        //Lista de tabelas a serem ignoradas
        'ignoreTable'     => array () ,
    );

    /**
     * @var string[] um array com todos os campos obrigatorios
     */
    protected $attRequered = array (
        'driver'   => true ,
        'database' => true ,
        'host'     => true ,
        'username' => true ,
        'path'     => true
    );

    protected $arrFunc = array ();

    private $framworkFiles = array ();

    public $reservedWord = array ();

    private static $dataTypesDefault = array (
        'int'       => 'int' ,
        'float'     => 'float' ,
        'string'    => 'string' ,
        'text'      => 'string' ,
        'date'      => 'date' ,
        'datetime'  => 'datetime' ,
        'timestamp' => 'timestamp' ,
        'boolean'   => 'boolean'
    );

    protected $dataTypes = array ();

    const SEPARETOR = "";

    /**
     * verifica se todos valores obrigatorios tem valor
     *
     * @return bool
     */
    protected function checkConfig ()
    {
        if ( array_diff_key ( $this->attRequered , array_filter ( $this->arrConfig ) ) )
        {
            return false;
        }

        return true;
    }

    /**
     * retorna os parametros da configuração do framework
     *
     * @return array
     */
    abstract protected function getParams ();

    /**
     * Popula as config do generater com as configuraçoes do framework
     *
     * @return mixed
     */
    abstract protected function parseFrameworkConfig ();

    /**
     * Cria Instancias dos arquivos que devem ser gerados
     *
     * @return \Classes\AdapterMakerFile\AbstractAdapter[]
     */
    abstract public function getMakeFileInstances ();

    abstract protected function init ();

    /**
     * retorna a base do Namespace
     *
     * @return array
     */
    protected function getBaseNamespace ()
    {
        return array (
            $this->arrConfig[ 'namespace' ] ,
            'Model'
        );
    }

    /**
     * @param \Classes\Db\DbTable|\Classes\Db\Constrant $table
     *
     * @return mixed
     */

    public function createClassNamespace ( $table )
    {
        $arrNames = $this->getBaseNamespace ();

        if ( isset( $this->arrConfig[ 'folder-database' ] )
             && $this->arrConfig[ 'folder-database' ]
        )
        {
            $arrNames[] = AbstractMaker::getClassName ( $this->arrConfig[ 'driver' ] );
        }

        if ( isset( $this->arrConfig[ 'folder-name' ] )
             && $this->arrConfig[ 'folder-name' ]
        )
        {
            $arrNames[] = AbstractMaker::getClassName ( $this->arrConfig[ 'folder-name' ] );
        }

        if ( $table->hasSchema () )
        {
            $arrNames[] = $this->replaceReservedWord ( AbstractMaker::getClassName ( $table->getSchema () ) );
        } else
        {
            $arrNames[] = $this->replaceReservedWord ( AbstractMaker::getClassName ( $table->getDatabase () ) );
        }

        return implode ( static::SEPARETOR , array_filter ( $arrNames ) );
    }

    public function __construct ( $array )
    {
        $this->dataTypes = $this->dataTypes + self::$dataTypesDefault;
        $array += array (
            'version'     => Config::$version ,
            'author'      => ucfirst ( get_current_user () ) ,
            'last_modify' => date ( "d-m-Y" )
        );

        $this->setFrameworkFiles ( $array );
        $this->parseFrameworkConfig ();
        $this->setParams ( $this->getParams () );
        $this->setParams ( $array );
        $this->init ();
        $this->validTableNames ();
        if ( ! $this->isValid () )
        {
            $var = array_diff_key ( $this->attRequered , array_filter ( $this->arrConfig ) );
            throw new Exception( $var );
        }
    }

    /**
     * Set os arquivos de configuracao do framework
     *
     * @param $array
     */
    public function setFrameworkFiles ( $array )
    {
        $this->framworkFiles[ 'library' ] = isset( $array[ 'framework-path-library' ] )
            ? $array[ 'framework-path-library' ] : null;

        $this->framworkFiles[ 'ini' ] = isset( $array[ 'framework-ini' ] )
            ? $array[ 'framework-ini' ] : null;

        $this->framworkFiles[ 'environment' ] = isset( $array[ 'environment' ] )
            ? $array[ 'environment' ] : 'production';

    }

    protected function isValidFrameworkFiles ()
    {
        if ( ! is_file ( $this->framworkFiles[ 'ini' ] ) )
        {
            return false;
        }

        if ( ! is_dir ( $this->framworkFiles[ 'library' ] ) )
        {
            return false;
        }

        if ( ! isset ( $this->framworkFiles[ 'environment' ] )
             or empty( $this->framworkFiles[ 'environment' ] )

Using logical operators such as or instead of || is generally not recommended.

        )
        {
            return false;
        }
        set_include_path (
            implode (
                PATH_SEPARATOR ,
                array (
                    realpath ( $this->framworkFiles[ 'library' ] ) ,
                    get_include_path () ,
                )
            )
        );

        return true;
    }

    protected function getFrameworkIni ()
    {
        return $this->framworkFiles[ 'ini' ];
    }

    protected function getEnvironment ()
    {
        return $this->framworkFiles[ 'environment' ];
    }

    /**
     * Popula as variaveis de acordo com o arquivo de configuração do seu  framework
     */
    protected function isValid ()
    {
        return $this->checkConfig ();
    }

    private function setParams ( $array )
    {
        if ( count ( $array ) > 0 )
        {
            $this->arrConfig = array_filter ( $array ) + $this->arrConfig;
        }
    }

    /**
     * @return string
     */
    public function getDatabase ()
    {
        return $this->arrConfig[ 'database' ];
    }

    /**
     * @return bool
     */
    public function hasSchemas ()
    {
        return ! empty ( $this->arrConfig[ 'schema' ] );
    }

    /**
     * @return string[]
     */
    public function getSchemas ()
    {
        if ( is_string ( $this->arrConfig[ 'schema' ] ) )
        {
            return array ( $this->arrConfig[ 'schema' ] );
        }

        return $this->arrConfig[ 'schema' ];
    }

    public function setSchema ( $schema )
    {
        $this->arrConfig[ 'schema' ] = $schema;
    }

    /**
     * @return string
     */
    public function getHost ()
    {
        return $this->arrConfig[ 'host' ];
    }

    /**
     * @return int
     */
    public function getPort ()
    {
        return $this->arrConfig[ 'port' ];
    }

    /**
     * @return boolean
     */
    public function hasPort ()
    {
        return ! empty( $this->arrConfig[ 'port' ] );
    }

    /**
     * @return boolean
     */
    public function isCleanTrash(){
        return (boolean) $this->arrConfig[ 'clean-trash' ];
    }

    /**
     * @return string
     */
    public function getSocket ()
    {
        return $this->arrConfig[ 'socket' ];
    }

    /**
     * @return string
     */
    public function getUser ()
    {
        return $this->arrConfig[ 'username' ];
    }

    /**
     * @return string
     */
    public function getPassword ()
    {
        return $this->arrConfig[ 'password' ];
    }

    /**
     * @param string $schema

There is no parameter named $schema. Was it maybe removed?

     *
     * @return string
     */
    public function replaceReservedWord ( $palavra )
    {
        if ( isset( $this->reservedWord[ strtolower ( $palavra ) ] ) )
        {
            return $this->reservedWord[ strtolower ( $palavra ) ];
        }

        return $palavra;
    }

    /**
     * @return bool
     */
    public function isStatusEnabled ()
    {
        return (bool) $this->arrConfig[ 'status' ];
    }

    public function validTableNames ()
    {
        $matches = preg_grep ( '*\.*' , $this->getTablesName () );
        if ( count ( $matches ) )
        {
           die("\033[0;31mError: Table name must not contain the schema.\033[0m\n");

The method validTableNames() contains an exit expression.

        }
    }

    /**
     * @return bool
     */
    public function hasTablesName (){
        return ! empty( $this->arrConfig[ 'tables' ] );
    }

    /**
     * @return string[]
     */
    public function getTablesName ()
    {
        if ( is_string ( $this->arrConfig[ 'tables' ] ) )
        {
            return array ( $this->arrConfig[ 'tables' ] );
        }

        return $this->arrConfig[ 'tables' ];
    }

    /**
     * @return string
     */
    public function getListTablesName(){
        $str = implode("','", $this->getTablesName() );
        return "'$str'";
    }

    /**
     * @return bool
     */
    public function hasOptionalClasses (){
        return ! empty( $this->arrConfig[ 'optional-classes' ] );
    }

    /**
     * @return string[]
     */
    public function getOptionalClasses ()
    {
        if ( is_string ( $this->arrConfig[ 'optional-classes' ] ) )
        {
            return array ( $this->arrConfig[ 'optional-classes' ] );
        }

        return $this->arrConfig[ 'optional-classes' ];
    }

    /**
     * @param $str
     *
     * @return string
     */
    public function __get ( $str )
    {
        $arr = array (
            'namespace' ,
            'framework' ,
            'author' ,
            'license' ,
            'version' ,
            'copyright' ,
            'link' ,
            'last_modify' ,
            'path' ,
            'folder-database' ,
            'folder-name'
        );

        if ( in_array ( $str , $arr ) )
        {
            return $this->arrConfig[ strtolower ( $str ) ];
        }

        return;
    }

    /**
     * @param string $type
     *
     * @return string
     */
    public static function convertTypeToPHP ( $type )
    {
        return self::$dataTypesDefault[ $type ];
    }

    /**
     * @param string $type
     *
     * @return string
     */
    public function convertTypeToTypeFramework ( $type )
    {
        return $this->dataTypes[ $type ];
    }
}