OpenSource ¿Cosa solo de marcianos y hackers?

OpenSource ¿Cosa solo de marcianos y hackers?

Programando un Servlet para crear código HTML, use String, StringBuilder, etc., para crear el contenido de mi pagina, no quede muy satisfecho con los resultado, después de cierto tiempo perdí el control de mi código. Busque un API libre y fácil de usar para salvarme la cordura, me encontré con Java HTML Generator v0.9: http://artho.com/webtools/java/index.shtml, vi los ejemplos, lo use y me gusto mucho, luego revise el código a detalle y me sorprendí de lo ingenioso del código y recordé que muchos de nosotros en la comunidad nos preguntamos por un proyecto al cual contribuir, aprender, ver crecer, en fin, ser parte del proyecto mismo.

Tengo la sensación de que cuando se habla de proyectos de código abierto se mencionan proyectos enormes, que requieren un conocimiento extenso en el lenguaje en el que se programo, tiempo, tiempo, y más tiempo libre para estudiar el código, ya que como yo y mucho otros, no nos pagan para contribuir al OpenSource.

Pero creo que con proyectos como este, que si bien son pequeños, ¡son proyectos! y son libres. Solo usándolos y viendo que si me gusta, que no, que le falta, que le sobra (¿?), se puede contribuir de más formas que solo usando los, si bien eso ya es una gran apoyo a la comunidad, contribuyendo al código es un aporte aun mejor para mí.

Estoy trabajando en un par de contribuciones, solo quería expresar y compartir mi entusiasmo con ustedes.

Les dejo un ejemplo de cómo usar ‘Java HTML Generator’ en la versión v0.9.

public class Test {

    public static void main(String... args) throws IOException {
        Tag html = new Tag("html");
        Tag body = new Tag("body");
        Tag table = new Tag("table");
        Tag tr = new Tag("tr");
        Tag td = new Tag("td");

        String saludo = "saludo";

        td.add(saludo);
        tr.add(td);
        table.add(tr);
        body.add(table);
        html.add(body);
        Attribute border = new Attribute("border", "1");
        table.addAttribute(border);
        //table.remove(tr);

        writeFile(html.toString());

    }

    public static void writeFile(String html) throws IOException {
        System.out.println(html);
        String fileName = "testHtml.html";
        FileWriter fstream = new FileWriter(fileName);
        System.out.println("file path: " + new File(fileName).getAbsolutePath());
        BufferedWriter out = new BufferedWriter(fstream);
        out.write(html);
        out.close();
    }
}

run:
<html><body><table border="1"><tr><td>saludo</td>
</tr>
</table>
</body>
</html>

file path: C:\Documents and Settings\rodrigo\Mis documentos\NetBeansProjects\html-generator\testHtml.html

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de ezamudio

Muy bien

Buen aporte. Y es muy cierto lo que dices, hay infinidad de proyectos pequeños, bibliotecas sencillas de software libre que atacan un problema y lo resuelven de la mejor manera posible (o al menos eso intentan). La mayoría de esos proyectos son creados, desarrollados, mantenidos y administrados por una sola persona. En esos proyectos puede ser más fácil participar que en los megaproyectos tipo Spring, JBoss, el kernel de Linux, Grails, etc; si ves algo que se puede mejorar, puedes contactar al autor y mandarle tu sugerencia, de preferencia con el código; seguramente obtendrás una respuesta y si tu parche es aceptado pues ya te darán crédito (asegúrate que así sea, porque finalmente si es algo significativo, puedes ponerlo en tu CV).

Si claro, puedes entrarle

Si claro, puedes entrarle tambie al HackerGarten donde encuentras personas muy involucradas en las aporaciones a proyectos open source y como dicen, no importa que no sepas mucho, cualquier aporte por muy minimo que sea puede ayudar a mejorar basante e incluso dar pie a otras mejoras adicionales. Mi ecperiencia, no sabia ni que era eso y tuve la suerte de participar con @ecamacho en un poryecto (jAlarms de @ezamudio) y sucedio lo que dices. Cuando vi como estaba estructurado dije "AAAY WEY!" y pues resulto muy sencillo aportar con un canal para enviar alarmas via XMPP... claro que resulto facil orqueya Erick sabia lo qe hacia y el fue quien llevo la batuta del aporte... A que voy con esto? que puedes "como bien dces" aportar con proyectos pequeños que te enseñen como se hace un API, como se moldean las extensiones... esas cosas que hacen a los proyectos enormes

Muy recomendable HackerGarten...

Imagen de Nopalin

Libreria

En eso tienes razón.
Yo hace tiempo que hize una libreria en swing para mejorar la forma en que se maneja la información de un jtable, un poco mas simple que el default de swing (no he checado si alguien mas haya hecho algo), todo lo maneja con listas de pojos, un pojo representa una fila y cada propiedad una columna (aunque como no todas las propiedades de un pojo serán columnas, estas hay que especificarlas), tiene la faclidad de poder mostrar u ocultar columnas, así como agregar cadenas de información custom al table-header como el total de filas contra las seleccionadas, etc. Tiene la ventaja de que utiliza un data source para llenarse y este mismo maneja ordenacion de las columnas tanto interna como externa. Tiene la capacidad de manejar un paginador. Ademas de que tiene la posibilidad de agregar colores customs a cada fila y a cada celda dependiendo de varios criterios.

Desde hace tiempo que me gustaria ponerlo como proyecto opensourcepara ver si alguien mas me ayuda a mejorarlo o a decirme que el modelo que hize esta mal y hay que hacerlo de nuevo jeje, aunque la funcionalidad se quede, o a agregarle nuevas funciones o mejorar las que estan.

En fin a ver si un dia de estos hago el tiempo necesario para colocarlo por ahi.

Aqui un ejemplo de como crear una tabla y como manipular la informacion:

//se crea la tabla pasandole el class del pojo que manejará, un array de columnas, cada columna indica si es visible,
//si es editable, la propiedad del pojo, nombre y el tooltip.
table = new PojoTable(SimplePojo.class, new PojoColumn[]{
    new DefaultPojoColumn(true, true, "id", "Id", "Id"),
    new DefaultPojoColumn("name", "Name", "Name"),
    new DefaultPojoColumn(true, true, "description", "Description", "Description"),
    new DefaultPojoColumn(false, false, "disabled", "Disabled", "Disabled")
}, false, false);
//se le asigna un data source con una lista vacia
table.getPojoModel().setDataSource(new LocalListPojoDataSource(new ArrayList()));

SimplePojo pojo = new SimplePojo();
table.getPojoModel().insertPojo(pojo); //inserta el pojo enla ultima posicion
table.getPojoModel().deletePojo(pojo); //busca el pojo con equals y lo elimina

sobres

Imagen de ezamudio

abreviación

Si el método Tag.add devuelve el objeto recién agregado, entonces se puede abreviar a html.add(body).add(table).add(tr).add(td).add(saludo). Te ahorras la fabulosa cantidad de 4 líneas de código...

bueno y si el addAttribute devuelve this, entonces podrías hacer html.add(body).add(table).addAttribute(border).add(tr).add(saludo). En fin, lo veo muy verborreico, pero tal vez para páginas más complejas (y que quieras modificar al vuelo o algo así) pueda servir.

Esta biblioteca, puede hacer alguna otra cosa con la estructura del documento, aparte de generar el texto HTML?

Imagen de domix

Totalmente de acuerdo con

Totalmente de acuerdo con Enrique, si se usara Chaining methods se reduciría un poco la cantidad de código

Hasta lo pueden usar para

Hasta lo pueden usar para generar sus XML (bueno, XHTML es un XML) pero pues para que no se espanten con los Element, Document, Attribute... etc

ah pus tambien te pudiste generar el Html con un parser de XML

Imagen de rodrigo salado anaya

@java.daba.doo HackerGarten

HackerGarten Orale java.daba.doo le voy a echar un ojo, y que padre que le metes al OpenSource en este caso jAlarms de @ezamudio que es un pryecton :).

Imagen de rodrigo salado anaya

@Nopalin

Orale se ve muy interesante, ojala y tengas tiempo para compartirnos tu creación, unos pantallazos estaría super :)

Imagen de rodrigo salado anaya

@ezamudio y @domix

Si tiene mucha razón, es mucho código para tan poco HTML jejeje se ve luego luego el cayo que se cargan, gracias por la observación.
Domingo jejeje a por eso el Twitt de "mucho java para tan poco HTML" jejeje :P, procurare mejorar el código de ejemplos.

Gracias a todos, bye.

Imagen de rodrigo salado anaya

@ezamudio

Esta biblioteca, puede hacer alguna otra cosa con la estructura del documento, aparte de generar el texto HTML?
Nop solo genera el texto del HTML. Es muy humilde la biblioteca.

Imagen de domix

Mi propuesta

import java.util.*;

class Tag {
        private String name;
        private String content = null;
        private Deque<Tag> stack = new ArrayDeque<Tag>();
        private Tag(String name) { this.name = name; }
        private Tag(String name, String content) { this.name = name; this.content = content; }
        public static final String T_S = "<";
        public static final String T_E = ">";
        public static final String E = "/";
        public static final String S = System.getProperty("line.separator");
       
        public static Tag build(String name) { return new Tag(name); }
       
        public static Tag build(String name, String content) { return new Tag(name, content); }
       
        public Tag add(Tag tag) {
                stack.add(tag);
                return tag;
        }
       
        public Tag add(String name) {
                return add(name, null);
        }
       
        public Tag add(String name, String content) {
                Tag t;
                if(content != null) {
                        t = Tag.build(name, content);
                } else {
                        t = Tag.build(name);
                }
                stack.add(t);
                return t;
        }
       
        public String toString() {
                StringBuilder sb = new StringBuilder();
                sb.append(T_S);
                sb.append(name);
                sb.append(T_E);
                sb.append(S);
                if(content != null) {
                        sb.append(content);
                        sb.append(S);
                }
                for(Tag t : stack) {
                        sb.append(t.toString());
                }
                sb.append(T_S);
                sb.append(E);
                sb.append(name);
                sb.append(T_E);
                sb.append(S);
                return sb.toString();
        }
}

public class BuilderJava {
        public static void main(String[] args) {
                Tag html = Tag.build("html");
                Tag body = Tag.build("body");
                Tag p = Tag.build("p", "Hola desde el parrafo");
                body.add(p);

                html.add(body);

                System.out.println(html.toString());
        }
}

Y eso da como salida esto:

<html>
<body>
<p>
Hola desde el parrafo
</p>
</body>
</html>

Hay mas casos a considerar, pero es un ejemplo de Chainning Methods.

Saludos

El punto es comenzar a

El punto es comenzar a participar en algún proyecto open source. La dificultad de entrarle a un proyecto grande está para empezar en lograr compilar el proyecto ( buen ejemplo, el kernel de linux como bien lista Enrique )

Entonces proyecto sencillititos como este son un buen inicio para por ejemplo, utilizar un controlador de versiones diferente, bajar el código, correr pruebas o simple y sencillamente ver como está estructurado el código de otra persona.

Imagen de Jose_Gastelum

E T

jXD :P printFull(System.out.println("System.out.println(System.out.println(System.out.println("WAOooo");););");):

Imagen de bferro

Considera un builder cuando tienes varios constructores

Aprovecho este hilo para usarlo como ejemplo del principio (item2) de Joshua Blosh en Effective Java, que a la letra dice "Consider a Builder when faced with many constructor parameters".

Usaré parte de lo que aquí se quiere hacer, pero solamente para no complicar el código, el ejemplo que viene más adelante solamente se refiere a la construcción de un tag de html, que puede tener atributos, contenido y otras cosas.

¿De que se trata?
Este principio de diseño trata de evitar usar el estilo de constructores telescopios que muchas veces usamos o el estilo de métodos de fábrica telescopios que también usamos.
Ese telescopio lo tenemos en el ejemplo que aquí se discute: Construimos una clase Tag para representar una etiqueta de html y se nos puede ocurrir escribir los constructores siguientes, donde el primer argumento es obligado y los restantes son opcionales:

//Lo de telescopio es evidente
Tag(String tagName) { ... }
Tag(String tagName, String content, String attr1) { ... }
Tag(String tagName, String content, String attr1, String attr2) { ... }
Tag(String tagName, String content,String attr1, String attr2, String attr3) { ...}

//Por ejemplo, para crear una etiqueta de  tipo input, podemos escribir:
new Tag("input","" "type=\"text\"", "name=\"email\"", "value =\"Enter your name\"");

//y obtenemos entonces la etiqueta:

<input type="text" name="email" value ="Enter your name"></input>

new Tag("p", "Esto es un parrafo sin acento");
//Y obtenemos:
<p>Esto es un parrafo sin acento</p>

El patrón telescopio funciona pero a veces nos molesta. Si el lenguaje no soporta parámetros opcionales ni parámetros nombrados, y queremos usar un constructor de 5 argumentos, con el primer argumento obligatorio y el quinto argumento necesario para el caso particular, estamos obligados a pasar 3 valores de default en los argumentos restantes.

Una solución al problema es acompañar a la clase con otra clase que se encargue de construir al objeto. La solución es similar a la del patrón de diseño Builder descrito en GOF.
El cliente ahora, en lugar de crear el objeto directamente, crea un builder al que se le puede pedir la creación del objeto con los parámetros requeridos. Con métodos setter se especifican las propiedades opcionales, con una sintaxis similar al modelo de JavaBeans. El patrón usa de manera efectiva el encadenamiento de métodos

La solución tiene ventajas y desventajas. No hablo de ellas aquí para fomentar la discusión.

El código que aparece a continuación ilustra este principio de diseño para crear etiquetas de HTML.

public class TagWithBuilder {

  private final String tag;
  private final String content;
  //Optional Parameters
 
  private final String attr1;
  private final String attr2;
  private final String attr3;
  private TagWithBuilder(Builder builder) {
    tag = builder.tag;
    content = builder.content;
    attr1 = builder.attr1;
    attr2 = builder.attr2;
    attr3 = builder.attr3;

  }

  @Override
  public String toString() {
    return "<" + tag + attr1 + attr2 + attr3 + ">" + content + "<"
             + "/"+tag + ">";

  }

  public static class Builder {
    // Required parameters

    private final String tag;
    private final String content;
    // Optional parameters
   
    private String attr1 = "";
    private String attr2 = "";
    private String attr3 = "";

    public Builder(String tag, String content) {
      this.tag = tag;
      this.content=content;

    }

   

    public Builder attr1(String val) {
      attr1 = " " + val;
      return this;
    }

    public Builder attr2(String val) {
      attr2 = " " + val;
      return this;
    }

    public Builder attr3(String val) {
      attr3 = " " + val;
      return this;
    }

    public TagWithBuilder build() {
      return new TagWithBuilder(this);
    }
  }
}

Un pequeño ejemplo que hace uso de lo anterior:

public class Main1 {

  public static void main(String[] args) {
    TagWithBuilder.Builder tagBuilder = new TagWithBuilder.Builder("input", "abc");
    TagWithBuilder input = tagBuilder.attr1("type=\"text\"")
                                         .attr2("name=\"email\"")
                                         .attr3("value =\"Enter your name\"")
                                         .build();
   
    System.out.println(input);
    tagBuilder = new TagWithBuilder.Builder("p", "Esto es un parrafo sin acento");
    TagWithBuilder paragraph =tagBuilder.build();
    System.out.println(paragraph);
  }
}

Al ejecutarlo obtenemos:

<input type="text" name="email" value ="Enter your name">abc</input>
<p>Esto es un parrafo sin acento</p>
Imagen de Sr. Negativo

Si, al parecer

Es cosa de hackers y nerds/geeks ?:{

Yo odio los servlets. Sin embargo, esta solución me parece buena. No sabía que existia Java HTML Generator

Creo que valela pena

Creo que valela pena mencionar que El HackerGarten 3 será el proximo 21 de Mayo de 2011... aqui esa la liga del evento

http://loseventos.de/grailsmx/hgmx3