Console::dispatch()   B
last analyzed

Complexity

Conditions 8
Paths 19

Size

Total Lines 65

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
cc 8
nc 19
nop 1
dl 0
loc 65
rs 7.5191
c 0
b 0
f 0

How to fix   Long Method   

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

1
<?php
2
/**
3
 * KumbiaPHP web & app Framework
4
 *
5
 * LICENSE
6
 *
7
 * This source file is subject to the new BSD license that is bundled
8
 * with this package in the file LICENSE.
9
 *
10
 * @category   Kumbia
11
 * @package    Core
12
 *
13
 * @copyright  Copyright (c) 2005 - 2019 KumbiaPHP Team (http://www.kumbiaphp.com)
14
 * @license    https://github.com/KumbiaPHP/KumbiaPHP/blob/master/LICENSE   New BSD License
15
 */
16
/**
17
 * @see Util
18
 */
19
require CORE_PATH . 'kumbia/util.php';
20
/**
21
 * @see KumbiaException
22
 */
23
require CORE_PATH . 'kumbia/kumbia_exception.php';
24
/**
25
 * @see Config
26
 */
27
require CORE_PATH . 'kumbia/config.php';
28
/**
29
 * @see Load
30
 */
31
require CORE_PATH . 'kumbia/load.php';
32
33
/**
34
 * modificado por nelsonrojas
35
 * el problema: al usar console controller create produce un error en linea 85.
36
 *              no reconoce FileUtil
37
 * solucion: incluir la libreria con la linea siguiente
38
 */
39
require CORE_PATH . 'libs/file_util/file_util.php';
40
41
/**
42
 * Manejador de consolas de KumbiaPHP
43
 *
44
 * Consola para la creación de modelos.
45
 * Consola para la creación de controladores.
46
 * Consola para el manejo de cache.
47
 *
48
 * @category   Kumbia
49
 * @package    Core
50
 */
51
class Console
52
{
53
54
    /**
55
     * Genera la lista de argumentos para la consola, el primer argumento
56
     * retornado corresponde al array de parametros nombrados de terminal
57
     *
58
     * @param array $argv argumentos de terminal
59
     * @return array
60
     * */
61
    private static function _getConsoleArgs($argv)
62
    {
63
        $args = array(array());
64
65
        foreach ($argv as $p) {
66
            if (is_string($p) && preg_match("/--([a-z_0-9]+)[=](.+)/", $p, $regs)) {
67
                // carga en el array de parametros nombrados
68
                $args[0][$regs[1]] = $regs[2];
69
            } else {
70
                // lo carga como argumento simple
71
                $args[] = $p;
72
            }
73
        }
74
75
        return $args;
76
    }
77
78
    /**
79
     * Crea una instancia de la consola indicada
80
     *
81
     * @param string $console_name nombre de la consola
82
     * return object
83
     * @throw KumbiaException
84
     * */
85
    public static function load($console_name)
86
    {
87
        // nombre de la clase de consola
88
        $Console = Util::camelcase($console_name) . 'Console';
89
90
        if (!class_exists($Console)) {
91
            // intenta carga el archivo de consola
92
            $file = APP_PATH . "extensions/console/{$console_name}_console.php";
93
94
            if (!is_file($file)) {
95
                $file = CORE_PATH . "console/{$console_name}_console.php";
96
97
                if (!is_file($file)) {
98
                    throw new KumbiaException('Consola "' . $file . '" no se encontro');
99
                }
100
            }
101
102
            // incluye la consola
103
            include_once $file;
104
        }
105
106
        // crea la instancia de objeto
107
        $console = new $Console();
108
109
        // inicializa la consola
110
        if (method_exists($console, 'initialize')) {
111
            $console->initialize();
112
        }
113
114
        return $console;
115
    }
116
117
    /**
118
     * Despacha y carga la consola a ejecutar desde argumentos del terminal
119
     *
120
     * @param array $argv argumentos recibidos desde el terminal
121
     * @throw KumbiaException
122
     * */
123
    public static function dispatch($argv)
124
    {
125
        // Elimino el nombre de archivo del array de argumentos
126
        array_shift($argv);
127
128
        // obtiene el nombre de consola
129
        $console_name = array_shift($argv);
130
        if (!$console_name) {
131
            throw new KumbiaException('No ha indicado la consola a ejecutar');
132
        }
133
134
        // obtiene el nombre de comando a ejecutar
135
        $command = array_shift($argv);
136
        if (!$command) {
137
            $command = 'main';
138
        }
139
140
        // Obtiene los argumentos para la consola, el primer argumento
141
        // es el array de parametros nombrados para terminal
142
        $args = self::_getConsoleArgs($argv);
143
144
        // verifica el path de aplicacion
145
        if (isset($args[0]['path'])) {
146
            $dir = realpath($args[0]['path']);
147
            if (!$dir) {
148
                throw new KumbiaException("La ruta \"{$args[0]['path']}\" es invalida");
149
            }
150
            // elimina el parametro path del array
151
            unset($args[0]['path']);
152
        } else {
153
            // obtiene el directorio de trabajo actual
154
            $dir = getcwd();
155
        }
156
157
        // define el path de la aplicacion
158
        define('APP_PATH', rtrim($dir, '/') . '/');
159
160
        // lee la configuracion
161
        $config = Config::read('config');
162
163
        // constante que indica si la aplicacion se encuentra en produccion
164
        define('PRODUCTION', $config['application']['production']);
165
166
        // crea la consola
167
        $console = self::load($console_name);
168
169
        // verifica que exista el comando en la consola
170
        if (!method_exists($console, $command)) {
171
            throw new KumbiaException("El comando \"$command\" no existe para la consola \"$console_name\"");
172
        }
173
174
        // si se intenta ejecutar
175
        if ($command == 'initialize') {
176
            throw new KumbiaException("El comando initialize es un comando reservado");
177
        }
178
179
        // verifica los parametros para la accion de consola
180
        $reflectionMethod = new ReflectionMethod($console, $command);
181
        if (count($args) < $reflectionMethod->getNumberOfRequiredParameters()) {
182
            throw new KumbiaException("Número de parametros erroneo para ejecutar el comando \"$command\" en la consola \"$console_name\"");
183
        }
184
185
        // ejecuta el comando
186
        call_user_func_array(array($console, $command), $args);
187
    }
188
189
    /**
190
     * Lee un dato de entrada desde la consola
191
     *
192
     * @param string $message mensaje a mostrar
193
     * @param array $values array de valores validos para entrada
194
     * @return string Valor leido desde la consola
195
     * */
196
    public static function input($message, $values = null)
197
    {
198
        // abre la entrada
199
        $stdin = fopen('php://stdin', 'r');
200
201
        do {
202
            // imprime el mensaje
203
            echo $message;
204
205
            // lee la linea desde el terminal
206
            $data = str_replace(PHP_EOL, '', fgets($stdin));
207
        } while ($values && !in_array($data, $values));
208
209
        // cierra el recurso
210
        fclose($stdin);
211
212
        return $data;
213
    }
214
215
}
216