Yuppy! ahora se puede disfrutar del desarrollo web...

Liberamos Yupp CMS v0.2

2012-01-25T22:17:00.000-02:00

El proyecto va tomando forma con nuevas funcionalidades, mejoras y código más limpio. Todavía falta mucho camino por recorrer, pero vamos bien. Espero que en poco tiempo más gente se sume al proyecto y puedan aportar módulos y skins.

El CMS puede ser descargado desde:

http://code.google.com/p/yupp-cms/downloads/list
http://yupp-cms.googlecode.com/svn/tags/v0.2/ (usando un cliente SVN como Subclipse o Tortoise)

Les recuerdo algunos posts anteriores sobre el CMS:

Algunos comentarios:

Funciona con la versión trunk de Yupp Framework: http://yupp.googlecode.com/svn/trunk/YuppPHPFramework/
Para instalar es solo:

copiar el directorio en yupp/apps
crear la base de datos yupp_cms (corregir datos de conexión a la base si es necesario)
correr el bootstrap del cms (creará algunas páginas y módulos de ejemplo)

Solo para fanaticos de PHP

2012-01-25T18:26:00.000-02:00

Muy bueno:

Acelerando la ejecucion de jquery

2011-10-05T11:41:00.000-02:00

Ayer leí un artículo interesante, sobre cómo registrar eventos con jQuery en distintos elementos del DOM, y cómo con live() funciona más rápido que haciendo el registro luego de que termine de cargar el DOM.

http://encosia.com/dont-let-jquerys-document-ready-slow-you-down/

Yupp CMS: creando modulos

2011-09-23T12:52:00.000-03:00

En este artículo veremos como crear nuevos módulos para Yupp CMS.

Lo primero que tenemos es la estructura interna del CMS:

controllers

apps.cms2.controllers.CmsController.class.php

model

cms2.model.cms.Layout.class.php
cms2.model.cms.Module.class.php
cms2.model.cms.Page.class.php
cms2.model.cms.PageZone.class.php
cms2.model.cms.Zone.class.php

views

createModule.view.php
createPage.view.php
displayPage.view.php
displayPageRO.view.php
editModule.view.php
listModules.view.php
listPages.view.php

module

displayModule.template.php

El objetivo es crear un módulo para poder mostrar HTML y editarlo de forma visual en la web.

Lo primero que hacemos es crear la clase en el modelo, y ubicarla en model/nombreDelModulo:

YuppLoader::load('cms2.model.cms', 'Module');

class HtmlModule extends Module
{
   function __construct($args = array (), $isSimpleInstance = false)
   {
      $this->setWithTable("cms_html_module");
        
      $this->addAttribute("content", Datatypes :: TEXT);

      parent :: __construct($args, $isSimpleInstance);
   }

   public static function listAll(ArrayObject $params)
   {
      self :: $thisClass = __CLASS__;
      return PersistentObject :: listAll($params);
   }

   public static function count()
   {
      self :: $thisClass = __CLASS__;
      return PersistentObject :: count();
   }

   public static function get($id)
   {
      self :: $thisClass = __CLASS__;
      return PersistentObject :: get($id);
   }

   public static function findBy(Condition $condition, ArrayObject $params)
   {
      self :: $thisClass = __CLASS__;
      return PersistentObject :: findBy($condition, $params);
   }

   public static function countBy(Condition $condition)
   {
      self :: $thisClass = __CLASS__;
      return PersistentObject :: countBy($condition);
   }
}

El módulo se llama HtmlModule, y siempre debe extender a Module. La estructura de directorios en model quedará así:

model

htmlModule

cms2.model.htmlModule.HtmlModule.class.php

Ahora necesitamos crear un controlador que implemente las acciones particulares sobe ese módulo, como editar el contenido. El controlador debe tener el mismo nombre que el módulo. Aquí está el código del controlador:

YuppLoader::load('cms2.model.htmlModule', 'HtmlModule');

class HtmlModuleController extends YuppController {

   /**
    * Edita el contenido del modulo de HTML.
    * 
    * in: id
    * in: pageId
    */
   public function editAction()
   {
      $module = HtmlModule::get($this->params['id']);
      if (isset($this->params['doit']))
      {
         $module->setProperties($this->params);
         if (!$module->save()) print_r($module->getErrors());
         
         return $this->renderString('Modulo salvado correctamente');
      }
      
      return array('module'=>$module);
   }
}

Aquí está la estructura de directorios resultante de controladores:

controllers

apps.cms2.controllers.CmsController.class.php
apps.cms2.controllers.HtmlModuleController.class.php

Por último, se implementan las vistas del módulo. Una vista será para la edición del contenido, y otra para la visualización del contenido del módulo. La estructura de directorios resultante es la siguiente:

views

....

module

displayModule.template.php

htmlModule

edit.view.php
displayModule.template.php

Como se puede ver, en realidad la vista de visualización del contenido del módulo es en realidad un template.

displayModule.template.php:

<?php echo $module->getContent(); ?>
<?php if ($mode=='edit') : ?>
  <div class="customModuleActions">
    <a href="'htmlModule', 'action'=>'edit', 'class'=>$module->getClass(), 'id'=>$module->getId())); ?>" alt="editar html" class="edit_html">
      <?php echo h('img', array('app'=>'cms2', 'src'=>'edit.gif')); ?>
    </a>  
  </div>
<?php endif; ?>

Este template muestra el contenido del módulo, y si estamos en modo "edit", muestra el botón para editar el contenido del módulo.

edit.view.php:

<?php

$m = Model::getInstance();

$module = $m->get('module');

YuppLoader::load('core.mvc', 'DisplayHelper');

?>
<html>
  <head>
    <style>
      body {
         padding: 5px;
      }
    </style>
    
    <?php echo h('js', array('app'=>'cms2', 'name'=>'jquery/jquery-1.5.1.min')); ?>
    <?php echo h('js', array('app'=>'cms2', 'name'=>'jquery/jquery.form-2.84')); ?>
    <script type="text/javascript">
      
      // Funcion que va a llamar el editor cuando termine de cargar (ver config del TinyMCE)
      var htmlinit = function() {
         
         parent.modalReady(document); // Notifica para que el parent actualice el tamanio del iframe
      }
      
      $(document).ready( function() {
        
        // Para que actualice el textarea con el contenido del TinyMCE, antes de mandarlo por ajax.
        // Ref: http://maestric.com/doc/javascript/tinymce_jquery_ajax_form
        $('#editForm').bind('form-pre-serialize', function(e) {
            
            tinyMCE.triggerSave();
        });
        
        // Submitea el form por ajax
        $('#editForm').ajaxForm({
          
          // Cuando el servidor responde ok, quiero actualizar
          // automaticamente el HTML del modulo sin hacer F5.
          success: function (res, status, response) {
             
            // Este es el modulo que cambia en el dom
            var module = $('#getClass().'__'.$module->getId(); ?>', parent.document);
             
            // Tengo que pedir al servidor el HTML actualizado para este modulo
            // Luego meto el actualizado en el dom, antes del que cambie
            // Luego elimino el modulo viejo del dom para que quede solo el actualizado
            
            $.ajax({
              url: ''cms', 'action'=>'moduleContent', 'params'=>array('class'=>$module->getClass(), 'id'=>$module->getId()))); ?>',
              success: function (newModuleContent, status) {
                
                // Actualiza solo el contenido!
                module.children('.moduleContent').html(newModuleContent);

                // Obtengo ventana modal
                var modal = $('#modal', parent.document); // Selecciona ventana
                
                // Cierra ventana modal
                modal.fadeOut('slow').css('display', 'none').children('iframe').attr('src', '');
              }
            });
          }
        });
      });
      
    </script>
  </head>
  <body>
    <form id="editForm" method="post" action="'edit')); ?>">
      <input type="hidden" name="id" value="getId(); ?>" />
      <input type="hidden" name="pageId" value="get('pageId'); ?>" />
      <?php DisplayHelper::html( 'content', $module->getContent() ); ?>
      <input type="submit" name="doit" value="Guardar" />
    </form>
  </body>
</html>

Eso es todo. Cualquiera puede desarrollar sus propios módulos, por ejemplo un cliente de twitter, un visualizador de videos de youtube, un blog, un albúm de fotos, etc, el límite es la imaginación!

.

Yupp CMS: un nuevo comienzo

2011-09-02T13:24:00.001-03:00

Hace ya varios años que vengo desarrollando en PHP, y desde el principio comencé a experimentar distintas técnicas para el desarrollo de sitios web dinámicos. La culminación de esa investigación dio lugar a mi primer proyecto de CMS. Luego de seguir avanzando en mi formación universitaria, y conociendo diversas tecnologías, me di cuenta que aquel primer CMS no era suficiente, y tratando de hacerlo más genérico y extensible fue que comencé el proyecto Yupp Framework (si, todo esto comenzó como una librería que sería el core de un CMS).

Ahora Yupp tiene vida propia y superó mis expectativas como proyecto, convirtiéndose en una herramienta muy potente para el desarrollo PHP en general. Ahora estoy volviendo a las raíces, y con todo lo aprendido de los distintos intentos de CMS, y de la experiencia acumulada durante años, me lancé a lograr algo mejor, más genérico, más extensible, más fácil de usar, más dinámico, o sea la herramienta perfecta. Claro está, que la herramienta perfecta para unos puede no serlo para otros, desde mi humilde lugar lo que quiero es bajar a tierra todas esas "grandes ideas" y ponerlas en una herramienta que me facilite en el trabajo diario.

Aquí están algunas capturas de pantalla del prototipo que tengo hasta ahora. Es una aplicación para Yupp Framework v0.4, donde desarrollé varias funcionalidades básicas, y aunque faltan otras tantas, se puede usar.

Todos los que quieran colaborar con el proyecto, por favor contesten este hilo de discusión.

Esta primer captura de pantalla muestra una página del portal en modo "edición", donde hay zonas que se ven de colores (rojo, violeta, azul, etc), y cada zona puede contener varios módulos (las cajitas celestes).
Los módulos pueden ser de 3 tipos: html, menú y google maps. Estos son solo algunos que desarrollé para probar el concepto, la idea es que sea algo con extensibilidad ilimitada y cualquiera pueda crear sus propios módulos fácilmente, extendiendo así la funcionalidad del CMS.

Los módulos pueden arrastrarse y soltarse en distintas zonas, lo que ayuda a que rápidamente un editor pueda ubicar los módulos en las zonas correctas. En la siguiente imagen se ve como el módulo html que contenía el banner en la zona superior, es movido a la zona intermedia.

Esta tercer captura de pantalla muestra la edición del contenido de un módulo de html.

Y esta cuarta captura muestra el resultado luego de la edición del contenido del módulo de html.

Otra funcionalidad que provee este prototipo, es el cambio de layout con un clic. Un layout define la estructura general de las páginas, con las zonas donde se pueden ubicar distintos módulos. Un programador puede generar nuevos layouts, e instalarlo en el CMS. Incluso los diseñadores gráficos no programadores, podrían generar layouts. La siguiente imagen muestra el cambio de layout con respecto a las imágenes anteriores:

Esta imagen muestra otro cambio de layout:

Un editor podría crear nuevos módulos y agregarlos en distintas zonas con un par de clics.

La siguiente imagen muestra el módulo luego de creado:

El editor podría también crear subpáginas para la página actual:

Las subpáginas de la página actual aparecen en el menú en la parte inferior:

Por último, si salimos del modo "edición", podemos ver la página en modo "visualización":

Aplicacion para gestion de contenido con tags

2011-08-22T22:32:00.002-03:00

Este fin de semana desarrollé un prototipo de un sistema de gestión de contenido, concentrándome en las funcionalidades de agregar y quitar tags del contenido.

Aquí les dejo la aplicación para descargar y probar.

El objetivo fue evaluar que tan costoso era implementarlo en Yupp framework, y el resultado fue el siguiente:

Aplicación: Yupp/Ajax/jQuery/MySQL
Dedicación: 4 horas
Funcionalidades principales: crear tags, agregar tags a varios videos (contenido), quitar una tag de un video
Funcionalidades de soporte: obtener todas las tags existentes, obtener las tags para cada video

Lo que logré fue algo así:

A continuación les cuento un poco cómo lo hice:

Estructura de la aplicación:

bootstrap

apps.resman.bootstrap.Bootstrap.script.php

controllers

apps.resman.controllers.TagsController.class.php
apps.resman.controllers.VideoController.class.php

javascript

jquery-1.6.2.min.js
jquery.form-2.84.js

model

resman.model.Tag.class.php
resources

resman.model.resources.Video.class.php

views

video

list.view.php

app.xml

Como pueden ver, es una aplicación pequeña, con un par de controllers, un par de clases de modelo persistente, una vista y un par de archivos javascript, uno es el famoso framework javascript jQuery y el otro el plugin para gestionar formularios y poder hacer envíos por ajax, en lugar del clásico submit que nos hace tener que recargar toda la página, y hacerlo por ajax mejora enormemente la experiencia del usuario.

En el archivo de bootstrap se crean algunos videos y la etiqueta que guarda todas las etiquetas del sistema (luego explico como es esto). Como esto es una prueba y no es un gestor de contenidos completo se deben crear los videos en el bootstrap. Si fuera un gestor de contenidos completo, tendría funcionalidades para poder crear, modificar y eliminar videos y otros tipos de contenidos como archivos, links, etc.

En el bootstrap tenemos:

// Incluye clases del modelo persistente

YuppLoader::load('resman.model', 'Tag');

YuppLoader::load('resman.model.resources', 'Video');



// Crea videos de prueba

$videos = array();



$videos[] = new Video(array(

  'name'=>'La Coka Nostra - That\'s coke',

  'comment'=>'excelente!',

  'embedCode'=>'<iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/HaVf_yrq6Q0" width="560"></iframe>',

  'link'=>'http://youtu.be/HaVf_yrq6Q0'

));

$videos[] = new Video(array(

  'name'=>'Snoop Dog - Vato',

  'comment'=>'hardcore',

  'embedCode'=>'<iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/D_9Dfh2Hf-A" width="560"></iframe>',

  'link'=>'http://youtu.be/D_9Dfh2Hf-A'

));

$videos[] = new Video(array(

  'name'=>'Snoop Dog - Drop it like it\'s hot',

  'comment'=>'chambalala',

  'embedCode'=>'<iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/LfgMC6F0FVo" width="420"></iframe>',

  'link'=>'http://youtu.be/LfgMC6F0FVo'

));



// Guarda en la base los videos de prueba

foreach ($videos as $video)

{

   $video->save();

}



// Crea la instancia global con todas las tags

$globalTags = new Tag(array('tags'=>''));

$globalTags->save();

Antes comentaba que se crea una instancia de Tag que va a guardar todas las tags que se crean en el sistema, la idea es que desde esas tags se seleccionen las tags que se le van a poner a los videos.

Las tablas que generan las clases del modelo persistente son las siguientes:

Tabla de videos con los 3 videos creados en el bootstrap:

id	name	comment	embedCode	link	class
1	La Coka Nostra - That's coke	excelente!	<iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/HaVf_yrq6Q0" width="560"></iframe>	http://youtu.be/HaVf_yrq6Q0	Video
2	Snoop Dog - Vato	hardcore	<iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/D_9Dfh2Hf-A" width="560"></iframe>	http://youtu.be/D_9Dfh2Hf-A	Video
3	Snoop Dog - Drop it like it's hot	chambalala	<iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/LfgMC6F0FVo" width="420"></iframe>	http://youtu.be/LfgMC6F0FVo	Video

Tabla de tags con la tag que tiene todas las tags creadas en el sistema (la que tiene objClass y objId en NULL), y las tags creadas para cada uno de los videos. Todas las tags de cada video se guardan codificadas en la columna "tags", separadas por coma. Estas son las tags que aparecen en la captura de pantalla que puse más arriba.

id	objClass	objId	tags	class
1	NULL	NULL	papa,pepe,popo,pupu,caradura,sampatrucha	Tag
2	Video	1	popo,sampatrucha,pepe	Tag
3	Video	2	sampatrucha,caradura,pepe	Tag
4	Video	3	popo,sampatrucha,caradura	Tag

Podría repasar toda las funcionalidades, pero aquí les dejo la aplicación para descargar, donde pueden ver el código y probar de instalarla en Yupp Framework 0.4, además el código está lleno de comentarios.

La idea central era mostrar que con aproximadamente 300 líneas de código, entre PHP y Javascript, y en 4 horas, se pueden lograr funcionalidades muy interesantes, que agilizan la experiencia del usuario, y que tienen gran usabilidad.

Google code search una herramienta excelente

2011-06-20T21:41:00.000-03:00

Google code search es una herramienta de Google para buscar código fuente dentro de los proyectos alojados en Google code. Por ejemplo, Yupp Framework es un proyecto de código abierto alojado en Google code.

Ingresando al buscador de código, podemos ingresar el siguiente texto: "helper ajax_link package:http://yupp\.googlecode\.com". Al buscar, vamos a obtener una lista de resultados. Haciendo clic en alguno de los resultados de esa lista, podemos acceder al código fuente:

Luego podemos recorrer el código fuente de uno o más archivos donde se dieron resultados para nuestra búsqueda, o también podemos realizar otras búsquedas.

Esta es una excelente herramienta para encontrar en pocos segundos el código fuente exacto que estamos buscando.

Ideas para mejorar el framework

2011-06-17T22:26:00.001-03:00

En esta página de la wiki, dejé algunas ideas para mejorar el framework, su usabilidad y funcionalidad: http://code.google.com/p/yupp/wiki/IdeasDeMejoras

Me gustaría hacer una evaluación de las cosas que más les gustaría que el framework incluya, a modo de "lluvia de ideas", para luego poder elegir las más interesantes y poder implementarlas como parte del framework.

Lo que más valor puede agregar en este momento al framework, creo que es la "arquitectura de plugins" (descrita en el link previo). La idea es poder extender el framework indefinidamente, pero de forma controlada y gestionable, mediante "plugins" o "agregados". Por ejemplo, en el Yupp Connect que hicimos hace pocos días, hablamos de poder contar con un "módulo" de gestión de usuarios y permisos, que cualquier aplicación pudiera usar. Este es un claro ejemplo de lo que llamo "plugin": algo que no es parte del core o núcleo del framework, pero que tampoco es una aplicación, sino que es algo que está en el medio y que las aplicaciones pueden usar.

¿Cómo seguimos?

Lee las "ideas de mejoras" que hay publicadas en la wiki, comenta al respecto en la misma wiki o respondiendo a este hilo. Los comentarios se convertirán en mejoras a las ideas propuestas.
Proponé nuevas ideas para extender y mejorar el framework respondiendo a este hilo de discusión. Todas las ideas serán tomadas en cuenta y debatidas para lograr especificarlas lo más posible, luego haremos una votación en la comunidad para detectar las ideas más útiles o novedosas. Estas serán en las que nos concentraremos para su desarrollo.
Si tienes algún desarrollo ya hecho, que pueda servir para integrar con el framework, también puedes proponerlo, y entre todos los podemos evaluar. Lo que se debe considerar en este caso, es que el dueño del código debe dar soporte al mismo y documentación, además deberá ayudar en la integración con el framework. Esto es para mantener el nivel del framework y no integrar código que no tiene documentación y al que nadie puede dar soporte.

¡Espero sus comentarios e ideas!

Nuevo Yupp PHP Framework v0.4

2011-06-10T22:30:00.001-03:00

Estamos muy contentos de anunciar la liberación de la nueva versión de Yupp PHP Framework.

En esta versión se incluyen varias mejoras y correcciones que hacen al framework más simple de usar y más completo en cuanto a su funcionalidad de base. Además hemos actualizado la documentación de referencia para facilitar la tarea de quienes están comenzando a usar el framework.

Como siempre, el framework podrá ser descargado desde nuestro sitio en Google Code:
http://code.google.com/p/yupp/

Aquí podrás encontrar los detalles de los cambios y mejoras hechos en esta nueva versión:
http://code.google.com/p/yupp/wiki/Hoja_de_ruta#v0.4:_codename_Genesis_3_%28liberado%29

Las notas de la versión con detalles de las pruebas realizadas, de la instalación del framework y mucha información útil para comenzar a usar el framework, las puedes encontrar aquí:
http://code.google.com/p/yupp/wiki/YuppPHPFrameworkv04

La documentación actualizada la puedes encontrar aquí:
http://www.simplewebportal.net/yupp_framework_php_doc/

Pronto estaremos actualizando las aplicaciones en nuestro sitio de Yupp Apps para aprovechar al máximo las novedades de esta versión del framework:
http://code.google.com/p/yupp-apps/

Como siempre, todas las consultas y comentarios serán recibidas en nuestro sitio de Google Groups:
http://groups.google.com/group/yuppframeworkphp

Yupp Connect

2011-05-31T01:33:00.002-03:00

¿Cuál es la idea?

Tomar un par de horas para hablar del framework, de cómo usarlo, de cómo se podría adaptar para encarar sus proyectos, resolver dudas de programación o simplemente charlar de conceptos generales en tecnología, mejores prácticas, gestión de proyectos, patrones de diseño, etc.

¿Cómo y cuando?

Nos conectamos por Skype (mi usuario es simplewebportal.net).

La primera charla la hacemos el miércoles 8 de Junio, a las 15 horas de Montevideo (puedes ver tu horario local aquí: http://timeanddate.com/worldclock/).

Un par de días antes, voy a crear un hilo de discusión donde quienes estén interesados en conectarse, pueden proponer temas. Igualmente, para romper el hielo, voy a proponer un par.

¿Qué se espera de ti?

Primero que nada, ponerle buena onda. Luego, el objetivo es charlar de cosas interesantes para ti, de tus proyectos, de tus dudas sobre el framework y su funciomiento, de problemas que tratas de resolver o que te gustaría resolver en el futuro usando el framework, del futuro del framework como proyecto, entre otros.

Más info.

Temas:

Hasta el miércoles!,
Pablo.

PD: esto se haría aparte, no sustituyendo, a las charlas por LiveStream (http://www.livestream.com/yuppphpframework) sobre el framework.

Google Code Playground

2011-05-23T21:57:00.001-03:00

Google Code Playground es un sitio de pruebas en vivo, por donde todo programador que quiera utilizar APIs de Google debería pasar.

Este sitio presenta ejemplos de casi todas las APIs de Google, incluyendo:

Ya sea que vamos a jugar un poco, o que vamos a utilizar las APIs de Google para nuestros proyectos, este es un sitio para tener siempre en las bookmarks...

Videos del tutorial virtual

2011-05-21T13:25:00.000-03:00

Estimados, aquí dejo las dos partes del tutorial para quienes no pudieron estar en el momento de la emisión. Las consultas que tengan las pueden realizar en nuestro grupo.

Watch live streaming video from yuppphpframework at livestream.com

Link para el tutorial virtual de hoy

2011-05-19T08:27:00.005-03:00

El tutorial virtual de Yupp PHP Framework de hoy, a las 18:30 (GMT -03:00) lo hacemos por LiveStream http://www.livestream.com/yuppphpframework

De haber problemas, lo haremos por skype con solo sonido. Mi usuario de skype es simplewebportal.net

Saludos,
Pablo.

Día y hora del tutorial virtual de Yupp

2011-05-13T19:07:00.002-03:00

Estimados,

El tutorial virtual del framework se llevará a cabo el día jueves 19 de mayo a las 1830 (hora de Montevideo, GMT -03:00). Por favor verifiquen su uso horario para saber a qué hora local corresponde. Por ejemplo, Buenos Aires está en el mismo uso horario que Montevideo. Caracas está en GMT -04:30, o sea que la hora local de inicio en Caracas será a las 1700. Para ver la diferencia horaria en distintas ciudades, les dejo este sitio: http://timeanddate.com/worldclock/

La idea es que lo hagamos en una hora y media, dos horas máximo con preguntas y comentarios. Por favor agenden ese día, y no se preocupen si no pueden a esa hora, que ya haremos otros eventos de este tipo.

Yo estaré conectado un rato antes para realizar pruebas. Quienes puedan estar antes, les agradezco, así podemos verificar que la comunicación es correcta.

El evento lo haremos por UStream (http://www.ustream.tv/channel/yupp-php-framework), y en caso de haber problemas, tenemos la alternativa de LiveStream (http://www.livestream.com/yuppphpframework). El plan C, si nada funciona correctamente, sería mediante skype. Mi usuario en skype es: simplewebportal.net

Todos los que se anotaron al tutorial, recibirán este mismo correo, y además el link para descargar todo el material necesario para el tutorial. Este material será publicado luego del tutorial para todos quienes quieran tenerlo y no hayan podido estar. Este incluye: documentación, presentación guía, última versión del framework, y aplicaciones de ejemplo con las que estaremos jugando un poco.

La idea de este primer tutorial virtual es que sea muy llevado de la mano, para que todos los que recién empiezan con el framework puedan sus primeros pasos sobre firme, entender algunos conceptos clave, y
llegar a crear aplicaciones sencillas. Luego haremos otros eventos virtuales, donde tocaremos temas concretos y más complejos, y dará más para la discusión. La idea que esta segunda parte la podamos hacer en un par de semanas luego de este evento. Luego daré una lista de temas que les pueden interesar, así tocamos primero los temas que más les interesen.

No está de más decir que estos eventos son gratuitos y totalmente libres para todos quienes quieran acercarse al proyecto para concerlo, probarlo, evaluarlo y usarlo. El objetivo de estos eventos es consolidar la comunidad Yupp, para darle continuidad al proyecto, y poder mejorarlo entre todos.

Muchas gracias a todos, espero que podamos hacer de este primer evento un éxito, ¡y que sea el primero de muchos!

¡Un saludo desde mi paisito Uruguay!
Pablo.

Tutorial de Yupp Framework version virtual

2011-04-29T18:15:00.001-03:00

Estoy armando una versión virtual del tutorial. Les cuento un poco lo que pasó en la versión presencial y las ideas para el virtual, cualquier comentario o duda es todo bienvenido.

Hace unos días hicimos un taller de Yupp PHP Framework en Montevideo, Uruguay.

La idea fue dar a conocer el framework a quienes no lo conocían, e ir de conceptos básicos de funcionamiento, instalación y configuración, hasta la creación de una aplicación web completa con algún grado de dificultad.

Los participantes llevaron sus notebooks, y les dimos todo el material necesario para que pudieran instalar el framework y ejecutar los ejemplos en sus propias computadoras.

Muchos desarrolladores me han preguntado si se podría hacer el evento en otros países, y tengo ganas de organizar algo virtual para que todos puedan participar (aunque sea por curiosidad) desde sus casas u oficinas. Voy a pensar un poco más cómo podría implementarse esto. Si tienen sugerencias, son bienvenidas. Por ahora sería:

- Audio por Skype
- Visualización de documentos y presentaciones por Google Docs
- Consultas por chat (Google Talk o mismo Skype)
- Todo el material lo tienen para descargar por lo que pueden seguirlo cada uno localmente

Por ahora dejo disponible todo el material del taller que puede descargarse aquí: http://yuppframework.blogspot.com/2011/04/post-mortem-del-tutorial-de-yupp.html
Esto contiene un documento hecho especialmente para el taller, la presentación, el framework, aplicaciones de ejemplo y el software de base necesario (usamos WAMP y Notepad++).

He creado un formulario para organizar a los interesados en participar del evento virtual, si quieren participar pueden poner sus datos aquí: https://spreadsheets.google.com/spreadsheet/viewform?formkey=dFlpbW8ySVljS1dPZmNaaGJpOTFQREE6MQ

Post mortem del tutorial de Yupp

2011-04-23T21:44:00.000-03:00

El pasado viernes 15 de abril se llevó a cabo el primer tutorial de Yupp PHP Framework "manos a la obra con Yupp Framework".

La idea central fue empapar a los asistentes en el uso del framework y sus posibilidades, por esta razón fuimos desde la instalación del framework a la creación de una aplicación web simple, pero con algún nivel de complejidad en la parte de ORM.

A los asistentes se les entregó todo el material, que también está disponible en línea para todos los que deseen tenerlo. Este material consiste en el software de base necesario, en la versión "trunk" del framework, un documento especialmente diseñado para el tutorial, la presentación utilizada, y una serie de aplicaciones. Las aplicaciones son en realidad, distintas versiones de la misma aplicación, la cual evoluciona a medida que avanza en tutorial, agregando complejidad para mostrar distintos aspectos del framework.

Gracias a esta primer experiencia, la idea es mejorar el tutorial y repetirlo en Uruguay y en la región. Muchos desarrolladores argentinos me han consultado sobre hacerlo ahí. Ojalá podamos organizar algún evento pequeño con la comunidad argentina de desarrolladores web.

Aquí dejo un par de fotitos del evento:

Tutorial Yupp PHP Framework: manos a la obra

2011-04-06T23:56:00.001-03:00

Sobre el evento:

El objetivo de este tutorial es mostrar cómo se trabaja con el framework, simplificando tareas repetitivas y disminuyendo al máximo las necesidades de configuración.

La entrada es libre y gratuita. Se aconseja traer laptop/notebook para poder realizar pruebas de instalación e implementar algunas aplicaciones sencillas. Para quienes tengan Windows, se aconseja tener WAMP (http://www.wampserver.com) instalado.

Dictado por Ing. Pablo Pazos Gutiérrez (http://www.linkedin.com/in/pablopazosgutierrez).

Apoya: LINS (http://www.fing.edu.uy/inco/grupos/lins/projects.html)

Día y hora:

Viernes 15 de abril de 2011, a las 20 horas.

Lugar:
En el salón C11 del edificio polifuncional Faro (Julio Herrera y Reissig 631, al lado de Facultad de Ingeniería http://www.fing.edu.uy/)

Ver en Google Maps

Temario:

Fundamentos de patrones MVC y ORM
Fundamentos de programación ágil y aplicaciones web
Instalación y configuración del framework
Estructura de Yupp Framework
URLs en Yupp
Creando una aplicación simple: hello world
Estructura de las aplicaciones Yupp

Configuración de la base de datos por aplicación
Script de bootstrap
Scripts de testing

Model:

Creando modelos de datos complejos: hasOne, hasMany, herencia
Creando restricciones sobre campos y relaciones

View:

Fundamentos de implementando vistas.
Uso de helpers.
Helpers layout y template.
Integración de liberías Javascript.
Vistas scaffolded.

Controller:

Convenciones.
Render vs Redirect.
Recibiendo archivos.
Devolviendo XML o JSON.
Acciones scaffolded.

Mejoras para las próximas versiones de Yupp PHP Framework.

Sobre Yupp:

Yupp PHP Framework es una herramienta ágil para el desarrollo de aplicaciones web orientadas a objetos. Yupp implementa el patrón arquitectónico Modelo-Vista-Controlador, y posee una herramienta ORM para la persistencia de objetos. Yupp está desarrollado sobre PHP5 y trabaja con distintos DBMS como MySQL, PostgreSQL y SQLite. Por más info:

Una característica a destacar es que este framework fue desarrollado en Uruguay.

Por más información:

Raquel Sosa <raquels@fing.edu.uy> (LINS)
Pablo Pazos <pablo.swp@gmail.com> (Yupp PHP Framework)

Tutorial manos a la obra con Yupp

2011-03-15T02:11:00.001-03:00

Estamos preparando un tutorial para el mes de abril con el objetivo de dar los fundamentos básicos para el desarrollo de aplicaciones web usando Yupp PHP Framework.

Si bien la temática aún no está 100% definida, el hilo de temas será muy parecido al siguiente:

Fundamentos de patrones MVC y ORM
Fundamentos de programación ágil y aplicaciones web
Instalación y configuración básica del framework
Estructura del framework
URLs en Yupp
Creando una aplicación simple: hello world
Estructura de las aplicaciones Yupp
Model:

Creando modelos de datos complejos: hasOne, hasMany, herencia
Creando restricciones sobre campos y relaciones

View:

Fundamentos de implementando vistas.
Uso de helpers.
Helpers layout y template.
Integración de liberías Javascript.
Vistas scaffolded.

Controller:

Convenciones.
Render vs Redirect.
Recibiendo archivos.
Devolviendo XML o JSON.
Acciones scaffolded.

Mejoras para las próximas versiones del framework.

Este temario podrá variar de aquí al evento.

El lugar será en Facultad de Ingeniería, Universidad de la República, Montevideo, Uruguay. Luego publicaremos el día y hora exactos.

.

Nuevo Yupp PHP Framework v0.3

2011-03-01T13:51:00.001-02:00

Estamos muy contentos de anunciar la liberación de la nueva versión de Yupp PHP Framework.

En esta versión se incluyen varias mejoras y correcciones que hacen al framework más simple de usar y más completo en cuanto a su funcionalidad de base. Además hemos actualizado la documentación de referencia para facilitar la tarea de quienes están comenzando a usar el framework.

Como siempre, el framework podrá ser descargado desde nuestro sitio en Google Code:
http://code.google.com/p/yupp/

Aquí podrás encontrar los detalles de los cambios y mejoras hechos en esta nueva versión:
http://code.google.com/p/yupp/wiki/Hoja_de_ruta#v0.3:_codename_Genesis_2_%28liberado%29

Las notas de la versión con detalles de las pruebas realizadas, de la instalación del framework y mucha información útil para comenzar a usar el framework, las puedes encontrar aquí:
http://code.google.com/p/yupp/wiki/YuppPHPFrameworkv03

La documentación actualizada la puedes encontrar aquí:
http://www.simplewebportal.net/yupp_framework_php_doc/

Pronto estaremos actualizando las aplicaciones en nuestro sitio de Yupp Apps para aprovechar al máximo las novedades de esta versión del framework:
http://code.google.com/p/yupp-apps/

Como siempre, todas las consultas y comentarios serán recibidas en nuestro sitio de Google Groups:
http://groups.google.com/group/yuppframeworkphp

¡Hasta pronto!

Inminente liberación de Yupp v0.3

2011-02-15T15:13:00.000-02:00

Llegamos a un punto donde la próxima liberación de Yupp PHP Framework se hace inminente.

Desde la versión anterior (Yupp Genesis v0.2.5) se han hecho varias correcciones, verificaciones y agregado nuevas funcionalidades. En nuestra wki se pueden encontrar los cambios realizados: http://code.google.com/p/yupp/wiki/Hoja_de_ruta#v0.3:

La nueva versión de Yupp seguramente estará disponible para descargar luego de actualizar las notas de la versión y la documentación del proyecto: http://www.simplewebportal.net/yupp_framework_php_doc/

Igualmente, todo el código fuente de esta nueva versión ya se encuentra en nuestro repositorio de versiones: http://yupp.googlecode.com/svn/YuppPHPFramework/

La versión 0.3 de Yupp Framework será conocida por el nombre clave: Yupp Genesis v2.

Documetacion actualizada

2011-02-14T15:00:00.000-02:00

Hemos actualizado la documentación de Yupp PHP Framework:

http://www.simplewebportal.net/yupp_framework_php_doc/index.html

Algunas de las actualizaciones son:

Cualquier consulta la pueden enviar al grupo de discusión: http://groups.google.com/group/yuppframeworkphp

Movix: gestor de peliculas hecho en Yupp

2011-02-02T04:59:00.002-02:00

Movix es una pequeña aplicación que implementé para gestionar mi colección de películas, de modo de saber qué películas tengo y tener un mecanismo fácil para buscar y ordenar películas cuando tengo ganas de ver algo específico.

Esta aplicación básicamente es un proxy que realiza búsquedas de películas en IMDB (http://www.imdb.com), y mediante técnicas de web scrapping, obtiene el contenido buscado y lo guarda en la base de datos local. Nada del otro mundo. La aplicación completa no supera los 127 KB.

Una de las características que más me gustó como quedó implementada es la de mostrar el ranking de la película como una barra coloreada, donde si la película recibe una puntuación de más de 75% se ve en verde y de menos del 30% se ve en rojo, pasando por un par de grados intermedios. Además se puede ordenar por ranking (ver las mejores rankeadas primero). Otra característica útil es la de filtrado por género, de modo que puedo querer una de "acción", y ordenando por rankeo puedo elegir entre las mejores.

Aquí se puede descargar esta y otras aplicaciones: http://code.google.com/p/yupp-apps/

Nota: si bien es una aplicación funcional, no está garantizado que funcione en el 100% de las búsquedas, debido a que las reglas de obtención de la información son estáticas y las páginas de IMDB pueden cambiar en cualquier momento, de todos modos se puede ir adaptando la aplicación a los cambios de IMDB.

Yupp Genesis v0.2.5

2010-12-20T02:41:00.001-02:00

Estamos contentos de anunciar la liberación de Yupp Framework v0.2.5 (versión Genesis).

Con motivo de esta liberación, se compatibilizaron todas las aplicaciones de Yupp Apps. Las nuevas versiones pueden descargarse aquí: http://code.google.com/p/yupp-apps/

Los cambios hechos desde la liberación anterior pueden verse en la hoja de ruta: http://code.google.com/p/yupp/wiki/Hoja_de_ruta

Notas de la versión: http://code.google.com/p/yupp/wiki/YuppPHPFrameworkv025

Documentación actualizada: http://simplewebportal.net/yupp_framework_php_doc

Descargas: http://code.google.com/p/yupp/downloads/list

Dudas o comentarios: http://groups.google.com/group/yuppframeworkphp

Agradecemos desde ya a toda la comunidad que nos apoya, y a quienes prueban el framework, nos envían consejos y mejoras, y lo usan para sus proyectos.

Para todos, gracias por seguir el desarrollo de este pequeño framework PHP en español, y por apoyarnos. Felices fiestas y un muy feliz año.

Encuesta sobre la version de PHP que usas

2010-12-07T06:38:00.000-02:00

Estoy tratando de implementar algunas características en Yupp que a su vez requieren de características que están disponibles desde PHP 5.3.0.

Siendo que Yupp funciona desde PHP 5.2.3 (e incluso anteriores), estos cambios requerirán el uso de PHP 5.3.0 o superior.

Queda abierta la encuesta para evaluar si vale la pena agregar estas características, en función del costo del cambio de versión de PHP.

¿Qué versión de PHP usas para desarrollar?
¿Qué versión de PHP tienen tus servidores de aplicaciones en producción?

Muchas gracias por la ayuda.

Mejorando la performance de Yupp Framework

2010-12-05T02:48:00.000-02:00

Hace un par de semanas hice la primer prueba de performance en tiempos de respuesta sobre el framework. Para hacer las pruebas utilicé Apache Bench (http://httpd.apache.org/docs/2.0/programs/ab.html).

Primero lancé una prueba sin ninguna optimización. Para esto utilicé una aplicación simple, sin acceso a la base de datos (lo que llaman un "hello world" básico). De esta prueba obtuve como resultado que el framework soportaba 5.5 pedidos por segundo y en promedio cada pedido se resolvía en 1.8 segundos (esto cuenta envío
del pedido, procesamiento de Apache, procesamiento del framework y envío de la respuesta).

Luego, puse un objetivo para bajar los tiempos de respuesta y aumentar los pedidos que se pueden hacer por segundo. El objetivo fue llevarlo al doble, o sea: atender 11 pedidos por segundo y que en promedio, el tiempo de respuesta fuera de 0.9 seg.

Luego de algunas optimizaciones en la inclusión de clases en el index.php, se obtuvieron mejores resultados de los esperados: más de 27 pedidos por segundo y una demora promedio de 367 ms por pedido. A continuación dejo el detalle de los resultados.

Creo que con un poco más de optimización podremos llegar a 40 pedidos por segundo y 200 ms de tiempo promedio por pedido.

C:\wamp\bin\apache\Apache2.2.11\bin>ab -k -n 1000 -c 10 http://localhost/YuppPHPFramework/apli/entrada/index
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking localhost (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests
Server Software: Apache/2.2.11
Server Hostname: localhost
Server Port: 80
Document Path: /YuppPHPFramework/apli/entrada/index
Document Length: 33 bytes
Concurrency Level: 10
Time taken for tests: 181.797 seconds
Complete requests: 1000
Failed requests: 0
Write errors: 0
Keep-Alive requests: 995
Total transferred: 449790 bytes
HTML transferred: 33000 bytes
Requests per second: 5.50 [#/sec] (mean)
Time per request: 1817.969 [ms] (mean)
Time per request: 181.797 [ms] (mean, across all concurrent
requests)
Transfer rate: 2.42 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 0 0.5 0 16
Processing: 1031 1810 445.8 1672 4844
Waiting: 1031 1810 445.9 1672 4844
Total: 1031 1810 445.8 1672 4844
Percentage of the requests served within a certain time (ms)
50% 1672
66% 1828
75% 2063
80% 2344
90% 2516
95% 2641
98% 2719
99% 2828
100% 4844 (longest request)

C:\wamp\bin\apache\Apache2.2.11\bin>ab -k -n 1000 -c 10 http://localhost/YuppPHPFramework/apli/entrada/index
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking localhost (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests
Server Software: Apache/2.2.11
Server Hostname: localhost
Server Port: 80
Document Path: /YuppPHPFramework/apli/entrada/index
Document Length: 33 bytes
Concurrency Level: 10
Time taken for tests: 36.891 seconds
Complete requests: 1000
Failed requests: 0
Write errors: 0
Keep-Alive requests: 997
Total transferred: 449836 bytes
HTML transferred: 33000 bytes
Requests per second: 27.11 [#/sec] (mean)
Time per request: 368.906 [ms] (mean)
Time per request: 36.891 [ms] (mean, across all concurrent
requests)
Transfer rate: 11.91 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 0 0.5 0 16
Processing: 266 367 50.1 359 828
Waiting: 266 367 50.1 359 828
Total: 266 367 50.1 359 828
Percentage of the requests served within a certain time (ms)
50% 359
66% 375
75% 391
80% 391
90% 422
95% 453
98% 516
99% 563
100% 828 (longest request)

Proximas liberaciones del framework

2010-11-21T16:28:00.000-02:00

Estimados,

Ya estamos en condiciones de liberar Yupp Framework v0.2.3, pero no haremos liberaciones hasta la v0.2.5, para acumular las mejoras y evitar el elevado costo en tiempo que tiene realizar cada liberación.

Como siempre, el código actualizado estará en nuestro servidor de versiones SVN (con cualquier cliente SVN como Tortoise o Subclipse lo pueden descargar y probar): http://yupp.googlecode.com/svn/YuppPHPFramework/

También puedes ver el código en el SVN por versión: http://yupp.googlecode.com/svn/tags/

Aquí está la hoja de ruta actualizada al día de hoy: http://code.google.com/p/yupp/wiki/Hoja_de_ruta#v0.2.3:

Seguiremos la hoja de ruta, actualizando los avances ahí mismo (los tickets resueltos llevan un cartel "HECHO").

Cualquier pregunta o comentario es bienvenido.

Atte.,
Pablo.

Agrega tus aplicaciones a Yupp Apps

2010-11-09T19:27:00.003-02:00

Para quienes quieran mostrar sus desarrollos, aunque sean pequeños, o sean simplemente pruebas del framework, son bienvenidos a enviármelas para su publicación en nuestro sitio de Yupp Apps: http://code.google.com/p/yupp-apps.

La idea es tener todas las aplicaciones desarrolladas con Yupp Framework en un mismo lugar, además que las pruebas que cada uno hizo con el framework, pueden servirle a los demás para comenzar a usarlo. Lo que buscamos son aplicaciones compatibles con la última versión del framework (v0.2.2), o sea que básicamente deben tener un descriptor de la aplicación (ver ejemplos en http://code.google.com/p/yupp-apps/downloads/list).

Esto ayudará a fortalecer la comunidad y mostrar nuestros desarrollos, incluso para ponerse en contacto con otros miembros y poder colaborar en los proyectos en común.

Para enviar tu aplicación, primero ponte en contacto con el grupo respondiendo a este hilo de discusión: http://groups.google.com/group/yuppframeworkphp/browse_thread/thread/c376238ddb1579bb

¡Estamos en contacto!

Nuevo sitio de Yupp Apps

2010-10-14T21:27:00.000-02:00

Estimados,

Como habrán notado en la descarga de la nueva versión de Yupp PHP Framework, no se incluye la aplicación de Blog ni el gestor de películas que se incluía en las versiones anteriores como aplicaciones de ejemplo de cómo usar Yupp.

De esta forma la descarga es más liviana, y además cada uno puede instalar luego las aplicaciones que desee probar.

Para este fin, hemos creado un sitio en Google Code llamado Yupp Apps, en el cual publicaremos todas las versiones de las distintas aplicaciones y las futuras aplicaciones que desarrolle cualquier miembro de la comunidad Yupp.

Aquí pueden ver las aplicaciones que ya están disponibles: http://code.google.com/p/yupp-apps/downloads/list

Para instalar una aplicación, simplemente es descargar el ZIP con una aplicación y descomprimir su contenido en la carpeta "apps" de Yupp (carpeta que existe desde la versión 0.2.2 del framework).

Cualquier pregunta sobre como instalar aplicaciones o cómo subir sus propias aplicaciones Yupp al sitio de Yupp Apps, no duden en preguntar en nuestro grupo de discusión: http://groups.google.com/group/yuppframeworkphp.

Liberamos Yupp Portal v03

2010-10-13T22:08:00.000-02:00

Estamos muy contentos de anunciar la nueva liberación de Yupp Portal, la aplicación para gestión de portales de Yupp Framework.

La nueva versión incluye nuevas características y la corrección de varios bugs:

Soporte para comentarios en las páginas: http://code.google.com/p/yupp-portal/issues/detail?id=16
Corrección de inclusión de clase en Bootstrap: http://code.google.com/p/yupp-portal/issues/detail?id=24
Corrección de problema al volver del registro de un nuevo usuario: http://code.google.com/p/yupp-portal/issues/detail?id=27
Corrección del paginador en el listado de usuarios pendientes: http://code.google.com/p/yupp-portal/issues/detail?id=21

Esta versión de Yupp Portal funciona desde Yupp PHP Framework v0.2.2.

Descarga ahora: http://code.google.com/p/yupp-portal/downloads/list

También puedes descargar desde el sitio de Yupp Apps: http://code.google.com/p/yupp-apps/downloads/list

Nuevo Yupp PHP Framework 022

2010-10-12T01:36:00.000-02:00

Estamos muy contentos de anunciar la liberación de una nueva versión de Yupp PHP Framework.

Esta versión 0.2.2 marca un antes y un después en el desarrollo de aplicaciones con Yupp.

La principal mejora es la del fortalecimiento del concepto de "aplicación web", frente al concepto previo de "componente", en donde las aplicaciones eran desarrolladas como plugins al framework. Ahora lo importante son las aplicaciones web, donde:

Cada aplicación web tiene una estructura definida pero flexible.
Cada aplicación web puede tener sus propios iconos.
Cada aplicación web puede usar sus propias librerías Javascript o usar las del framework.
Cada aplicación web puede usar su propia configuración de base de datos o usar la del framework (si, cada aplicación puede tener su propio servidor de bases de datos, separado del resto de las aplicaciones)
Cada aplicación web tiene su propio descriptor, que contiene información útil para integrar las aplicaciones al framework y para actualizar automáticamente las versiones de las aplicaciones que se tengan instaladas.
Cada aplicación web puede tener su propio conjunto de tests, para facilitar su testeo automático.
Una sola instancia del framework puede alojar un número ilimitado de aplicaciones web.

Descarga el framework ahora: http://code.google.com/p/yupp/downloads/list

En breve crearemos un conjunto de videos para explicar mejor los temas relacionados con la instalación y configuración del framework, y también el desarrollo de distintas aplicaciones web y cómo obtener mejores resultados utilizando Yupp PHP Framework.

También estaremos actualizando la documentación: http://www.simplewebportal.net/yupp_framework_php_doc/

Nueva liberacion de Yupp PHP Framework

2010-07-25T20:24:00.000-03:00

Estamos muy contentos de anunciar la nueva liberación del framework, Yupp PHP Frameowrk v0.2.1.

Cambios con respecto a la versión anterior:

Se creó el generador de aplicaciones.
Se corrigieron los mensajes de errores de validación para que sean internacionalizables.
Se creó la primer versión de Yupp Desktop, desde donde ser permite el acceso a las aplicaciones, la generación de tablas y la creación de nuevas aplicaciones de forma simple.
Nuevo paquete de testing para crear y ejecutar casos de prueba de forma automática.
Correcciones al paquete http.
Se agregan descriptores de aplicación para simplificar la gestión de las aplicaciones Yupp.

Le cambiamos la cara al framework, nuevo Yupp Desktop v0.1.0

Esta es la primer versión de Yupp Desktop, una interfaz simple desde donde acceder a las aplicaciones instaladas en el framework, poder generar tablas para las aplicaciones, poder generar nuevas aplicaciones, ejecutar pruebas y más. Así comenzamos a mejorar la interfaz con el usuario y a simplificar la interacción con el framework, además de dar un aspecto más amigable.

Notas de la versión:

http://code.google.com/p/yupp/wiki/YuppPHPFrameworkV021

Documentación de referencia (en actualización)

http://www.simplewebportal.net/yupp_framework_php_doc/

Descarga:

http://code.google.com/p/yupp/downloads/list

Colabora con el framework:

http://groups.google.com/group/yuppframeworkphp/web/colabora-con-yupp-framework

Resolviendo llamados AJAX entre dominios distintos

2010-07-03T23:04:00.002-03:00

Esta semana tuve la necesidad de consumir servicios JSON a través de AJAX, el problema es que esos servicios estaban en otro host. Buscando en internet, llegué a que el tema de realizar llamadas a AJAX entre distintos dominios no funcionaba directamente, ya que era una gran brecha de seguridad permitir hacer esto en HTTP. Luego de un rato de darme la cabeza contra el teclado, decidí hacerlo de esta forma.

Digamos que tengo una vista (una página) desde la que necesito consumir el servicio JSON invocando una determinada URL por AJAX, con Prototype esto sería algo así (esta invocación falla por hacerse a un dominio distinto al local):

Event.observe(window, 'load', function() {

   new Ajax.Request('http://www.otrohost.com/servicio', {
      method: 'get',
      onLoading: function(res) {
         ....
      },
      onSuccess: function(res) {
         var json = res.responseJSON; // resultado del servicio JSON
         ....
      }
   });
});

Sustituyendo la url destino del llamado AJAX por una url local, quien atiende la llamada es la acción de un controlador de Yupp, entonces se puede hacer que esa acción sea la que haga el llamado al servicio JSON en http://www.otrohost.com/servicio y devuelva a la vista el resultado.

El controlador tendrá este aspecto (archivo: /components/xxx/controllers/components.xxx.controllers.ServicioController.class.php):

YuppLoader::load('core.http', 'HTTPRequest');

class ServicioController extends YuppController {

   public function getJSONAction()
   {
      $req = new HTTPRequest();
      $req->setTimeOut( 5 );
      $res = $req->HTTPRequestGet('http://www.otrohost.com/servicio');

      // La respuesta
      $json = $res->getBody();
      
      // Devuelve la respuesta a la vista
      header('Content-Type: application/json');
      return $this->renderString( $json );
   }
}

Así logramos pedirle a un controlador local que haga un pedido HTTP al servicio JSON remoto y que devuelva el objeto JSON a la vista local desde la que partió el pedido AJAX original. El javascript en la vista con la invocación al controlador local quedaría así:

Event.observe(window, 'load', function() {

   new Ajax.Request('<?php echo h('url', array('component'=>'xxx', 'controller'=>'servicio', 'action'=>'getJSON'); ?>', {
      method: 'get',
      onLoading: function(res) {
         ....
      },
      onSuccess: function(res) {
         var json = res.responseJSON; // resultado del servicio JSON local
         ....
      }
   });
});

Así con pocas líneas de código podemos resolver un problema que tenemos frecuentemente, sobre todo cuando necesitamos consumir APIs externas con servicios JSON o XML.

Liberamos Yupp PHP Framework v0.2.0

2010-06-18T01:39:00.000-03:00

Ha pasado algún tiempo desde la última liberación, por eso estamos muy contentos de anunciar la nueva versión de Yupp PHP Framework v0.2.0.

Esta nueva versión es más estable ya que se corrigieron varios problemas encontrados en la versión anterior, y cuenta con varios ejemplos de componentes y uso de helpers para hacer más fácil el aprendizaje.

Las notas de la versión con descripción de la instalación del framework:

http://code.google.com/p/yupp/wiki/YuppPHPFrameworkV020

Descargas:

http://code.google.com/p/yupp/downloads/list

Documentación:

http://www.simplewebportal.net/yupp_framework_php_doc/

La lista detallada de los cambios y las correcciones se encuentra aquí:

http://code.google.com/p/yupp/source/list

Colabora con el desarrollo del framework:

http://groups.google.com/group/yuppframeworkphp/web/colabora-con-yupp-framework

En breve haremos algunos videos para explicar el funcionamiento del framework y mostrar cómo crea aplicaciones web desde cero. También mejoraremos la documentación, agregando más ejemplos.

Liberamos nueva version de Yupp PHP Framework

2010-04-11T20:33:00.001-03:00

Estamos muy contentos de anunciar la nueva liberación del Yupp PHP Framework v0.1.9.

Para esta nueva versión se incorporación correcciones a varios bugs encontrados desde la versión anterior, además tendrá un nuevo paquete HTTP que servirá para enviar pedidos HTTP a otros sistemas y procesar su respuesta (gracias a Magdalena que implementó este paquete). También incluirá un mecanismo de conversión
automática de instancias del modelo a XML, incluso de estructuras de datos complejas.

Esta nueva versión es muy estable y tiene muchas funcionalidades y cuenta con nuevos ejemplos de uso para hacer más fácil la adopción por parte de los programadores, mejorando su curva de aprendizaje.

Las notas de la versión con descripción de la instalación del framework:

http://code.google.com/p/yupp/wiki/YuppPHPFrameworkV019

Descargas:

http://code.google.com/p/yupp/downloads/list

Documentación:

http://www.simplewebportal.net/yupp_framework_php_doc/

La lista detallada de los cambios y las correcciones se encuentra aquí:

http://code.google.com/p/yupp/source/list

Colabora con el desarrollo del framework:

http://groups.google.com/group/yuppframeworkphp/web/colabora-con-yupp-framework

Liberamos Yupp Portal v0.2

2010-02-16T00:21:00.001-02:00

¡Yupp Portal v0.2 liberado!
Yupp Portal es el componente para crear portales de Yupp PHP Framework.

Descargas:
http://code.google.com/p/yupp-portal/

Hoja de ruta del proyecto:
http://groups.google.com/group/yuppframeworkphp/web/yupp-portal---hoja-de-ruta

¿Para qué sirve Yupp Portal?

Es una herramienta de alta productividad que permite crear un portal web completo en pocos minutos, sin necesidad de programación extra, solamente es necesario configurar la conexión con la base de datos.

Este componente permite:

Administrar páginas:

Crear páginas con un clic
Editar contenido con editor visual desde la web
Estados de páginas: Normal, Borrador, Deshabilitada, Oculta
Edición visual de items del menú principal
Edición visual de contenido fijo (por ejemplo banners que se muestran en todas las páginas)

Administración de usuarios:

Administración de roles
Crear/Editar/Eliminar/Aprobar usuarios
Registro de usuarios y aprobación con email en un clic
Login/Logout

Tres roles disponibles:

Administrador: crea/edita páginas, modifica el menú, crea/edita usuarios
Editor: crea/edita páginas, modifica el menú
Usuario: ve páginas ocultas

Nueva liberación de Yupp PHP Framework

2010-02-09T02:35:00.001-02:00

Estamos muy contentos de anunciar la nueva liberación del framework, Yupp PHP Frameowrk v0.1.8.

Esta liberación es la primera que incluye un juego de tests para detectar problemas en el YORM, el modulo de ORM de Yupp Framework.

Para esta liberación hemos corregido los siguientes tickets:

También hemos corregido y mejorado la documentación de referencia:

http://www.simplewebportal.net/yupp_framework_php_doc/

Para descargar la nueva versión, accede a nuestro sitio en google code:

http://code.google.com/p/yupp/downloads/list

Nos interesa que nos cuentes si has probado el framework, qué cosas buenas le encontraste y qué cosas le mejorarías, tu opinión cuenta!

Si quieres colaborar con el framework y no sabes como, accede a la guía de colaboración:

http://groups.google.com/group/yuppframeworkphp/web/colabora-con-yupp-framework

Las notas de la versión están en nuestra wiki:

http://code.google.com/p/yupp/wiki/YuppPHPFrameworkV018

¡Esperamos tus comentarios!
-
-

Testing del ORM

2010-01-19T16:32:00.008-02:00

En la línea de acción que estamos siguiendo para estabilizar el framework, estamos implementando un set de pruebas para YORM, el componente de ORM de Yupp Framework. Los tests se centran en la generación de las tablas en la base de datos, guardar correctamente estructuras complejas de datos, obtener estructuras complejas de datos desde la base, y verificar restricciones sobre los datos que se intentan guardar en la base.

Con esto lograremos encontrar las debilidades del YORM, al mismo tiempo que demostramos las fortalezas que tiene actualmente.

Los juegos de tests pueden ser descargados del SVN en nuestro sitio en Google Code: http://code.google.com/p/yupp/source/checkout

De esta forma nos acercamos a una versión estable de Yupp Framework, garantizando su poder para crear proyectos web de forma ágil y sencilla, ordenando el desarrollo y evitando las tareas repetitivas.

Actualización:
Uno de los tests que estoy desarrollando es el de probar estructuras de árboles en la base de datos. La prueba consiste en implementar una clase persistente en YORM, la cual es una página web, que a su vez puede tener subpáginas. Aquí está la implementación de la clase:

class Pagina extends PersistentObject
{
   function __construct($args = array (), $isSimpleInstance = false)
   {
      $this->setWithTable("test_a004_pagina");

      $this->addAttribute("titulo",  Datatypes :: TEXT);
      $this->addAttribute("contenido", Datatypes :: TEXT);

      // Pagina padre
      $this->addHasOne('owner', 'Pagina');

      // Paginas hijas
      $this->addHasMany('subpages', 'Pagina');

      $this->addConstraints(
         "titulo",
         array (
            Constraint :: maxLength(255)
         )
      );
      $this->addConstraints(
         "contenido",
         array (
            Constraint :: maxLength(100000)
         )
      );
      $this->addConstraints(
         "owner",
         array (
            Constraint :: nullable(true) // Las paginas del primer nivel no tienen padre.
         )
      );

      parent :: __construct($args, $isSimpleInstance);
   }

   // Mas codigo ...
}

Y ahora la prueba de cómo generar una estructura de árbol y guardarla en la base. Lo que vamos a hacer son 4 instancias de la clase Pagina, la primera es la página raíz, la segunda es hija de la página raíz y las dos restantes son a su vez hijas de esta última. Con el siguiente código no solo creamos la estructura de árbol de páginas, si no que vamos a ver que toda la estructura se guarda automáticamente en la base con una única línea de código por parte del programador!!!

$p1 = new Pagina(
        array(
          "titulo" => "Pagina raiz",
          "contenido" => "This step is usually done transparently as most compilers perform it and then invoke the assembler..."
        )
      );
      $p11 = new Pagina(
        array(
          "titulo" => "Subpagina de raiz 1",
          "contenido" => "This step is usually done transparently as most compilers perform it and then invoke the assembler...",
          "owner" => $p1
        )
      );
      $p111 = new Pagina(
        array(
          "titulo" => "Sub subpagina de raiz 1",
          "contenido" => "This step is usually done transparently as most compilers perform it and then invoke the assembler...",
          "owner" => $p11
        )
      );
      $p112 = new Pagina(
        array(
          "titulo" => "Sub subpagina de raiz 2",
          "contenido" => "This step is usually done transparently as most compilers perform it and then invoke the assembler...",
          "owner" => $p11
        )
      );
      
      
      // subpaginas de p11
      $p11->addToSubpages($p111);
      $p11->addToSubpages($p112);
      
      // subpaginas de p1
      $p1->addToSubpages($p11);
      
      // Guarda toda la estructura con esta única línea de código!
      if (!$p1->save())
      {
         Logger::struct( $p1->getErrors(), "Falla test A004.2 1" );
      }
      else
      {
         echo "Guarda Ok";
      }

ORM de nivel enterprise

2009-12-05T23:43:00.000-02:00

Si bien nos falta recorrer un largo camino vamos hacia ese objetivo: llegar a un ORM de nivel "enterprise". YORM, el ORM de Yupp Framework hoy está soportando las siguientes características:

Mapeo de clases con atributos de diversos tipos (TEXT, DATE, BOOLEAN, INT, FLOAT, entre otros)
Mapeo de estructuras de herencia en 2 sabores: cuando la clase A hereda de la clase B se puede optar por "mapeo de herencia en tabla única", entonces A y B se mapean a la misma tabla, o por "mapeo de herencia de múltiple tabla" donde A y B se mapean a distintas tablas, cualquiera de las opciones es transparente para el programador.
Mapeo de relaciones entre clases: estamos soportando relaciones unidireccionales y bidireccionales con cardinalidades 1-1, 1-N y N-N.
Las relaciones múltiples pueden ser de 3 tipos: colecciones, listas o conjuntos. Las colecciones pueden tener elementos repetidos y desordenados, las listas tienen elementos ordenados, y los conjuntos no tienen repetidos.
Estamos soportando 3 bases de datos: MySQL, SQLite y el último agregado PosgreSQL.
Podemos definir restricciones sobre los datos y esas restricciones se verifican antes de ingresar cualquier dato a la base.
Salvado en cascada: simplifica el código PHP al salvar en la base una estructura compleja de clases relacionadas a partir de la invocación al método save() en la clase principal.
Carga perezosa: cuando se carga una clase desde la base no se cargan sus clases asociadas, las mismas son cargadas una vez que son referenciadas, o sea que si no se usan, no se cargan, ahorrando tiempo.
Creación automática del esquema de en la base de datos: crea todas las tablas necesarias haciendo un clic.

Qué esperamos para el futuro en ORM:

Soporte para más bases de datos: Oracle, SQLServer, Access, etc.
Soporte para persistencia de colecciones de valores simples (Strings, Integers, Dates, etc).
Soporte para transacciones y rollback.
Capacidad de especificar los nombres de las columnas donde se guardan los campos de las clases.
muchas otras características...

¡Aceptamos sugerencias!

Liberamos Yupp PHP Framework v0.1.7

2009-12-01T12:18:00.001-02:00

-
Luego de largas horas de trabajo estamos muy contentos de liberar la nueva versión de Yupp PHP Framework.

Las diferencias con la versión 0.1.6.7 son:

Se corrije un bug que se liberó con Yupp 0.1.6.7 en la clase routing.Executer, pasaba cuando se retornaba null de una accion de un controller.
Corrección de DatabaseMySQL en consultas que buscan por strings numéricos.
Se eliminaron las clases Filter y Mapping, y se creó una clase Router que cumple las tareas de las elminadas y es mucho mas simple de usar. (http://code.google.com/p/yupp/issues/detail?id=10)
YuppContext se quitan pasajes por referencia.
Se agregan pruebas de generacion de controles complejos en formularios: html y calendar. html usa TinyMCE y calendar usa YUI Calendar. Se agregan ambas librerias al framework.
Primer integración de PostgreSQL a Yupp. Nueva clase DatabasePosgreSQL.
Correcciones a DAL, PersistentObject y PersistentManager.

Descargas:
http://code.google.com/p/yupp/downloads/list
http://www.simplewebportal.net/host/1022.htm

TAG SVN:
http://code.google.com/p/yupp/source/browse/#svn/tags/v017

Cualquier duda, consulta o reporte de error pueden hacerla en el grupo google (opción "debates > nueva entrada"):
http://groups.google.com/group/yuppframeworkphp

Hasta pronto!

Pablo Pazos Gutiérrez
Líder de proyecto
Yupp PHP Framework
-
-

Próxima liberación de Yupp Framework

2009-11-23T13:37:00.000-02:00

Amigos, como todos quienes siguen el grupo sabrán, en la última
versión de Yupp (v0.1.6.7) se me coló un bug en la clase Executer que
no permitía el correcto funcionamiento del framework. Si ven en un
post previo adjunté la solución, esta solución también fue subida al
SVN como todos los cambios que voy haciendo: http://yupp.googlecode.com/svn/trunk/

Ahora me encuentro integrando PostgreSQL al framework. La próxima
versión será la 0.1.7 y aparte de PostgreSQL vendrá con algunos
frameworks Javascript adjuntos, con los cuales estoy haciendo pruebas
de integración, como el editor WYSIWYG TinyMCE y el YUI Calendar.
También hice una siplificación del Router, creando una sola clase y
eliminando las clases Filter y Mapping (ahora todas sus
funcionalidades están en la clase Router).

En definitiva, la próxima versión podrá usarse con cualquiera de estos
DBMS: MySQL, SQLite o PostgreSQL.

Cómo crear un blog, paso a paso

2009-11-01T17:31:00.003-02:00

He actualizado el documento de como crear un blog simple con Yupp PHP Framework para su última versión 0.1.6.7.

El documento puede descargarse desde: http://code.google.com/p/yupp/downloads/list

La última versión del framework se puede descargar desde el mismo sitio y contiene la implementación del blog para poder ver el producto final de lo que se muestra en el documento.

Cualquier duda o comentario la pueden colgar en nuestro grupo: http://groups.google.com/group/yuppframeworkphp

Hasta pronto.

Yupp Portal v0.1

2009-10-27T00:12:00.003-02:00

Estamos muy contentos de poder liberar la primer versión del componente para crear portales web de Yupp Framework: Yupp Portal

¿Para qué sirve Yupp Portal?

Es una herramienta de alta productividad que permite crear un portal web completo en 5 minutos, sin necesidad de programación extra, solamente es necesario configurar la conexión con la base de datos.

Este componente permite:

Administrar páginas:

Crear páginas con un clic
Editar contenido con editor visual desde la web
Estados de páginas: Normal, Borrador, Deshabilitada, Oculta
Edición visual de items del menú principal
Edición visual de contenido fijo (por ejemplo banners que se muestran en todas las páginas)

Administración de usuarios:

Administración de roles
Crear/Editar/Eliminar/Aprobar usuarios
Registro de usuarios y aprobación con email en un clic
Login/Logout

Tres roles disponibles:

Administrador: crea/edita páginas, modifica el menú, crea/edita usuarios
Editor: crea/edita páginas, modifica el menú
Usuario: ve páginas ocultas

Por más información: http://code.google.com/p/yupp-portal/

Liberamos Yupp PHP Framework v0.1.6.7

2009-10-25T21:04:00.004-02:00

Amigos, estamos muy contentos de anunciar la liberación de la nueva versión de Yupp PHP Framework.

Las diferencias con respecto a la versión 0.1.6.4 son:

1. Correccion a YuppForm en el campo date.

2. Se agrega el método YuppController.componentControllersAction() que sirve para mostrar los controladores de un componente dado.

3. Se agrega la restricción "inList" que permite verificar si un valor está en una lista de valores dados.

4. Se agrega el metodo PersistentObject.hasFieldErrors( $attr ) para preguntar si existen errores en el valor de un atributo particular.

5. Se agrega el metodo PersistentObject.attributeDeclaredOnThisClass() para saber si un determinado atributo fue declarado en una clase. Sirve para derivar los nombres de las tablas intermedias en relaciones multiples.

6. Se agrega el helper DisplayHelper.yupp_select para crear selects html de forma sencilla.

7. Se corrije el metodo PersistentObject.validate() para que priorice la validacion de nulos y vacios sobre el resto de las validaciones. Ahora si un valor es nullable(true) y tambien debe ser email(), la validacion de un valor vacío devuelve true, antes fallaba en la validacion de email.

8. Correcciones menores en la clase Contraints.

9. El método PersistentObject.setProperties() ahora hace trim de los valores antes de asginarlos a los campos, esto es para evitar el llenado accidental de datos con espacios en blanco delante o detrás del valor ingresado.

10. Agregamos soporte para varios subdirectorios dentro del directorio de clases de modelo, para ordenar las clases cuando son muchas.
- Se corrige el metodo ModelUtils.getModelClasses() para poder crear subdirectorios en el directorio del modelo de un componente.
- Correccion al metodo YuppConventions::getModelPath().
- Correccion en PackageNames a una expresion regular para poder poner subdirectorios en el modelo.
- Correcciones en YuppLoader, en el cargado del modelo para permitir definir clases en subdirectorios.

11. Corrección en el método YuppConventions::relTableName(..) donde se creaba mal el nombre de la tabla intermedia para relaciones hasMany si se trataba de salvar una subclase y el atributo estaba declarado en su superclase.

12. Se corrige el helper Helpers.template() para mejorar el pasaje de parametros.

13. Correccion en el mapeo de herencia de tabla multiple para soportar modelos de relaciones y herencia complejos (PersistentManager, PersistentObject, MultipleTableInheritanceSupport).

14. Se corrije el metodo YuppController::getFlash() y se hace limpieza.

15. Corrección de la comparación de strings para generar consultas MySQL (donde el "=" no considera mayúsculas y minúsculas)
- Se reescribió completamente la evaluación de QUery que genera las consultas SQL, para que considera las particularidades de cada DBMS (MySQL, SQLite, PostgreSQL, etc)

Descargas:
http://code.google.com/p/yupp/downloads/list
http://www.simplewebportal.net/host/1022.htm

TAG SVN:
http://code.google.com/p/yupp/source/browse/#svn/tags/v0167

Cualquier duda, consulta o reporte de error pueden hacerla en el grupo google (opción "debates > nueva entrada"):
http://groups.google.com/group/yuppframeworkphp

Hasta pronto!

Pablo Pazos Gutiérrez
Líder de proyecto
Yupp PHP Framework

Herramientas para comprimir codigo javascript

2009-09-17T12:49:00.003-03:00

Para crear sistemas web muchas veces me veo utilizando librerías y scripts javscript que encuentro en internet. Muchos de estos pesan entre 150 y 300 Kb, haciendo que el tiempo de carga de las páginas web sea muy lento. Por suerte existen herramientas que nos permiten comprimir esas librerías y dejarlas de un tamaño aproximadamente de un 30% del tamaño original.

En general estas herramientas tienen un cuadro de texto donde se debe pegar el código javascript a comprimir, elegir algunas opciones de compresión, luego vemos el código comprimido y la razón de compresión (tamaño original / comprimido). Distintas opciones de compresión harán que tu código quede más reducido aún.

Aquí dejo algunos links a estas herramientas:

Feliz compresión!

PHP y los problemas con la sesión

2009-08-03T20:23:00.004-03:00

PHP tiene un problema (depende de si se lo considera como tal) con las sesiones cuando se acceden a subdominios del sitio actual.

Hoy particularmente me sucedió que tenía un sitio http://femisaluddigital.net.uy el cual corre con el componente Yupp Portal. En una página del portal había un link a otra página pero el dominio del link era a http://www.femisaluddigital.net.uy/...., notar el WWW adelante.

Entonces, cuando si usuario está logueado en el sitio http://femisaluddigital.net.uy e intenta acceder al link que empieza con www la sesión se pierde y el usuario aparece como no logueado, con los problemas que esto trae (el usuario debe volver a loguearse).

Entonces las opciones serían:

Que los links a páginas locales se armen dinámicamente considerando la URL actual (viendo si tiene o no www al principio).
Guardar la sesión en la base de datos y que tanto para el dominio que empieza con www como para el que no tiene www, la sesión se acceda de la misma forma.

Hay que tener cuidado que para otro subdominio que no sea www (por ejemplo subdominio.femisaluddigital.ney.uy) tal vez quiera acceder a otra sesión, no a la misma del dominio principal. Esto puede ser un problema y el proceso de guardar y pedir información de la sesión debería ser lo suficientemente inteligente como para distinguir casos, nada muy complicado.

Con este post espero ayudar a otros que tengan el mismo problema. Hay algunos comentarios sobre el tema en la página de documentación de PHP sobre las sesiones, donde también indica que ante un cambio de protocolo (HTTP a HTTPS) la sesión también es eliminada. http://us2.php.net/manual/en/book.session.php

Historia del User Agent

2009-07-08T02:09:00.002-03:00

Navegando por internet buscando información acerca de HTTP (estoy estudiando para un próximo exámen de Introducción a las Redes de Computadoras), encontré un artículo muy interesante al respecto de la historia del User Agent que no tiene desperdicio alguno:

http://webaim.org/blog/user-agent-string-history/

Enjoy :)

Feliz cumpleaños Tetris!

2009-06-06T02:59:00.004-03:00

Hoy es un día muy especial para todos los amantes del Tetris, el legendario juego creado por Alexey Pajitnov. El juego combina agilidad, estrategia y simplicidad como ningún otro juego en la historia de los video juegos, por algo cuando decimos "Tetris" todos saben de que estamos hablando. Tetris es más que un juego, este trascendió la pantalla para convertirse en parte de la cultura de los que vivimos nuestra adolescencia en los 90's y aún hoy vivimos como un nuevo reto cada vez que volvemos a jugar al Tetris.

Desde aquí nuestro tributo.

Más información:
http://www.rtve.es/noticias/20090602/tetris-cumple-anos/279442.shtml

Liberamos la nueva versión de Yupp! v0.1.6.4

2009-06-02T00:25:00.002-03:00

Estamos muy contentos de anunciar la liberación de la nueva versión de Yupp PHP Framework.

Estaos agradecidos con los usuarios que últimamente se han interesado en el proyecto, enviándonos sus comentarios, dudas y reportando errores, y es gracias a ellos que podemos seguir mejorando.

Hemos corregido y mejorado muchas cosas desde la versión anterior, entre ellas:

1. Se corrigió y mejoró el web flow.
2. Se agrego el metodo 'validateOnly' a la clase PersistentObject.
3. Correcciones para CRUD y vistas dinamicas.
4. Cambia el nombre de la clase ControllerFilter2 por YuppControllerFilter.
5. Se agregó addslashes en los métodos insert_query y update_query de DAL y stripslashes en PersistentManager, para resolver problemas con caracteres de control de MySQL.
6. Se agregó el helper "pager" para crear links de paginación de registros para los listados.
7. Se agrego el helper orderBy para crear columnas ordenables en los listados.
8. Corrección de restricción de email.
9. Ya no es necesario pasarle $this->params al método "render" de YuppController:
- Antes: return $this->render("show", &$this->params);
- Ahora: return $this->render("show");
10. Corrección del helper "locale_chooser" que generaba XHTML inválido.
11. Se agrega al paginador los params de ordenamiento por columnas en los listados (helper "orderBy") si los hay.

Descargas:
http://code.google.com/p/yupp/downloads/list
http://www.simplewebportal.net/host/1022.htm

TAG SVN:
http://code.google.com/p/yupp/source/browse/#svn/tags/v0164

Cualquier duda, consulta, crítica o reporte de error pueden hacerla en el grupo google (opción "debates > nueva entrada"):
http://groups.google.com/group/yuppframeworkphp

Hasta pronto!

Pablo Pazos Gutiérrez
Líder de proyecto
Yupp PHP Framework

Como ser un buen programador

2009-04-23T11:33:00.001-03:00

Este sitio presenta una guía paso a paso de cómo ser un buen programador :D

http://secretgeek.net/howtobeaprogrammer.asp

Que lo disfruten!

Nueva versión de Yupp PHP Framework v0.1.6.3

2009-04-02T13:49:00.005-03:00

En esta nueva versión estabilizamos aún más el framework, probándolo con distintas versiones de PHP. Además se corrigieron bugs y se mejoraron algunas características.

Este es el detalle del trabajo realizado:

Corregido que si se crean urls con parametros llamados param_1, param_2, etc, esos se pongan en la propia url sin ?param_1&...

Correccion de clase Filter, el metodo que procesa los params dependía de la cantidad de directorios en la ruta a donde está instalado Yupp Framework, ahora es independiente de donde se instale el framework.

Se quitó devolver la referencia (&) en YuppSession::get porque da error cuando se devuelve NULL.

Correción en clase Helpers: correccion de compatibilidad con PHP 5.2.8.

Corregido el flash que se perdía cuando se hace redirect, los valores se mandan en la url.

Resuelto un pequeño bug en la clase Logger.

Se integró la funcionalidad de submit de forms via ajax, utiliza el plugin forms de jQuery.

YuppDateTime: Se agrega operacion para manipular fechas.

Nueva clase YuppForm2 que suplanta a YuppForm y acepta submit por ajax. Se deja YuppForm hasta la próxima liberación. Se agregó el campo "select" y la forma de pasarle los parámetros a los campos ahora es mediante un array asociativo, y los parámetros desconocidos son ingresados en la tag HTML generada como atributo de la misma.

Se hicieron grandes modificaciones en cómo se definen y ejecutan los filtros de controladores, estos filtros sirven para definir acciones que se ejecutan antes o después de las acciones de los controladores según ciertas reglas (se pueden definir filtros por componente, por controlador, por accion, todas las acciones menos una, etc).

Correccion de metodo PersistentObject.hasErrors, tenia un error en la condicion.

Renombrado de archivo de arranque a components.{componente}.Bootstrap.script.php

Correccion de bug en PersistentManager::generateAll(), se agregaban las restricciones para atributos que todavía no se habían agregado.

Notas de versión completas: http://code.google.com/p/yupp/wiki/YuppPHPFrameworkv0163

Para descargar esta versión se puede hacer directamente desde el sitio de google code o mediante el SVN:

Cualquier duda o sugerencia será bienvenida en nuestro grupo:

http://groups.google.com/group/yuppframeworkphp

Para acceder a la última documentación:

http://www.simplewebportal.net/yupp_framework_php_doc/

A/C Pablo Pazos Gutierrez
Líder de Proyecto
Yupp PHP Framework

Prototype vs jQuery

2009-03-11T11:44:00.003-03:00

Navegando en internet encontré esta excelente presentación con la comparación de estos dos grandes de Javascript. Aquí se las dejo:

| View | Upload your own

Transformar errores y warnings de PHP en excepciones

2009-03-10T14:30:00.003-03:00

Hoy estuve probando la funcionalidad de envío de email de PHP y como tenía el servidor de mail mal configurado en el PHP.INI, mi aplicación me mostraba un WARNING. El problema es que el WARNING no se tira como una excepción, o sea que no se le puede hacer TRY/CATCH, por lo tanto tuve que buscar como hacer para que estas WARNINGS se pudieran atrapar como cualquier excepción, el resultado es el siguiente:

En PHP existe una función llamada set_error_handler, la cual me permite establecer una función mía para manejar los errores de PHP (PHP tiene distintos tipos de errores y puedo definir distintos manejadores para cada tipo de error).

Entonces, para que todos los errores de PHP (incluyendo WARNINGS) sean enviados a mi manejador (para arrojar una excepción en su lugar) es implementado con el siguiente código:

set_error_handler("my_warning_handler", E_ALL);

function my_warning_handler($errno, $errstr, $errfile, $errline, $errcontext) {
throw new Exception( $errstr );
}

Seleccionando E_ALL, cualquier tipo de error es enviado a mi función para arrojar una excepción.

Los distintos tipos de errores que tiene PHP son:

E_ALL
E_WARNING
E_ERROR
E_PARSE
E_CORE_ERROR
E_CORE_WARNING
E_COMPILE_ERROR
E_COMPILE_WARNING
E_STRICT

Por más información sobre set_error_handler y manejo de errores en PHP:

Espero que les sirva.

Liberación de PHP v5.2.9

2009-03-06T16:41:00.001-02:00

Aquí el link a la página oficial del anuncio:
http://www.php.net/releases/5_2_9.php

Aquí la página con los cambios por versión:
http://www.php.net/ChangeLog-5.php#5.2.9

Nueva versión de Yupp PHP Framework v0.1.6.2

2009-02-28T15:31:00.005-02:00

Como anunciábamos ayer, hoy liberamos la versión 0.1.6.2 de Yupp PHP Framework.

Esta es una versión de estabilización, donde se corrigieron muchos bugs y se mejoraron algunas características. Este es el detalle del trabajo realizado:

Correccion en PersistentManager.generate() para que genere todas las tablas intermedias con la columna "ord" que se utiliza cuando el atributo hasMany es de tipo LIST, cuando es de tipo SET o COLLECTION, no se toma en cuenta.
Se agregó soporte para incluir CSS o imagenes desde un componente. Para esto se modificó el helper "css" y se agregó el helper "img".
Corrección al helper "errors", lanzaba un error si el elemento no tenía errores.
Correcciön al método "hasErrors" de PersistentObject, que no verificaba que el campo errors fuera NULL.
Se agrega el constructor para la condicion Not Equal a la clase Condition.
Correccion del metodo addOrder de la clase Criteria2.
Hay un problema con la extraccion de los parametro de la url: http://localhost:8081/YuppPHPFramework/portal/page/display/mi_pagina_bbb/sdfda/asdf?as=sdfg
- El tema fue que al intriducir el tema del ruteo, UlrProcessing, quien antes hacia el trabajo de crear los params de la url, no se llama mas, y ahora el ruteo solo toma params de POST y GET y no considera la url.
Varias correcciones para compatibilizar Yupp con versiones anteriores de PHP (PHP 5.2.0 y 5.2.1).
Se agregó el método firstToUpper a core.basic.String.
Se agregaron los siguientes campos a la configuración de Yupp (clase YuppConfig):
- currentMode: indica el modo de ejecucion de la aplicacion (development, production o testing).
- modeDefaultMapping: indica que accion debe ejecutarse por defecto, dependiendo del modo actual, al acceder a la aplicación.
Se agregó el método addCustomParams en la clase routing.Filter

Notas de versión completas: http://code.google.com/p/yupp/wiki/YuppLiberacionV0162

Para descargar esta versión se puede hacer directamente desde el sitio de google code o mediante el SVN:

Cualquier duda o sugerencia será bienvenida en nuestro grupo:

http://groups.google.com/group/yuppframeworkphp

Para acceder a la última documentación:

http://www.simplewebportal.net/yupp_framework_php_doc/

A/C Pablo Pazos Gutierrez
Líder de Proyecto
Yupp PHP Framework

Modificada la hoja de ruta hacia Yupp PHP Framework v0.2.0

2009-02-28T00:51:00.001-02:00

Modificamos la hoja de ruta por la gran cantidad de problemas que detectamos, corregimos y otras cosas que agregamos. Mañana (sábado 28 de febrero) estaremos liberando la versión 0.1.6.2 del framework. Los últimos cambios ya están en el SVN del grupo de google: http://code.google.com/p/yupp/source/checkout.

La modificación fue correr todas las liberaciones 0.1.6.x y liberar como 0.1.6.2 el framework con las últimas correcciones, lo que consideramos un paso gigante en cuanto a estabilización del framework se trata.

Si bien esperamos que Yupp v 0.2.0 sea la primer liberación estable para producción, en este momento estamos utilizando Yupp en producción para un sistema de CMS muy simple, este sistema será liberado una vez completado con el nombre de Yupp Portal y apuntará a la generación de portales de forma rápida y 100% actualizable via web (cero código HTML/PHP para el usuario).

Pablo Pazos Gutierrez
Líder de proyecto
Yupp PHP Framework

------

Haz clic en http://groups.google.com/group/yuppframeworkphp/web/hoja-de-ruta-hacia-v0-2-0
Si haciendo clic no se activa, copia el enlace y pégalo en la barra de
direcciones de tu navegador.

Herramienta de SEO para generar urls amigables

2009-02-12T14:18:00.004-02:00

Esta herramienta "URL Rewriting Tool" nos ayuda a generar urls amigables para que los buscadores puedan encontrar términos relacionados con el tema del sitio en la url, lo que ayuda a que nuestro sitio se posicione mejor en los resultados del buscador.

Con URL Rewriting Tool podemos generar desde una url dinámica, una url que parece estática y a su vez genera la regla de MOD_REWRITE que consume esa url e internamente genera el pedido a la url dinámica.

Dejo el link: http://www.webconfs.com/url-rewriting-tool.php

Feliz url rewriting!

PHP 5.3.0 ahora esta en beta!

2009-02-04T00:45:00.004-02:00

Esta beta de PHP 5.3.0 anticipa que dentro de poco tendremos la liberación de la versión estable 5.3.0 de PHP, la cual trae nuevas (y esperadas hace mucho tiempo) características.

Las características más importantes de PHP 5.3.0 son:

Soporte para namespaces, un viejo problema de PHP, para esto se agrega la keyword "use".
Soporte para cláusulas (o funciones lamda).
Soporte de "Late Static Bindings", mejora la POO (mejora herencia y polimorfismo. que en realidad es como funciona cualquier otro lenguaje OO). Sobre esta característica hice un post hace tiempo: http://yuppframework.blogspot.com/2008/03/problemas-al-acceder-al-nombre-de-la.html
Driver nativo para MySQL, ya no será una extensión.
Soporte para constantes de clase.

Dejo algunos links para completar la informacion:

Liberación de estabilización Yupp Framework PHP v0.1.6.1

2009-01-30T17:37:00.003-02:00

Esta es una versión de estabilización de la versión 0.1.6 de Yupp PHP Framework, la cual contiene pequeños cambios y correcciones con respecto a v0.1.6.

Agregado de la verificación de existencia de una vista y de un layout, que en caso de no existir, se lanza una excepción que es mostrada de forma amigable al usuario.
Correcciones y ampliacion de funcionalidades de la clase YuppForm para generar formularios en las vistas.
Se modifico el helper JS para que pueda tomar javascripts de componentes particulares, ahora acepta un nuevo parámetro "component" que es el nombre del componente dentro del cual está alojado el archivo javascript a incluir en la vista.

Descargas: http://code.google.com/p/yupp/downloads/list

Por consultas o sugerencias: http://groups.google.com/group/yuppframeworkphp
Documentación: http://www.simplewebportal.net/host/1021.htm

Nueva versión de Yupp PHP Framework

2009-01-08T14:57:00.003-02:00

Tengo el agrado de anunciar la liberación de la nueva versión de Yupp PHP Framework.

En su versión 0.1.6, Yupp Framework presenta los siguientes agregados:

Se agregaron tipos para los atributos hasMany, ahora se pueden generar con tipos LIST, COLECTION o SET. Con LIST, los elementos en la colección se mantienen ordenados, esto se logra almacenando un nuevo atributo "ORD" que guarda el lugar del elemento en la lista. COLECTION es el comportamiento por defecto, no concerva orden y se permiten repetidos. SET es una colección donde no se permiten elementos repetidos. Estamos pensando en agregar el tipo ORDERED_SET donde no se permitan repetidos y se concerve el orden (se comporta como SET y como LIST).
Se agregó una pantalla de administración en donde:

Permite generar las tablas para el modelo de datos existente (de todos los componentes).

Permite ejecutar el script de bootstrap de cada componente (este script es donde se inicializan los datos que el componente necesita en la base de datos).

Permite ingresar a los controladores existentes (igual que en v0.1.5)

Permite ver estadísticas de líneas de código del framework, totales y por clase.

Se realizaron pruebas con "custom validators" que son validadores de datos o restricciones que se pueden poner sobre los atributos de las clases del modelo de datos, y que pueden ser creadas por el usuario y no están ya implementadas en Yupp. En el archivo "blog.model.Usuario.class.php" se agregó la declaración de una clase "EmailsStartsWithName", la cual es una restricción agregada por el usuario para validar que el atributo"email" empiece con el nombre del usuario, que está en el atributo "nombre". De la misma forma se puede crear cualquier otro "custom validator". Agregaremos una guía de esto a la documentación: http://www.simplewebportal.net/yupp_framework_php_doc/

Página de descargas: http://code.google.com/p/yupp/downloads/list
Documentación: http://www.simplewebportal.net/yupp_framework_php_doc/
Grupo Google: http://groups.google.com/group/yuppframeworkphp/

Presentacion de Yupp PHP Framework en JIIO 2008

2008-12-13T12:12:00.006-02:00

Esta es la presentación sobre Yupp Framework PHP hecha en las Jornadas de Informática e investigación Operativa de la Facultad de Ingeniería de Montevideo, Uruguay, que la disfruten.

Yupp PHP Framework

View SlideShare presentation or Upload your own. (tags: framework mvc php)

También puede ser descargada aquí.

Yupp Framework en Barcelona PHP Conference #2

2008-12-13T11:31:00.003-02:00

Hoy, navegando por internet, me he topado con el sitio de PHP Barcelona, en una zona del sitio he encontrado varias presentaciones de la última PHP Conference, y para mi asombro en una de las presentaciones aparece Yupp Framework PHP, en las páginas 43 y 44 de la presentación está el logo de Yupp.

Ahora viene la crítica, quien hizo la presentación es Arno Schneider, core team member de Akelos Framework. En la página 44 de la presentación se cataloga a Yupp como "weaker PHP", si bien esto no me ofendió (bueno, Yupp aparece al lado de grandes como Zend, Cake, Akelos, Symphony, etc), mi actitud fue enviarle un mail muy respetuoso donde le consultaba porque consideraba que Yupp era "MVC débil", este email nunca fue contestado, y las razones de que Yupp Framework sea catalogado como "débil" por este señor, serán un eterno misterio. La crítica más dura se le puede hacer por el lado de lo rigurosa de la investigación que haya realizado este señor, nunca me contactó para preguntarme nada del framework, simplemente lo vio y lo catalogó. ¿Donde está la objetividad?, me sigo pregutando. Bien cabe destacar que Yupp se encuentra en etapa de desarrollo, que recién vamos por la versión 0.1.5, mientras muchos de los frameworks listados ahí ya pasan el 1.x.

Pese a todo, sigo apostando a este proyecto, el framework cada día toma más forma, se hace más robusto y estable, se amplía en funcionalidad, etc, etc. Esperemos a llegar a 1.x y ver si Akelos no queda "weaker" al lado de Yupp (tal vez lo catalogue así en alguna presentación futura :), creo que es el miedo de los grandes, repitiendo siempre el mismo verso de "reinventar la rueda" de que algún desarrollador invente una rueda mejor que la suya y lo saque del mercado...

Yupp PHP Framework dice presente en las JIIO

2008-11-24T12:37:00.002-02:00

Este miércoles 26 de noviembre estaremos dando una charla sobre Yupp en las Jornadas de Informática e Investigación Operativa, organizada por el Instituto de Computación de la Facultad de Ingeniería, Montevideo, Uruguay.

Búsqueda de emails en gmail

2008-11-24T12:24:00.002-02:00

GMail es sin duda uno de los mejores sistemas de la web en sí, y uno de los mejores sistemas de email.

Una curiosidad interesante, hoy se me presentó la necesidad de buscar emails enviados desde el buscador (si ya se que hay una sessión de emails enviados, pero igual quise probar el buscador), al notar que los emails enviados por mi tienen un "me" en el sender en la versión en inglés (la que uso), intenté buscar por "me", y el resultado fue que no encontró ningún email enviado por mí.

Aquí va la crítica: como desarrollador de software, pienso que si una página tiene un buscador, debe dejarte buscar en la información como te la muestra, si me muestra "me" en lugar de mi usuario de gmail "pablo.swp", pienso que debería dejarme buscar por "me". Ahora, si busco por "pablo" encuentra en seguida todos los emails enviados por mi.

Simplemente una curiosisdad de gmail.

Nuevas ideas para Yupp PHP Framework v0.1.6

2008-11-01T02:50:00.004-02:00

Ya empezamos a trabajar en la próxima versión del framework. Estuvimos pensando en varios temas para hacer las tareas más sencillas para quienes recién empiezan a utilizar el framework, algunas son:

Bootstrap: La idea es tener por cada componente y script de bootstrap. Un bootstrap es un código que se corre previamente a la operación del sistema, básicamente sirve para ingresar información a la base de datos, información que el componente necesita precargada para su correcto funcionamiento.
Modos de ejecución: Esta idea ya está vista en varios frameworks y no nos podíamos quedar atrás. Se tendrían los tres modos de ejecución clásicos: development (desarrollo), testing (test) y production (producción), y posiblemente agreguemos un cuarto modo que podría ser algo como de administración y configuración.
Interfaz de generación de tablas en la base de datos: una interfaz simple donde se pueda ver que tablas están creadas y cuales no, y poder crear desde ahí las tablas que falten, y también borrar las que ya hay y generarlas de nuevo. Esto puede ser útil en modo "development" donde es necesario o útil a veces, empezar con una tabla vacía y si hacemos cambios al modelo, poder regenerar la tabla y que esos cambios se vean plasmados en la base de datos. La idea es de a poquito ir tendiendo a un generador automático de bases de datos, que pueda no solo generar (ya hay un generador automático que solo genera), si no ver cambios y actualizar la base sin modificar los datos, o hacerlo lo suficientemente inteligente como para que también pueda migrar datos de una tabla a otra versión más nueva de la misma tabla.

Estas son algunas ideas que intentaremos tener implementadas para Yupp PHP Framework v0.1.6, más las tareas de la hoja de ruta para llegar a dicha versión:

TICKET #38: terminar las funcionalidades para inspeccionar la base de datos.
Agregar interfaz para generar las tablas de la base de datos.
Implementar helpers para formularios y formularios ajax.
Implementar custom validators para validación automática de información.

Nuevo hotmail, ¿copia de Gmail?

2008-10-29T20:36:00.004-02:00

Acabo de ingresar a mi cuenta de hotmail vía web y me encuentro con que tiene nuevo look, lo extraño es que los últimos cambios al aspecto de hotmail lo hacen más y más parecido a Gmail, aunque hice una prueba de enviar mails mientras veía la pantalla y no tiene la capacidad de AJAX que tiene desarrollada Gmail para mostrar los mensajes nuevos sin tener que recargar la página. Aquí dejo el screen shot.

Nueva liberación de Yupp PHP Framework

2008-10-25T16:20:00.003-02:00

Notas de la versión:

Versión 0.1.5 del Yupp Framework PHP

Incluye los siguientes componentes:

versión 0.5 del YORM (Yupp Object Relational Mapping)
versión 0.1.4 del YMVC (Yupp Model View Controller)

Requisitos:

Version de PHP: 5.2.x (nosotros utilizamos 5.2.3)
Motor de bases de datos: MySQL 5.x o superior (nosotros utilizamos 5.0.41)
Tener el modulo de Apache MOD_REWRITE instalado y activado.

Cambios con respecto a la versión anterior:

El mayor cambio de esta versión es el soporte de MTI, que es la posibilidad de mapear un modelo de clases con herencia entre ellas, en distintas tablas. Previamente Yupp solo soportaba mapeo de herencia de una tabla, con esta nueva opción tenemos un componente ORM de gran funcionalidad y flexibilidad a la hora de diseñar los modelos de datos de nuestros sistemas.
Se corrigieron problemas en DAL y PersistentManager.
Se agregó la generación de Foreign Keys para evitar errores de consistencia de datos al eliminar, esto sirve para avisarle al usuario cuando se olvida de actualizar asociaciones antes de eliminar algún objeto.

Que contiene esta liberacion?

Contiene los componentes mencionados antes, el YORM y el YMVC.

Esta liberación contiene un ejemplo de un sistema de Blog sencillo donde
se pueden crear entradas y comentarios, mostrando el funcionamiento básico
del framework, con funcionalidades como:

- Definicion de modelo persistente
- Crear modelo
- Modificar modelo
- Obtener modelo
- Definicion de controladores
- Definicion de vistas
- Uso de helpers basicos
- Validacion automatica de informacion

Para correr el ejemplo

Debes tener un servidor Apache con soporte para PHP corriendo.
Debes tener PHP 5.2.x o superior.
Debes tener MySQL 5.x o superior instalado y corriendo.

Descomprime el contenido de la liberacion que descargaste desde www.SimpleWebPortal.net
en un directorio de tu servidor Apache, accesible desde un browser,
por ejemplo /www o /public_html.

Configuracion de la base de datos y creacion de la base:

Para configurar los datos de conexion a la base de datos MySQL se debe
editar la informacion presente en el archivo:
"/core/config/core.config.YuppConfig.class.php",
modificando el campo $dev_datasource, estableciendo los valores correctos
para cada clave de dicho array: url, user, pass y database.

Y se debe crear la base de datos con el nombre que hayas configurado en
"/core/config/core.config.YuppConfig.class.php" en el campo "database".

Generacion de las tablas:

Debes editar el archivo "/index.php" descomentando la siguiente linea:

PersistentManager::getInstance()->generateAll();

Esto generara las tablas automaticamente a partir de las clases de modelo
en "/model", al acceder al sistema.

Debajo se explica como acceder al sistema, luego de haber accedido por
primera vez vuelve a comentar esa linea ya que si no la comentas
generara un error porque las tablas ya existen. En las próximas versiones
intentaremos crear un mecanismo más amigable para generar las tablas
en la base.

Acceder al ejemplo:

Accede al directorio donde se descomprimió Yupp Framework PHP desde un
browser, aparecerá una página con links, esos links ejecutan las acciones
por defecto de los controladores existentes, el único controlador que
tiene utilidad por el momento es "EntradaBlog" que es de donde se permite
crear entradas para el blog.

Cualquier duda o sugerencia, envianos un mail desde http://www.SimpleWebPortal.net > contacto.
Tambien puedes contactarnos a por nuestro blog: http://YuppFramework.blogspot.com.

Descargas:

Pablo Pazos Gutierrez
Project Leader
www.SimpleWebPortal.net

El nuevo navegador de Google es incompatible con Google Groups

2008-09-12T13:29:00.004-03:00

He descargado el nuevo navegador de Google, Google Chrome, un navegador sencillo, elegante, ina interfaz intuitiva, es rápido, cada pestaña se procesa en un thread distinto, lo que permite que las demás pestañas no se bloqueen cuando una se bloquea por un javascript con errores u otros motivos.

Ahora bien, voy a editar uno de mis grupos de google y al quere crear una página obtengo esto:

Tú navegador web no admite la edición de páginas. Descarga una copia nueva de Firefox o Internet Explorer para editar las páginas.

ORM: Mapeo de herencia a multiples tablas

2008-08-30T02:58:00.003-03:00

Como es sabido, Yupp Framework PHP implementa mapeo de herencia de una sola tabla, pero para la próxima versión (0.1.5) queríamos implementar también la posibilidad de mapear herencia a diferentes tablas, pudiendo así optar por cualquiera de las dos opciones según las necesidades del problema a resolver.

Estudiando el tema, tiene dos puntos bien importantes, la generación del esquema y como son pedidos los datos a la base. En primer lugar, la generación del esquema debe tener reglas que permitan saber cuando una clase se debe mapear a la misma tabla que su superclase o a una tabla distinta, para esto decidimos usar el atributo "withTable" con el que cuentan todas las clases persistentes, de este modo si una subclase define este atributo en un valor distinto al de alguna superclase, automáticamente se toma como que para esa clase (y sus subclases que sigan las mismas reglas) se genere una nueva tabla.

Por otro lado, para obtener datos de la base, como una instancia de una clase puede estar dividida entre varias tablas, debe haber algún mecanismo que permita hacer joins entre las tablas para reconstruir el registro completo, y así levantar toda la información de una instancia de una determinada clase. Para esto se inyecta un nuevo atributo "super_id" que es una foreign key a la tabla que mapee las superclases de la clase que se quiere cargar, y el join se hace por ese atributo con el identificador en la tabla de las superclases. Esto es medio complicado de explicar pero va a ser muy simple de utilizar, más que simple, va a ser transparente al usuario, ya que toda la responsabilidad de cargar la información correctamente corre por parte del framework.

Como se mencionaba antes, esta característica da más flexibilidad a la hora de resolver un problema, por ejemplo en el caso de tener muchas clases que heredan de una sola, en el caso de mapeo de una sola tabla la cantidad de columnas de la misma sería muy alta, y se podría "dividir" el problema mapeando algunas clases en otras tablas y dejando que las clases más utilizadas se sigan mapeando en la misma tabla que la superclase (para que sea más rápida la carga por no tener que hacer joins).

Esperamos tener esta caracteristica funcionando para la semana que viene y con suerte también tendremos la liberación de la próxima versión del framework.

Visión a futuro

2008-08-15T03:46:00.002-03:00

Con la versión 0.1.4 del framework vimos a Yupp crecer como nunca antes, logrando mejoras y nuevas características que lo hacen más estable, brindando más opciones y aún conservar la simplicidad (tanto de las soluciones como a nivel de usuario), cosa no menos importante porque en general agregar nuevas características implica complicar las cosas, pero con la premisa de la simplicidad siempre en mente (premisa principal del framework) tratamos de llevarla a la práctica siempre.

Ahora bien, ¿qué tenemos?, tenemos un framework con una implementación completa del patrón MVC, tenemos una implementación completa de un primo lejano del patrón Active Record, tenemos generación automática de las tablas de la base de datos, tenemos integración con 2 motores de bases de datos (MySQL y SQLite), tenemos convenciones que, si se siguen, nos simplifican la vida (que poner, donde ponerlo, como llamarlo, etc), tenemos una forma sencilla de definir controladores, tenemos una forma sencilla de definir las vistas, tenemos helpers que nos ayudan a generar vistas, tenemos soporte de templates que nos ayudan a reutilizar código entre vistas (páginas), tenemos soporte para layout que son simplifica el tema de definir un mismo formato general para un conjunto de páginas y poder actualizarlo y mantenerlo de forma sencilla, tenemos soporte completo para i18n (una gran cosa), tenemos una primer integración con AJAX (la parte de llamadas no de efectos y animaciones), tenemos soporte para custom mappings, que son mapeos de las urls que nos dejan apuntar al controlador y acción que querramos, tenemos soporte para filtros de acciones que permiten ejecutar una serie de funciones, definidas por el usuario, antes y después de ejecutar la acción del controlador, en fin, tenemos un lindo framework, pero eso no alcanza, además recién estamos en 0.1.4, y mi visión es que recién en v0.2.0 se va a llegar a un framework completo con el cual se pueda desarrollar cualquier sistema y ponerlo en producción.

Ahora el trabajo estará concentrado en ampliar los helpers, completar la integración con AJAX para llamadas y procesamiento de respuestas JSON, integrar algún otro motor de bases de datos (tenemos a PostgreSQL en la mira), seguir mejorando y estandarizando la API y corrigiendo bugs conocidos y que encontremos. Además trabajaremos en terminar la definición de componentes, concepto importante dentro del sistema, para que el día de mañana se puedan desarrollar componentes e instalar en sistemas Yupp que estén en producción, de forma sencilla, lo que permitiría poder encarar proyectos de mediano y gran porte en distintas etapas, dejando en cada una un sistema 100%, y agregando funcionalidad en distintas etapas. Para la versión 0.3.0 del framework buscaremos proponer un proceso de desarrollo con Yupp Framework PHP que intentará definir las etapas básicas del desarrollo, orientado al framework, señalando mejores prácticas y orientando al desarrollador, de forma de hacer el proceso lo más rápido y bien posible. Ya hablaremos más de esta parte en el futuro.

Noticia: hay nueva documentación en el sitio sobre Yupp Framework PHP, dejo el link: http://www.simplewebportal.net/yupp_framework_php_doc/

Gracias por leer,
Pablo.

Tenemos nueva versión! Yupp Framework v0.1.4

2008-08-10T03:52:00.003-03:00

Apuramos el paso en algunas áreas por posibles proyectos que pueden salir en torno a Yupp, esta versión tiene algunas características nuevas y muchas correcciones, cave destacar que se mejoraron algunas funcionalidades de persistencia, del sistema de layouts, se agregó el primer helper ajax usando prototype, se implementó el concepto de filtros y se muestra un ejemplo de uso de los mismos para verificar si un usuario tiene permisos para editar un blog, y muchas más cosas...

Por descargar e informe de cambios de la versión ver: http://www.simplewebportal.net/host/1022.htm

Nueva documentación disponible

2008-08-09T16:42:00.003-03:00

Publicamos en el sitio de Simple Web Portal la primera documentación de referencia de Yupp Framework PHP, está accesible desde aquí:

http://www.simplewebportal.net/yupp_framework_php_doc/

Seguimos trabajando en la doc y en la liberación v0.1.4 que esperamos tener pronta mañana.

Nueva versión 0.1.3!!!

2008-08-04T14:37:00.001-03:00

Hemos hecho la nueva liberación y alcanzado el hito de la v0.1.3 marcado en la hoja de ruta.

Los cambios en esta versión son:

1. Soporte para layouts. Como demo, hay un layout definido para el componente blog y la vista list de entradaBlog incluye ese layout. El layout muestra una barra con selección de idioma del blog.

2. Moficación a la forma en que se verifican los mappings de ruteo en routing.Mapping.

3. Se agregó una operación toJSON para las clases del modelo, no está completa.

4. Se agregó soporte para SQLite, para configurar que dbms se usa hay que modificar la información en YuppConfig.

En cuanto a JSON, todavía falta un poco para generar un JSON completo de todo el modelo.

Por mas info:

Descargas: http://www.simplewebportal.net/host/1022.htm

Soporte para layouts

2008-07-15T17:51:00.004-03:00

El soporte para layouts es una característica bien importante para cualquier framework MVC y Yupp Framework no se podría quedar atrás, así que empecé a buscar información sobre implementación de layouts, patrones de diseño, y frameworks especializados en layouts y templates.

Un sistema de layout ayuda a ahorrar código en las vistas, de forma que varias vistas puedan compartir código común que está en un único archivo externo.

En un momento, luego de leer un rato sobre las posibles formas de implementarlo, más algunas ideas que tenía en mente, probé una pequeña implementación de un sistema de layout, y luego de un par de horas (y para mi sorpresa) lo teníaandando integrado con el framework. En este post mostraré como es que se utilizaría esta implementación de layouts.

La idea principal era no tener que modificar demasiado las vistas de forma que las vistas ya creadas sigan funcionando bien aunque no tengan referencia a un layout. Por lo tanto inventé una tag que sirve para crear la referencia desde una vista:

Esta tag debe ser incluída luego de <html> y antes de <head>,
para hacer más clara la referencia y más fácil de implementar el procesamiento de esa tag.

El procesamiento debía ser muy rápido y casi no afectar la velocidad de procesamiento actual, de esta forma probé hacer un procesamiento de layout mediante expresiones regulares y mediante operaciones con strings, y la velocidad con las operaciones con strings fue muchísimo mejor que con expresiones regulares, y muchísimo mejor me refiero a varios órdenes por debajo:

velocidad con expresiones regulares promedio: 0.03 ms
velocidad con operaciones de strings promedio: 5.5E-5 ms

El layout tiene la estructura de una vista pero no hace referencia al modelo y tiene dos variables disponibles para poder mostrar el contenido de la vista de la cual es layout, estas son $head y $body, que representan el contenido del <head> y del <body> de la vista.

Este es un ejemplo de un layout:

<html>
 <head>
   <style type="text/css">
   ...
   </style>
   <?php echo $head; ?>
 </head>
 <body>

     <div style="padding:10px; background-color:#6af;" align="right">

     <?php echo h('locale_chooser'); ?>
     </div>

     <div style="padding:10px;">

     <?php echo $body; ?>

   </div>
 </body>
</html>

Por último quien hace el proceso de la vista es una clase llamada LayoutManager que se
encarga de resolver referencias a layouts y mostrar la vista generada. Si la vista no contiene una referencia a un layout, simplemente muestra la vista igual que antes.

Si bien esta solución funciona bien, se puede mejorar en varios aspectos:

Chequeos de errores, para hacerlo más robusto.

Más flexible, por ejemplo poder acceder a más información de la vista como el título, ahora solo se accede al head y al body.

Poder incluir N niveles de layouts en cascada, podría servir para que un layout a su vez pueda tener un layout que
lo contiene y poder definir distintas secciones de la página que se arma en distintas layouts.

Esta característica estará disponible con la próxima liberación del framework, Yupp Framework PHP v0.1.3.

Característica: devolver directamente el modelo

2008-07-11T17:50:00.001-03:00

Una nueva característica que vino con la versión 0.1.2 del framework es la de no necesitar explicitar la vista que se va a utilizar. Por ejemplo con la acción edit, la forma de especificar la vista a utlizar se hace mediante el retorno de llamar al método “render” de YuppController:

class EntradaBlogController extends YuppController {

public function editAction()

{

$id = $this->params['id'];

$obj = EntradaBlog::get( $id );

$this->params['object'] = $obj;

return $this->render("entradaBlog/edit", &$this->params);

}

Esta es la única forma de especificar la vista previo a la versión 0.1.2, con Yupp Framework PHP v0.1.2 se puede retornar solo el modelo y la vista se resuelve de forma automática por Yupp Framework:

class EntradaBlogController extends YuppController {

public function editAction()

{

$id = $this->params['id'];

$obj = EntradaBlog::get( $id );

$this->params['object'] = $obj;

return $this->params;

}

En este caso, el framework buscará una vista llamada “edit”, igual al nombre de la acción, dentro del directorio de vistas del controller “EntradaBlog”. También se podría retornar NULL o nada en caso de no querer mostrar modelo. En una próxima versión no será necesario tampoco retornar el modelo, ya que como “params” es un campo de “YuppController” puede ser accedido sin necesidad de retornarlo de forma explícita.

La idea fundamental de estas pequeñas características es reducir la cantidad de código que es necesario escribir para implementar cierta funcionalidad y tener varias formas consistentes de hacer lo mismo de forma que cada usuario programe como más le guste y que el framework no restrinja esa libertad.

Descargar Yupp Framework PHP v0.1.2

2008-07-05T15:54:00.003-03:00

Tenemos el agrado de anunciar la liberación de la nueva versión de Yupp Framework PHP, que ya está disponible para descargar desde:

http://groups.google.com/group/yuppframeworkphp
http://code.google.com/p/yupp/downloads/list
http://www.simplewebportal.net/host/1022.htm

Con esta versión hemos resuelto:

TICKET #34: mejorar el tema del ruteo implementando un componente especificamente para eso, y agregar custom mappings para poder modificar facilmente que accion de que controller ejecutar si viene determinada url.
TICKET #32: cambiar de lugar la funcionalidad de saber el nombre de una tabla dada una clase.
TICKET #43: no se verifican constraints sobre relaciones hasOne.
TICKET #46: simplificar el acceso a recursos estaticos como imagenes, css y js.

Nuevas características:

Helper para cambiar el idioma (disponible para probar desde el ejemplo del blog).
Helpers para incluir Javascript y CSS.
Ahora las acciones pueden obviar el tener que devolver la vista, pueden devolver solo el modelo y Yupp busca y muestra la vista correcta => escribir menos código!
Nuevo paquete de ruteo con mapeos de urls que se pueden configurar a medida para permitir urls que no sigan las convenciones de Yupp.
Se modificó el ejemplo del blog para mostrar algunas de las nuevas características.

Gracias por tu atención y si pruebas el framework esperamos tus comentarios!

Nuevo sitio en Google Code

2008-07-05T14:07:00.004-03:00

Hemos hecho una cuenta en Google Code para disponer de las herramientas que brindan en beneficio del proyecto. Entre ellas wiki, sistema de tickets, repositorio de archivos y repositorio svn.

En breve empezaremos a utilizar el repositorio svn y a trabajar sobre él, para quien quiera descargarse la última versión de implementación lo pueda hacer.

El link: http://code.google.com/p/yupp/

PD: los últimos archivos generados por el proyecto están ya en el sitio de google code.

Nueva versión de Yupp Framework PHP 0.1.1

2008-06-22T20:52:00.003-03:00

Como anunciamos anteriormente ya está disponible para descargar y probar la nueva versión de Yupp Framework PHP. La nueva versión v0.1.1 agrega nuevas características y mejoras al framework, que son las primeras mejoras de tantas otras que iremos haciendo hacia la versión v0.2.0 del framework.

En esta versión incluye:

- Redirects a acciones de controladores.
- Corrección de errores.
- Simplificación de render y redirect en las acciones de controladores.
- * Soporte para templates *
- Se agregó una clase que almacena variables de contexto que simplifica el acceso a variables globales a la aplicación.
- Se agregaron helpers para mensages i18n y para templates.

Para descargar siga el siguiente link: http://www.simplewebportal.net/host/1022.htm
También lo puedes descargar desde el grupo google del proyecto: http://groups.google.com/group/yuppframeworkphp

Próxima liberación Yupp Framework PHP v0.1.1

2008-06-19T00:57:00.004-03:00

Como ya avisáramos desde nuestro grupo google (de forma informal) , este fin de semana estaremos liberando una nueva versión de Yupp Framework PHP, esta versión agrega características y resuelve algunos problemas menores y es la primera de la hoja de ruta hacia la versión 0.2.0 del framework.

En esta versión 0.1.1, algunas de las nuevas características son:

- Redirects a acciones de controladores.
- Corrección de errores.
- Simplificación de render y redirect en las acciones de controladores.
- * Soporte para templates *
- Se agregó una clase que almacena variables de contexto que simplifica el acceso a variables globales a la aplicación.
- Se agregaron helpers para mensages i18n y para templates.

La versión 0.2.0 será una versión 100% funcional, estable y completamente documentada. El objetivo es que pueda comenzar a ser utilizado en producción para desarrollo de sistemas pequeños y prototipos, ya que más adelante agregaremos características y herramientas que permitan trabajar con sistemas más grandes de forma sencilla.

Saludos a todos y gracias por el interes, los comentarios son bienvenidos!

Presentación oficial del grupo google de Yupp Framework PHP

2008-06-04T15:50:00.003-03:00

Dándole la importancia que se merece hago un nuevo post para la presentación del grupo google de Yupp Framework PHP.

El grupo es un medio más para acercar el proyecto a la comunidad de desarrolladores PHP, para difundirlo entre quienes realmente lo van a usar y para escuchar sus sugerencias y aportes al proyecto, para así hacerlo mejor para todos.

La dirección del grupo es: http://groups.google.com/group/yuppframeworkphp

El grupo es un lugar donde discutir detalles de implementación, donde se harán anuncios sobre el avance del proyecto, y donde publicaremos documentación y las últimas descargas a medida que estén disponibles.

El proyecto está abierto a todos quienes quieran aportar su granito de arena, sean expertos o principiantes, para todos quienes estén interesados en programación, gestión de bases de datos, diseño de software, patrones, procesos de desarrollo, testing, frameworks, etc, todos son bienvenidos.

Página activa de nuevo!

2008-06-02T13:17:00.001-03:00

Por suerte ya fueron superados los problemas por el incendio en el datacenter y la página web está de nuevo operativa.

http://www.simplewebportal.net/

Pagina web offline por incendio en datacenter

2008-06-01T16:41:00.002-03:00

Lamentablemente nuestra página web oficial www.SimpleWebPortal.net está inaccesible debido a un importante incendio en el datacenter donde es alojada.

Debido a que últimamente hubo mucha gente interesada en el framework y lo quería descargar, creamos un grupo de google donde se publicarán las descargas que estaban en el sitio para que puedan seguir descargándolo y probándolo sin problemas.

La dirección es http://groups.google.com/group/yuppframeworkphp, y ya fueron publicados el archivo con la última liberación del framework y la documentación sobre como crear un sistema de blog simple.

Este grupo servirá también para discutir detalles de implementación y como vía alternativa de comunicación con la comunidad. Por lo pronto estaremos al tanto de las noticias sobre el servicio de hosting, y cualquier actualización que hagamos será publicada en el grupo y notificado aquí en el blog.

Por más información sobre el incendio en los datacenters: http://hostingdelsur.net

Nueva documentación de Yupp Framework PHP

2008-05-31T02:21:00.003-03:00

Hemos publicado un documento que explica los pasos necesarios para empezar a desarrollar aplicaciones web utilizando Yupp Framework PHP.

El mismo trata el ejemplo de desarrollo de un sistema simple de blog, donde los usuarios serán capaces de crear entradas y agregar comentarios. Dicho ejemplo viene implementado junto con la descarga de Yupp Framework v0.1.

Para descargarlo puedes acceder aquí.

Tercer liberacion de Yupp Framework PHP !!!

2008-05-25T01:07:00.002-03:00

Y como lo prometido es deuda...

Esta liberacion corresponde a Yupp Framework PHP en su version 0.1, que se compone de la version 0.3 de YORM (Yupp Object-Relational Mapping) y la version 0.1 de YMVC (Yupp Model View Controller), los cuales son los componentes principales del Yupp Framework PHP.

Esta version viene con un ejemplo de implementacion de un Blog sencillo que permite crear entradas y comentarios. Cave destacar que es la primer implementacion 100% mvc usando Yupp Framework PHP y muestra distintos aspectos de funcionalidades provistas por el framework, entre ellas:

Manejo de modelo.
Ruteo y ejecucion de acciones de controladores.
Manejo de vistas.
Utilizacion de helpers.
Validacion automatica de informacion.

Por mas informacion y descargarlo puedes hacerlo desde > aqui <

La descarga incluye informacion de la version, informacion de como instalarlo y ponerlo a funcionar y requisitos de instalacion.

Cualquier comentario lo puedes hacer aqui en el blog o mediante la pagina de contacto de www.SimpleWebPortal.net

Proxima liberacion

2008-05-21T14:47:00.002-03:00

Estamos trabajando para poder este fin de semana hacer una nueva liberacion de Yupp Framework PHP.

Esta liberacion contendra la version 0.3 del YORM (el componente de modelo persistente) y la version 0.1 del componente MVC que esta bastante avanzado pero como es la primer liberacion sale con version 0.1, luego veremos como ajustar el versionado a medida que se agregan caracteristicas.

En cuanto al YORM se hicieron cambios importantes en la parte de consultas para poder hacerlas mas sencillas y potentes. Tambien se mejoro y se integro la parte de validacion de informacion, esta caracteristica aunque existia en las liberaciones anteriores, no fue expuesta para probar, ahora esta 100% accesible y la liberacion va a incluir algunos ejemplos de uso.

En el YUPP MVC (o YMVC) implementa lo que seria el ruteo de requests a ejecucion de acciones de controladores, generacion de modelo, manejo de vistas y contiene algunos helpers basicos para mostrar informacion del modelo y errores que puedan haber ocurrido. Tambien fue implementado un controlador por defecto que permite hacer CRUD (Create Retrieve Update Delete) para cualquier clase de dominio (clase persistente definida con YORM). Y viene con 4 vistas genericas para listado, creacion, edicion y vista de detalles que funcionan con informacion provista por las clases de dominio (definidas con YORM).

Bueno, esperamos llegar al fin de semana con esta nueva liberacion, si no, sera para el proximo.

Primer versión del logo de Yupp Framework PHP

2008-04-15T13:42:00.004-03:00

Es un placer presentarles en nuevo logo de Yupp Framework PHP.
Los comentarios son bienvenidos.

Segunda liberación del Yupp Framework PHP

2008-04-07T00:22:00.002-03:00

El componente de modelo persitente YORM en su versión 0.2 está listo para ser descargado y probado.

En el post anterior donde avisábamos de la liberación se comentan las características más importantes en esta liberación, entre lo más notable está el soporte para carga perezosa, que se une a la previa carga en cascada, y la operación *Contains sobre objetos del modelo.

Puedes encontrar toda la información de la liberación en la documentación dentro del .zip en la página de descargas.

Cualquier duda o comentario será bien recibido y lo tomaremos en consideración.

La versión 0.3 del YORM estará lista mas o menos en un mes, con nuevas características, pero sobre todas las cosas será una liberación de estabilización, donde se harán pruebas exhaustivas, se revisará la API y se documentará lo mejor posible. Intentaremos con esta versión del YORM liberar tambén la primer versión (v0.1) del componente MVC del Yupp Framework PHP, el YMVC.

Anuncio de liberación de la versión 0.2 del YORM

2008-04-05T21:39:00.002-03:00

En el día de mañana estaremos liberando la versión 0.2 del YORM, el componente de modelo persistente del Yupp Framework PHP.

Aquí va un resumen de algunas de las nuevas características:

Carga de relaciones bidireccionales instanciadas unidireccionales corregida.
Es básicamente la consideración de que si tengo una relación bidireccional entre dos clases, puedo tener una instancia de la relación que no es bidireccional, a no ser que tenga una restricción no estructural que diga lo contrario.
Se agrego operacion *Contains( id ) para preguntar si un atributo hasMany contiene un objeto con ese id.
Si una clase Empresa tiene un atributo hasMany llamado "personas" (o sea que tiene asociadas varias "personas"), puedo preguntarle a una instancia de Empresa: $emp->personasContains( 123 ), eso retornará un booleano y será true solo si la lista de personas de la empresa tiene una persona con id 123.
Soporte para multiples relaciones entre las mismas 2 clases.
Esto es, por ejemplo cuando tengo artículos escritos y autores, y en cada artículo quiero tener asociado un autor principal y los autores secundarios, antes no se podía modelar algo así de forma estándar. Ahora hay una forma "Yupp" de hacerlo ;)
Soporte para carga perezosa (lazy loading).
Esta es la característica más importante de esta liberación, la capacidad de poder cargar un modelo de forma lazy, esto quiere decir que se puede cargar una instancia de una clase sin cargar las instancias de las clases asociadas, cosa que antes no se podía hacer y se cargaba en cascada (cargando una instancia se cargaban todas las de los elementos asociados). De esta forma, se cargan los objetos asociados solo si son utilizados, lo que representa un gran ahorro en el número de consultas que se deben hacer a la base de datos.

Entre hoy y mañana estaremos terminando de actualizar los tests para poder correr esta nueva versión, y en la noche estará publicada la nueva versión.

Primer liberación del Yupp Framework

2008-03-19T02:13:00.002-03:00

Esta liberación de código del Yupp Framework está relacionada con uno de los componentes principales del mismo, el YORM. Este componente se encarga de manejar todo el acceso a datos, definición de modelos y generación de esquemas, en una forma 100% orientada a objetos, simplificando las tareas en dichas áreas.

Hoy con la versión 0.1 de este componente se inicia un largo camino para este framework que espera y apunta a ser el más simple y productivo del mercado (en frameworks PHP, claro está).

En esta primer versión encontramos una primer solución para definir clases del modelo, generar esquemas, persistir datos y obtener datos, sin necesidad de codificar una sola línea de SQL y con una configuración mínima (apenas los datos de conexión a la base). Esta versión cuenta con soporte para definición del modelo de datos, soporte de relaciones de herencia y relaciones entre clases con cardinalidades 1-1, 1-n y n-n unidireccionales o bidireccionales.

Aquí está es link para descargar esta versión.

Problemas al acceder al nombre de la clase en un esquema de herencia desde metodos estaticos en PHP

2008-03-19T01:54:00.003-03:00

Digamos que tenemos un esquema como el siguiente, en donde hay dos clases que mantienen una relación de herencia, y hay un método estático definido en la clase padre, el cual accede al nombre de la clase y es invocado por la clase hija. El resultado esperado sería que el nombre de la clase fuera el de la clase hija, pero como veremos en el ejemplo, el resultado es la clase padre.

 class A {
public static function who() {
   echo __CLASS__;
}
public static function test() {
   self::who();
}
}

class B extends A {
public static function who() {
    echo __CLASS__;
}
}

B::test();

Lo descrito anteriormente sucede porque PHP resuelve el nombre de la clase por la clase a la cual pertenece el método que se está invocando, lo que tal vez se puede ver como una violación al polimorfismo, es decir, que esperamos que el código anterior devuelva el nombre de la clase sobre la cual es invocado el método, pero no es así.

Según el manual de PHP, con la versión 5.3.0 este tema será resuelto de forma nativa por PHP, la solución a este problema lleva el nombre de "Late Static Bindings". Lo que básicamente agrega esta solución es una palabra clave que ayuda a referenciar a la clase correcta en tiempo de ejecución conservando el comportamiento deseado en un ambiente Orientado a Objetos con polimorfismo. Este es el ejemplo que se ofrece en la documentación de PHP:


class A {
  public static function who() {
      echo __CLASS__;
  }
  public static function test() {
      static::who(); // Here comes Late Static Bindings  
  }
}

class B extends A {   
  public static function who() {
       echo __CLASS__;
  }
}

B::test();

En este ejemplo se agrega la palabra clave "static" para referenciar a la clase correcta en tiempo de ejecución, devolviendo el valor correcto y esperado para un ambiente que soporta polimorfismo.

Por más información sobre el tema, accede al manual de PHP - Late Static Bindings.

Metadata en nombres de archivos PHP

2008-02-29T01:54:00.000-02:00

Por suerte con PHP no hay restricciones o estandares a seguir con respecto al nombrado de los archivos PHP. Algo que no es nada nuevo es que podemos usar el nombre del archivo para comunicar más información que solo el nombre del archivo. Algo muy usado es ponerle "archivo.class.php" o directamente "archivo.class" a los archivos PHP que contienen una o más clases. Se puede notar que ni siquiera es requerido que el archivo tenga extensión ".php".

A continuación voy a mostrar algunos ejemplos de nombrado de archivos que pueden ser de utilidad al implementar aplicaciones.

1. Paquetes codificados en el nombre del archivo

PHP no soporta paquetes, lo que es un dolor de cabeza para la implementación de aplicaciones de cierto tamaño. Hay muchas formas de simular la presencia de paquetes en PHP, en este caso se hace con el nombrado de los archivos.

Los paquetes son una setructura jerárquica similar a una estructura de directorios, lo paquetes pueden contener archivos y otros paquetes. Por ejemplo, en Java, los paquetes coinciden con la estructura de directorios en donde se encuentran los archivos (paquetes físicos), en cambio, en C# se pueden definir una especie de paquetes lógicos llamados "namespaces".

Usando el nombre de los archivos para codificar paquetes lógicos nos evitamos problemas como tener dos archivos con el mismo nombre, o simplemente tener un poco más de orden cuando trabajamos con gran cantidad de archivos, y se podrían tener una inmensa cantidad de archivos, en el mismo directorio, perfectamente distinguidos entre si y fáciles de encontrar a simple vista.

Digamos que en nuestro proyecto tenemos 3 paquetes: "core", "core.utils", "core.db". Por otro lado tenemos 100 archivos, 20 del paquete "core", 40 de "core.utils" y otros 40 de "core.db". Y llamamos a los archivos dentro de estos paquetes de la siguiente forma:

- core.UnArchivo.php
- core.OtroArchivo.php
- ...
- core.utils.UnArchivo.php
- core.utils.OtroArchivo.php
- ...
- core.db.MySQL.php
- core.db.PostgreSQL.php
- ...

En principio, estos nombres pueden servir para ver de forma simple que archivos están en que paquete, simplemente listando los archivos ordenados por nombre.

Otra ventaja, ya desde el punto de vista del sistema que estemos construyendo, es por ejemplo hacer un script para cargar o incluir todos los archivos de determinado paquete, por ejemplo, la siguiente función incluye todos los archivos del paquete:

function includeDB( $path )
{
$d = dir($path);

while (false !== ($entry = $d->read())) // Por cada entrada del directorio
{
if (is_file($path . "/" . $entry)) // Si la entrada es un archivo
{
if ( strcmp("core.db", substr($entry,0,7)) == 0 ) // Si el nombre empieza con "core.db"
{
include_once($path . "/" . $entry); // Lo incluye para usarlo
}
}
}
}

Explicación del código:

$path es la ruta del directorio que contiene los archivos. No se verifica que sea correcta, esta verificación se podría agregar para hacerlo mas robusto.

$entry son los archivos del directorio.

Lo demás ya se explica con los comentarios en el código.

Tambien se podria usar el nombrado para hacer un class loader (como el del codigo anterior) mas inteligente, sin necesidad de incluir todos los archivos del sistema, si no incluyendo solo los que se van a usar.

2. Decir que contiene el archivo

Un archivo php puede contener cualquier cosa, ya que no es mas que un archivo de texto.

Pensando en alguno de los posibles contenidos que puede tener un archivo php podría nombrar:

- scripts (en el sentido de tener un código que se ejecuta automáticamente al cargar el archivo)
- funciones
- clases
- interfaces
- paginas (código HTML mezclado con script PHP)

Entonces, podríamos utilizar el nombre del archivo para decir que tipo de contenido tiene, en los casos anteriores podríamos tener los siguientes nombres:

- DownloadFile.script.php
- String.functions.php
- Invoice.class.php
- Clonable.interface.php
- Contacts.page.php

También, esta notación puede servir para saber a simple vista que tiene cada archivo, o también para cargar los archivos por su tipo, por ejemplo si quiero cargar todas las clases de un determinado directorio, puedo usar el código anterior y modificarlo un poco y buscar los archivos que tienen "class" adelante del ".php" como en el siguiente ejemplo:

function includeDB( $path )
{
$d = dir($path);

while (false !== ($entry = $d->read())) // Por cada entrada del directorio
{
if (is_file($path . "/" . $entry)) // Si la entrada es un archivo
{
if ( preg_match("/(.*)class\.php$/", $entry, $matches) ) // Si el nombre tiene "class" antes del ".php"
{
include_once($path . "/" . $entry); // Lo incluye para usarlo
}
}
}
}

Una posible aplicacion de esto es si uno tiene scripts de testing para correr, y algun otro script encargado de correr los tests, y los test se llaman por ejemplo "paquete.Nombre.test.php", puedo buscar todos los tests, incluirlos, correrlos y mostrar los resultados. A simple vista se puede ver el poder con el que se cuenta simplemente por nombrar los archivos de cierta forma.

3. Paquetes y contenido

Y podemos también decir en que paquete esta un archivo y ademas poner que tipo de contenido tiene, por ejemplo:

- core.db.MySQL.class.php
- core.String.functions.php
- ...

Conclusión:

Podemos utilizar los nombres de los archivos para poner metadatos que nos dan información sobre el archivo, que lugar ocupa o que responsabilidad tiene en el sistema y que tipo de contenido tiene. Esa información la podemos utilizar para hacer sistemas mejores, mas eficientes, mas potentes, etc, ademas de que es una buena forma de ordenar los archivos cuando tenemos un gran numero de ellos. Y como vimos es muy simple hacer scripts que procesen los nombres de los archivos, utilizando funciones del file system como dir() para leer nombres de archivos y funciones de strings o expresiones regulares para filtrarlos.

Consultas sobre archivos de un directorio en PHP

2008-02-27T19:56:00.001-02:00

Problema: necesidad de obtener los nombres de archivos de un directorio filtrados por alguna condición.
Solución: utilizar expresiones regulares para las condiciones sobre los nombres de archivos del directorio.

function getFileNames($path, $match = null, $groups = null)
{
if (is_dir($path))
{
$res = array();
$d = dir($path);

while (false !== ($entry = $d->read()))
{
if (is_file($path . "/" . $entry))
{
$matches = null;
if ($match)
{
if (preg_match($match, $entry, $matches))
{
if (!$groups) $res[] = $entry;
else
{
$gentry = "";
foreach($groups as $i)
{
$gentry .= $matches[$i];
}
$res[] = $gentry;
}
}
}
else // Si no paso match, le entrego derecho la entrada.
{
$res[] = $entry;
}
}
}
$d->close();
return $res;
}
else
{
throw new Exception("El directorio: $path no existe.");
}
}

Explico el código:

function getFileNames($path, $match = null, $groups = null)

path: directorio del cual se quieren leer los nombres de archivos
match: expresión regular con la cual se filtran los nombres de archivos (si no se pasa nada, se devuelven los nombres de todos los archivos del directorio)
groups: solo se usa si match no es null, y se usa para seleccionar los grupos de la expresión regular cuando coinciden los nombres de los archivos con match. Más adelante explicaré como es que se usa, pero la idea es poder sacar pedazos del nombre del archivo y devolver eso, por ejemplo si tenemos infomración codificada en el nombre como: paquete.Clase.class.php, y me interesa devolver solo el nombre de la clase, o sea "Clase". Si groups es null se devuelven los nombres de todos los archivos que coincidan con la expresión regular match.

if (is_dir($path))

Verifica si path es un directorio válido, si no lo es lanza una excepción.

$res = array();

Se crea la lista de nombres a devolver, todos los nombres de archivos que coincidan con los criterios serán incluidos en res.

$d = dir($path);

Se abre el directorio para comenzar a leer sus entradas. Para entender como trabaja dir() visita el manual.

while (false !== ($entry = $d->read()))

Recorre cada entrada del directorio, estas son archivos y subdirectorios, entry es el nombre del archivo o subdirectorio actual en la recorrida.

if ($match)
{
if (preg_match($match, $entry, $matches))

Si match no es null, verifico que entry coincida con él. Para entender como trabaja preg_match, visita el manual. En matches se guardan los grupos definidos en match que coincidieron con entry, y si groups no es null los voy a usar para armar los nombres que voy a devolver.

if (!$groups) $res[] = $entry;
else
{
$gentry = "";
foreach($groups as $i)
{
$gentry .= $matches[$i];
}
$res[] = $gentry;
}

Si groups es null, simplemente agrego entry a la solución, o sea, devuelvo el nombre del archivo así como está y se que ese nombre coincide con la expresión regular match.
Si groups no es null, busco en matches los grupos indicados por groups, concatenando dichos grupos, la concatenación de todos los grupos seleccionados es el nombre a incluir en la solución. De esta forma, si los archivos tienen nombres por ejemplo "paquetes.Clase.class.php", podría devolver "Clase.php", luego mostraré ejemplos de como se hace esto.

else // Si no paso match, le entrego derecho la entrada.
{
$res[] = $entry;

Si match es null, simplemente agrego a la solución el nombre del archivo sin procesarlo.

$d->close();
return $res;

Cierra el directorio y devuelve la solución.

Algunos ejemplos de uso:

Para entender que hacen necesitas entender las expresiones regulares usadas, si no sabes mucho de expresiones regulares te aconsejo que busques en google algún manual de expresiones regulares.

En estos casos usaremos como directorio "." que es el directorio actual. Puedes cambiarlo y utilizar otro directorio si lo deseas.

getFileNames("."); // Todos los archivos, no hay ninguna restricción.

getFileNames(".", "/\.php$/i"); // Todos los archivos con extensión ".php"

getFileNames(".", "/^utils\.(.*)\.php$/i"); // Todos los ".php" del paquete utils (pensado para nombres con la forma "paquete.Class.php", en este caso paquete es "utils"). Observar el "(.*)", eso es un grupo y se podría usar el parámetro groups para obtenerlo, como veremos en el siguiente ejemplo.

getFileNames(".", "/(.*)\.php$/i", array(1)) ); // Todos los ".php", pero sin el .php (ver que la regexp match tiene un grupo y en el array selecciono ese grupo). El grupo 0 (cero) coincide con el nombre del archivo.

getFileNames(".", "/^utils\.(.*)\.php$/i", array(1,5,0)) ); // Todos los php del paquete utils, idem anterior, ahora sin el "utils." Observar todo lo que se pasa en groups, ver que el grupo 5 no existe y por lo tanto no es considerado, luego si tengo un archivo "utils.Class.php", el resultado de esto es "Classutils.Class.php", porque concatena el grupo 1 ("Class") y el grupo 0 (que es el nombre del archivo), y ver que se respeta el orden establecido en groups.

En conclusión, no solo se logró hacer una función que resuelve el problema, si no que se obtuvo una solución que puede hacer un preproceso de los nombres a devolver (gracias a groups), lo que permite extraer información presente en los nombres de los archivos y concatenarla a gusto.

Siéntanse libres de utilizar este script, modificarlo a gusto, hacer comentarios y mejoras sobre él. Y si lo incluyen en algún proyecto no se olviden de hacer referencia a este blog y/o a este post.