Nueva liberación de Yupp PHP Framework

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:

• http://code.google.com/p/yupp/issues/detail?id=19  
• http://code.google.com/p/yupp/issues/detail?id=22

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

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

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!

-