PHP Util::camelcase方法代码示例

 /**
  * Maneja las excepciones no capturadas
  *
  * @param Exception $e
  * */
 public static function handleException($e)
 {
     self::setHeader($e);
     //TODO quitar el extract, que el view pida los que necesite
     extract(Router::get(), EXTR_OVERWRITE);
     // Registra la autocarga de helpers
     spl_autoload_register('kumbia_autoload_helper', true, true);
     $Controller = Util::camelcase($controller);
     ob_start();
     if (PRODUCTION) {
         //TODO: añadir error 500.phtml
         include APP_PATH . 'views/_shared/errors/404.phtml';
         return;
     }
     if ($e instanceof KumbiaException) {
         $view = $e->view;
         $tpl = $e->template;
     } else {
         $view = 'exception';
         $tpl = 'views/templates/exception.phtml';
     }
     //Fix problem with action name in REST
     $action = $e->getMessage() ? $e->getMessage() : $action;
     include CORE_PATH . "views/errors/{$view}.phtml";
     $content = ob_get_clean();
     // termina los buffers abiertos
     while (ob_get_level()) {
         ob_end_clean();
     }
     include CORE_PATH . $tpl;
 }

 /**
  * Maneja las excepciones no capturadas
  *
  * @param Exception $e
  * */
 public static function handle_exception($e)
 {
     if (isset($e->_view) && ($e->_view == 'no_controller' || $e->_view == 'no_action')) {
         header('HTTP/1.1 404 Not Found');
     } else {
         header('HTTP/1.1 500 Internal Server Error');
     }
     extract(Router::get(), EXTR_OVERWRITE);
     $Controller = Util::camelcase($controller);
     ob_start();
     if (PRODUCTION) {
         include APP_PATH . 'views/_shared/errors/404.phtml';
         return;
     } else {
         $Template = 'views/templates/exception.phtml';
         if (isset($e->_view)) {
             include CORE_PATH . "views/errors/{$e->_view}.phtml";
         } else {
             include CORE_PATH . "views/errors/exception.phtml";
         }
     }
     $content = ob_get_clean();
     // termina los buffers abiertos
     while (ob_get_level()) {
         ob_end_clean();
     }
     // verifica si esta cargado el View
     if (class_exists('View')) {
         if (View::get('template') === NULL) {
             echo $content;
             exit;
         }
     }
     include CORE_PATH . $Template;
 }

 /**
  * Ejecuta el builder
  *
  * @param string $name elemento a construir
  * @param array $params
  * @return boolean
  * @throw BuilderException
  */
 public static function execute($name, $params)
 {
     $filter = Util::camelcase($name);
     $sfilter = Util::smallcase($name);
     /**
      * Nombre de archivo
      **/
     $__file__ = APP_PATH . 'filters/' . "{$sfilter}_filter.php";
     /**
      * Generando archivo
      **/
     if (!file_exists($__file__)) {
         extract($params);
         echo "\r\n-- Generando filter: {$filter}\r\n{$__file__}\r\n";
         ob_start();
         echo "<?php\n";
         include CORE_PATH . 'libs/builder/base_builders/templates/filter.php';
         $code = ob_get_contents();
         ob_end_clean();
         if (!file_put_contents($__file__, $code)) {
             throw new KumbiaException("No se ha logrado generar el archivo de filter {$__file__}");
         }
     } else {
         echo "\r\n-- El filter ya existe en {$__file__}\r\n";
     }
     return true;
 }

 /**
  * Ejecuta el destroyer
  *
  * @param string $name elemento a destruir
  * @param array $params
  * @return boolean
  * @throw KumbiaException
  */
 public static function execute($name, $params)
 {
     $path = APP_PATH . 'models/';
     if (isset($params['module']) && $params['module']) {
         $path .= "{$params['module']}/";
     }
     $model = Util::camelcase($name);
     $smodel = Util::smallcase($name);
     /**
      * Nombre de archivo
      **/
     $file = $path . "{$smodel}.php";
     echo "\r\n-- Eliminando model: {$model}\r\n{$file}\r\n";
     if (!unlink($file)) {
         throw new KumbiaException("No se ha logrado eliminar el archivo {$file}");
     }
     return true;
 }

 /**
  * Edita un Registro
  */
 public function editar($id = null)
 {
     if ($id != null) {
         View::select('crear');
         $model = Util::camelcase($this->model);
         //se verifica si se ha enviado via POST los datos
         if (Input::hasPost($this->model)) {
             $obj = Load::model($this->model);
             if (!$obj->update(Input::post($this->model))) {
                 Flash::error('Falló Operación');
                 //se hacen persistente los datos en el formulario
                 $this->result = Input::post($this->model);
             } else {
                 return Router::redirect("{$this->controller_path}");
             }
         }
         //Aplicando la autocarga de objeto, para comenzar la edición
         $this->result = Load::model($this->model)->find($id);
     } else {
     }
 }

 /**
  * Comando de consola para crear un modelo
  *
  * @param array $params parametros nombrados de la consola
  * @param string $model modelo
  * @throw KumbiaException
  */
 public function create($params, $model)
 {
     // nombre de archivo
     $file = APP_PATH . 'models';
     // obtiene el path
     $path = explode('/', trim($model, '/'));
     // obtiene el nombre de modelo
     $model_name = array_pop($path);
     if (count($path)) {
         $dir = implode('/', $path);
         $file .= "/{$dir}";
         if (!is_dir($file) && !FileUtil::mkdir($file)) {
             throw new KumbiaException("No se ha logrado crear el directorio \"{$file}\"");
         }
     }
     $file .= "/{$model_name}.php";
     // si no existe o se sobreescribe
     if (!is_file($file) || Console::input("El modelo existe, �desea sobrescribirlo? (s/n): ", array('s', 'n')) == 's') {
         // nombre de clase
         $class = Util::camelcase($model_name);
         // codigo de modelo
         ob_start();
         include CORE_PATH . 'console/generators/model.php';
         $code = '<?php' . PHP_EOL . ob_get_clean();
         // genera el archivo
         if (file_put_contents($file, $code)) {
             echo "-> Creado modelo {$model_name} en: {$file}" . PHP_EOL;
         } else {
             throw new KumbiaException("No se ha logrado crear el archivo \"{$file}\"");
         }
     }
 }

 /**
  * Ejecuta el destroyer
  *
  * @param string $name elemento a destruir
  * @param array $params
  * @return boolean
  * @throw KumbiaException
  */
 public static function execute($name, $params)
 {
     $path = APP_PATH . 'controllers/';
     if (isset($params['module']) && $params['module']) {
         $path .= "{$params['module']}/";
     }
     $controller = Util::camelcase($name);
     $scontroller = Util::smallcase($name);
     /**
      * Nombre de archivo
      **/
     $file = $path . "{$scontroller}_controller.php";
     echo "\r\n-- Eliminando controller: {$controller}\r\n{$file}\r\n";
     if (!unlink($file)) {
         throw new KumbiaException("No se ha logrado eliminar el archivo {$file}");
     }
     $path = APP_PATH . 'views/';
     if (isset($params['module']) && $params['module']) {
         $path .= "{$params['module']}/";
     }
     $path .= Util::smallcase($name) . '/';
     echo "\r\n-- Eliminando directorio:\r\n{$path}\r\n";
     if (!Util::removeDir($path)) {
         throw new KumbiaException("No se ha logrado eliminar el directorio {$path}");
     }
     return true;
 }

 /**
  * Ejecuta un destroyer
  *
  * @param string $destroyer nombre del destroyer (destructor) a ejecutar
  * @param string $name elemento a eliminar
  * @param array $params array de parametros para el destructor
  * @return boolean
  */
 public static function destroy($destroyer, $name = null, $params = array())
 {
     $success = false;
     $destroyer_class = Util::camelcase($destroyer) . 'Destroyer';
     if (class_exists($destroyer_class)) {
         $success = call_user_func(array($destroyer_class, 'execute'), $name, $params);
     } else {
         throw new KumbiaException("No se ha encontrado la clase {$destroyer_class} necesaria para el destroyer");
     }
     return $success;
 }

 /**
  * Obtiene la instancia de un modelo
  *
  * @param string $model
  * @return obj model
  */
 public static function model($model)
 {
     //Nombre de la clase
     $Model = Util::camelcase(basename($model));
     //Carga la clase
     if (!class_exists($Model, FALSE)) {
         //Carga la clase
         if (!(include APP_PATH . "models/{$model}.php")) {
             throw new KumbiaException("No existe el modelo {$model}");
         }
     }
     return new $Model();
 }

 /**
  * Obtiene la instancia de un modelo
  *
  * @param string $model modelo a instanciar
  * @param mixed $params parámetros para instanciar el modelo
  * @return obj model
  */
 public static function model($model, $params = NULL)
 {
     //Nombre de la clase
     $Model = Util::camelcase(basename($model));
     //Carga la clase
     if (!class_exists($Model, FALSE)) {
         //Carga la clase
         if (!(include_once APP_PATH . "models/{$model}.php")) {
             throw new KumbiaException($model, 'no_model');
         }
     }
     return new $Model($params);
 }

 /**
  * Realiza el dispatch de una ruta
  *
  * @return Object
  */
 public static function execute($route)
 {
     extract($route, EXTR_OVERWRITE);
     if (!(include_once APP_PATH . "controllers/{$controller_path}" . '_controller.php')) {
         throw new KumbiaException(NULL, 'no_controller');
     }
     //Asigna el controlador activo
     $app_controller = Util::camelcase($controller) . 'Controller';
     $cont = self::$_controller = new $app_controller($module, $controller, $action, $parameters);
     View::select($action);
     View::setPath($controller_path);
     // Se ejecutan los filtros before
     if ($cont->k_callback('initialize') === FALSE) {
         return $cont;
     }
     if ($cont->k_callback('before_filter') === FALSE) {
         return $cont;
     }
     //Se ejecuta el metodo con el nombre de la accion
     //en la clase de acuerdo al convenio
     if (!method_exists($cont, $action)) {
         throw new KumbiaException(NULL, 'no_action');
     }
     //Obteniendo el metodo
     $reflectionMethod = new ReflectionMethod($cont, $action);
     //k_callback y __constructor metodo reservado
     if ($reflectionMethod->name == 'k_callback' || $reflectionMethod->isConstructor()) {
         throw new KumbiaException('Esta intentando ejecutar un método reservado de KumbiaPHP');
     }
     //se verifica que el metodo sea public
     if (!$reflectionMethod->isPublic()) {
         throw new KumbiaException(NULL, 'no_action');
     }
     //se verifica que los parametros que recibe
     //la action sea la cantidad correcta
     $num_params = count($parameters);
     if ($cont->limit_params && ($num_params < $reflectionMethod->getNumberOfRequiredParameters() || $num_params > $reflectionMethod->getNumberOfParameters())) {
         throw new KumbiaException("Número de parámetros erroneo para ejecutar la acción \"{$action}\" en el controlador \"{$controller}\"");
     }
     $reflectionMethod->invokeArgs($cont, $parameters);
     //Corre los filtros after
     $cont->k_callback('after_filter');
     $cont->k_callback('finalize');
     //Si esta routed volver a ejecutar
     if (Router::getRouted()) {
         Router::setRouted(FALSE);
         return Dispatcher::execute(Router::get());
         // Vuelve a ejecutar el dispatcher
     }
     return $cont;
 }

 /**
  * Ejecuta el destroyer
  *
  * @param string $name elemento a destruir
  * @param array $params
  * @return boolean
  * @throw KumbiaException
  */
 public static function execute($name, $params)
 {
     $filter = Util::camelcase($name);
     $sfilter = Util::smallcase($name);
     /**
      * Nombre de archivo
      **/
     $file = APP_PATH . "filters/{$sfilter}_filter.php";
     echo "\r\n-- Eliminando filter: {$filter}\r\n{$file}\r\n";
     if (!unlink($file)) {
         throw new KumbiaException("No se ha logrado eliminar el archivo {$file}");
     }
     return true;
 }

 /**
  * Ejecuta el builder
  *
  * @param string $name elemento a construir
  * @param array $params
  * @return boolean
  * @throw BuilderException
  */
 public static function execute($name, $params)
 {
     $path = APP_PATH . 'controllers/';
     if (isset($params['module']) && $params['module']) {
         $path .= "{$params['module']}/";
     }
     if (!is_dir($path)) {
         if (!Util::mkpath($path)) {
             throw new KumbiaException("No se ha logrado generar la ruta para controllers {$path}");
         }
     }
     $controller = Util::camelcase($name);
     $scontroller = Util::smallcase($name);
     /**
      * Nombre de archivo
      **/
     $__file__ = $path . "{$scontroller}_controller.php";
     /**
      * Generando archivo
      **/
     if (!file_exists($__file__)) {
         extract($params);
         echo "\r\n-- Generando controller: {$controller}\r\n{$__file__}\r\n";
         ob_start();
         echo "<?php\n";
         include CORE_PATH . 'libs/builder/base_builders/templates/controller.php';
         $code = ob_get_contents();
         ob_end_clean();
         if (!file_put_contents($__file__, $code)) {
             throw new KumbiaException("No se ha logrado generar el archivo de controller {$__file__}");
         }
         $path = APP_PATH . 'views/';
         if (isset($params['module']) && $params['module']) {
             $path .= "{$params['module']}/";
         }
         $path .= $scontroller;
         if (!is_dir($path)) {
             echo "\r\n-- Generando directorio de vistas: \r\n{$path}\r\n";
             if (!is_dir($path)) {
                 if (!Util::mkpath($path)) {
                     throw new KumbiaException("No se ha logrado generar la ruta para controllers {$path}");
                 }
             }
         }
     } else {
         echo "\r\n-- El controller ya existe en {$__file__}\r\n";
     }
     return true;
 }

 /**
  * Comando de consola para crear un controlador
  *
  * @param array $params parametros nombrados de la consola
  * @param string $controller controlador
  * @throw KumbiaException
  */
 public function create($params, $controller)
 {
     // nombre de archivo
     $file = APP_PATH . 'controllers';
     // limpia el path de controller
     $clean_path = trim($controller, '/');
     // obtiene el path
     $path = explode('/', $clean_path);
     // obtiene el nombre de controlador
     $controller_name = array_pop($path);
     // si se agrupa el controlador en un directorio
     if (count($path)) {
         $dir = implode('/', $path);
         $file .= "/{$dir}";
         if (!is_dir($file) && !FileUtil::mkdir($file)) {
             throw new KumbiaException("No se ha logrado crear el directorio \"{$file}\"");
         }
     }
     $file .= "/{$controller_name}_controller.php";
     // si no existe o se sobreescribe
     if (!is_file($file) || Console::input("El controlador existe, ¿desea sobrescribirlo? (s/n): ", array('s', 'n')) == 's') {
         // nombre de clase
         $class = Util::camelcase($controller_name);
         // codigo de controlador
         ob_start();
         include __DIR__ . '/generators/controller.php';
         $code = '<?php' . PHP_EOL . ob_get_clean();
         // genera el archivo
         if (file_put_contents($file, $code)) {
             echo "-> Creado controlador {$controller_name} en: {$file}" . PHP_EOL;
         } else {
             throw new KumbiaException("No se ha logrado crear el archivo \"{$file}\"");
         }
         // directorio para vistas
         $views_dir = APP_PATH . "views/{$clean_path}";
         //si el directorio no existe
         if (!is_dir($views_dir)) {
             if (FileUtil::mkdir($views_dir)) {
                 echo "-> Creado directorio para vistas: {$views_dir}" . PHP_EOL;
             } else {
                 throw new KumbiaException("No se ha logrado crear el directorio \"{$views_dir}\"");
             }
         }
     }
 }

 /**
  * Aplica filtro de manera estatica
  *
  * @param mixed $s variable a filtrar
  * @param string $filter filtro
  * @param array $options
  * @return mixed
  */
 public static function get($s, $filter, $options = array())
 {
     if (is_string($options)) {
         $filters = func_get_args();
         unset($filters[0]);
         $options = array();
         foreach ($filters as $f) {
             $filter_class = Util::camelcase($f) . 'Filter';
             if (!class_exists($filter_class, false)) {
                 self::_load_filter($f);
             }
             $s = call_user_func(array($filter_class, 'execute'), $s, $options);
         }
     } else {
         $filter_class = Util::camelcase($filter) . 'Filter';
         if (!class_exists($filter_class, false)) {
             self::_load_filter($filter);
         }
         $s = call_user_func(array($filter_class, 'execute'), $s, $options);
     }
     return $s;
 }