O S : L - ARCO Researcharco.esi.uclm.es/public/pfc/carlos.ruiz.pdf · 2011-06-30 ·...

OPENSHEET: LIBRERÍA MULTIPLATAFORMA PARA PROCESAMIENTOAUTOMÁTICO DE HOJAS DE CÁLCULO

UNIVERSIDAD DE CASTILLA-LA MANCHA

ESCUELA SUPERIOR DE INFORMÁTICA

INGENIERÍA

EN INFORMÁTICA

PROYECTO FIN DE CARRERA

OpenSheet: Librería multiplataforma para procesamientoautomático de hojas de cálculo

Carlos Ruiz Ruiz

Junio, 2011

UNIVERSIDAD DE CASTILLA-LA MANCHA

ESCUELA SUPERIOR DE INFORMÁTICADepartamento de Tecnologías y Sistemas de Información

PROYECTO FIN DE CARRERA

OpenSheet: Librería multiplataforma para procesamientoautomático de hojas de cálculo

Autor: D. Carlos Ruiz RuizDirector: Dr. David Villa Alises

Junio, 2011

Carlos Ruiz Ruiz

Ciudad Real – Spain

E-mail: Carlos2res@gmailWeb site: http://arco.esi.uclm.es/c© 2011 Carlos Ruiz Ruiz

Permission is granted to copy, distribute and/or modify this document under the terms of the GNUFree Documentation License, Version 1.3 or any later version published by the Free SoftwareFoundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copyof the license is included in the section entitled "GNU Free Documentation License".Se permite la copia, distribución y/o modificación de este documento bajo los términos de laLicencia de Documentación Libre GNU, versión 1.3 o cualquier versión posterior publicada porla Free Software Foundation; sin secciones invariantes. Una copia de esta licencia esta incluida enel apéndice titulado «GNU Free Documentation License».Muchos de los nombres usados por las compañías para diferenciar sus productos y servicios sonreclamados como marcas registradas. Allí donde estos nombres aparezcan en este documento, ycuando el autor haya sido informado de esas marcas registradas, los nombres estarán escritos enmayúsculas o como nombres propios.

http://arco.esi.uclm.es/

TRIBUNAL:

Presidente:

Vocal 1:

Vocal 2:

Secretario:

FECHA DE DEFENSA:

CALIFICACIÓN:

PRESIDENTE VOCAL 1 VOCAL 2 SECRETARIO

Fdo.: Fdo.: Fdo.: Fdo.:

Resumen

Las hojas de cálculo gracias a su gran versatilidad, por su gran cantidad de funciones, asu potencia de cálculo, que permite automatizar operaciones a través de fórmulas, y a sugran sencillez de uso, han hecho que se conviertan para muchas empresas y organizacionesen las herramientas utilizadas para realizar cálculos financieros, guardar informes, gráficosestadísticos, clasificación de datos, etc. Convirtiéndose los documentos de hojas de cálculoen una fuente importante de datos.

Por tanto son muchas las organizaciones que cuentan con un gran número de hojas decálculo que contienen a su vez gran cantidad de datos, por lo que sería deseable el poder con-tar con una herramienta que permita la extracción e inserción de datos en hojas de cálculo demanera automática. Permitiendo así utilizar en otras aplicaciones los datos almacenados enhojas de cálculo, a través de la extracción de datos; y viceversa, utilizar los datos disponiblesen otras aplicaciones en las hojas de cálculo a través de la inserción de datos.

En este marco se plantea el diseño de OpenSheet, un proyecto cuyo objetivo principal esla extracción e inserción de datos en hojas de cálculo de manera automática y sencilla, sopor-tando los principales formatos de los productos Microsoft Excel y OpenOffice.org Calc.

IX

A Natalia y a mis padres

Agradecimientos

Por fin ha llegado este momento del camino, en el que hay que agradecer a todas aquellaspersonas que me han apoyado en algún momento para que lograra terminar el proyecto finde carrera, a todos ellos gracias.

Primero, quiero dar las gracias a Natalia, mi compañera en este viaje que es la vida, pordarle sentido y por querer compartirla conmigo. Gracias por todo el apoyo que me ha dadopara lograr este objetivo y sobre todo por su paciencia. Espero a partir de ahora poder recu-perar todo el tiempo perdido para compensar mi ausencia en esta etapa tan importante paraambos.

Después, quiero dar las gracias a mis padres que me han enseñado el valor de las cosas. Ami madre por ser siempre un apoyo incondicional para mí, y a mi padre que deseaba poderver alguna vez esta memoria escrita.

Gracias a Juani, Carmelo y a Mario por darme ánimos constantemente.

Gracias a mis amigos por apoyarme y animarme. En especial, quiero agradecer a Ángel ya Jose Ántonio todas esas llamadas de ánimo y apoyo.

Pero no puedo terminar, sin agradecer al artífice de que diera el paso definitivo para co-menzar con el proyecto, David mi director. Gracias por tu paciencia, por hacerme ver lascosas fáciles cuando las veía difíciles y sobre todo por compartir tus conocimientos y tutiempo conmigo.

Carlos

XIII

Índice general

Resumen IX

Agradecimientos XIII

Índice general XV

Índice de cuadros XXI

Índice de figuras XXIII

Índice de listados XXV

Listado de acrónimos XXIX

1. Introducción 1

1.1. Estructura del documento . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2. Antecedentes 5

2.1. Hojas de cálculo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.1.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.1.2. Conceptos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.1.3. Principales aplicaciones de hojas de cálculo . . . . . . . . . . . . . 7

2.2. Alternativas para trabajar con hojas de cálculo . . . . . . . . . . . . . . . . 7

2.2.1. Estudio e implementación de los estándares . . . . . . . . . . . . . 8

2.2.2. Microsoft Office y COM . . . . . . . . . . . . . . . . . . . . . . . 9

2.2.3. OpenOffice.org y UNO . . . . . . . . . . . . . . . . . . . . . . . . 12

2.2.4. Apache POI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.2.5. Spreadsheet::ParseExcel . . . . . . . . . . . . . . . . . . . . . . . 19

2.2.6. Spreadsheet::Read . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.2.7. Spreadsheet::WriteExcel . . . . . . . . . . . . . . . . . . . . . . . 22

2.2.8. OpenOffice::OODoc . . . . . . . . . . . . . . . . . . . . . . . . . 23

XV

2.2.9. Java Excel API . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.2.10. GemBox.SpreadSheet . . . . . . . . . . . . . . . . . . . . . . . . 27

2.2.11. Spreadsheet SDK . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

2.2.12. Comparativa de alternativas . . . . . . . . . . . . . . . . . . . . . 29

3. Objetivos del proyecto 33

3.1. Objetivo general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

3.2. Objetivos específicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

3.2.1. Objetivo 1: Formatos soportados . . . . . . . . . . . . . . . . . . . 34

3.2.2. Objetivo 2: Operaciones permitidas . . . . . . . . . . . . . . . . . 34

3.2.3. Objetivo 3: Conversiones entre formatos . . . . . . . . . . . . . . . 35

3.2.4. Objetivo 4: Exportación a pdf . . . . . . . . . . . . . . . . . . . . 35

3.2.5. Objetivo 5: Multiplataforma . . . . . . . . . . . . . . . . . . . . . 35

3.2.6. Objetivo 6: Librería . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.2.7. Objetivo 7: Comando . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.2.8. Objetivo 8: Servicio web . . . . . . . . . . . . . . . . . . . . . . . 36

4. Método y entorno de trabajo 37

4.1. Método de trabajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4.1.1. Metodologías Ágiles . . . . . . . . . . . . . . . . . . . . . . . . . 37

4.1.2. Scrum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

4.1.3. Adaptación de Scrum al marco de trabajo . . . . . . . . . . . . . . 43

4.1.4. Desarrollo dirigido por tests . . . . . . . . . . . . . . . . . . . . . 48

4.1.5. Adaptación de TDD al marco de trabajo . . . . . . . . . . . . . . . 49

4.2. Entorno de trabajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

4.2.1. Herramientas de desarrollo . . . . . . . . . . . . . . . . . . . . . . 50

4.2.2. Lenguajes de programación . . . . . . . . . . . . . . . . . . . . . 52

4.2.3. Herramientas de documentación . . . . . . . . . . . . . . . . . . . 53

4.2.4. Sistemas Operativos . . . . . . . . . . . . . . . . . . . . . . . . . 54

5. Resultados 55

5.1. Análisis y planificación . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

5.1.1. Análisis de requisitos . . . . . . . . . . . . . . . . . . . . . . . . . 55

5.1.2. Estudio de viabilidad de alternativas . . . . . . . . . . . . . . . . . 58

5.1.3. Planificación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

5.2. Sprint 1: Creación y almacenamiento de documentos . . . . . . . . . . . . 64

5.2.1. Historia 1.1 - Crear nuevos documentos . . . . . . . . . . . . . . . 65

5.2.2. Historia 1.5 - Convertir el formato del documento . . . . . . . . . . 69

5.2.3. Resumen de sprint . . . . . . . . . . . . . . . . . . . . . . . . . . 69

5.3. Sprint 2: Apertura de documentos y modificación de hojas . . . . . . . . . 70

5.3.1. Historia 1.2 - Abrir documentos . . . . . . . . . . . . . . . . . . . 71

5.3.2. Historia 1.3 - Modificar hojas de cálculo de un documento . . . . . 73


5.4. Sprint 3: Modificación de celdas . . . . . . . . . . . . . . . . . . . . . . . 76

5.4.1. Historia 1.4 - Insertar valores en celdas . . . . . . . . . . . . . . . 77

5.4.2. Historia 1.6 - Extraer valores de celdas . . . . . . . . . . . . . . . 79


5.5. Sprint 4: Estudio de lenguaje script y comando . . . . . . . . . . . . . . . 81

5.5.1. Historia 2.1 - Estudio de lenguaje script . . . . . . . . . . . . . . . 83

5.5.2. Historia 2.2 - Comando para ejecutar scripts . . . . . . . . . . . . . 84


5.6. Sprint 5: Script genérico para el comando . . . . . . . . . . . . . . . . . . 87

5.6.1. Historia 2.3 - Script Genérico . . . . . . . . . . . . . . . . . . . . 87


5.7. Sprint 6: Servicio web . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

5.7.1. Historia 3.1 - Operación de listado de scripts . . . . . . . . . . . . 90

5.7.2. Historia 3.2 - Operación de selección y ejecución de un script sobreun documento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92


5.8. Sprints 7-10: Documentación . . . . . . . . . . . . . . . . . . . . . . . . . 95

5.8.1. Sprint 7: Documentación 1 - Antecedentes . . . . . . . . . . . . . 95

5.8.2. Sprint 8: Documentación 2 - Objetivos y Método de Trabajo . . . . 96

5.8.3. Sprint 9: Documentación 3 - Resultados . . . . . . . . . . . . . . . 97

5.8.4. Sprint 10: Documentación 4 - Conclusiones e Introducción . . . . . 97

5.9. API OpenSheet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

5.10. Comando OpenSheet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

5.11. Servicio web OpenSheet . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

5.12. Documentación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

5.13. Estadísticas del proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

6. Conclusiones 105

6.1. Objetivos alcanzados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

6.2. Posibles mejoras y ampliaciones . . . . . . . . . . . . . . . . . . . . . . . 107

6.2.1. Uso de OpenOffice.org remoto . . . . . . . . . . . . . . . . . . . . 107

6.2.2. Soporte para fórmulas . . . . . . . . . . . . . . . . . . . . . . . . 107

6.2.3. Añadir nuevos tipos para la inserción de dependencias . . . . . . . 108

6.2.4. Crear nuevos scripts para uso general . . . . . . . . . . . . . . . . 109

6.2.5. Permitir dependencias entre scripts . . . . . . . . . . . . . . . . . 109

6.3. Conclusiones personales . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

6.3.1. Conclusiones sobre la metodología de planificación . . . . . . . . . 110

6.3.2. Conclusiones sobre la metodología de desarrollo . . . . . . . . . . 110

A. Manual de usuario 115

A.1. OpenSheet Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

A.1.1. Instalación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

A.1.2. Operación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

A.1.3. Formato de fichero de datos . . . . . . . . . . . . . . . . . . . . . 116

A.1.4. Uso del script OpenSheetScript.groovy . . . . . . . . . . . . . . . 118

A.1.5. Ejemplo de uso de OpenSheet Command . . . . . . . . . . . . . . 127

A.2. OpenSheet Web Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

A.2.1. Requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

A.2.2. Despliegue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

A.2.3. Fichero web.xml . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

A.2.4. Activar scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

A.2.5. Clientes de OpenSheet Web Service . . . . . . . . . . . . . . . . . 131

B. Manual de desarrollo 133

B.1. Direcciones de interés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

B.1.1. Repositorio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

B.1.2. Gestión de incidencias y peticiones de mejora . . . . . . . . . . . . 134

B.2. OpenSheet API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

B.2.1. Ejemplos de uso . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

B.2.2. Clases y métodos principales . . . . . . . . . . . . . . . . . . . . . 138

B.3. OpenSheet Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141


B.3.2. Creación de nuevos scripts . . . . . . . . . . . . . . . . . . . . . . 141

B.4. OpenSheet Web Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142


B.4.2. Creación de nuevos scripts . . . . . . . . . . . . . . . . . . . . . . 143

B.4.3. Pasos de la operación executeScript . . . . . . . . . . . . . . . . . 144

B.4.4. Cliente de ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . 145

C. GNU Free Documentation License 149

C.0. PREAMBLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

C.1. APPLICABILITY AND DEFINITIONS . . . . . . . . . . . . . . . . . . . 149

C.2. VERBATIM COPYING . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

C.3. COPYING IN QUANTITY . . . . . . . . . . . . . . . . . . . . . . . . . . 150

C.4. MODIFICATIONS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

C.5. COLLECTIONS OF DOCUMENTS . . . . . . . . . . . . . . . . . . . . . 152

C.6. AGGREGATION WITH INDEPENDENT WORKS . . . . . . . . . . . . 152

C.7. TRANSLATION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

C.8. TERMINATION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

C.9. FUTURE REVISIONS OF THIS LICENSE . . . . . . . . . . . . . . . . . 153

C.10. RELICENSING . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Bibliografía 155

Índice de cuadros

2.1. Comparativa de funcionalidades de las distintas alternativas . . . . . . . . . 30

2.2. Comparativa de características generales de las alternativas . . . . . . . . . 31

5.1. Pila de producto inicial . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

5.2. Historias añadidas al Sprint 1 . . . . . . . . . . . . . . . . . . . . . . . . . 65









5.11. Historias añadidas al Sprint 10 . . . . . . . . . . . . . . . . . . . . . . . . 97

5.12. Resultado de ejecución de SLOCCount con src . . . . . . . . . . . . . . . 103

5.13. Resultado de ejecución de SLOCCount test . . . . . . . . . . . . . . . . . 103

XXI

Índice de figuras

4.1. Roles de Scrum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

4.2. Representación de un sprint de Scrum . . . . . . . . . . . . . . . . . . . . 43

4.3. Ejemplo de gráfico de burndown de un sprint . . . . . . . . . . . . . . . . 44

4.4. Algoritmo TDD: Rojo, Verde, Refactorizar. . . . . . . . . . . . . . . . . . 49

5.1. Diagrama de casos de uso básico de API . . . . . . . . . . . . . . . . . . . 56

5.2. Diagrama de casos de uso básico del comando y servicio web . . . . . . . . 57

5.3. Gráfico de burndown del sprint 1 . . . . . . . . . . . . . . . . . . . . . . . 70

5.4. Diagrama de clases resultante del sprint 1 . . . . . . . . . . . . . . . . . . 71










5.14. Diagrama de clases de la API de OpenSheet . . . . . . . . . . . . . . . . . 98

5.15. Diagrama de clases del Comando de OpenSheet . . . . . . . . . . . . . . . 100

5.16. Diagrama de clases del Servicio Web de OpenSheet . . . . . . . . . . . . . 101

XXIII

Índice de listados

2.1. Cómo cargar la aplicación Excel para ser usada través de COM . . . . . . . 10

2.2. Cómo hacer que la carga del servicio COM sea en segundo plano . . . . . . 10

2.3. Abrir un fichero Excel a través de COM . . . . . . . . . . . . . . . . . . . 11

2.4. Seleccionar una hoja de cálculo a través de su nombre usando COM . . . . 11

2.5. Arracar OpenOffice.org en modo servicio escuchando en un socket . . . . . 13

2.6. Arracar OpenOffice.org en modo servicio escuchando en una tubería o pipe 13

2.7. Cadena de conexión para conectar con un servicio a través de socket . . . . 13

2.8. Cadena de conexión para conectar con un servicio a través de una tubería opipe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.9. Ejemplo uso UNO parte 1: Cómo obtener el objeto remoto XComponentLoader 14

2.10. Ejemplo uso UNO parte 2: Cómo crear un nuevo documento de hojas decálculo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.11. Ejemplo uso UNO parte 3: Añadir una nueva hoja de cálculo al documento 15

2.12. Ejemplo uso UNO parte 4: Insertar valores a celdas . . . . . . . . . . . . . 16

2.13. Ejemplo uso UNO parte 5: Guardar un documento con formato xls . . . . . 16

2.14. Ejemplo uso Apache POI . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.15. Ejemplo uso Spreadsheet::ParseExcel . . . . . . . . . . . . . . . . . . . . 19

2.16. Ejemplo uso Spreadsheet::Read . . . . . . . . . . . . . . . . . . . . . . . 20

2.17. Ejemplo de la estructura de datos de un documento de Spreadsheet::Read . 21

2.18. Ejemplo uso Spreadsheet::WriteExcel . . . . . . . . . . . . . . . . . . . . 23

2.19. Ejemplo uso OpenOffice::OODoc . . . . . . . . . . . . . . . . . . . . . . 24

2.20. Ejemplo uso Java Excel API . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.21. Ejemplo uso GemBox.SpreadSheet . . . . . . . . . . . . . . . . . . . . . . 27

2.22. Ejemplo uso Spreadsheet SDK . . . . . . . . . . . . . . . . . . . . . . . . 28

5.1. Añadiendo un directorio a Java Library Path . . . . . . . . . . . . . . . . . 66

5.2. Cambio la localización del path del ejecutable en la clase Bootstrap . . . . 67

A.1. Ejecución OpenSheet Command . . . . . . . . . . . . . . . . . . . . . . . 116

A.2. Ejemplo de uso de variable especial @OpenSheetManager; . . . . . . . . . 116

A.3. Ejemplo de uso de variable especial @OpenSheetDocument; para crear undocumento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

XXV

A.4. Ejemplo de uso de variable especial @OpenSheetDocument; para abrir undocumento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

A.5. Ejemplo de uso de variable especial @number; . . . . . . . . . . . . . . . 117

A.6. Ejemplo de uso de variable especial @list; . . . . . . . . . . . . . . . . . . 118

A.7. Ejemplo de uso de variable especial @list; con escape del separador . . . . 118

A.8. Ejemplo de uso de variable especial @list; con cadenas vacias . . . . . . . 118

A.9. Ejemplo de asignación de nuevo documento a la variable openSheetDocu-ment de OpenSheetScript . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

A.10.Ejemplo de asignación de un documento a la variable openSheetDocumentde OpenSheetScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

A.11.Ejemplo de uso por defecto de la variable logFileName . . . . . . . . . . . 121

A.12.Ejemplo de asignación de un fichero a la variable logFileName de OpenS-heetScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

A.13.Ejemplo de asignación de valores a la variable deleteSheets de OpenSheetScript122

A.14.Ejemplo de asignación de valores a la variable deleteSheetsByPosition deOpenSheetScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

A.15.Ejemplo de asignación de valores repetidos a la variable deleteSheetsByPo-sition de OpenSheetScript . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

A.16.Ejemplo de asignación de valores a la variable addSheets de OpenSheetScript 123

A.17.Ejemplo de asignación de valores a la variable insertCellsValues de OpenS-heetScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123




A.21.Ejemplo de asignación de valores a la variable extractCellsValues de OpenS-heetScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

A.22.Ejemplo de asignación de valores a la variable extractCellsValuesBySheet-Position de OpenSheetScript . . . . . . . . . . . . . . . . . . . . . . . . . 126

A.23.Ejemplo de uso por defecto de la variable extractCellsValuesFile . . . . . . 126

A.24.Ejemplo de asignación de un fichero a la variable extractCellsValuesFile deOpenSheetScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

A.25.Ejemplo de uso por defecto de la variable saveDocumentTo . . . . . . . . . 127

A.26.Ejemplo de asignación de un fichero a la variable saveDocumentTo de OpenS-heetScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

A.27.Ejemplo de asignación de un fichero con extensión PDF a la variable save-DocumentTo de OpenSheetScript . . . . . . . . . . . . . . . . . . . . . . . 127

A.28.Ejemplo de fichero de datos . . . . . . . . . . . . . . . . . . . . . . . . . . 128

A.29.Ejemplo de fichero Properties para script de servicio web . . . . . . . . . . 131

B.1. Crear un nuevo documento con OpenSheet API . . . . . . . . . . . . . . . 135

B.2. Abrir un documento con OpenSheet API . . . . . . . . . . . . . . . . . . . 135

B.3. Insertar datos a celdas con OpenSheet API . . . . . . . . . . . . . . . . . . 136

B.4. Insertar datos a rangos con OpenSheet API . . . . . . . . . . . . . . . . . 136

B.5. Extraer datos de celdas con OpenSheet API . . . . . . . . . . . . . . . . . 137

B.6. Extraer datos de rangos de celdas con OpenSheet API . . . . . . . . . . . . 137

B.7. Añadir hojas de cálculo con OpenSheet API . . . . . . . . . . . . . . . . . 138

B.8. Borrar hojas de cálculo con OpenSheet API . . . . . . . . . . . . . . . . . 138

B.9. Convertir un documento de un formato a otro con OpenSheet API . . . . . 138

B.10. Exportar un documento a formato PDF con OpenSheet API . . . . . . . . . 139

B.11. Ejemplo de fichero Properties para script de servicio web . . . . . . . . . . 145

B.12. Ejemplo de cliente de OpenSheet Web Service - Parte 1 . . . . . . . . . . . 147

B.13. Ejemplo de cliente de OpenSheet Web Service - Parte 2 . . . . . . . . . . . 148

Listado de acrónimos

GNU GNU is Not Unix

API Application Programming Interface

OOO OpenOffice.org

XML Extensible Markup Language

COM Component Object Model

OLE Object Linking and Embedding

MFC Microsoft Fundations Classes

UNO Universal Network Objects

URL Uniform Resource Locator

SDK Software Development Kit

PDF Portable Document Format

GPL General Public License

LGPL Lesser General Public License

CSV Comma-Separated Values

IDE Integrated Development Environment

JDK Java Development Kit

EE Enterprise Edition

JVM Java Virtual Machine

UML Unified Modelling Language

TDD Test Driven Development

XP eXtreme Programming

SLOC Source Lines Of Code

XXIX

Capítulo 1

Introducción

L As aplicaciones de hojas de cálculo son programas que permiten la creación y manipu-lación de documentos compuestos por una cuadrícula con múltiples celdas ordenadas

por fila y columna, y que pueden contener datos numéricos, alfanuméricos o fórmulas. Lasfórmulas permiten indicar cómo el contenido de una celda debe ser calculado a partir de otracelda o grupo de celdas.

Las hojas de cálculo son consideradas por algunos autores como un lenguaje de progra-mación funcional [RA09], donde el usuario de manera visual y directa genera programas decálculo sin necesidad de conocimientos previos de programación. Gracias a su facilidad deuso, a la gran cantidad de funciones que proporcionan y a la intercomunicación con otrasaplicaciones, las hojas de cálculo ofrecen una gran versatilidad que ha hecho que su uso seamuy extendido y variado en campos muy diversos. Las hojas de cálculo son usadas como he-rramienta en las ingenierías [CTC06, Fre92, Arg93] debido a su gran potencia para realizarcálculos y a la facilidad para automatizarlos a través de fórmulas; y sobre todo son usadaspor muchas empresas y organizaciones para realizar cálculos financieros, guardar informes,gráficos estadísticos, clasificación de datos, etc. Convirtiéndose estos documentos en unafuente importante de datos.

Es debido al papel tan importante que juegan las hojas de cálculo, en las empresas y organi-zaciones, que un simple error en una hoja de cálculo puede ocasionar grandes pérdidas [Gro].Por ello se han realizado diferentes estudios que han dado como resultado, la identificaciónde riesgos para cada tipo de organización [BFJLP07], las diferencias de uso entre usuarioscon diferente grado de experiencia [LBPFJ07], y lo más importante un conjunto de buenasprácticas [NR99] en el diseño y modelado de hojas de cálculo proponiendo un ciclo de vidaque se adapta a las diferentes necesidades según el tipo de modelo.

En el mercado existen diferentes alternativas en lo que a aplicaciones de hojas de cálculose refiere, y cada una de ellas con su propio formato, pero la más utilizada y extendida esMicrosoft Excel [SL99], con su formato xls [Mic08b] [Mic08a], que se proporciona dentrode la suite de aplicaciones de oficina Microsoft Office, y que se impuso en los 90 a la suiteLotus 1-2-3 de IBM y a su formato [Cor84].

Como alternativa libre, destaca la suite OpenOffice.org [ope], que incluye la aplicación de

1

2 1. INTRODUCCIÓN

hojas de cálculo Calc. Esta suite ha ido ganando cada vez más mercado al permitir la utiliza-ción de otros formatos como los de Microsoft Office, y al utilizar como formato nativo OpenDocument Format [OAS07] [OAS10], formato estándar de la organización OASIS [oas],para garantizar que los documentos generados no queden atados a una única aplicación.

Según lo descrito, son muchas las organizaciones que cuentan con un gran número dehojas de cálculo que contienen a su vez gran cantidad de datos, por lo que sería deseable elpoder contar con una herramienta que permita la extracción e inserción de datos en hojasde cálculo de manera automática. Permitiendo así utilizar en otras aplicaciones los datosalmacenados en hojas de cálculo, a través de la extracción de datos; y viceversa, utilizar losdatos disponibles en otras aplicaciones en las hojas de cálculo a través de la inserción dedatos.

Además, a pesar de los estudios mencionados anteriormente sobre buenas prácticas parael diseño de hojas de cálculo, sigue habiendo un mal uso a la hora de modelar hojas de cálcu-lo [BFJLP06], y muchas otras hojas de cálculo que ya se encuentran en uso, siendo inviablevolverlas a modelar usando el conjunto de buenas prácticas propuestas; por lo tanto la es-trategia en este caso debe ir encaminada a detectar los posibles errores para eliminarlos, demanera que dichas hojas de cálculo sean correctas y estén libres de errores. Para ello se debenrealizar pruebas con el objetivo de depurar las hojas de cálculo [RA08] y así poder garan-tizar un mínimo de calidad, para evitar riesgos y pérdidas como se comentó anteriormente.Esta tarea de pruebas se facilitaría mucho si se contara con la herramienta mencionada an-teriormente, puesto que permitiría automatizar las pruebas, usando un conjunto de datos deentrada que insertaría de manera automática, y extrayendo los datos obtenidos para que otroprograma los comparara con los datos esperados.

Aunque las aplicaciones como Microsoft Excel permiten la automatización de algunastareas a través del uso de macros escritas en lenguajes de tipo script como Visual Ba-sic [Wal10], sería deseable una herramienta que permita trabajar con los principales formatosde hojas de cálculo, y no sólo con el formato nativo de la aplicación donde se ejecuta la ma-cro; además, sería deseable que permitiera de manera sencilla automatizar diferentes tareassin necesidad de utilizar una interfaz gráfica.

Por todas las necesidades anteriores se plantea el diseño de OpenSheet, un proyecto cuyoobjetivo principal es la extracción e inserción de datos en hojas de cálculo de manera auto-mática y sencilla, soportando los principales formatos de los productos Microsoft Excel yOpenOffice.org Calc.

1.1. Estructura del documentoEl presente documento se encuentra dividido en los diferentes capítulos establecidos por

la normativa académica para proyectos fin de carrera [dIU07]. El autor recomienda leer cada

1. INTRODUCCIÓN 3

uno de los capítulos de manera secuencial para una mejor comprensión.

Los capítulos que puede encontrar el lector en el documento son los siguientes:

Capítulo 2: Antecedentes En este capítulo primero se definen los principales conceptosbásicos relacionados con los documentos de hojas de cálculo, necesarios para podercomprender el proyecto. Y después, se explican las alternativas, para trabajar con hojasde cálculo, analizadas en un estudio comparativo.

Capítulo 3: Objetivos del proyecto En este capítulo se explica de manera detallada quése quiere lograr con el proyecto. Para ello se describen todos los objetivos que sepersiguen, tanto el objetivo general como los objetivos específicos.

Capítulo 4: Método y entorno de trabajo En este capítulo se explican los principales con-ceptos de las metodologías aplicadas al desarrollo del proyecto, y también se describelas herramientas o aplicaciones software que han formado parte del entorno de trabajo.

Capítulo 5: Resultados En este capítulo se explica cómo se ha llevado a cabo las metodo-logías elegidas, descritas en el capítulo 4, para lograr alcanzar los objetivos marcadosal comienzo del proyecto.

Capítulo 6: Conclusiones En este capítulo se presentan diferentes contenidos relacionadoscon las conclusiones del proyecto. Por un lado se describe cómo se han logrado cubrirlos objetivos marcados al comienzo del proyecto. Por otro lado se describen diferentespropuestas que pueden ser llevadas a cabo en futuros desarrollos, y que han quedadofuera del alcance del proyecto. Y por último, se incluye una sección donde el autorcomenta sus conclusiones personales acerca de la experiencia adquirida durante eldesarrollo del proyecto.

Capítulo 2

Antecedentes

E N este capítulo se pretende por un lado dar una breve explicación sobre qué es una hojade cálculo y los conceptos que incorpora; y por otro lado ofrecer una visión general

de las diferentes alternativas existentes de librerías y APIs de programación que permitenal desarrollador, mediante su incorporación en aplicaciones, realizar diferentes operacionescon documentos de hojas de cálculo sin necesidad de utilizar ninguna interfaz gráfica.

2.1. Hojas de cálculo

2.1.1. Introducción

Una aplicación de hojas de cálculo es un programa que permite crear y editar documentosde hojas de cálculo. Estos documentos están compuestos por una cuadrícula con múltiplesceldas ordenadas por fila y columna, que pueden contener datos de diferentes tipos: numéri-cos, alfanuméricos o fórmulas.

Las fórmulas permiten indicar cómo el contenido de una celda debe ser calculado a partirde otra celda o grupo de celdas. Las fórmulas son uno de los principales causantes que hanhecho que hoy en día las aplicaciones de hojas de cálculo tengan un uso muy extendido encampos muy diversos. Esto es debido a que las fórmulas permiten realizar y automatizarcálculos complejos de manera muy sencilla.

Debido a su gran uso y a la potencia de los cálculos permitidos, los documentos de hojasde cálculo son una fuente importante de datos para empresas y organizaciones.

A continuación, se realizará una breve descripción de los conceptos necesarios para poderentender mejor qué es una hoja de cálculo.

2.1.2. Conceptos

En este apartado se pretende explicar aquellos conceptos necesarios para entender mejorel concepto de hoja de cálculo y los elementos que lo componen, y por tanto para facilitar lacomprensión de este documento.

5

6 2. ANTECEDENTES

Hoja de cálculo

Aunque en la introducción de esta sección ya se ha dado una definición de la palabrahoja de cálculo, en inglés spreadsheet, dicha palabra es usada de manera habitual para hacerreferencia a distintos conceptos, y para evitar confundir al lector, en este documento siemprese usará un único significado.

Una hoja de cálculo es una cuadrícula con múltiples celdas ordenadas por fila y columna,que pueden contener datos numéricos, alfanuméricos o fórmulas.

Celda

Una celda, en inglés cell, es el elemento que forma la cuadrícula de una la hoja de cálculo,y donde se sitúa una fórmula o un dato, ya sea numérico o alfanumérico.

Una celda es identificada por una columna y una fila. Normalmente para nombrar o iden-tificar las columnas se usan letras y para las filas se utilizan números enteros, por tanto, unacelda cuyo nombre sea A1 hará referencia a la celda con posición fila 0 y columna 0 en lacuadrícula.

Rango

Un rango, en inglés range, es un conjunto contiguo de celdas identificados mediante elidentificador de la celda superior izquierda y el identificador de la celda inferior izquierda,normalmente separado por dos puntos.

El rango permite manejar un conjunto de celdas como una única entidad, facilitando operarcon ellas.

Documento de hojas de cálculo

Un documento de hojas de cálculo, en inglés spreadsheet document, como su nombreindica, es un documento o fichero que se compone de diferentes hojas de cálculo cada unade ellas identificada por un nombre o una posición lineal.

Es habitual usar la palabra hoja de cálculo, en inglés spreadsheet, para referirse a un do-cumento de hojas de cálculo. Y puesto que en inglés para referirse a las hojas de cálculo quecomponen un documento se utilizan las palabras sheets o worksheets, no existe problemapara distinguir en una misma frase cuando se hace referencia al documento o una hoja pro-piamente dicha, el problema existe en castellano pues la traducción de las palabras anterioreses hoja u hoja de cálculo respectivamente, lo que impide usar esa nomenclatura sin llevar aconfusión; por tanto se evitará en este documento.

2. ANTECEDENTES 7

Aplicación de hojas de cálculo

Una aplicación de hojas de cálculo es programa que opera con tablas formadas por filas ycolumnas de celdas que contienen información numérica y fórmulas o texto, y las presenta enuna pantalla. Esta es la definición dada por la Real Academia Española para la palabra hojade cálculo pues puede ser usada también para nombrar a la aplicación propiamente dicha,pero en este documento siempre se hablará de aplicación para evitar ambigüedades.

2.1.3. Principales aplicaciones de hojas de cálculoEn el mercado existen diferentes alternativas en lo que a aplicaciones de hojas de cálculo

se refiere, y cada una de ellas con su propio formato, pero la más utilizada y extendida esMicrosoft Excel [SL99], con su formato xls [Mic08b] [Mic08a], que se proporciona dentrode la suite de aplicaciones de oficina Microsoft Office, y que se impuso en los 90 a la suiteLotus 1-2-3 de IBM y a su formato [Cor84].

Como alternativa libre, destaca la suite OpenOffice.org [ope], que incluye la aplicación dehojas de cálculo Calc. Esta suite ha ido ganando cada vez más mercado al permitir la utiliza-ción de otros formatos como los de Microsoft Office, y al utilizar como formato nativo OpenDocument Format [OAS07] [OAS10], formato estándar de la organización OASIS [oas],para garantizar que los documentos generados no queden atados a una única aplicación.

2.2. Alternativas para trabajar con hojas de cálculoEn esta sección se muestran diferentes alternativas que permiten trabajar con hojas de

cálculo, sin necesidad de utilizar ninguna interfaz gráfica. De cada alternativa se ha analizadolas siguientes características:

Formatos de documentos de hojas de cálculo que soporta.

Operaciones que permite realizar sobre los diferentes elementos del documento dehojas de cálculo.

Lenguaje de programación que usa.

Plataformas o sistemas operativos dónde se puede utilizar.

Tipo de licencia.

Soporte que se ofrece, decir, la ayuda a resolver fallos o problemas encontrados al uti-lizar la solución. Contar con un buen soporte en el caso de se produzcan problemastécnicos durante el uso de la alternativa puede evitar un retraso elevado en su resolu-ción.

8 2. ANTECEDENTES

Actividad del proyecto, es decir, cada cuanto tiempo se saca una nueva versión conmejoras y resolución de bugs.

Madurez de la alternativa, es decir, el tiempo y uso que tiene. Normalmente, cuantamás madurez tiene un proyecto más estable es.

Características de la documentación de uso de la alternativa.

Dificultad de uso. Aunque posiblemente es la característica más subjetiva de todas, sepuede tratar de hacer una valoración lo más objetiva posible a través del análisis delesfuerzo que requiere realizar un ejemplo que sea lo más parecido posible en todaslas alternativas o en su defecto analizando el esfuerzo a la hora de realizar diferentesoperaciones.

A continuación, se detalla cada una de las alternativas analizadas.

2.2.1. Estudio e implementación de los estándaresUna alternativa que permite poder trabajar con diferentes formatos de hojas de cálculo y

realizar todas las operaciones que se necesiten, es la de implementar los mecanismos necesa-rios para modificar directamente los ficheros binarios de cada formato. Para ello es necesarioel estudio completo de las especificaciones de aquellos formatos a los que se desea dar so-porte, y cumplir con los estándares marcados por dichas especificaciones de manera que sepuedan crear nuevos documentos y, que además se puedan realizar modificaciones sobre unfichero ya creado sin invalidarlo, permitiendo así su uso en otras aplicaciones que tambiénsoporten dicho formato.

Por tanto para trabajar con los principales formatos de documento de hojas de cálculo,como son los de Microsoft Excel [Mic10b] y de OpenOffice.org Calc [OAS10] necesitaría-mos estudiar sus especificaciones e implementarlas. Por ejemplo, el formato de un ficheroxls [Mic08b] de Microsoft Excel está dividido en diferentes registros binarios, donde algunosbytes indican el tamaño de los registros que vienen detrás, y otros registros hacen de índicesdentro del propio fichero, por tanto es necesario conocer todos los registros que lo formanpara poder llevar a cabo la implementación de un nuevo documento y cada cambio que serealice sobre uno ya existente. Otro formato como el ods [OAS10] de OpenOffice.org Calces un conjunto de ficheros en XML empaquetados en un sólo fichero, por tanto es necesarioconocer tanto la distribución de los ficheros que intervienen como su estructura interna parapoder generar documentos válidos y permitir su modificación.

En esta alternativa destaca la flexibilidad que ofrece en la mayoría de características a ana-lizar, permitiendo elegir: el lenguaje de programación, las plataformas donde poder utilizarse(la propia elección del lenguaje puede proporcionar esta característica), el tipo de licencia y

2. ANTECEDENTES 9

la posibilidad de conversión entre formatos. La característica que si permanece fija es la dedificultad de implementación que es muy alta.

2.2.2. Microsoft Office y COMExiste una alternativa que permite utilizar la funcionalidad de las aplicaciones de Micro-

soft Office e incorporarla en otras aplicaciones, se llama Automation y en este apartado seva explicar en qué consiste.

Automation

Segun Microsoft [Mic08c] Automation (antes conocido como OLE Automation) es unatecnología que permite usar la funcionalidad de otros programas existentes e incorporarla anuestras aplicaciones.

Para poder utilizar las funcionalidades de otro programa se hace uso de COM que es laarquitectura software de componentes de Microsoft, que permite la comunicación entre pro-cesos y la creación de objetos dinámicos. El programa que quiere ofrecer sus funcionalidadespara ser usadas con COM debe de generarse teniendo en cuenta la especificación de dicha ar-quitectura y hacer públicas las interfaces que va a permitir usar.

Microsoft Excel es una aplicación que implementa COM como servicio de manera quepublica sus interfaces para permitir que otras aplicaciones hagan uso de sus funcionalidades,es través del uso de Automation como se consigue que aplicaciones que no implementenCOM puedan acceder a los servicios de dicha arquitectura.

Formas de usar un componente COM

Existen principalmente 3 formas de utilizar los servicios de un componente COM desdeVisual C++:

1. Usar MFC.

2. Usar la directiva #import.

3. Usar C/C++ Automation.

La primera opción, hace uso de MFC para generar un envoltorio o wrapper de clases dela aplicación cliente (la que va a usar los servicios de COM) a partir de la librería de tiposde la aplicación Office a utilizar. De esta manera las clases de la aplicación cliente pasan aser también clases de MFC y por tanto facilita su uso con Automation. Para poder generar elenvoltorio o wrapper mencionado se hace uso de una utilidad que proporciona Visual C++(disponible a partir de su versión 5.0).

La segunda opción, consiste en usar la directiva #import. Al incluir dicha directiva se creanpuntos de entrada a la librería que se desea utilizar, proporcionando una opción sencilla y

10 2. ANTECEDENTES

potente. El inconveniente es que la propia Microsoft [Mic08c] desaconseja su uso por pro-blemas existentes con el control del número de referencias en aplicaciones como MicrosoftOffice.

La tercera y última opción, consiste en usar directamente la API de COM con C/C++,haciendo un uso a más bajo nivel de Automation del que se realiza a través de MFC, lo queda mayor versatilidad y evita el tener que realizar envoltorios o wrappers de la clase, peroque a su vez tiene el inconveniente de ser más complejo su uso.

Ejemplos de operaciones con hojas de cálculo en C/C++

A continuación, se muestran algunos fragmentos de código con la idea de ilustrar la difi-cultad de uso de esta alternativa a través de la tercera de las opciones mostradas en el apartadoanterior, es decir, haciendo uso de C++ Automation. Para que el código sea más sencillo, Mi-crosoft [Mic07] en sus ejemplos hace uso de una función llamada AutoWrap que facilita eluso de Automation.

// 1) Buscamos el identificador del programa Excel para COMCLSID clsid;HRESULT hr = CLSIDFromProgID(L"Excel.Application", &clsid);if(FAILED(hr)) {

::MessageBox(NULL, "CLSIDFromProgID() failed", "Error", 0x10010);return -1;

}

// 2) Arrancamos el servico Excel a traves de su indetificadorIDispatch *pXlApp;hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (

void **)&pXlApp);if(FAILED(hr)) {

::MessageBox(NULL, "Excel not registered properly", "Error", 0x10010);

return -2;}

Listado 2.1: Cómo cargar la aplicación Excel para ser usada través de COM

{VARIANT x;x.vt = VT_I4;x.lVal = 0; //Con 0 sera invisible (segundo plano) y con 1 se

hara visibleAutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlApp, L"Visible", 1, x);

}

Listado 2.2: Cómo hacer que la carga del servicio COM sea en segundo plano

Como se puede ver en el listado 2.1 la carga del programa Excel como servicio COM parausarlo en otra aplicación es medianamente sencilla. Si se quiere usar dicha aplicación en

2. ANTECEDENTES 11

segundo plano evitando que sea visible para el usuario, basta con asignar el valor cero a lapropiedad de visibilidad como se puede ver en el listado 2.2.

En [Mic07] se puede ver un ejemplo completo de uso donde se crea un nuevo documentode hoja de cálculo, se añade una nueva hoja de cálculo, se selecciona la hoja activa, seselecciona un rango y a cada celda del mismo le asigna un valor distinto, por último salva eldocumento y lo cierra.

//El objeto donde se carga el documento es un puntero a IDispatch.{

VARIANT result, fileName;fileName.vt = VT_BSTR;fileName.bstrVal = ::SysAllocString(OLESTR("c:\\fichero_prueba.

xls"));VariantInit(&result);AutoWrap(DISPATCH_PROPERTYGET, &result, pXlBooks, L"Open", 1,

fileName);pXlBook = result.pdispVal; //IDispatch *pXlBook;

}

Listado 2.3: Abrir un fichero Excel a través de COM

//El objeto donde se carga la hoja de calculo es un puntero a IDispatch.{

VARIANT result, parm;parm.vt = VT_BSTR;parm.bstrVal = ::SysAllocString(L"Hoja1");VariantInit(&result);AutoWrap(DISPATCH_PROPERTYGET, &result, pXlBook, L"Sheets", 1,

parm);pXlSheet = result.pdispVal; //IDispatch *pXlSheet;

}

Listado 2.4: Seleccionar una hoja de cálculo a través de su nombre usando COM

Otras operaciones como la de abrir un documento con formato Excel (listado 2.3) u ob-tener una determinada hoja del documento a partir de su nombre (listado 2.4) también sonoperaciones medianamente sencillas una vez se conoce el mecanismo de su uso. El principalproblema es conocer el nombre y cómo usar determinadas operaciones, siendo en muchasocasiones necesario crear una macro en Excel con la operación que se quiere realizar parapoder entender como funciona dicha operación y poder usarla en COM.

Características de la alternativa

Una vez introducida la alternativa, se van a analizar las diferentes características comen-tadas en la introducción del capítulo.

Esta alternativa permite trabajar con cualquier formato que soporte Microsoft Excel, per-mitiendo además realizar cualquier operación que se pueda realizar con dicha aplicación.

12 2. ANTECEDENTES

En realidad se soportarán todas aquellas versiones y formatos válidos para la versión deMicrosoft Excel usada como servicio.

La necesidad de uso de la arquitectura COM impide su uso en otras plataformas distintasde Windows. Los lenguajes que se pueden usar para la aplicación, son todos aquellos quepermitan el uso de COM.

La licencia de la aplicación que implemente esta alternativa puede ser del tipo que se desee,pero al necesitar hacer uso del programa Microsoft Excel siempre será necesario contar conuna licencia del mismo.

La dificultad de su uso es alta, aunque a primera vista viendo los ejemplos del apartadoanterior pueda parecer un uso algo más sencillo, este se complica a la hora de buscar cómorealizar las diferentes operaciones, pues no existe un índice de todas las operaciones disponi-ble online, y por tanto a veces es necesario buscar en ejemplos más complejos para localizarun uso concreto del mismo y la mayoría de las veces la única posibilidad es realizar unamacro en la aplicación Microsoft Excel para analizar el código generado por la misma y asíusarlo de guía para conocer cómo realizar la operación.

Esta alternativa al hacer uso de la tecnología de componentes de Windows y existir mul-titud de aplicaciones que hacen uso de ella tiene como resultado una alternativa con unamadurez y actividad muy alta. Además, el soporte también es muy alto.

2.2.3. OpenOffice.org y UNO

Existe una alternativa que permite utilizar la funcionalidad de las aplicaciones de OpenOf-fice.org e incorporarla en otras aplicaciones, al igual que ocurre con COM y Microsoft Officecomo se ha visto en el apartado anterior, esta se llama UNO y en este apartado se va explicaren qué consiste.

UNO Universal Network Objects

UNO [Ora10] es la base de la tecnología de componentes de OpenOffice.org que permiteutilizar objetos entre diferentes plataformas y lenguajes a través de la definición de una seriede interfaces que deben de ser implementadas.

UNO tiene soporte para la siguientes plataformas: GNU/Linux, Solaris, Windows, Po-wer PC, FreeBSD, MacOS. Y también permite usarse con los lenguajes: Java, C++, Ope-nOffice.org Basic, .Net, Python.

La suite de ofimática OpenOffice.org implementa a su vez las interfaces de UNO necesariaspara permitir incorporar las funcionalidades de sus aplicaciones en otras aplicaciones.

2. ANTECEDENTES 13

Formas de conectar a OpenOffice.org con UNO

Existen principalmente 2 formas de utilizar los servicios de OpenOffice.org a través deUNO:

1. Usar una comunicación local a través de una tubería o pipe.

2. Usar una comunicación remota a través de sockets.

soffice -headless -accept="socket,port=8100;urp;"

Listado 2.5: Arracar OpenOffice.org en modo servicio escuchando en un socket

La primera opción requiere que el ejecutable soffice sea arrancado con unas opcionesdeterminadas para que se inicie en modo servicio escuchando en un puerto. En el listado 2.5se muestra como arrancar el proceso de OpenOffice.org como servicio para que se quedea la escucha de peticiones por socket en el puerto 8100. Esto permite poder usar toda lafuncionalidad de OpenOffice.org Calc, y del resto de aplicaciones de la suite ofimática, sinnecesidad de tener instalado el programa en la misma máquina donde se va a usar, puesproporciona una comunicación remota a través de un puente o bridge de UNO.

soffice -headless -accept=pipe,name=uno2;urp;"

Listado 2.6: Arracar OpenOffice.org en modo servicio escuchando en una tubería o pipe

La segunda opción requiere que el ejecutable soffice sea arrancando con la opciones deservicio escuchando en una tubería o pipe con un determinado identificador. Esto permite lacomunicación con otros procesos en local a través de UNO para hacer uso de la funcionalidadde OpenOffice.org. En el listado 2.6 se muestra como arrancar el proceso OpenOffice.orgcomo servicio para que escuche en una tubería o pipe de proceso identificada con el nombre«uno2».

String sConnect ="uno:socket,host=localhost,port=8100;urp;StarOffice.ComponentContext";

Listado 2.7: Cadena de conexión para conectar con un servicio a través de socket

Una vez se ha arrancado el servicio de OpenOffice.org para conectar con él desde otraaplicación, en ambas opciones, es necesario resolver la cadena de conexión o URL corres-pondiente en cada caso (listado 2.7 y listado 2.8) a través del objeto XUnoUrlResolver, quedevolverá el objeto XComponentContext del servicio remoto a través del cuál se puedenobtener el resto de objetos necesarios para trabajar con OpenOffice.org Calc.

14 2. ANTECEDENTES

String sConnect = "uno:pipe,name=uno2;urp;StarOffice.ComponentContext";

Listado 2.8: Cadena de conexión para conectar con un servicio a través de una tubería o pipe

Método bootstrap

En el SDK de OpenOffice.org se proporciona la clase Bootstrap con un método estáticollamado bootstrap que permite en una sola llamada ejecutar el servicio de OpenOffice.orgy recuperar el objeto XComponentContext. Esto facilita mucho la conexión con el servicio,pues proporciona directamente el objeto necesario para trabajar con OpenOffice.org Calcocultando todos los pasos necesarios para establecer la comunicación. Este método por den-tro realiza los siguientes pasos:

1. Localiza el directorio donde se encuentra el ejecutable soffice (según el sistema dondese ejecuta sea GNU/Linux o Windows usa distintos mecanismos).

2. Ejecuta el fichero soffice con los parámetros necesarios para que actúe como servicioy escuche en una tubería o pipe.

3. Conecta con el servicio a través de la tubería abierta.

4. Recupera el XComponentContext y lo devuelve.

Este método sólo puede ser utilizado cuando la instalación de OpenOffice.org está en lamisma máquina que la clase que va a usar el método bootstrap.

Ejemplo de operaciones con hojas de cálculo usando UNO

En este apartado se va a explicar un ejemplo completo de método que hace uso de Calcpara crear un nuevo documento de hojas de cálculo al que le añade una nueva hoja de cálculoy asigna valores a dos celdas, para finalmente guardar el documento con formato xls deExcel. El objetivo de este ejemplo es el de ilustrar el nivel de complejidad de uso de laalternativa.

XComponentContext xContext = Bootstrap.bootstrap();XMultiComponentFactory xServiceManger = xContext.getServiceManager();Object desktop =xServiceManger.createInstanceWithContext("com.sun.star.frame.Desktop",

xContext);

XComponentLoader xComponentLoader =(XComponentLoader) UnoRuntime.queryInterface(XComponentLoader.class,

desktop);

Listado 2.9: Ejemplo uso UNO parte 1: Cómo obtener el objeto remoto XComponentLoader

2. ANTECEDENTES 15

El primer paso (listado 2.9) es obtener el objeto remoto XComponentLoader, para ellose utiliza el método bootstrap comentado en el apartado anterior, y mediante el XCompo-nentContext recuperado se crear una instancia remota del tipo com.sun.star.frame.Desktopque permite hacer un casting a la clase del objeto esperado. Los castings en el entorno UNO

se realizan a través de una consulta al runtime que comprueba primero que el objeto puederealizar el casting a una determinada clase y además que el enlace al objeto remoto sigueactivo.

PropertyValue[] loadProps = new PropertyValue[1];loadProps[0] = new PropertyValue();loadProps[0].Name = "Hidden";loadProps[0].Value = new Boolean(true);

XComponent xSpreadsheetComponent =xComponentLoader.loadComponentFromURL("private:factory/scalc", "_blank",

0, loadProps);

XSpreadsheetDocument xSpreadsheetDocument =(XSpreadsheetDocument) UnoRuntime.queryInterface(XSpreadsheetDocument.class, xSpreadsheetComponent);

Listado 2.10: Ejemplo uso UNO parte 2: Cómo crear un nuevo documento de hojas decálculo

El segundo paso (listado 2.10) es cargar un nuevo documento de hojas de cálculo haciendouso del objeto remoto XComponentLoader, para ello se le pasa una lista de propiedadescon la propiedad que hace que se realice la operación de creación en segundo plano, y portanto de manera transparente al usuario. Como resultado de la creación obtenemos un objetoXSpreadsheetDocument.

XSpreadsheets xSpreadsheets = xSpreadsheetDocument.getSheets();xSpreadsheets.insertNewByName("Hoja_prueba", (short) 0);Object sheet = xSpreadsheets.getByName("Hoja_prueba");XSpreadsheet xSpreadsheet =(XSpreadsheet) UnoRuntime.queryInterface(XSpreadsheet.class, sheet);

Listado 2.11: Ejemplo uso UNO parte 3: Añadir una nueva hoja de cálculo al documento

El tercer paso (listado 2.11) consiste en añadir una nueva hoja de cálculo y para ello esnecesario recuperar el objeto XSpreadsheets que representa la lista de hojas de cálculo deldocumento. Puesto que el método que añade hojas de cálculo no devuelve nada, para poderoperar después con la hoja creada, es necesario recuperarla antes a través de su nombre. Alfinal como resultado obtenemos un objeto XSpreadsheet.

16 2. ANTECEDENTES

XCell xCell = xSpreadsheet.getCellByPosition(0, 0); //celda A1xCell.setValue(16.6);

xCell = xSpreadsheet.getCellByPosition(1, 1); //celda B2xCell.setValue(199);

Listado 2.12: Ejemplo uso UNO parte 4: Insertar valores a celdas

El siguiente paso (listado 2.12) consiste en insertar valores a dos celdas del objeto XS-preadsheet recuperado en el paso anterior. Para ello es necesario primero obtener el objetoXCell, que se recupera a través de la posición que ocupa en la hoja de cálculo, y despuésusar el método que permite asignarle un valor.

XStorable xStorable =(XStorable)UnoRuntime.queryInterface(XStorable.class,

xSpreadsheetComponent);

PropertyValue[] storeProps = new PropertyValue[1];storeProps[0] = new PropertyValue();storeProps[0].Name = "FilterName";storeProps[0].Value = "MS Excel 97";File outputFile = new File("salida.xls");xStorable.storeAsURL("file:///"+outputFile.getAbsolutePath(), storeProps)

;

Listado 2.13: Ejemplo uso UNO parte 5: Guardar un documento con formato xls

El último paso (listado 2.13) consiste en salvar el documento y las modificaciones realiza-das en él en un fichero con formato de Microsoft Excel concretamente el formato xls. Paraello es necesario obtener a partir del XComponent, que representa el documento cargado enmemoria, un objeto XStorable que permite realizar el salvado a fichero. Como se desea guar-dar el documento con un formato distinto al nativo de la aplicación OpenOffice.org Calc, esnecesario definir una lista de propiedades con un filtro que indique al método de salvado enqué formato se desea guardar el documento.



Esta alternativa permite trabajar con cualquier formato que soporte OpenOffice.org Calcque incluye los formatos de Microsoft Excel, permitiendo realizar cualquier operación per-mitida en dicha aplicación, incluyendo la conversión entre los formatos permitidos y la ex-portación a PDF.

Como ya se comentó en apartados anteriores UNO permite el uso de diferentes lenguajesy plataformas.

2. ANTECEDENTES 17

La licencia de la aplicación que implemente esta alternativa puede ser libre y seguir ha-ciendo uso de OpenOffice.org sin necesidad de tener ningún tipo de licencia.

La dificultad de su uso de esta alternativa es alta debido a la compleja jerarquía de objetosque deriva en una gran cantidad de interfaces que siempre debe ser recuperadas en tiempode ejecución lo que obliga a conocer dicha estructura previamente.

La documentación para usar UNO es completa y existen gran cantidad de ejemplos, sobretodo para el desarrollo en Java.

Esta alternativa hace uso de la tecnología de componentes diseñada para usarse directa-mente con la suite ofimática OpenOffice.org y forma parte de ella, eso unido al uso extendidode esta suite desde hace varios años y a la salida con frecuencia de versiones da como re-sultado una alternativa con una madurez y actividad muy alta. Además, el soporte ofrecidotanto por la comunidad como por los desarrolladores también es muy alto.

2.2.4. Apache POIExiste un grupo de proyectos con el nombre de Apache POI [Foua] que proporcionan

una serie de APIs en Java para trabajar con los diferentes formatos de Microsoft Office.Concretamente la API que proporciona el soporte para acceder a los formatos de MicrosoftExcel, es decir, a los documentos de hojas de cálculo, es la compuesta por los proyectosPOI-HSSF and POI-XSSF [Foud].

Estas APIs están escritas totalmente en Java e implementan los estándares de los formatosque soportan que son xls y xlsx, es decir, llevan a cabo lo mencionado en la primera de lasalternativas y por tanto no necesitan hacer uso de otras aplicaciones como si ocurre en lasdos alternativas anteriores.

Ejemplo de operaciones con hojas de cálculo usando Apache POI

En este apartado se va a explicar un ejemplo completo de método que hace uso de lalibrería Apache POI para crear un nuevo documento de hojas de cálculo al que le añade unanueva hoja de cálculo y le asigna valores a dos celdas, para finalmente guardar el documentocon formato xls de Excel.

En el listado 2.14 se puede ver el código resultante de realizar las operaciones sobre unnuevo documento de hojas cálculo. Los pasos seguidos han sido los siguientes:

1. Se ha creado un nuevo documento xls a partir de un objeto HSSFWorkbook.

2. Se ha añadido al documento una nueva hoja de cálculo, usando el método corres-pondiente para ello createSheet. Este método nos devuelve el objeto HSSFSheet querepresenta la hoja creada.

18 2. ANTECEDENTES

HSSFWorkbook wb = new HSSFWorkbook();HSSFSheet sheet = wb.createSheet("Hoja_prueba");

HSSFRow row0 = sheet.createRow((short)0);row0.createCell(0).setCellValue(16.6); //Celda A1

HSSFRow row1 = sheet.createRow((short)1);row1.createCell(1).setCellValue(199); //Celda B2

FileOutputStream fileOut = new FileOutputStream("workbook.xls");wb.write(fileOut);fileOut.close();

Listado 2.14: Ejemplo uso Apache POI

3. Para poder asignar un valor a una celda, antes es necesario crear un objeto Row querepresenta la fila.

4. Una vez se tiene el objeto Row simplemente se usa el método para asignarle un valora la celda indicando el índice de la columna.

5. El último paso consiste en guardar el contenido del documento, para ello se hace usodel método write proporcionado, al que es necesario pasarle un objeto FileOutputS-tream con el nombre que se desea dar al fichero.



Esta alternativa permite trabajar con los formatos xls y xlsx de Microsoft Excel, permi-tiendo realizar la mayoría de las operaciones con las siguientes limitaciones:

No permite crear gráficos, aunque si el fichero con el que trabaja ya tiene alguno creadocon otro programa, se pueden modificar las celdas que son usadas como datos de dichográfico.

No permite crear macros ni modificarlas, pero si el fichero tiene macros las mantiene.

No permite crear tablas dinámicas, en inglés pivot tables, pero las mantiene si el do-cumento las incluye.

El lenguaje de programación usado es Java, y al estar la librería escrita completamenteen dicho lenguaje, hace que la solución sea multiplataforma, pudiendo usarse en cualquiersistema que tenga una implementación de máquina virtual de Java.

La librería tiene una licencia Apache 2.0 por tanto la aplicación que implemente estaalternativa puede ser libre o con licencia privativa.

2. ANTECEDENTES 19

La dificultad de su uso es más sencilla que otras alternativas al no necesitar conectar conotras aplicaciones para operar con hojas de cálculo si no que se usan directamente los objetosque representan cada elemento de un documento de hojas de cálculo.

Apache POI cuenta con una documentación en línea completa y con gran cantidad deejemplos que muestran cómo utilizar la mayoría de las funcionalidades que ofrece.

Esta alternativa lleva en usándose en diferentes proyectos tanto libres como privativosdesde hace varios años, esto unido a la publicación frecuente de nuevas versiones y al so-porte proporcionado por Apache y su comunidad da como resultado una solución con unaactividad, soporte y madurez muy altas.

2.2.5. Spreadsheet::ParseExcelSpreadsheet::ParseExcel [Tak] es un módulo en Perl que permite extraer información de

ficheros de Excel en las versiones 95 y 97-2000 a través de la implementación de los es-tándares de dichos formatos. No permite insertar información en los documentos de hojasde cálculo y tampoco permite extraer fórmulas generadas con el módulo de Perl Spreads-heet::WriteExcel.

Ejemplo de código usando ParseExcel

En este apartado se muestra un ejemplo [Tak], extraído de la documentación del módulo,con el objetivo de ilustrar el nivel de complejidad de uso del mismo. En el ejemplo se recorrenlas celdas de un documento y se imprimen .

use strict;use Spreadsheet::ParseExcel;my $oBook =

Spreadsheet::ParseExcel::Workbook->Parse(’Excel/Test97.xls’);my($iR, $iC, $oWkS, $oWkC);foreach my $oWkS (@{$oBook->{Worksheet}}) {

print "--------- SHEET:", $oWkS->{Name}, "\n";for(my $iR = $oWkS->{MinRow} ;

defined $oWkS->{MaxRow} && $iR <= $oWkS->{MaxRow} ; $iR++) {for(my $iC = $oWkS->{MinCol} ;

defined $oWkS->{MaxCol} && $iC <= $oWkS->{MaxCol} ; $iC++) {$oWkC = $oWkS->{Cells}[$iR][$iC];print "( $iR , $iC ) =>", $oWkC->Value, "\n" if($oWkC);

}}

}

Listado 2.15: Ejemplo uso Spreadsheet::ParseExcel

En el listado 2.15 se puede ver el código resultante de realizar la operación de lectura delas celdas de un documento.

20 2. ANTECEDENTES



Esta alternativa sólo permite trabajar con las versiones antiguas del formato xls, y sola-mente para la lectura de la información, es decir, no permite su modificación.

El lenguaje de programación usado es Perl, y al estar el módulo escrito completamente endicho lenguaje, el módulo es multiplataforma, permitiendo su uso en cualquier sistema quetenga una implementación del intérprete de Perl.

La librería tiene una licencia GNU GPL y por tanto la aplicación que implemente estaalternativa debe ser libre y usar el mismo tipo de licencia.

La dificultad de esta alternativa es alta al no disponer de una documentación completa.

Spreadsheet::ParseExcel lleva en desarrollo desde el 2000 sacando versiones con frecuen-cia,y ofreciendo soporte a través de un grupo creado en Google, por tanto este módulo tieneuna madurez y actividad altas, con un soporte medio.

2.2.6. Spreadsheet::ReadSpreadsheet::Read [Bra] es un módulo en Perl que permite extraer los datos de diferentes

formatos de documentos de hoja de cálculo como los formatos sxc y ods de OpenOffice.org,xls y xlsx de Microsoft Excel, CSV y otros.

Este módulo en lugar de implementar los diferentes formatos, hace uso de diferentes mó-dulos para obtener la información de cada tipo de documento de hoja de cálculo, ofreciendoun mecanismo homogéneo de acceso a los datos de un documento independientemente de suformato.

Ejemplo de código usando Read

En este apartado se muestra un ejemplo [Bra], extraído de la documentación del módulo,en el que se abre un documento de formato xls y se obtiene el valor de una celda. Además, semuestra un ejemplo de la estructura usada para almacenar la información de un documentode hojas de cálculo. El objetivo principal de mostrar el código usado es el de ilustrar el nivelde complejidad de uso del componente.

use Spreadsheet::Read;

my $ref = ReadData ("test.xls");my $a3 = $ref->[1]{A1}, "\n";

Listado 2.16: Ejemplo uso Spreadsheet::Read

2. ANTECEDENTES 21

En el listado 2.16 se puede ver el código resultante para abrir un documento de hojas decálculo que tiene formato xls, y después obtener el valor de la celda A1 de la primera hojade cálculo.

$ref =[

# Elemento 0: contiene la informacion general del documento{ sheets => 2,

sheet => {"Sheet 1" => 1,"Sheet 2" => 2,

},type => "xls",parser => "Spreadsheet::ParseExcel",version => 0.26,

},# Elemento 1: contiene la informacion de la primera hoja{ label => "Sheet 1",

maxrow => 2,maxcol => 4,cell => [ undef,

[ undef, 1 ],[ undef, undef, undef, undef, undef, "Nugget" ],

],A1 => 1,B5 => "Nugget",

},# Elemento 2: contiene la informacion de la segunda hoja{ label => "Sheet 2",

:: }

Listado 2.17: Ejemplo de la estructura de datos de un documento de Spreadsheet::Read

En el listado 2.17 obtenido de la documentación del módulo [Bra] se puede ver como todala información recuperada al leer un documento de hojas de cálculo se almacena en array

donde el primer elemento contiene los datos referentes al documento completo, tales como elnúmero y nombre de las hojas que contiene, el tipo de documento y el parser utilizado juntocon su versión; el resto de elementos contienen los datos de cada una de las hojas de cálculo(nombre, número de filas, número de columnas, valores de las celdas). Como el módulo noestá programado con orientación a objetos, basta con conocer las estructuras que contienenla información para trabajar con ellas.



Esta alternativa permite trabajar con múltiples formatos de hojas de cálculo pero solamente

22 2. ANTECEDENTES

para la lectura de la información como el nombre del módulo indica, por lo tanto no permitemodificación ni creación de documentos.

El lenguaje de programación usado es Perl, y al estar el módulo escrito completamente endicho lenguaje, incluyendo los módulos que utiliza, es multiplataforma, pudiendo usarse encualquier sistema que tenga una implementación del intérprete de Perl.

La librería tiene una licencia GNU GPL y la aplicación que implemente esta alternativadebe ser libre y usar el mismo tipo de licencia.

La dificultad de uso es sencilla al disponer de una documentación donde se muestran lasestructuras completas en las que se carga la información a utilizar, como ya se ha ilustradoen el apartado anterior, y las funciones principales de uso. En este caso como el módulo noestá programado con orientación a objeto, basta con conocer las estructuras que contienen lainformación para trabajar con ellas.

Spreadsheet::Read lleva en desarrollo desde el 2005 sacando versiones con frecuencia perono ofrece soporte directamente a través de algún canal directo salvo la gestión de bugs queofrece CPAN [CPA] por defecto, lo que hace que tenga una madurez y actividad altas, sinsoporte directo, puesto que no existe ninguna actividad en el sistema ofrecido por CPAN.

2.2.7. Spreadsheet::WriteExcel

Spreadsheet::WriteExcel [McN] es un módulo en Perl que permite crear nuevos ficherosde Excel en las versiones 97-2000, 2002, 2003 y 2007 a través de la implementación de losestándares de dichos formatos. No tiene soporte para modificar ficheros Excel generados conMicrosoft Excel, y en caso de modificarlo todos aquellos elementos como macros, gráficosy otras funcionalidades que no se soportan se perderán.

Ejemplo de código usando WriteExcel

En este apartado se muestra un ejemplo que adapta el primer ejemplo [McN] de la docu-mentación para que se realicen las mismas operaciones que se han hecho con otras alterna-tivas. El ejemplo consiste en crear un nuevo documento de hojas de cálculo al que le añadeuna nueva hoja de cálculo y le asigna valores a dos celdas. El objetivo de este ejemplo es elde ilustrar el nivel de complejidad de uso de la alternativa.

En el listado 2.18 se puede ver el código resultante de realizar la creación del documentode hojas de cálculo, al que se le añade una nueva hoja de cálculo y se asignan valores a dosde sus celdas.

2. ANTECEDENTES 23

use Spreadsheet::WriteExcel;

my $workbook = Spreadsheet::WriteExcel->new(’workbook.xls’);

$worksheet = $workbook->add_worksheet(’Hoja_prueba’, 1);

$worksheet->write(’A1’, 16.6);$worksheet->write(’B2’, 199);

$workbook->close();

Listado 2.18: Ejemplo uso Spreadsheet::WriteExcel



Esta alternativa permite trabajar con las diferentes versiones del formato xls, para su crea-ción, pero la modificación de ficheros generados con Microsoft Excel puede provocar pérdidade diferentes funcionalidades.

El lenguaje de programación usado es Perl, y al estar el módulo escrito completamenteen dicho lenguaje es multiplataforma, pudiendo usarse en cualquier sistema que tenga unaimplementación del intérprete de Perl.

La librería tiene una licencia GNU GPL y la aplicación que implemente esta alternativadebe ser libre y usar el mismo tipo de licencia.

La dificultad es sencilla pues los métodos son bastantes explícitos y además se proporcionauna documentación con el listado de todos los métodos disponibles.

Spreadsheet::WriteExcel lleva en desarrollo desde hace más de diez años, sacando versio-nes con cierta frecuencia,y ofreciendo soporte a través de un grupo creado en Google, portanto este módulo tiene una madurez y un soporte altos, y su actividad es media, al habersereducido en el último año los cambios realizados en el módulo.

2.2.8. OpenOffice::OODocOpenOffice::OODoc [Gou] es un módulo en Perl que permite trabajar con documentos en

formato Open Document [OAS07], ofreciendo las funcionalidades necesaria para crear nue-vos documentos y modificar documentos ya existentes, siendo compatible con documentosde texto, documentos de hojas de cálculo y documentos de presentación.

En la documentación de OpenOffice::OODoc, no se recomienda usar dicho módulo paracrear tablas complejas como las usadas para representar una hoja de cálculo. En su lugar seaconseja usar otras herramientas que también trabajen con Open Document y que permitancrear este tipo de tablas.

24 2. ANTECEDENTES

Ejemplo de código usando OODoc

En este apartado debido a la limitación del módulo para crear hojas de cálculo, se harealizado un ejemplo haciendo uso de los ejemplos mostrados en la documentación del mó-dulo [Gou] que consiste en crear un nuevo documento de hojas de cálculo y asignarle a laprimera hoja de cálculo valores a dos de sus celdas. El objetivo de este ejemplo es el deilustrar el nivel de complejidad de uso de la alternativa.

use OpenOffice::OODoc;

my $workbook = odfContainer("workbook.ods", create => ’spreadsheet’);

my $worksheet = $workbook->expandTable(0, 5, 5);

$workbook->cellValue($worksheet,0,0,16.6);$workbook->cellValue($worksheet,1,1,199);$workbook->save;

Listado 2.19: Ejemplo uso OpenOffice::OODoc

En el listado 2.19 se puede ver el código resultante de realizar la creación del documentode hojas de cálculo, el cuál por defecto es creado con una única hoja de cálculo que contieneuna celda. Para poder aumentar el número de celdas, es necesario hacer uso del métodoexplandTable, en el ejemplo se añaden varias celdas, y una vez añadidas se asignan valoresa dos de ellas.



Esta alternativa permite trabajar con el formato Open Document proporcionando las fun-cionalidades necesarias para la creación y modificación de los diferentes tipos de ficheros,odt para documentos de texto, ods para documentos de hojas de cálculo y odp para docu-mentos de presentaciones; con una importante limitación, puesto que no se recomienda usarsus funciones para crear nuevas hojas de cálculo dentro de un documento.

El lenguaje de programación usado es Perl, y al estar el módulo escrito completamenteen dicho lenguaje hace que la alternativa sea multiplataforma, pudiéndose usar en cualquiersistema que tenga una implementación del intérprete de Perl.

La librería tiene una licencia GNU LGPL y por tanto la aplicación que implemente estaalternativa puede ser libre o usar una licencia privativa.

La dificultad es alta puesto que al tratar de manejar de manera uniforme todos los tiposde documentos del formato Open Document, hay conceptos que desaparecen, por ejemplono existe directamente el concepto de hojas de cálculo si no que se representa a través del

2. ANTECEDENTES 25

concepto de tabla, y los diferentes tipos de tablas se tratan igual, ya sea una simple tabla contexto que se vaya a insertar en un documento de texto o una tabla compleja que representa unahoja de cálculo; sin embargo, hay acciones que si requieren realizar operaciones adicionalescuando se trata con tablas que representan hojas de cálculo. Además de todo lo anterior, ladocumentación tiende a hablar de los diferentes elementos que existen sin hacer divisionesde lo permitido para cada uno de los tipos de documento, lo que hace que no sea sencilloidentificar que operaciones están permitidas en cada uno de ellos. Todo lo anterior hace queel uso del módulo no sea intuitivo ni sencillo a la hora de trabajar con documentos de hojasde cálculo.

OpenOffice-OODoc lleva en desarrollo desde el 2004, siendo la última versión liberadade julio de 2010, el soporte se ofrece a través de los foros de CPAN [CPA], por todo ello estemódulo cuenta con una madurez alta, una actividad actual baja y un soporte medio.

2.2.9. Java Excel APIJava Excel API es un API para Java que permite leer, modificar y generar documentos de

hojas de cálculo con formato Excel en las versiones 95 y 97-2000 a través de la implemen-tación de los estándares de dichos formatos.

Ejemplo de código usando Java Exel API

En este apartado se muestra un ejemplo donde se llevan a cabo las mismas operacionesque se han realizado en los ejemplos de otras alternativas. El ejemplo consiste en crear unnuevo documento de hojas de cálculo al que le añade una nueva hoja de cálculo y le asignavalores a dos celdas. El objetivo de este apartado es el de ilustrar el nivel de complejidad deuso de la alternativa.

WritableWorkbook workbook = Workbook.createWorkbook(new File("output.xls"));

WritableSheet sheet = workbook.createSheet("Hoja_prueba", 0);

jxl.write.Number number = new jxl.write.Number(0, 0, 16.6); //Celda A1sheet.addCell(number);

number = new jxl.write.Number(1, 1, 199);//Celda B2sheet.addCell(number);

workbook.write();workbook.close();

Listado 2.20: Ejemplo uso Java Excel API

En el listado 2.20 se puede ver el código resultante de realizar las operaciones sobre unnuevo documento de hojas cálculo. Los pasos seguidos han sido los siguientes:

26 2. ANTECEDENTES

1. Se ha creado un nuevo documento xls creando un nuevo objeto WritableWorkbook

2. Se ha añadido al documento una nueva hoja de cálculo, usando el método correspon-diente para ello createWorkbook. Este método nos devuelve el objeto WritableSheetque representa la hoja creada.

3. Para poder asignar un valor a una celda, antes es necesario crear un objeto con elformato del dato a insertar, es decir, un objeto que representa el contenido de la cel-da y su posición; en el ejemplo al insertar un valor numérico se hace uso del objetojxl.write.Number. Si se deseará insertar una cadena entonces sería necesario crear unobjeto jxl.write.Label.

4. Una vez creado el objeto que representa al contenido de la celda, se inserta a la hojade cálculo deseada a través de su método addCell.

5. El último paso consiste en escribir los cambios que se han realizado en el documentoy cerrarlo para liberar los recursos asociados al mismo.



Esta alternativa trabaja con el formato xls en las versiones 95 y 97-2000 Excel, permitien-do realizar la mayoría de las operaciones con las limitaciones de que no da la posibilidadde generar macros ni gráficos, no obstante si el fichero a modificar contiene alguno de estoselementos los preservará.

El lenguaje de programación usado es Java, y al estar la librería escrita completamente endicho lenguaje hace que esta alternativa sea multiplataforma, pudiendo usarse en cualquiersistema que tenga una implementación de máquina virtual de Java.

La librería tiene una licencia LGPL por tanto la aplicación que implemente esta alternativapuede ser libre o con licencia privativa.

La dificultad es sencilla pues los objetos y métodos para trabajar con ellos son intuitivosy están bien organizados, permitiendo coger rápidamente la filosofía seguida por esta API.Además se proporciona una documentación muy completa con un tutorial que facilita todavíamás su uso.

Java Excel API empezó en 2002 a partir de la implementación basada en ExcelRead,siendo la última versión liberada de octubre de 2009. Para el soporte cuenta con un grupocreado en Yahoo. A partir de la información anterior se puede decir que la librería tiene unamadurez alta, con una actividad actual nula y un soporte medio.

2. ANTECEDENTES 27

2.2.10. GemBox.SpreadSheetGemBox.SpreadSheet [Sof] es un componente .NET que permite a los desarrolladores

escribir, leer y convertir ficheros de documentos de hojas de cálculo a través de una API sinnecesidad de tener instaladas otras aplicaciones. GemBox.SpreadSheet es compatible conlos formatos de Excel 97-2007 (xls y xlsx) y Open Document a través de la implementaciónde los estándares de dichos formatos. Tiene las siguientes limitaciones:

Las imágenes y comentarios sólo se soportan en los formatos xlsx y ods.

Sólo se conserva la información de gráficos y de tablas dinámicas , en inglés pivot

tables, para el formato xlsx.

Ejemplo de código usando GemBox.SpreadSheet

En este apartado se muestra cómo realizar el ejemplo ilustrado en otras alternativas estavez haciendo uso de la librería GemBox.SpreadSheet. El ejemplo consiste en crear un nue-vo documento de hojas de cálculo, añadirle una nueva hoja de cálculo, asignarle valores ados celdas y salvar el documento. El objetivo de este ejemplo es el de ilustrar el nivel decomplejidad de uso de la alternativa.

ExcelFile excelFile = new ExcelFile();ExcelWorksheetCollection worksheets = excelFile.Worksheets;ExcelWorksheet ws = worksheets.Add("Hoja_prueba")ws.Cells["A1"].Value = 16;ws.Cells["B2"].Value = 199;excelFile.SaveXls("ejemplo.xls");

Listado 2.21: Ejemplo uso GemBox.SpreadSheet

En el listado 2.21 se puede ver el código resultante del ejemplo, en el que primero serealizar la creación del documento de hojas de cálculo, en este caso con formato Excel, paradespués recuperar la colección de hojas de cálculo del documento a la que se le añade unanueva hoja de cálculo, que será a la que se le asignen los valores numéricos a dos de susceldas.



Esta alternativa permite trabajar con las diferentes versiones del formato Microsot Excely Open Document, pero la modificación de ficheros xls que hayan sido creados con otrasherramientas puede provocar pérdida de alguna información como gráficos y tablas dinámi-cas.

28 2. ANTECEDENTES

El lenguaje de programación a usar puede ser cualquiera de la plataforma .NET. Estaalternativa sólo se puede usar en sistemas Windows.

GemBox.SpreadSheet tiene licencia privativa, y una licencia gratuita que permite el usode la API con limitaciones (un máximo de 150 filas por hoja de cálculo, y 5 hojas por docu-mento).

La dificultad es sencilla pues los métodos son bastantes explícitos, se proporciona un fiche-ro de ayuda para usarlo con el entorno de desarrollo Visual Studio, y además se proporcionanvarios ejemplos que ilustran las diferentes operaciones que se pueden realizar.

La madurez y actividad de la solución son más difíciles de analizar en productos con licen-cia privativa que con alternativas de código abierto en las que se puede acceder al repositoriopara ver ambas características por tanto no se evaluarán. En este caso lo que si es muy altoes el soporte pues se puede contratar.

2.2.11. Spreadsheet SDKSpreadsheet SDK [Byt] es un componente .NET que permite a los desarrolladores escribir,

leer y convertir ficheros de documentos de hojas de cálculo a través de una API sin necesidadde tener instaladas otras aplicaciones. Spreadsheet SDK es compatible con los formatos deExcel 97-2010 (xls y xlsx) y Open Document a través de la implementación de los estándaresde dichos formatos, y permite la exportación en diferentes formatos incluido PDF.

Ejemplo de código usando Spreadsheet SDK

En este apartado se muestra cómo realizar el ejemplo usado en otras alternativas haciendouso de la API Spreadsheet SDK. El ejemplo consiste en crear un nuevo documento de hojasde cálculo, añadirle una nueva hoja de cálculo, asignarle valores a dos celdas y salvar eldocumento. El objetivo de este ejemplo es el de ilustrar el nivel de complejidad de uso de laalternativa.

Spreadsheet document = new Spreadsheet();Worksheet worksheet = document.Workbook.Worksheets.Add("Hoja_prueba");worksheet.Cell(0, 0).Value = 16;worksheet.Cell(1, 1).Value = 199;document.SaveAs("ejemplo.xls");

Listado 2.22: Ejemplo uso Spreadsheet SDK

En el listado 2.22 se puede ver el código resultante de realizar la creación del documentode hojas de cálculo, en este caso con formato Excel, se recupera la colección de hojas decálculo del documento para añadir una nueva, y se le asignan valores a dos de sus celdas.

2. ANTECEDENTES 29



Esta alternativa permite trabajar con las diferentes versiones del formato Microsot Excel yOpen Document, permitiendo la modificación de documentos ya creados con Microsoft Ex-cel sin pérdida de información. Además, permite la exportación a PDF y otros formatos.

El lenguaje de programación permitido para trabajar con esta alternativa puede ser cual-quiera de la plataforma .NET. Este módulo sólo se puede usar en sistemas Windows.

Spreadsheet SDK tiene licencia privativa.

La dificultad es sencilla pues los métodos son bastantes explícitos, y además se proporcio-na documentación y varios ejemplos que ilustran las diferentes operaciones que se puedenrealizar.

La madurez y actividad de la solución son más difíciles de analizar en productos con licen-cia privativa que con alternativas de código abierto en las que se puede acceder al repositoriopara ver ambas características por tanto no se evaluarán. En este caso lo que si es muy altoes el soporte pues se puede contratar.

2.2.12. Comparativa de alternativasEn esta sección se pretende dar una visión general de las alternativas estudiadas en el

capítulo a través de la comparación de la características analizadas. Para ello se han creadodos cuadros comparativos que se analizarán a continuación.

Comparativa de funcionalidades

En el cuadro 2.1 se realiza una comparación de las funcionalidades puramente técnicas,representadas por las siguientes columnas:

Lenguaje: es el lenguaje de programación con el que permite trabajar la alternativa.

Formatos: son los formatos de documentos de hojas de cálculo que se soportan.

C: representa la operación de Creación de documentos de hojas de cálculo.

M: representa la operación de Modificación de documentos de hojas de cálculo.

E: representa la operación de Exportación de información de documentos de hojas decálculo.

Cv: representa la operación de Conversión de documentos de hojas de cálculo a losformatos soportados.

30 2. ANTECEDENTES

PDF: representa la operación de exportación de documentos de hojas de cálculo alformato PDF.

Plataforma: es la plataforma o sistema operativo donde se puede utilizar la alternativa.

Una vez se han explicado qué representa cada una de las columnas del cuadro 2.1, va-mos a analizar la información que se puede extraer de él. Existen cuatro alternativas quepermiten trabajar con los formatos más extendidos Excel y Open Document, estas son: Ope-nOffice.org con UNO, Spreadsheet::Read, GemBox.SpreadSheet, y Spreadsheet SDK. Delas alternativas anteriores sólo dos permiten realizar todas las operaciones y conversiones:OpenOffice.org con UNO y Spreadsheet SDK, de las anteriores sólo la primera es multipla-taforma.

Nombre Lenguaje Formatos C M E Cv PDF PlataformaMS Office y COM C++ y otros Excel X X X X WindowsOpenOffice.org y UNO Java y otros Excel y OOO X X X X X VariasApache POI Java Excel X X X X VariasSpreadsheet::ParseExcel Perl xls X VariasSpreadsheet::Read Perl Excel y OOO X VariasSpreadsheet::WriteExcel Perl Excel X VariasOpenOffice::OODoc Perl OOO X X X VariasJava Excel API Java xls X X X VariasGemBox.SpreadSheet .Net Excel y OOO X X X X WindowsSpreadsheet SDK .Net Excel y OOO X X X X X Windows

Cuadro 2.1: Comparativa de funcionalidades de las distintas alternativas

Comparativa de características generales

En el cuadro 2.2 se realiza una comparación de las características a tener en cuenta a la ho-ra de elegir una alternativa y que van más allá de las puramente técnicas. Estas característicasson representadas por las siguientes columnas:

Licencia: es la licencia que tiene la alternativa y que debe ser compatible con la licenciadel producto que la vaya a usar.

Doc: Es la documentación y ejemplos con los que cuenta la solución. Normalmentecuanto mejor es la documentación antes y mejor se puede llevar a cabo la implemen-tación de un producto.

Soporte: Es el soporte a fallos o problemas encontrados al utilizar la solución. Duranteel desarrollo hay riesgo de que aparezcan problemas y es importante contar con algúntipo de soporte que pueda reducir los tiempos en solucionarlos.

2. ANTECEDENTES 31

Actividad: representa la actividad que tiene un proyecto, es decir, cada cuanto tiempose libera una nueva versión. Esta característica es importante porque se resuelven anteslos problemas encontrados.

Madurez: representa el tiempo y uso que tiene una solución, de manera que cuantomás tiempo y más uso tenga más madura será. Normalmente cuanto más madura esuna solución mayor estabilidad tiene.

Dif: Dificultad, característica que indica lo fácil o difícil que es usar una determinadasolución; En ella influye entre otros factores la documentación del proyecto.

Una vez se han explicado qué representa cada una de las columnas del cuadro 2.2, vamosa analizar la información que se puede extraer de él. Existen tres alternativas que tiene unadocumentación completa, junto con una madurez, actividad y soporte muy altos, estas son:Microsoft Office y COM, OpenOffice.org con UNO, y Apache POI. De las alternativas an-teriores sólo las dos últimas tienen licencia libre, puesto que si se usa Microsoft Office serequiere adquirir una licencia de esta suite ofimática. Además, de las alternativas libres sóloApache POI tiene una dificultad baja.

Nombre Licencia Doc. Soporte Actividad Madurez Dif.MS Office y COM privativa Completa Muy Alto Muy Alta Muy Alta AltaOpenOffice.org y UNO LGPL Completa Muy Alto Muy Alta Muy Alta AltaApache POI Apache Completa Muy Alto Muy Alta Muy Alta BajaSpreadsheet::ParseExcel GPL Poca Medio Alta Alta AltaSpreadsheet::Read GPL Completa No Alta Alta BajaSpreadsheet::WriteExcel GPL Completa Alto Media Alta BajaOpenOffice::OODoc LGPL Completa Medio Baja Alta AltaJava Excel API LGPL Completa Medio Muy Baja Alta BajaGemBox.SpreadSheet privativa Completa Muy Alto - - BajaSpreadsheet SDK privativa Completa Muy Alto - - Baja

Cuadro 2.2: Comparativa de características generales de las alternativas

Capítulo 3

Objetivos del proyecto

E N la comparativa de alternativas realizada en el capítulo anterior, se puede ver quede todas las alternativas estudiadas sólo tres (OpenOffice.org y UNO, GemBox.SpreadSheet

y Spreadsheet SDK) permiten la posibilidad de insertar y extraer información de documen-tos de hojas de cálculo con los principales formatos del mercado, que son los formatos deMicrosoft Excel y los de OpenOffice.org Calc. De esas tres alternativas sólo OpenOffice.orgtiene una licencia no privativa.

La alternativa de usar OpenOffice.org a través de UNO es la más completa siendo multi-plataforma y ofreciendo a los desarrolladores la posibilidad de incluir toda funcionalidad desu suite ofimática en sus aplicaciones. Pero esa gran funcionalidad ofrecida hace que su usotenga una dificultad elevada y por tanto sea compleja de incluir en otras aplicaciones.

El proyecto OpenSheet a través del objetivo general y de los objetivos específicos pretendecubrir ese vacío detectado en el estudio realizado de las alternativas. En este capítulo sedescriben tanto los objetivos generales como los específicos para determinar así el alcancedel proyecto.

3.1. Objetivo generalEl objetivo general que persigue el proyecto es proporcionar mecanismos para poder rea-

lizar la extracción e inserción de datos en los documentos de hojas de cálculo de maneraautomática y sencilla, soportando los principales formatos existentes en el mercado.

3.2. Objetivos específicosLos objetivos específicos que persigue el proyecto son los siguientes:

1. Permitir trabajar con documentos de hojas de cálculo con los siguientes formatos:xls [Mic08b], xlt y xlsx [Mic10a] [Mic10b] de la aplicación Microsoft Excel; ods yots de Open Document Format [OAS07] [OAS10] para hojas de cálculo.

2. Permitir realizar las siguientes operaciones con documentos de hojas de cálculo: crear

33

34 3. OBJETIVOS DEL PROYECTO

un nuevo documento, abrir un documento ya existente, extraer datos de celdas, insertardatos en celdas, crear nuevas hojas de cálculo y eliminar hojas de cálculo.

3. Permitir conversiones de hojas de cálculo entre los formatos soportados, siempre ycuando las funciones incorporadas en las hojas de cálculo a exportar existan tanto elformato origen como en el destino y además sean compatibles.

4. Permitir la exportación de hojas de cálculo al formato pdf.

5. Ser multiplataforma, soportando al menos los sistemas operativos Windows y GNU/-Linux.

6. Proporcionar una librería que exponga como funcionalidades los objetivos del proyec-to, permitiendo así su incorporación en otras aplicaciones y proyectos.

7. Proporcionar una herramienta o comando que utilice la librería mencionada anterior-mente, preparado para ejecutarse desde un terminal o consola del sistema para poderser usado en un procesamiento por lotes.

8. Proporcionar un servicio web que haga uso de la librería mencionada anteriormente,ofreciendo las funcionalidades de los objetivos del proyecto de forma remota.

A continuación, se detallará cada uno de los ocho objetivos anteriores.

3.2.1. Objetivo 1: Formatos soportadosEl primer objetivo consiste en permitir trabajar con aquellos formatos de documentos de

hojas de cálculo de los programas más extendidos: Microsoft Excel y OpenOffice.org Calc.Concretamente los formatos permitidos serán: xlt, xls, xlsx, ods y odt. Con este objetivo sepretende que se pueda trabajar de manera homogénea y sencilla con cualquier documento dehojas de cálculo independientemente de su formato.

3.2.2. Objetivo 2: Operaciones permitidasEl segundo objetivo fija las operaciones que se pretenden ofrecer para trabajar con docu-

mentos de hojas de cálculo que tengan alguno de los formatos soportados, estas operacionesson:

1. Crear nuevos documentos: se permitirá crear nuevos documentos de hojas de cálculopara poder trabajar con ellos, y luego poder almacenar las modificaciones realizadas.

2. Abrir documentos: se permitirá abrir documentos de hojas de cálculo creados ante-riormente por OpenSheet o por otros programas siempre y cuando su formato estesoportado.

3. OBJETIVOS DEL PROYECTO 35

3. Extraer datos: se permitirá extraer datos numéricos y textos de las celdas que formanparte de las distintas hojas de cálculo del documento.

4. Insertar datos: se permitirá insertar datos en las distintas celdas de las hojas de cálculodel documento, ya sean datos numéricos o textos.

5. Crear hojas de cálculo: se permitirá crear nuevas hojas de cálculo dentro de un docu-mento.

6. Eliminar hojas de cálculo: se permitirá eliminar hojas de cálculo que forman parte deun documento.

Todas las operaciones deben ofrecer una forma de uso sencilla.

3.2.3. Objetivo 3: Conversiones entre formatosEl tercer objetivo es permitir de manera automática y sencilla la conversión de documentos

de hojas de cálculo entre los diferentes formatos soportados, siempre que los elementosincluidos en el formato de origen sean compatibles con los elementos del formato destino.

3.2.4. Objetivo 4: Exportación a pdfEl cuarto objetivo consiste en dar la opción de exportar al formato PDF un documento de

hojas de cálculo que tenga alguno de los formatos permitidos.

3.2.5. Objetivo 5: MultiplataformaEl quinto objetivo es conseguir que el proyecto sea multiplataforma, de manera que se per-

mita su uso en diferentes sistemas operativos, concretamente, se debe soportar los sistemasoperativos GNU/Linux y Windows.

3.2.6. Objetivo 6: LibreríaEl sexto objetivo consiste en proporcionar una librería o API que cumpla con todos los

objetivos anteriores, de manera que permita incorporar la funcionalidad proporcionada enotras aplicaciones.

3.2.7. Objetivo 7: ComandoEl séptimo objetivo consiste en usar la librería del objetivo anterior para implementar una

herramienta o comando que permita realizar las operaciones de inserción y extracción de da-tos, la conversión entre formatos y la exportación a PDF. Este comando debe estar preparadopara ejecutarse desde un terminal del sistema, lo que permitirá automatizarlo fácilmente parausarlo en trabajo por lotes.

36 3. OBJETIVOS DEL PROYECTO

3.2.8. Objetivo 8: Servicio webEl último objetivo consiste en usar la librería del sexto objetivo para implementar un ser-

vicio web que permita, al igual que el comando, realizar las operaciones de inserción yextracción de datos, la conversión entre formatos y la exportación a PDF. Al tratarse de unservicio web permitirá trabajar con los documentos de hojas de cálculo de forma remota.

Capítulo 4

Método y entorno de trabajo

E N este capítulo se va a describir tanto el método como el entorno de trabajo del pro-yecto. En el método de trabajo se pretende en primer lugar ofrecer una descripción

de las metodologías utilizadas para conocer en qué consisten, y luego explicar cómo se hanadaptado para poder usarlas en el marco de trabajo de un proyecto fin de carrera. En en elentorno de trabajo se enumerarán las diferentes herramientas y aplicaciones software usadasa lo largo del desarrollo, con una breve descripción de para qué sirven y cómo se han usadoen el proyecto.

4.1. Método de trabajo

En esta sección se describe el método de trabajo usado para el desarrollo del proyecto, ylas metodologías en las que se basa dicho método. Concretamente el método de trabajo sebasa en el uso de metodologías ágiles: Scrum que se ha usado para la planificación y gestióndel proyecto, y Test Driven Development (desarrollo dirigido por test) que se ha utilizadocomo metodología de desarrollo. A continuación, se describirá con mayor detalle en quéconsisten estas metodologías ágiles utilizadas y cómo se han adaptado para su aplicación enel proyecto realizado.

4.1.1. Metodologías Ágiles

Si por algo se caracteriza el método de trabajo utilizado es por que se basa en el uso demetodologías ágiles, por lo que antes de entrar a definir las metodologías concretas que sehan usado es importante conocer el concepto de metodología ágil.

Las metodologías de desarrollo ágiles son metodologías de desarrollo software basadas enel desarrollo iterativo, donde se considera que los requisitos y las soluciones van evolucio-nando a lo largo de todo el desarrollo, y por tanto se da más importancia a la capacidad deadaptarse rápidamente a esos cambios que a la capacidad para aplicar medidas de contingen-cia que eviten que los cambios detectados afecten a la planificación establecida.

37

38 4. MÉTODO Y ENTORNO DE TRABAJO

Manifiesto Ágil

El término de desarrollo ágil de software fue acuñado en el 2001 cuando un grupo dedesarrolladores convocados por Kent Beck se reunió para discutir sobre los métodos dedesarrollo de software ligeros, de esa reunión surgió el manifiesto del desarrollo de softwareágil [BBvB+01]:

Estamos descubriendo formas mejores de desarrollarsoftware tanto por nuestra propia experiencia comoayudando a terceros. A través de este trabajo hemosaprendido a valorar:

Individuos e interacciones sobre procesos y herramientasSoftware funcionando sobre documentación extensivaColaboración con el cliente sobre negociación contractualRespuesta ante el cambio sobre seguir un plan

Esto es, aunque valoramos los elementos de la derecha,valoramos más los de la izquierda.

Los doce principios que sigue el manifiesto ágil [BBvB+01] son:

1. Nuestra mayor prioridad es satisfacer al cliente mediante la entrega temprana y conti-nua de software con valor.

2. Aceptamos que los requisitos cambien, incluso en etapas tardías del desarrollo. Losprocesos Ágiles aprovechan el cambio para proporcionar ventaja competitiva al clien-te.

3. Entregamos software funcional frecuentemente, entre dos semanas y dos meses, conpreferencia al periodo de tiempo más corto posible.

4. Los responsables de negocio y los desarrolladores trabajamos juntos de forma cotidia-na durante todo el proyecto.

5. Los proyectos se desarrollan en torno a individuos motivados. Hay que darles el en-torno y el apoyo que necesitan, y confiarles la ejecución del trabajo.

6. El método más eficiente y efectivo de comunicar información al equipo de desarrolloy entre sus miembros es la conversación cara a cara.

7. El software funcionando es la medida principal de progreso.

4. MÉTODO Y ENTORNO DE TRABAJO 39

8. Los procesos Ágiles promueven el desarrollo sostenible. Los promotores, desarrolla-dores y usuarios debemos ser capaces de mantener un ritmo constante de forma inde-finida.

9. La atención continua a la excelencia técnica y al buen diseño mejora la Agilidad.

10. La simplicidad, o el arte de maximizar la cantidad de trabajo no realizado, es esencial.

11. Las mejores arquitecturas, requisitos y diseños emergen de equipos auto-organizados.

12. A intervalos regulares el equipo reflexiona sobre cómo ser más efectivo para a conti-nuación ajustar y perfeccionar su comportamiento en consecuencia.

Con estos doce principios queda patente qué es un desarrollo ágil y qué persigue. Ahorase van a analizar las ventajas que se obtienen con estos principios.

El primer principio de entregar al cliente software que funciona a lo largo de todo el desa-rrollo tiene varias ventajas. La primera de ellas es que con cada entrega se puede obtenerrealimentación continuamente del cliente, de manera que este se implique directamente enel proyecto al usar dichos artefactos generados, y transmitiendo si lo que se va entregandocorresponde a lo esperado o si se detectan nuevas necesidades. Esto hace que sin asistir areuniones periódicas del proyecto, cosa que la mayoría de veces para el cliente no es posible,el cliente esté implicado durante todo el desarrollo. Otra ventaja es que el cliente puede em-pezar a cubrir las necesidades del producto sin tener que esperar a que el proyecto finalice,que muchas veces son periodos de tiempos excesivamente largos que provocan que se acaberechazando el producto en beneficio de otros productos ya terminados existentes en el mer-cado. Por último, la ventaja desde el punto de vista económico es que se puede ir facturandocon cada entrega.

El segundo principio que dice que hay que asumir y reaccionar frente a los cambios en losrequisitos en cualquier etapa, es uno de los más importantes puesto que permite adaptarserápidamente a nuevas necesidades que surjan en el mercado, ofreciendo a la empresa unagran ventaja competitiva frente a aquellas que tienen modelos de desarrollo más pesados yque no podrán llegar a ciertas oportunidades del mercado. Este principio unido al primero,que habla de ir entregando software con funcionalidad, permite una reacción muy rápida a loscambios, y por tanto adaptarse al funcionamiento actual del mercado donde las tecnologíasy necesidades cambian muy rápidamente.

En los diferentes principios se puede observar que las metodologías ágiles dan mucha im-portancia a las personas que forman el equipo de desarrollo y a su comunicación, y ademásque implican a los responsables del negocio. Todo lo anterior unido a la posibilidad de irentregando software a lo largo del proyecto hace posible que dichas entregas reflejen com-pletamente las necesidades comerciales de la empresa. Por ejemplo, si se tiene la necesidad


de disponer de demostraciones técnicas para que el departamento comercial pueda usarlasmientras el proyecto de desarrollo avanza, y así poder buscar clientes, se pueden enfocarlas entregas para cumplir con ese objetivo. Como las entregas que se van a usar en las de-mostraciones siguen siendo el producto, con funcionalidad reducida, y no requieren que sededique más tiempo a cumplir este objetivo, el tiempo y coste no varían, lo único necesarioes priorizar los requisitos en función de las necesidades.

Por último, otra ventaja muy importante que se puede obtener de algunos de los objetivos,es que se persigue el mejorar constantemente el proceso de desarrollo a través de tratar demaximizar la reutilización, de perseguir el buen diseño y la excelencia técnica, y sobre todocon las reflexiones colectivas periódicas que permiten analizar que se ha hecho mal paracorregirlo y que se ha hecho bien para potenciarlo.

4.1.2. ScrumEn esta sección no se pretende dar una explicación extensa y profunda de Scrum, para eso

se cuentan con libros y referencias en la web, si no que el objetivo perseguido es dar unavisión global de Scrum y sus principales conceptos para entender en otros capítulos cómo seha adaptado su uso en el proyecto, y comprender mejor el capítulo de resultados.

¿Por qué usar Scrum?

El escenario de negocio ha cambiado de manera que las necesidades tecnológicas cambianrápidamente y aparecen otras nuevas, por lo que es necesario que los proyectos cuenten conuna gran velocidad a la hora de reaccionar a esos cambios para dar una respuesta rápida quese traduzca en los productos reclamados por el mercado.

Algunos autores [Pal07] comentan que puede que estemos en una etapa en la que ha dejadode existir el concepto de producto final, y en su lugar existen productos en continua evolucióna partir de los incrementos de funcionalidad de las versiones iniciales o versiones beta de unproducto. De esta manera, el producto va cambiando e incorporando los nuevos requisitospara ofrecer cada poco tiempo nuevas versiones.

Para permitir llevar a cabo proyectos cuyos productos se adapten de manera rápida a lasnecesidades del mercado, existe una metodología ágil para la gestión de proyectos llamadaScrum.

¿Qué es Scrum?

Scrum es una metodología ágil que define un marco de trabajo iterativo e incrementalpara la gestión de proyectos. Esta metodología gestiona proyectos basándose en un modeloágil, cuyo objetivo es permitir adaptarse rápidamente a cambios en los requisitos en lugar deintentar identificar todos los requisitos necesarios al comienzo del proyecto.


Scrum ofrece un conjunto de prácticas y roles que pueden usarse como modelo de refe-rencia para definir el proceso de desarrollo concreto que se ejecutará en los proyectos. Acontinuación se definen estos roles y conceptos.

Roles

En Scrum se pueden identificar los siguientes roles implicados directamente en el proce-so:

Dueño de poducto (product owner): es el responsable de representar y asegurarse quese cumple con la perspectiva de negocio y los intereses del cliente. Las tareas querealiza son:

• Añadir nuevos requisitos o historias de usuario en la pila de producto (product

backlog).

• Priorizar las historias de usuario.

• Comprobar al finalizar un período de desarrollo (sprint) que el producto resul-tante cumple con los objetivos comprometidos.

Scrum master: es el responsable de que el equipo cumpla sus objetivos al finalizar elsprint y de que se cumplan las reglas de Scrum. Las tareas que realiza son:

• Convoca y dirige las reuniones para realizar las estimaciones de historias y di-visión en tareas. Tanto las estimaciones como la división en tareas las realizaconjuntamente todo el equipo.

• Dirige las reuniones diarias de seguimiento llamadas scrum.

• Asigna a los miembros del equipo aquellas tareas que no han sido seleccionadasde manera voluntaria.

Miembro de equipo (Scrum member): es el encargado de cumplir con las tareas ele-gidas o asignadas para que el equipo logre alcanzar el objetivo marcado en el sprint.En Scrum los equipos son multidisciplinares por lo que un miembro de equipo puedeser un desarrollador, diseñador, etc.

En la figura 4.1 se pueden ver los tres roles principales con el elemento del que es respon-sable cada uno: el dueño de producto es el responsable de la gestión de la pila de producto,el Scrum master es el responsable de la gestión de los sprints, y el miembro del equipo esresponsable de implementar las historias y tareas asignadas.

A parte de los roles anteriores, directamente implicados en el proceso de Scrum, existenotros roles muy importantes que participan a través de la realimentación o feedback a partirdel análisis o uso de los productos generados en los sprints. Algunos de estos roles son:clientes, usuarios, gerentes, comerciales, etc.


Figura 4.1: Roles de Scrum

Pila de Producto

La pila de producto (product backlog) es una lista priorizada de todos los requisitos ohistorias de usuario que se desean implementar en el producto. Estas historias de usuario,que es como se llaman a los requisitos en Scrum, son definidas usando la terminología deldueño de producto de modo que pueda trabajar con ellas sin problemas.

La pila de producto es algo muy dinámico, donde se añaden historias conforme se de-tectan nuevas necesidades, y donde la priorización va cambiando para que al principio dela pila estén siempre las historias que se quieren implementar primero. El mantenimiento ypriorización de la pila es llevado a cabo por el dueño de producto.

Sprint

Un sprint es el periodo de tiempo o iteración con un objetivo concreto, durante el cuál seimplementan aquellas historias planificadas dando como resultado un incremento funcionaldel producto. Normalmente la duración de los sprints no suele exceder los dos meses dedesarrollo para cumplir con los principios del manifiesto ágil.

Un proyecto implementa las historias de la pila de producto a través de su planificaciónen sprints. El número de historias que se pueden planificar para que se implementen en cadasprint depende por un lado de la estimación en tiempo de cada historia y por otro de lavelocidad del equipo.

En la figura 4.2 se puede ver ilustrado la representación de un sprint, donde primero seseleccionan en orden las historias que están en la pila de producto y se asignan al sprintque se va a comenzar, después se inicia el sprint y una vez ha transcurrido el tiempo fijadopara su desarrollo se obtiene como resultado el producto con las nuevas funcionalidadesimplementadas.

Antes del comienzo de un sprint se realiza una reunión del equipo con el dueño de productopara decidir que historias se van a llevar a cabo en ese sprint, para ello las historias deben


Figura 4.2: Representación de un sprint de Scrum

estar estimadas, pues se irán añadiendo al sprint en el orden establecido en la pila, hastaalcanzar la cantidad máxima de trabajo que puede realizar el equipo, medida dada por lavelocidad de equipo.

Durante el desarrollo del sprint se utiliza un diagrama llamado burn-down, ver figura 4.3en el que se representa el estado de la implementación de las historias. Con este gráfico sepuede comprobar de manera visual si el sprint sigue con la planificación establecida, o seestá produciendo alguna desviación positiva o negativa, de manera que se pueda corregirrápidamente.

Al final del sprint se analiza el resultado del mismo y se hace un análisis de todo lossucedido como por ejemplo si se ha cumplido completamente con la planificación,los fac-tores que han puesto en peligro el funcionamiento del mismo, qué cosas mejorar o cambiar,etc.

Scrum

Scrum es una reunión diaria, de no más de quince minutos, que realiza todo el equipo ydonde se analiza el estado de las tareas. Esta reunión, que da nombre a la metodología, esuna potente herramienta de comunicación para todo el equipo, puesto que permite conocerque está haciendo cada miembro, detectar los problemas encontrados y además analizar lasituación global del sprint.

4.1.3. Adaptación de Scrum al marco de trabajoEn esta sección se va a explicar como se ha adaptado la metodología Scrum para poder

usarse en la gestión de un proyecto fin de carrera.

Para la definición del proceso de Scrum se ha partido de las recomendaciones y experien-cias transmitidas por Henrik Kniberg en su libro [Kni07], y una adaptación posterior debido


Figura 4.3: Ejemplo de gráfico de burndown de un sprint

a las características propias del entorno donde se debían aplicar. Las características a teneren cuenta en el proyecto son:

Normalmente al aplicar Scrum se habla de un equipo de desarrollo de varias personasy en este caso sólo existen dos personas para abordar el proyecto: el alumno que deberealizar el proyecto fin de carrera, y el director que tiene la labor de orientar durante eldesarrollo del mismo.

En este caso concreto, el alumno no se puede dedicar a jornada completa al desarrollodel proyecto. El motivo es que el alumno trabaja a tiempo completo en otros proyectos,lo que hace que el número de horas diarias a dedicar sean muy limitadas, aumentandola dificultad de la gestión y planificación del proyecto.

Roles asignados

Cuando se habla de Scrum se habla de equipos de desarrollo y en el caso de un proyectofin de carrera sólo hay un miembro de equipo, el alumno que lo va a realizar, y por otrolado está el director de proyecto cuyo objetivo es orientar durante el desarrollo del proyecto.Siguiendo el funcionamiento de Scrum es necesario que los principales roles del procesosean asignados, pero en este caso teniendo en cuenta el número tan reducido de personas conlas que se cuenta para que la asignación de los roles encajen lo mejor posible. Los roles sevan a asignar de la siguiente forma:

El dueño del producto será el director del proyecto pues tiene la capacidad de identi-


ficar las prioridades que deben cumplirse para lograr tener un producto con la calidadsuficiente para que sea aceptado por el cliente. En este caso el cliente es el tribunalque debe evaluar el proyecto, y el producto es el proyecto fin de carrera que siga lanormativa académica establecida.

El rol Scrum master será llevado a cabo por el alumno pues uno de los objetivos delproyecto fin de carrera debe ser demostrar las aptitudes para la planificación y gestiónde proyectos.

El último rol por asignar es el de miembro de equipo que debe ser llevado a cabo porel alumno, donde tendrá el papel de desarrollador.

Por tanto el director de proyecto asumirá la responsabilidad de establecer la prioridad delas tareas siempre en comunicación con el Scrum master y será quién evalúe las entregas odemostraciones realizadas al finalizar cada sprint.

El alumno a parte de llevar el trabajo de desarrollo deberá gestionar el proyecto, realizandola estimación de las historias. Además la planificación de los sprints se deberán realizar conla aprobación del dueño de producto.

Identificación de historias: pila de producto

La pila de producto, siguiendo en parte las indicaciones del libro anteriormente mencio-nado [Kni07], se realizará de manera que a cada historia se le van a asignar los siguientescampos:

ID: Es el identificador único de la historia que permite hacer el seguimiento durantetodo el desarrollo permitiendo así que cambie de nombre en algún momento si seconsidera adecuado. El identificador usado será un numero entero para las historias,y para las subhistorias un número decimal donde la parte entera será el identificadorde la historia padre. Así si una hay dos subhistorias que parten de la historia con id 3,entonces esas subhistorias tendrán como ids 3.1 y 3.2 respectivamente.

Nombre: Es nombre descriptivo de la funcionalidad que representa, debe ser entendidapor el dueño de producto.

Descripción: Es una pequeña descripción con detalles concretos donde se explica enqué consiste la historia.

Estimación: Es la estimación inicial del tiempo que va a tardar en realizar la historia.La estimación se da en puntos historia que se explicarán más adelante.

Cómo probarlo: Es una descripción de los test que se deben realizar con éxito paraentender que la historia ha sido completada. Esto como se verá más adelante se podráutilizar como punto de entrada en el desarrollo dirigido por tests.


Notas: Son detalles a tener en cuenta a la hora planificar la historia en algún sprint.En estos detalles se pueden incluir por ejemplo las dependencias entre historias, demanera que si el dueño de producto quiere alguna tarea que dependa de otra, ambasdeben ser planificadas en el sprint o esperar a que la dependencia esté terminada.

Importancia: Es valor numérico asignado por el dueño de producto y que prioriza lapila de producto. No existe un valor máximo, simplemente cuanto mayor sea el númeromás importante es la historia. Es recomendable no usar valores secuenciales a la horade asignar las prioridades para permitir, en caso de necesitarse, que las historias nuevaspuedan situarse entre medias de historias ya existentes.

Aunque en otros proyectos normalmente no se planifican todas las historias en sprints di-rectamente, sino que se planifican aquellas que corresponden a un sprint, es decir, se haceuna planificación de sprint en sprint; en este proyecto al tener una fecha límite para su fi-nalización, es necesario realizar la planificación completa para conocer así el tiempo quese necesita para completarlo. Para ello se debe realizar la asignación de todas las tareas ensprints y comprobar así si con esa planificación inicial se dispone del tiempo suficiente.

División en Sprints

En esta adaptación de Scrum se ha asignado a cada sprint una duración de una semana,de manera que al final de cada semana se haga una reunión de sprint o se envíe un correo aldueño del producto donde se muestren las historias completadas. El objetivo es analizar laevolución del proyecto y de los productos semanalmente; de esta manera se permite detectarlas posibles desviaciones de tiempo muy rápidamente, puesto que en este caso concreto elalumno no puede tener dedicación completa en el proyecto y eso provoca que toda desviaciónpueda desembocar en un retraso excesivo. Así en el caso de detectar una desviación unasemana, se usará como medida correctora, siempre que sea posible, el aumento el número dehoras a dedicar en el siguiente sprint; una forma de aumentar el número de horas puede sermediante el uso de días de vacaciones del trabajo principal.

Para poder realizar la división en sprints primero hay que establecer la velocidad de desa-rrollo del equipo de Scrum, y cómo se miden los puntos por historia. En este proyecto seha decidido que 4 puntos de historia corresponde a una semana de desarrollo dedicando 27horas de trabajo que son las horas que el miembro del equipo puede dedicar sin hacer unasobre-estimación, por tanto, la velocidad de equipo se establecerá en 4 puntos.

Herramienta para planificación

Para poder llevar la planificación se usará un documento de hojas de cálculo con tres hojasdonde se guardará toda la información necesaria para realizar la planificación siguiendo laadaptación de Scrum:


Semanas: en esta hoja se muestra la información de todas las semanas disponibleshasta la fecha límite de entrega del proyecto, y en cada una de ellas toda la informaciónresumen de la planificación. Esta tabla tiene los siguientes elementos:

• Semana: indica el número de semana.

• Comienzo: indica que día del mes comienza la semana de trabajo.

• Fin: indica que día del mes en el que finaliza esa semana de trabajo.

• Objetivo: es el nombre del objetivo que persigue el sprint planificado esa semana.

• Historias: contiene los identificadores de las historias planificadas para esa se-mana.

• Velocidad estimada: es la velocidad que se ha estimado que tendrá el equipo.

• Velocidad real: es la velocidad final que el equipo ha tenido en esa semana.

• Completado Fecha: contiene la fecha real en la que se han terminado todas lashistorias del sprint.

Historias: en esta hoja se muestra la información en detalle de todas las historias ysubhistorias con todos los elementos que contiene una historia excepto el campo queindica la importancia. Esta hoja sirve para poder conocer los detalles concretos decada historia de manera que tiene como principales usuarios los roles de Scrum master

y miembro de equipo, puesto que será la hoja que usen para estimar y para conocerque se debe implementar en cada historia.

Product Backlog: es la hoja que representa la pila de producto, y por tanto la que debeusar el dueño de producto para priorizar las historias. Esta hoja contiene una tabla conlos siguientes elementos:

• ID: indica el identificador de la historia.

• Nombre: indica el nombre de la historia para que el dueño de producto puedaidentificarla mejor.

• Importancia: es el valor numérico que le debe asignar el dueño de producto,cuanto mayor sea el valor más importancia tendrá. Las historias más importanteestán más arriba de la pila siendo las primeras en implementarse.

• Estimación: son los puntos de historia estimados que indican la duración de esahistoria. Hay que tenerlos en cuenta a la hora de poder asignar historias a unsprint.

• Sprint: Identificador del sprint al que se ha asignado la historia.

• Velocidad estimada: es la velocidad que se ha estimado que tendrá el equipo enese sprint.


• Velocidad real: es la velocidad final que el equipo ha tenido en en ese sprint.

• Estado: indica si la historia ha sido completada, es decir, se ha probado quecumple con lo establecido en el campo de cómo probarlo.

Las tres tablas anteriores en un documento de hojas de cálculo, junto con las opcionesque proporciona OpenOffice.org Calc como son la de reordenar por el valor de un campo,añadir nuevas historias, mover elementos, etc; es suficiente para llevar la información deplanificación y gestión del proyecto.

4.1.4. Desarrollo dirigido por testsEl desarrollo dirigido por test o TDD es una técnica ágil de diseño y desarrollo de software

que se caracteriza por comenzar primero con la creación de los test unitarios que pruebanlos requisitos del proyecto, creando a continuación el código que cumple con esas pruebas,es decir, que a partir de esas pruebas se realiza la implementación de los requisitos. De estacaracterística recibe su nombre, pues son los test unitarios los que dirigen el desarrollo. Latécnica de TDD se basa en tres pilares fundamentales [Car10] :

1. La implementación de sólo aquellas funciones que son necesarias, y ninguna más. Setrata de evitar el hecho de generar código para tratar de adaptarse a posibles cambios,cuando en realidad sólo se está tratando de prever futuros cambios, cosa en que lasmetodologías ágiles no es necesario, pues frente a la necesidad de predicción está lade adaptación.

2. Minimizar el número de defectos que se introducen en el software durante la fase deproducción.

3. Hacer que el software sea modular, altamente reutilizable y preparado para el cambio.

Para usar esta técnica hay que seguir un simple algoritmo de tres pasos.

Algoritmo TDD

El algoritmo para utilizar la técnica de TDD es el siguiente:

1. Escribir la especificación del requisito a través de un test.

2. Implementar el código que cumple con dicho requisito, es decir, que haga superar eltest.

3. Refactorizar el código duplicado.


Figura 4.4: Algoritmo TDD: Rojo, Verde, Refactorizar.

A partir de estos simples pasos se consigue un código en el que se reduce mucho el número dedefectos introducidos, y cuyo diseño emerge a partir de las sucesivas refactorizaciones.

En la figura 4.4 se puede ver ilustrado el algoritmo de TDD donde se representan los pasosusando los colores que suelen mostrar los frameworks de pruebas. Usando la metáfora de loscolores, los pasos son: rojo, verde y refactorizar.

1. El rojo representa el test escrito que falla al ejecutarse puesto que todavía no existeuna implementación del requisito a probar.

2. El verde representa que se supera el test, lo que indica que se ha escrito el código queimplementa el requisito y es correcto.

3. El último paso siempre es refactorizar.

Es muy importante que se siga el algoritmo manteniendo el orden y sin saltarse ningúnpaso. La ventaja de definir primero los test es que se comprueban que estos fallan, pues aveces los test están mal escritos y no fallan nunca por lo que no cumplen con su función. Larefactorización es muy importante pues va generando un diseño emergente más sencillo ymantenible.

4.1.5. Adaptación de TDD al marco de trabajoTDD es una técnica definida dentro de la programación extrema o XP que es una metodo-

logía ágil de desarrollo. En el proyecto se adoptará esta técnica directamente como metodo-logía de desarrollo, sin usar otras técnicas definidas en XP.

El uso de TDD se complementa perfectamente con Scrum, pues cada historia lleva aso-ciado un campo llamado cómo probarlo que sirve de base para generar los test necesarioscon los que comienza el algoritmo de TDD. Al usar ese campo como base de las pruebas, seestá garantizando que cuando se termina de escribir el código de una historia, siguiendo elalgoritmo de TDD, se termina la historia, es decir, que cumple con lo establecido en el campocómo probarlo.


4.2. Entorno de trabajoPara poder llevar a cabo el proyecto, durante todo el desarrollo del mismo se ha hecho uso

de diferentes recursos software; a continuación, se comentan las más destacables agrupadassegún su tipo.

4.2.1. Herramientas de desarrolloEn esta sección se nombran aquellas herramientas que se han usado para llevar a cabo el

desarrollo del proyecto; entre ellas se encuentran las herramientas con las que se han gene-rado directamente los artefactos software, las librerías incluidas en el proyecto, las libreríasusadas para las llevar a cabo las pruebas y también el software usado para la gestión y con-trolar del desarrollo.

NetBeans IDE

NetBeans IDE [Orab] es un entorno de desarrollo integrado (IDE) multiplataforma conlicencia libre para desarrollos realizados principalmente con el lenguaje de programaciónJava, aunque a través de sus plugins también permite ser usado con de otros lenguajes co-mo C/C++, PHP, Ruby, etc. Gracias a la gran cantidad de plugins disponibles permite laintegración con gran cantidad de aplicaciones y frameworks.

Netbeans ha sido el IDE usado para el desarrollo de todos los artefactos software del pro-yecto: librería, comando y servicio web.

Java Development Kit

El JDK o kit de desarrollo de Java [Oraa] es el software que proporciona las herramientasnecesarias para compilar, depurar y ejecutar programas en Java.

Para el desarrollo del proyecto se ha utilizado el JDK con versión 6.

Subversion

Subversion [Foub] es un sistema de control de versiones centralizado con licencia libre.

Subversion se ha usado tanto para el control de versiones de los tres artefactos de softwaregenerados con el proyecto como para la documentación.

OpenOffice.org SDK

OpenOffice.org SDK [Orad] es un kit de desarrollo que proporciona las librerías con lasinterfaces necesarias para hacer uso de las funcionalidades de la suite ofimática OpenOffi-ce.org desde otras aplicaciones, y además, permite crear nuevos componentes o extensionespara incorporarlos a las aplicaciones que forman parte de la suite.

En el proyecto se ha hecho uso de OpenOffice.org SDK, concretamente de la versión 3.2,


para proporcionar acceso a OpenOffice.org Calc desde la librería creada, y así incorporarla funcionalidad necesaria para realizar las operaciones con documentos de hojas de cálcu-lo.

JUnit

JUnit [KB] es un framework para realizar pruebas unitarias de aplicaciones escritas enJava.

En el proyecto se ha usado JUnit con la versión 4.8.2, con el cual se han creado las cla-ses y método de pruebas unitarias y de integración usados para dirigir el desarrollo de losdiferentes artefactos software creados.

Mockito

Mockito [Fab] es un framework para realizar pruebas con el uso de mocks y objetos es-pía.

Un mock es un objeto sin funcionalidad que simula ser objeto de una determinada clase,ofreciendo la posibilidad de ser programado para que frente a determinadas condicionestenga un cierto comportamiento, como puede ser el caso de lanzar una excepción si se llamaa un método con ciertos valores o simplemente devolver un valor concreto. Estos objetospermiten que se registre el uso que se hace de ellos para posteriormente comprobar que se hahecho el uso esperado, comprobando los métodos invocados y los valores utilizados en lasllamadas.

Un objeto espía al contrario que un mock tiene la misma funcionalidad que la de cualquierotro objeto de la clase que va a espiar, pero añadiendo las funcionalidades que proporcionaun mock, es decir, permite programar el comportamiento al realizar la invocación de ciertosmétodos y mantiene un registro del uso realizado del objeto.

Mockito se ha usado en el proyecto, concretamente la versión 1.8.5, para realizar pruebasunitarias a través de sus mocks y objetos espías que han hecho posible realizar ciertas pruebasbajo determinadas condiciones controladas y realizar la prueba de componentes de maneraaislada.

PowerMock

PowerMock [Jay] es un framework de pruebas que extiende las funcionalidades de otrosframeworks de mocks, a través de su cargador de clases personalizado y de la modificacióndel bytecode, de manera que permite realizar la simulación de métodos estáticos y privados.PowerMock puede ser usado con los frameworks EasyMock y Mockito.

PowerMock se ha usado en el proyecto, concretamente la versión 1.4.8, para aumentarla funcionalidad de Mockito, de manera que en la pruebas unitarias fuera posible simular y


espiar métodos estáticos y privados.

Groovy

Groovy [Spr] es un lenguaje de programación interpretado e implementado sobre la pla-taforma Java, y que proporciona una librería con el interprete del lenguaje y con todo lonecesario para permitir el uso de este en otras aplicaciones Java.

En el proyecto se ha usado la librería de Groovy, versión 1.7.9, para incorporar funcionali-dades del interprete del lenguaje tanto en el comando como en el servicio web generados.

JAX-WS

JAX-WS [com] es un API de Java de código abierto para construir servicios web, siendola implementación de referencia de la plataforma Java EE.

JAX-WS, versión 2.2.3, se ha utilizado para crear el servicio web del proyecto.

Apache Tomcat

Apache Tomcat [Fouc] es un contenedor de servlets de Java de código abierto. ApacheTomcat implementa las especificaciones de los servlets y de JavaServer Pages.

En el proyecto se ha usado Apache Tomcat, versión 6.0, como contenedor de pruebas parael despliegue del servicio web desarrollado.

OpenOffice.org Calc

OpenOffice.org Calc [Orac] es una aplicación libre de hojas de cálculo que pertenece a lasuite ofimática de OpenOffice.org.

En el proyecto se ha usado esta aplicación para dos propósitos diferentes, por un ladose ha usado para realizar las pruebas de la librería desarrollada, puesto que hace uso de lasfuncionalidades de Calc para realizar diferentes operaciones con documentos de hojas decálculo; y por otro lado, se ha usado como editor del documento de hoja de cálculos con elque se ha realizado toda la planificación y gestión de proyecto.

4.2.2. Lenguajes de programaciónEn esta sección se nombran aquellos lenguajes de programación usados para el desarrollo

del proyecto.

Java

Java es un lenguaje de programación de alto nivel orientado a objetos, que fue desarro-llado por James Gosling en Sun Microsystem y liberado en 1995. Java toma en su sintaxismuchos elementos de C y C++, e incorpora mecanismos para una gestión automática de la


memoria.

Las aplicaciones Java pueden ser multiplataforma gracias a que son compiladas en un len-guaje intermedio llamado bytecode y que es interpretado por la Máquina Virtual de Java oJVM, de manera que pueden ejecutarse en cualquier plataforma que cuente con una imple-mentación de JVM.

Todos los artefactos software del proyecto: la librería, el comando y el servicio web, hansido desarrollados usando Java como lenguaje de programación.

Groovy

Groovy [Spr] es un lenguaje de programación, interpretado y orientado a objetos, imple-mentado sobre la plataforma Java. Este lenguaje tiene una sintaxis muy parecida a Java, ypermite utilizar tanto APIs como librerías de Java desde los scripts; además, las clases deGroovy pueden ser usadas desde aplicaciones Java, al poder ser compiladas en bytecodeentendible por la Máquina Virtual de Java o JVM.

Groovy ha sido usado en el proyecto para crear los scripts de funcionalidad básica queofrecen tanto el comando como el servicio web desarrollados.

4.2.3. Herramientas de documentación

En esta sección se nombran aquellas herramientas utilizadas para llevar a acabo toda ladocumentación del proyecto.

LATEX

LATEX [Pro] es un sistema de composición de textos usado como estándar de facto para lapublicación de documentos científicos.

Para el desarrollo de la memoria del proyecto se ha utilizado LATEX.

Eclipse con Texlipse

Eclipse [Foue] es un entorno de desarrollo integrado o IDE multiplataforma y de códi-go abierto para desarrollos realizados principalmente con el lenguaje de programación Ja-va, aunque a través de sus plugins también permite ser usado con de otros lenguajes comoC/C++, PHP, etc.

Texlipse [OKvLV] es un plugin de Eclipse IDE para soporte de proyectos en LATEX.

En el proyecto se ha usado Eclipse con el plugin Texlipse para el desarrollo de la docu-mentación en LATEX.


Umbrello UML Modeller

Umbrello UML Modeller [umb] es una herramienta de código abierto que permite creardiagramas UML.

En el proyecto se ha usado la herramienta Umbrello para la creación de los casos de usosy el resto de diagramas UML incluidos en la documentación.

Gimp

Gimp [Tea] es una aplicación software para edición de imágenes digitales de código abier-to.

Gimp se ha utilizado en el proyecto para la edición de imágenes usadas en la documenta-ción.

Inkscape

Inkscape [ink] es una aplicación libre para la generación de imágenes vectoriales. Inksca-pe se ha utilizado en el proyecto para la generación de imágenes usadas en la documenta-ción.

OpenOffice.org Draw

OpenOffice.org Draw [ooo] es una aplicación software para la generación de imágenesperteneciente a la suite OpenOffice.org.

OpenOffice.org Draw se ha utilizado en el proyecto para la generación de imágenes usadasen la documentación.

4.2.4. Sistemas OperativosEn esta sección se nombran los sistemas operativos usados durante el desarrollo del pro-

yecto.

Ubuntu GNU/Linux

Para el desarrollo del proyecto y su documentación se ha usado el sistema operativo Ubun-tu GNU/Linux compilado para la arquitectura i386.

Windows Vista

El sistema operativo Windows Vista, en su versión de 32 bits, ha sido utilizado únicamentepara realizar las pruebas que permiten comprobar la compatibilidad con Windows de cadauno de los artefactos software generados.

Capítulo 5

Resultados

E N este capítulo se van a explicar los resultados obtenidos al aplicar el método de tra-bajo descrito en el capítulo anterior. Para explicar los resultados el capítulo se divide

en diferentes secciones, donde en la primera sección se va a explicar la fase de análisis yplanificación, luego a lo largo de diferentes secciones se explicará el desarrollo de los sprintsrealizados para cumplir con los objetivos del proyecto, y por último se dedicará una secciónpor cada uno de los cuatro artefactos resultantes de la ejecución del proyecto.

5.1. Análisis y planificaciónEn esta sección se explica el desarrollo de la primera fase del proyecto que se corresponde

con la fase de análisis y planificación en la cual se han realizado las siguientes tareas:

1. Análisis de los requisitos u objetivos del proyecto.

2. Estudio de viabilidad de las alternativas.

3. Planificación del proyecto.

A continuación, se describirá cada una de las tareas.

5.1.1. Análisis de requisitosA partir del análisis de los objetivos del proyecto, ya explicados con detalle en el capítulo

3, y de los requisitos establecidos por la normativa académica para proyectos fin de carreravigente, se pueden extraer 4 historias principales que deben ser abordadas por el proyecto.

1. Librería (API): es la librería que permite la manipulación de documentos de hojas decálculo, con las funcionalidades necesarias para crear nuevos documentos, modificar-los, cambiar el formato y extraer datos.

2. Comando: es un comando preparado para ejecutarse desde un terminal que hace usode la librería que permite la manipulación de documentos hojas de cálculo y ofrece sufuncionalidad con la posibilidad de automatizarse.

55

56 5. RESULTADOS

3. Servicio web: es un servicio web que hace uso de la librería que permite la manipula-ción de documentos de hojas de cálculo, ofreciendo su funcionalidad para que puedaser usada de manera remota.

4. Memoria del proyecto: es la documentación oficial del proyecto exigida por la nor-mativa académica.

A continuación, se van a realizar un análisis de los requisitos.

Librería (API)

Para analizar este requisito u objetivo y poder identificar los actores con los que debeinteractuar se han generado un diagrama de casos de uso básico.

En la figura 5.1 se puede ver el diagrama de casos de uso básico. En este diagrama sepueden distinguir dos actores que van a actuar en el escenario de la librería o API:

Aplicación: es la aplicación que va a usar la librería o API de OpenSheet para podertrabajar con documentos de hojas de cálculo.

Framework o alternativa: es la alternativa que va a usar la librería o API para poderllevar a cabo la funcionalidad con documentos de hojas de cálculo ofrecida. Es decir,la librería va a ser una capa de abstracción de alguna de las alternativas estudiadas enel capítulo de antecedentes.

Figura 5.1: Diagrama de casos de uso básico de API

Además, se pueden distinguir cuatro casos de uso que hacen referencia a los objetivosespecíficos 2, 3 y 4 que hacen referencia a las operaciones que se deben permitir:

5. RESULTADOS 57

Crear documento de hojas de cálculo: este caso de uso contempla la operación decreación de nuevos documentos de hojas de cálculo para poder trabajar con ellos, yluego poder almacenar las modificaciones realizadas.

Modificar documentos de hojas de cálculo: este caso de uso contempla las siguientesoperaciones:

• Inserción de datos en las distintas celdas de las hojas de cálculo del documento.

• Creación de nuevas hojas de cálculo dentro de un documento.

• Eliminación de hojas de cálculo existentes en un documento.

Extracción de datos de un documento de hojas de cálculo: este caso de uso contemplala operación de extracción de datos, tanto numéricos como de texto, de las celdas queforman parte de las distintas hojas de cálculo del documento

Convertir el formato de un documento de hojas de cálculo: este caso de uso contemplalas operaciones que permiten cumplir con los objetivos 3 y 4, es decir, permitir la con-versión de un formato de documento de hojas de cálculo a otro de manera automática,y además la exportación a PDF.

Comando y servicio web

Estos elementos son las que hacen de actor como aplicación en el diagrama de casos deuso de la librería, ver figura 5.1, por tanto ambos se pueden incluir en dicho diagrama eidentificar los actores con los que van a interactuar. En la figura 5.2 se puede ver el diagramade casos de uso básico.

Figura 5.2: Diagrama de casos de uso básico del comando y servicio web

A partir del diagrama de casos de uso de la librería o API se ha identificado la necesi-dad de usar una alternativa o framework que permita trabajar con hojas de cálculo; para ello

58 5. RESULTADOS

se realizará un estudio de viabilidad de las alternativas analizadas en el capítulo de antece-dentes para seleccionar una de ellas como alternativa sobre la que se construirá la libreríaOpenSheet.

5.1.2. Estudio de viabilidad de alternativasPara poder seleccionar una alternativa que sirva para facilitar el trabajo de la API con

documentos de hojas de cálculo y que le permita lograr sus objetivos siendo compatible conla licencia del proyecto, ha sido necesario realizar un estudio de viabilidad de las diferentesalternativas, que además ha servido como documentación base para generar el capítulo deantecedentes.

De entre todas las alternativas estudiadas la única que permite realizar las operacionesdefinidas en los requisitos, trabajar con los formatos deseados y además es compatible con eltipo de licencia del proyecto, es la de usar OpenOffice.org a través de UNO. Esta alternativaademás de ser totalmente viable por cumplir con los requisitos de funcionalidad y licencia,gracias a la cantidad de documentación de desarrollo y uso que existe, al gran soporte yactividad que aporta tanto la comunidad como los desarrolladores, es la que se considera lamejor alternativa para utilizar como base en la creación de la librería OpenSheet.

Por tanto, la librería OpenSheet va a ofrecer una interfaz de uso sencilla que por dentrorealizará todas las operaciones necesarias para hacer uso de las funcionalidades ofrecidaspor OpenOffice.org Calc. De esta manera se aisla a las aplicaciones que usen OpenSheetde la complejidad de usar directamente las funcionalidades de OpenOffice.org a través deUNO.

5.1.3. PlanificaciónUna vez se han identificado las historias principales a partir del análisis de requisitos y

se ha seleccionado la alternativa o framework que se va a utilizar para llevar a cabo lasoperaciones con documentos de hojas de cálculo, se puede comenzar la planificación delproyecto haciendo uso de Scrum.

Preparación de la pila de producto

Lo primero consiste en analizar las cuatro historias identificadas y tratar de estimar lospuntos que les corresponde a cada una, y dividirlas en subhistorias si es necesario, de maneraque se complete la pila de producto inicial.

Las historias son divididas en subhistorias y estimadas por el Scrum master, es decir, por elalumno. Mientras que la prioridad o importancia de cada una, que indican el orden en el quetienen que ser implementadas, es una tarea del dueño del producto, es decir, del director delproyecto; aunque el Scrum master presentar un orden que puede ser tomado como referencia

5. RESULTADOS 59

por el dueño de producto.

Cuadro 5.1: Pila de producto inicial

ID Nombre Descripción Estimación Importancia1 Librería

(API)Librería que permite la manipula-ción de hojas de cálculo. Permitecrear nuevos documentos, modificar-los, cambiar el formato y extraer da-tos.

13.5 ptos 500

1.1 Crear nuevosdocumentos

Se debe poder crear nuevos docu-mentos que tengan uno de los forma-tos permitidos (Excel y OO) a partirde un path (incluyendo el nombre delmismo) y permitir guardarlo.

3 ptos 500

1.5 Convertir elformato deldocumento

Permitir salvar el documento conotro formato diferente (incluyendoPDF).

0.5 ptos 492

1.2 Abrir docu-mentos

Se debe poder abrir un documen-to (en segundo plano) ya existentea partir de su ruta. Además una vezabierto se debe poder recuperar suspestañas u hojas de cálculo.

3 ptos 490

1.3 Modificar ho-jas de cálcu-lo a un docu-mento

Se debe poder realizar las siguien-tes operaciones a un documento: 1)Añadir una nueva hoja de cálculo(tanto con un nombre como sin nom-bre). 2) Borrar una hoja de cálculo(por nombre o posición). 3) Renom-brar una hoja de cálculo.

1 ptos 480

1.4 Insertar valo-res en celdas

Se debe permitir insertar valores dela siguiente forma: 1) Insertar un va-lor de una celda. 2) Insertar un grupode valores en un rango de celdas.

3 ptos 470

1.6 Extraer valo-res de celdas

Se debe permitir extraer valores de lasiguiente forma: 1) Extraer un valorde una celda. 2) Extraer un grupo devalores de un rango de celdas.

3 ptos 460

60 5. RESULTADOS

ID Nombre Descripción Estimación Importancia2 Comando Comando que hace uso de la libre-

ría que permite la manipulación dehojas de cálculo. Permite crear nue-vos documentos, modificarlos, cam-biar el formato y extraer datos.

10.5 ptos 400



4 ptos 400



1 ptos 390



1 ptos 380



2 ptos 370



0.5 ptos 360



2 ptos 350

4.6 ObjetivosPCF

Realizar el capítulo de objetivos delproyecto.

2 ptos 320

5. RESULTADOS 61

ID Nombre Descripción Estimación Importancia3 Servicio Web Servicio web que hace uso de la

librería que permite la manipula-ción de hojas de cálculo. Permitecrear nuevos documentos, modificar-los, cambiar el formato y extraer da-tos.

9.5 ptos 300



2 ptos 300



1 ptos 290



1 ptos 280



2 ptos 270



0.5 ptos 260



2 ptos 250

4 Documentación Se debe realizar la memoria del pro-yecto necesaria para cumplir con lanormativa académica.

18 ptos 200

62 5. RESULTADOS

ID Nombre Descripción Estimación Importancia4.1 Introducción Realizar el capítulo de introducción. 2 ptos 200

4.2 Antecedentes Realizar el capítulo de estudio del es-tado del arte.

4 ptos 190

4.5 Método detrabajo

Realizar el capítulo de método de tra-bajo.

3 ptos 160

4.6 Resultados Realizar el capítulo de método de re-sultados.

2 ptos 150

4.7 Conclusiones Realizar el capítulo de método deconclusiones.

2 ptos 140

4.3 Manual deUNO

Realizar un manual para uso deUNO.

2 ptos x

A partir de la presentación de la pila de producto con las subhistorias, el dueño de productoen función de las estimaciones ha asignado la importancia a cada historia, en la mayoríade los casos respetando el orden inicial dado, pero en otros el orden ha sido cambiado parapoder incluir en cada sprint el máximo número de historias.

Como se puede ver en la tabla 5.1, cada historia se ha dividido en subhistorias y se haestimado de la siguiente manera:

1. Librería (API): se ha estimado en 13.5 puntos y se ha dividido en seis subhistorias.

2. Comando: se ha estimado en 10.5 puntos y se ha dividido en seis subhistorias.

3. Servicio web: se ha estimado en 9.5 puntos y también se ha dividido en seis subhisto-rias.

4. Documentación: se ha estimado en 18 puntos y se ha dividido en siete subhistorias.

Además, el dueño de producto en principio no ha asignado ningún valor a la importanciade la historia 4.3 y aunque en principio se mantiene en la pila de producto posiblemente seelimine pues la generación de un manual de UNO queda fuera de la memoria, y en todo casosería incluido a modo de apéndice.

División en sprints

Una vez se tienen estimadas y priorizadas las historias se deben dividir en sprints, puestoque el dueño de producto las ha priorizado teniendo sobre todo en cuenta el maximizar el

5. RESULTADOS 63

número de historias en cada sprint, simplemente basta con ir cogiendo historias intentandoque la suma de puntos estimados quede lo más cerca posible de 4.

Con la pila de producto inicial, que puesto que es una metodología ágil se permite quecambie con forme se avance en el desarrollo del proyecto y se detecten nuevas necesidades,se han planificado todas las historias, excepto la 4.3, en 13 sprints:

Sprint 1: Crear documentos y guardarlos

Historias : 1.1, 1.5

Velocidad estimada : 3.5

Sprint 2: Abrir y modificaciones de hojas


Velocidad estimada : 4

Sprint 3: Modificaciones de Celdas

Historias : 1.4


Sprint 4: Extraer información de documentos

Historias : 1.6


Sprint 5: Crear documentos con el comando

Historias : 2.1


Sprint 6: Abrir y modificar documentos con el comando

Historias : 2.2, 2.3, 2.4


Sprint 7: Extraer datos y cambiar formato con el comando

Historias : 2.5, 2.6, 4.4


Sprint 8: Web service (crear y abrir documentos)


64 5. RESULTADOS


Sprint 9: Web service (modificar documentos y conversiones de formato)

Historias : 3.3, 3.4, 3.5


Sprint 10: Web service (extraer valores) y Documentación 1



Sprint 11: Documentación 2

Historias : 4.2



Historias : 4.5





Una vez se ha explicado la planificación de comienzo del proyecto, en las siguientes sec-ciones se describirá el desarrollo de cada sprint, donde han aparecido cambios que han modi-ficado las historias y por tanto han variado la planificación inicial en duración y en el númerode sprints.

5.2. Sprint 1: Creación y almacenamiento de documentosEn este primer sprint las historias de producto planificadas son:

Historia 1.1: Crear nuevos documentos

Historia 1.5: Convertir el formato del documento

Ambas historias forman parte de la historia 1 que se corresponde con la creación de una libre-ría o API para la manipulación de documentos de hojas de cálculo. Por tanto como resultadode este sprint se obtendrá esa librería de la historia 1 pero con funcionalidad reducida, siendo

5. RESULTADOS 65

ID Nombre Descripción Estimación Importancia Notas1.1 Crear nuevos

documentosSe debe poder crear nuevos do-cumentos que tengan uno delos formatos permitidos (Excely OO) a partir de un path (inclu-yendo el nombre del mismo) ypermitir guardarlo.

3 ptos 500


Permitir salvar el documentocon otro formato diferente (in-cluyendo PDF).

0.5 ptos 492

Cuadro 5.2: Historias añadidas al Sprint 1

esta la proporcionada por cada una de las historias planificadas. La información resumen delas historias planificadas se puede ver en la tabla 5.2.

A la hora de asignar las historias al sprint, se ha tenido en cuenta que coincide con el co-mienzo del proyecto y en lugar de tratar de planificar 4 puntos de historia, que es lo definidocomo la carga normal, se ha aumentado la prioridad de la historia 1.5 de manera que entreen este sprint y los puntos de historia totales planificados sean 3.5.

A partir de las historias planificadas se define el objetivo del sprint. El objetivo perseguidopor este sprint es el de proporcionar una API o librería con la funcionalidad necesaria paracrear documentos de hojas de cálculo y almacenarlos.

A continuación, se va a detallar el desarrollo de cada una de las historias planificadas eneste sprint.

5.2.1. Historia 1.1 - Crear nuevos documentosLa historia 1.1 consiste en añadir a la librería la funcionalidad necesaria para crear nuevos

documentos de hojas de cálculo, con uno de los formatos admitidos, y guardarlos a partir delpath con el nombre del fichero.

Esta historia se puede dividir a su vez en dos tareas: implementar el mecanismo de comu-nicación con OpenOffice.org Calc, e implementar el código necesario para completar creary guardar nuevos documentos.

Mecanismo de comunicación con OpenOffice.org Calc

Al ser la primera subhistoria que se implementa de la historia 1, librería (API), conllevala tarea, ya incluida en la estimación, de implementar el mecanismo de comunicación conOpenOffice.org Calc. Esta tarea es diferente al resto de los requisitos pues no se va a usar elalgoritmo de TDD para llevarla a cabo, si no que se va a implementar directamente a partir deluso del mecanismo de la clase Bootstrap proporcionada por el SDK de OpenOffice.org.

Al usar el mecanismo de Bootstrap en GNU/Linux se han encontrado dos principales pro-

66 5. RESULTADOS

blemas:

1. No se encuentra el binario de soffice, y se produce el error no office executable found!.

2. Una vez solucionado el problema anterior, al usarse las funciones de UNO para conec-tarse con OpenOffice.org Calc dentro de la clase Bootstrap que hacen uso de libreríasdinámicas, estas no se localizan y se produce el error java.lang.UnsatisfiedLinkError:

createJNI at com.sun.star.lib.connections.pipe.PipeConnection.createJNI.

El primer problema se produce porque la clase Bootstrap intenta crear el proceso sofficeusando como directorio la ubicación del fichero de la clase, es decir, donde se encuentrael fichero juh.jar, y como en GNU/Linux por defecto los jars necesarios para usar UNO nose distribuyen por defecto con OpenOffice.org y tampoco se instalan en ese directorio, elusuario debe conocer este problema para poder solucionarlo copiando los jars necesarios enel directorio donde se encuentre el fichero ejecutable soffice, y luego poner en el classpatheste directorio para que la librería pueda encontrarlos para su uso. Esto complica bastanteal usuario que no le basta sólo con conocer donde tiene el directorio donde se encuentra elejecutable de OpenOffice.org.

El segundo problema se produce porque dentro de la clase Bootstrap una vez se ha arran-cado el proceso soffice con los parámetros necesarios para conectarse a través de una tuberíao pipe, al usar el método para crear una conexión desde java, este hace uso de una libreríadinámica que no se encuentra en el directorio del jar ni en el path y esto provoca que seproduzca una excepción java.lang.UnsatisfiedLinkError. Para solucionarlo el usuario debeponer al ejecutar el jar en la variable java.library.path, el directorio donde se encuentran laslibrerías necesarias, tal y como se puede ver en el listado 5.1. Esto también complica todavíamás el uso de la librería.

-Djava.library.path=/usr/lib/ure/lib

Listado 5.1: Añadiendo un directorio a Java Library Path

Para dar una solución a ambos problemas encontrados, haciendo lo más transparente po-sible al usuario los problemas de localización de dependencias, se ha modificado la claseBootstrap y se han utilizado las clases proporcionadas por el SDK para localizar el directoriode instalación, de manera que los jars necesarios se sitúan en un directorio lib junto a la libre-ría, y de forma automática se busca correctamente la ubicación del ejecutable de OpenOfficey se añade el directorio de las librerías dinámicas al java library path.

Los cambios realizados en la clase Bootstrap han sido los siguientes:

5. RESULTADOS 67

1. Ahora el bootstrap() recupera a partir de la llamada a getPath() de la clase Installation-Finder1 la ruta donde se encuentra el ejecutable de OpenOffice.org, y es esa ruta la quese usa en lugar de coger el path a la clase del Bootstrap. En el listado 5.2 se puede vercomentada como se obtenida la ruta antes, y a continuación se puede ver como se usaahora un array de objetos URL que contienen la ruta recuperada a través de la claseInstallationFinder.

2. Se ha creado una función setLibraryPath() que se llama en el método bootstrap yque resetea los valores asignados a la propiedad java.library.path de manera que lepueda asignar el directorio donde se encuentra el ejecutable y otros directorios dondese puede encontrar las librerías dinámicas necesarias.

Tanto la clase Bootstrap modificada como las clases para localizar el directorio de instalaciónde OpenOffice.org han sido incluidas en un paquete de la librería.

/* File fOffice = NativeLibraryLoader.getResource(Bootstrap.class.getClassLoader(), sOffice); */

File fOffice = NativeLibraryLoader.getResource(loader, sOffice);

Listado 5.2: Cambio la localización del path del ejecutable en la clase Bootstrap

Crear nuevos documentos

Para poder llevar a cabo esta tarea se ha utilizado el algoritmo de TDD pero con la decisiónde que las pruebas no incluirán el uso de mocks u objetos que simulen el comportamientode OpenOffice.org Calc, si no que a pesar de que se aumente un poco los tiempos se va usardirectamente los objetos remotos reales.

Para empezar a crear los test que sirven para realizar la implementación de la tarea, se hautilizado como base el campo de la historia cómo probarlo donde se especifican las pruebasque se deben cumplir para determinar que la historia se ha implementado correctamente:

1. Crear un nuevo documento docNuevo.ods y guardarlo. Comprobar que existe el ficheroy se puede abrir.

2. Repetir la prueba 1 con el documento docNuevo.xls.

3. Repetir la prueba 1 con los documentos plantillas docPlantilla.xlt y docPlantilla.odst.

4. Al abrir estos documentos deben abrirse como cualquier otra plantilla (no deben per-mitir su modificación directamente si no generar un nuevo documento).

1Esta clase viene en el SDK de UNO OpenOffice.org

68 5. RESULTADOS

5. Intentar crear nuevamente el documento docNuevo.ods (debe ya existir), al intentarcrear un documento ya existente debe fallar la creación devolviendo un error.

Las pruebas realizadas basadas en el campo cómo probarlo han sido las siguientes:

Prueba unitarias de creación de documentos para cada uno de los tipos de ficherospermitidos. A partir de la refactorización en las propias pruebas se ha creado un métodocreateNewDocument que es el que realmente realiza las comprobaciones dejando enel resto sólo el nombre y la extensión a probar; de esta manera se evita la repetición decódigo innecesaria.

Pruebas para la exportación a PDF.

Pruebas unitarias para provocar excepciones de manera que estás se incluyan en elcódigo. Estas excepciones son cuando no se soporta la extensión del fichero, cuandono tiene extensión o cuando se llama a exportar a PDF sin la extensión correcta.

A partir de las pruebas anteriores han emergido los siguientes elementos de diseño:

OpenSheetManager: es una clase que sigue el patrón factoría y que permite recuperarobjetos que implementan la interfaz IOpenSheetDocument de manera transparente.

IOpenSheetDocument: es la interfaz que proporciona el acceso a las funcionalidadesde un documento de hojas de cálculo. En este punto sólo se proporciona el métodopara close() cerrarlo.

OpenSheetDocument: es la clase que representa un documento de hojas de cálculoy que por tanto hace uso de los objetos necesarios de UNO y OpenOffice.org, imple-mentando además la interfaz IOpenSheetDocument.

OverwriteOpenSheetDocumentException: excepción que se produce cuando se in-tenta crear un nuevo documento y ya existe un fichero con ese nombre.

UnsupportedOpenSheetDocumentException: excepción que se produce cuando nose soporta la extensión del fichero a crear.

Estos elementos creados a partir de las pruebas y la refactorización cumplen con lo especi-ficado para determinar que la historia está completa, para ello basta con ejecutar las pruebasusadas en el algoritmo de TDD para su implementación.

5. RESULTADOS 69

5.2.2. Historia 1.5 - Convertir el formato del documentoPara empezar a crear los test que sirven para realizar la implementación de la historia, se ha

utilizado como base el campo de la historia cómo probarlo donde se especifican las pruebasque se deben cumplir para determinar que la historia se ha implementado correctamente:

1. Abrir un documento en formato ods y guardarlo con el mismo nombre en diferentesformatos: xls, xlt, odst y pdf.

2. Repetir la prueba 1 con los formatos permitidos.

3. Abrir un documento y salvarlo en un formato no permitido, debe fallar y devolver unerror.


Prueba unitarias de salvado entre los distintos tipos de ficheros permitidos. A partirde la refactorización en las propias pruebas se ha creado un método saveAsDocument

que es el que realmente realiza las comprobaciones dejando en el resto el fichero deorigen con su extensión y el fichero al que se quiere convertir; de esta manera se evitala repetición de código innecesaria.

Pruebas unitarias para provocar excepciones de manera que estás se incluyan en elcódigo. Estas excepciones son cuando no se soporta la extensión del fichero, cuandono tiene extensión o cuando ya existe un mismo documento con ese nombre.

A partir de las pruebas anteriores se han añadido los siguientes métodos a las clases IO-penSheetDocument y a OpenSheetDocument:

saveAs(String documentPath): es el método que permite almacenar el documento ytambién guardarlo con otro formato.

exportToPDF(String documenPath): es el método que permite exportar el documentode hojas de cálculo al formato PDF.


5.2.3. Resumen de sprintEn el sprint se han completado las dos historias planificadas en el plazo establecido. En el

gráfico de burndown, ver la figura 5.3, se puede ver la evolución del mismo.

70 5. RESULTADOS

Figura 5.3: Gráfico de burndown del sprint 1

En el gráfico se puede observar el poco avance los primeros días, esto es debido al tiempodedicado a la resolución de los problemas encontrados en la tarea de la conexión con Ope-nOffice.org Calc, como se ha explicado en detalle en la historia 1.1, y la recuperación seproduce una vez se han realizado los primeros tests y su refactorización, que han permitidoaumentar la velocidad del desarrollo.

En este sprint como resultado se ha obtenido una primera versión de la librería que con-tiene la funcionalidad de crear documentos de hojas de cálculo y guardarlos. En la figura 5.4se puede ver el diseño de clases resultante, no se han añadido al diagrama las clases querepresentan excepciones para aumentar la legibilidad.

5.3. Sprint 2: Apertura de documentos y modificación dehojas

En este sprint las historias de producto planificadas son:

Historia 1.2: Abrir documentos

Historia 1.3: Modificar hojas de cálculo de un documento

Ambas historias forman parte de la historia 1, al igual que el sprint anterior, y por tantocomo resultado de este sprint se obtendrá la librería para manipulación de documentos dehojas de cálculo pero con funcionalidad reducida. La funcionalidad de la librería resultanteserá la del sprint anterior más la proporcionada por cada una de las historias planificadas. Lainformación resumen de las historias planificadas se puede ver en la tabla 5.3.

5. RESULTADOS 71

Figura 5.4: Diagrama de clases resultante del sprint 1

En este caso se las dos tareas asignadas suman 4 puntos de historia a realizar en el sprint,que es lo que se ha considerado una carga normal.

A partir de las historias planificadas se define el objetivo del sprint. El objetivo perseguidopor este sprint es el de proporcionar a la API o librería del sprint anterior la funcionalidadnecesaria para abrir documentos de hojas de cálculo, y realizar modificaciones en la hojas decálculo de los documentos.


5.3.1. Historia 1.2 - Abrir documentosPara empezar a crear los test que sirven para realizar la implementación de la historia, se ha


1. Abrir un documento docExample.ods, comprobar tanto el número como el nombre desus pestañas u hojas de cálculo.

2. Repetir la prueba 1 con los formatos soportados.

72 5. RESULTADOS

ID Nombre Descripción Estimación Importancia Notas1.2 Abrir docu-

mentosSe debe poder abrir un docu-mento (en segundo plano) yaexistente a partir de su ruta.Además una vez abierto se de-be poder recuperar sus pestañasu hojas de cálculo.

3 ptos 490


Se debe poder realizar las si-guientes operaciones a un docu-mento: 1) Añadir una nueva ho-ja de cálculo (tanto con un nom-bre como sin nombre). 2) Borraruna hoja de cálculo (por nombreo posición). 3) Renombrar unahoja de cálculo.

1 ptos 480


3. Abrir un documento docUnknow.ods que no existe, debe fallar y devolver un error.

4. Abrir un documento con una extensión no permitida, debe fallar y devolver un error.

5. Recuperar una pestaña a partir de su posición y comprobar su nombre.

6. Recuperar una pestaña a partir de su nombre y comprobar su nombre.

7. Recuperar una pestaña a partir de una posición que no existe, debe fallar y devolver unerror.

8. Recuperar una pestaña a partir de un nombre que no existe, debe fallar y devolver unerror.


Prueba unitarias de apertura de los distintos tipos de ficheros permitidos. A partir de larefactorización en las propias pruebas se ha creado un método openNewDocument quees el que realmente realiza las comprobaciones dejando en el resto la ruta del fichero aabrir; de esta manera se evita la repetición de código innecesaria.

Pruebas unitarias para provocar excepciones en la apertura de manera que estás seincluyan en el código. Estas excepciones son cuando no se soporta la extensión delfichero o cuando no existe un documento con ese nombre.

Pruebas unitarias para la recuperación de hojas de cálculo a partir de una posición oun nombre.

5. RESULTADOS 73

Pruebas unitarias para provocar excepciones en la recuperación de hojas de cálculo alusar posiciones inválidas o al usar nombres nulos o inválidos.


ISpreadSheet: es la interfaz que proporciona el acceso a las funcionalidades de unahojas de cálculo. En este punto sólo se proporciona el método para getName() paraobtener el nombre.

SpreadSheet: es la clase que representa una hoja de cálculo y que por tanto hace uso delos objetos necesarios de UNO y OpenOffice.org, implementando además la interfazISpreadSheet.

LoadOpenSheetDocumentException: excepción que se produce cuando se intentaabrir un nuevo documento y no se puede por algún error.

SpreadSheetNoFoundException: excepción que se produce cuando se intenta recu-perar una hoja de cálculo de un documento y no existe.

Además de los elementos de diseño nuevos, se han añadido nuevos métodos a las clasesexistentes:

getSpreadSheetsNames(): es el método de IOpenSheetDocument que permite recupe-rar los nombres de todas sus hojas de cálculo en un array de cadenas.

getSpreadSheet(int pos): es el método de IOpenSheetDocument que permite recuperaruna hoja de cálculo u objeto ISpreadSheet a partir de su posición.

getSpreadSheet(String spreadSheetName): es el método de IOpenSheetDocument quepermite recuperar una hoja de cálculo u objeto ISpreadSheet a partir de su nombre.

openDocument(String documentPath): es el método de OpenSheetManager que se en-carga de abrir un documento de hojas de cálculo y devolver el correspondiente objetoIOpenSheetDocument.


5.3.2. Historia 1.3 - Modificar hojas de cálculo de un documentoPara empezar a crear los test que sirven para realizar la implementación de la historia, se ha


74 5. RESULTADOS

1. Crear un nuevo documento y añadirle dos nuevas hojas de cálculo, una de ellas sinasignarle un nombre.

2. Repetir la prueba 1 con un documento ya existente.

3. Crear un nuevo documento y borrar dos pestañas, una por nombre y la otra por posi-ción.

4. Abrir un documento y borrar una pestaña por nombre y otra por posición.

5. Crear un nuevo documento y renombrar una pestaña.

6. Abrir un documento y renombrar una pestaña.

7. Repetir las pruebas 1-6 para cada uno de los formatos permitidos.


Prueba unitarias de renombrado de hojas de cálculo para los diferentes tipos de docu-mentos permitidos. A partir de la refactorización en las propias pruebas se ha creadoun método renameSheet que es el que realmente realiza las comprobaciones del re-nombrado; de esta manera se evita la repetición de código innecesaria.

Pruebas unitarias para provocar excepciones en el renombrado de manera que estás seincluyan en el código. Para esto también se ha refactorizado los test obteniéndose elmétodo renameSheetFail.

Prueba unitarias para añadir y borrar hojas de cálculo a un documento, probando paralos diferentes tipos de documentos permitidos. A partir de la refactorización en las pro-pias pruebas se han creado los métodos addSheetToNewDocument y deleteSheet queson los que realmente realizan las comprobaciones evitando la repetición de código.

Pruebas unitarias para provocar excepciones al añadir nuevas hojas de cálculo de ma-nera que estás se incluyan en el código. Para esto también se ha refactorizado los testobteniéndose el método addSheetToNewDocumentMustFail.

Pruebas unitarias para provocar excepciones al eliminar hojas de cálculo que no exis-ten.

A partir de las pruebas anteriores, se han añadido nuevos métodos a las clases existen-tes:

rename(): es el método de ISpreadSheet que permite cambiar el nombre de la hoja decálculo.

5. RESULTADOS 75

addSpreadSheet(): es el método de IOpenSheetDocument que permite añadir una nue-va hoja de cálculo con un nombre por defecto al documento.

addSpreadSheet(String spreadSheetName): es el método de IOpenSheetDocument quepermite añadir una nueva hoja de cálculo al documento con el nombre dado.

deleteSpreadSheet(int pos): es el método de IOpenSheetDocument que permite borraruna hoja de cálculo del documento a partir de su posición.

deleteSpreadSheet(String spreadSheetName): es el método de IOpenSheetDocumentque permite borrar una hoja de cálculo del documento a partir de su nombre.


5.3.3. Resumen de sprintEn el sprint se han completado las dos historias planificadas antes del plazo establecido.

En el gráfico de burndown, ver la figura 5.5, se puede ver la evolución del mismo.


En el gráfico se puede observar el avance más rápido durante los primeros días que haceque antes de lo esperado se termine con las tareas planificadas, esto es debido a que al partirya de métodos de pruebas y algunas de las clases de dominio, se ha podido aumentar lavelocidad. Después de este terminar con las historias de este sprint se ha empezado a trabajarcon la siguiente historia de la pila de producto la 1.4 insertar valores en celdas.

76 5. RESULTADOS

En este sprint como resultado se ha obtenido la segunda versión de la librería que contienela funcionalidad de abrir documentos de hojas de cálculo ya creados y modificar las hojasde cálculo de un documento. En la figura 5.6 se puede ver el diseño de clases resultante,donde han aparecido nuevas clases y en algunos casos para las existentes se han añadidonuevos métodos, no se han añadido al diagrama las clases que representan excepciones paraaumentar la legibilidad.


5.4. Sprint 3: Modificación de celdasEn este sprint la historia de producto planificada es:

Historia 1.4: Insertar valores en celdas

Esta historia forma parte de la historia 1, al igual que los sprints anteriores, y por tantocomo resultado de este sprint se obtendrá la librería para manipulación de documentos dehojas de cálculo pero con funcionalidad reducida. La funcionalidad de la librería resultanteserá la del sprint anterior más la proporcionada por la historia planificada. En este sprintdebido a que en el anterior se terminó antes y se comenzó con esta tarea planificada, se hacompletado también la tarea planificada para lo que iba a ser el siguiente sprint, por tanto lafuncionalidad será además la de esta historia no planificada. La información resumen de lahistoria planificada y de la historia no planificada se puede ver en la tabla 5.4.

5. RESULTADOS 77

ID Nombre Descripción Estimación Importancia Notas1.4 Insertar valo-

res en celdasSe debe permitir insertar valoresde la siguiente forma: 1) Insertarun valor de una celda. 2) Insertarun grupo de valores en un rangode celdas.

3 ptos 470


Se debe permitir extraer valoresde la siguiente forma: 1) Extraerun valor de una celda. 2) Extraerun grupo de valores de un rangode celdas.

3 ptos 460


En este caso la historia asignada al sprint eran 3 puntos de historia, que es menos de loconsiderado una carga normal, el problema es que la siguiente historia a añadir eran otrosson otros 3 puntos, lo que podía suponer una carga excesiva pudiendo provocar que no sellegase a completar el sprint. De manera que si se terminaba la tarea se pudiera comenzarcon la siguiente sin necesidad de comprometerse a que se acabara en el mismo sprint, perocomo se ha comentado antes al final esta historia se ha completado en ese tiempo.

A partir de la historia planificada se define el objetivo del sprint. El objetivo perseguidopor este sprint es el de proporcionar a la API o librería del sprint anterior la funcionalidadnecesaria para insertar valores en las celdas de las hojas de cálculo.

A continuación, se va a detallar el desarrollo de cada una de las historias del sprint tantola planificada como la no planificada.

5.4.1. Historia 1.4 - Insertar valores en celdasPara empezar a crear los test que sirven para realizar la implementación de la historia, se ha


1. Insertar 20 valores en celdas diferentes, celda por celda, situadas en distintas pestañasu hojas de cálculo dentro de un nuevo documento.

2. Insertar 20 grupos de valores en rangos de celdas diferentes, situadas en distintas pes-tañas u hojas de cálculo dentro de un nuevo documento.

3. Repetir las pruebas 1 y 2 con documentos ya existentes, y que tengan los diferentesformatos permitidos.

4. Insertar un valor en una celda cuyo nombre no existe dentro de una pestaña, debedevolver un error.

78 5. RESULTADOS

5. Insertar valores en un rango de celdas que tiene una celda cuyo nombre no existe dentrode una pestaña, debe devolver un error.


Pruebas unitarias de inserción de valores numéricos y cadenas en celdas de hojas decálculo de los distintos tipos de ficheros permitidos. A partir de la refactorización enlas propias pruebas se han creado los métodos insertDoubleToCell, insertStringToCell,insertDoubleToRange e insertStringToRange que son los métodos encargados de rea-lizar las comprobaciones, dejando al resto las posiciones de celdas y los valores ainsertar, de manera que se evita la repetición de código innecesaria.

Pruebas unitarias para provocar excepciones en la inserción de valores en celdas al usarCellPosition inválidos o valores no permitidos. Para estás pruebas se han obtenido lossiguientes métodos tras la refactorización: insertDoubleToCellFail e insertStringToCe-

llFail. Para los rangos se ha definido test diferentes.

Pruebas unitarias para la recuperación de hojas de cálculo a partir de una posición oun nombre.

Pruebas unitarias para provocar excepciones en la recuperación de hojas de cálculo alusar posiciones inválidas o al usar nombres nulos o inválidos.


CellPosition: es el objeto que determina la posición de una celda a través de los valoresX e Y.

CellNoFoundException: excepción que se produce cuando se intenta referenciar auna celda que no existe dentro de la hoja de cálculo.


setCellValue(CellPosition position, double value): es el método de ISpreadSheet quepermite insertar un valor numérico en una celda identificada por su posición X e Y.

setCellValue(CellPosition position, String value): es el método de ISpreadSheet quepermite insertar una cadena en una celda identificada por su posición X e Y.

setRangeValue(CellPosition firstCellPosition, CellPosition lastCellPosition, double va-

lue): es el método de ISpreadSheet que permite insertar en todas la celdas de un rangoun valor numérico.

5. RESULTADOS 79

setRangeValue(CellPosition firstCellPosition, CellPosition lastCellPosition, String va-

lue): es el método de ISpreadSheet que permite insertar en todas la celdas de un rangouna cadena.

save(): es el método de IOpenSheetDocument que permite recuperar salvar los cam-bios realizados en un documento de hojas de cálculo.

Para comprobar que la historia está completa en este caso no ha sido suficiente con laspruebas unitarias usadas en el algoritmo de TDD, si no que ha sido necesario crear una clasede pruebas a parte, y su ejecución si garantiza que los elementos creados cumplen con lopedido. De hecho en este punto hay que destacar que se detectó un fallo en los rangos con lanueva clase creada para comprobar que la historia estaba completa.

5.4.2. Historia 1.6 - Extraer valores de celdasPara empezar a crear los test que sirven para realizar la implementación de la historia, se ha


1. Extraer 20 valores de celdas diferentes, celda por celda, situadas en distintas pestañasu hojas de cálculo dentro de un documento.

2. Extraer 20 grupos de valores de rangos de celdas diferentes, situadas en distintas pes-tañas u hojas de cálculo dentro de un documento.

3. Repetir las pruebas 1 y 2 con documentos con documentos de los diferentes formatospermitidos.

4. Extraer un valor de una celda cuyo nombre no existe dentro de una pestaña, debedevolver un error.

5. Extraer valores de un rango de celdas que tiene una celda cuyo nombre no existe dentrode una pestaña, debe devolver un error.


Pruebas unitarias de extracción de valores numéricos y cadenas en celdas de hojas decálculo de los distintos tipos de ficheros permitidos. A partir de la refactorización enlas propias pruebas se han creado los métodos getValueFromNewDocumentCell, get-

TextFromNewDocumentCell, getValuesFromNewDocumentRange, getTextsFromNew-

DocumentRange y getRangeContent que son los métodos encargados de realizar lascomprobaciones que se comparten en diferentes métodos de manera que se evita larepetición de código innecesaria.

80 5. RESULTADOS

Pruebas unitarias para provocar excepciones en la extracción de valores en celdas alusar CellPosition inválidos o valores no permitidos.

A partir de las pruebas anteriores, se han añadido nuevos métodos a las clases existen-tes:

getCellValue(CellPosition position): es el método de ISpreadSheet que permite obtenerel valor numérico contenido en la celda ubicada en la posición indicada.

getCellText(CellPosition position): es el método de ISpreadSheet que permite obtenerel valor de texto contenido en la celda ubicada en la posición indicada.

getCellContent(CellPosition position): es el método de ISpreadSheet que permite ob-tener el valor contenido en la celda ubicada en la posición indicada. Este método de-vuelve un tipo Object que puede ser un String o un Double según el contenido de lacelda.

getRangeValues(CellPosition firstCellPosition, CellPosition lastCellPosition): es el mé-todo de ISpreadSheet que permite obtener una lista de los valores numéricos conteni-dos en las celdas ubicadas en el rango indicado a partir de las posiciones de las dosceldas que lo definen.

getRangeTexts(CellPosition firstCellPosition, CellPosition lastCellPosition): es el mé-todo de ISpreadSheet que permite obtener una lista de los valores de texto contenidosen las celdas ubicadas en el rango indicado a partir de las posiciones de las dos celdasque lo definen.

getRangeContent(CellPosition firstCellPosition, CellPosition lastCellPosition): es elmétodo de ISpreadSheet que permite obtener una lista de los valores contenidos en lasceldas ubicadas en el rango indicado a partir de las posiciones de las dos celdas quelo definen. Los valores son de tipo Object pues cada valor puede ser un String o unDouble según el contenido de cada celda.

Para comprobar que la historia está completa en este caso tampoco ha sido suficiente conlas pruebas unitarias usadas en el algoritmo de TDD, si no que ha sido necesario añadirmétodos de prueba a la clase creada para probar la historia 1.4. Por tanto su ejecución pruebalas historias del sprint.

5.4.3. Resumen de sprintEn el sprint se ha completado la historia planificada antes del plazo establecido y además

se ha completado la siguiente historia que iba a ser un sprint completo. En el gráfico deburndown, ver la figura 5.7, se puede ver la evolución del mismo.

5. RESULTADOS 81


En el gráfico se puede observar que se comenzaba el sprint con la historia bastante avan-zada, lo que ha permitido implementar la siguiente historia, y por tanto adelantar una semanala planificación.

En este sprint se han completado todas las tareas restantes de la historia 1 y como resultadose ha obtenido la versión completa de la librería o API para trabajar con documentos dehojas de cálculo. En la figura 5.8 se puede ver el diseño de clases de la librería, no se hanañadido al diagrama las clases que representan excepciones para aumentar la legibilidad. Enel diagrama de clases se puede ver que es sencillo e intuitivo el uso de la librería, es decir, seha simplificado mucho respecto al uso directo de OpenOffice.org a través de UNO.

5.5. Sprint 4: Estudio de lenguaje script y comandoEn este punto se ha detectado que los requisitos iniciales del comando pueden ser mejora-

dos a través del uso de un lenguaje script; de esta manera lo que se persigue es que cuando seejecute el comando se le pase por parámetro un script y un fichero de datos, de manera que sepuede cambiar el fichero de datos para que el resultado del script vaya cambiando, o cambiarla funcionalidad a través del cambio de script. Por tanto en lugar de las seis subhistorias dela historia 2, se han definido ahora tres subhistorias repartidas en dos sprints, el 4 y el 5.


Historia 2.1: Estudio de lenguaje script

Historia 2.2: Comando para ejecutar scripts

82 5. RESULTADOS


Ambas historias forman parte de la historia 2, por tanto como resultado de este sprint seobtendrá el comando que a través de la librería obtenida en la historia 1 permite la mani-pulación de documentos de hojas de cálculo. La funcionalidad del comando como tal serácompleta pero no se creará, en este sprint, el script necesario para que cumpla con lo definidoen la planificación inicial. Este comando debe permitir ejecutar scripts en un lenguaje script,donde a partir de un fichero de datos realiza una inyección de dependencias, permitiendodefinir tipos especiales a inyectar como listas de valores.

La funcionalidad del comando resultante será la proporcionada por cada una de las his-torias planificadas. La información resumen de las historias planificadas se puede ver en latabla 5.5.

En este caso se las dos tareas asignadas suman 8 puntos de historia a realizar en el sprint,que es el doble de lo que se ha considerado una carga normal, por tanto este sprint se rea-lizará en dos semanas, en realidad se podría dividir en dos sprint distintos pero puesto quela primera historia no da como resultado ningún artefacto se ha decidido agruparlas en unmismo sprint pero con duración de dos semanas.

A partir de las historias planificadas se define el objetivo del sprint. El objetivo perseguidopor este sprint es el estudiar un lenguaje script para usarlo en el comando y la generación delcomando.

A continuación, se va a detallar el desarrollo de cada una de las historias planificadas en

5. RESULTADOS 83

ID Nombre Descripción Estimación Importancia Notas2.1 Estudio de

lenguajescript

Estudiar lenguajes scripts quepermitan desde Java ejecutarsecon diferentes ficheros de datosy permitan el uso de clases Java.

3 ptos 400

2.2 Comandopara ejecutarScripts

Crear el comando que permi-ta ejecutar Scripts y que reali-ce la inyección de dependenciasa partir de un fichero .proper-ties. Debe además permitir indi-car en el fichero tipos especia-les de propiedades: Documentos(debe crear o abrir un documen-to e inyectarlo a la propiedadcon el nombre dado), Managerde la API, Lista de cadenas, Nú-meros.

4 ptos 390


este sprint.

5.5.1. Historia 2.1 - Estudio de lenguaje scriptEn está historia no se ha aplicado la metodología TDD sino que se ha realizado más una

labor de investigación con pruebas de concepto para buscar un lenguaje script que se pudieraincorporar fácilmente al comando de manipulación de documentos de hojas de cálculo.

Después de buscar diferentes alternativas se ha seleccionado Groovy como lenguaje aincorporar debido a las siguientes características:

Permite incorporar fácilmente en una aplicación Java el intérprete de scripts.

El intérprete permite asignarle un objeto Binding para realizar asignaciones a las va-riables de un script que se va a interpretar.

Se pueden usar objetos Java en los scripts.

La sintaxis es muy parecida a Java.

Con las características de asignar valores a las variables de un script desde fuera y la posi-bilidad de usar objetos Java, y con la realización de una prueba de concepto donde se le haasignado a una variable un objeto de la API de OpenSheet, creada en con la historia 1, paratrabajar con un documento de hojas de cálculo; se ha comprobado que es una alternativaválida para usar, y se ha seleccionado como lenguaje script.

84 5. RESULTADOS

A partir de la prueba de uso de objetos de la API de OpenSheet en scripts de Groovy seha detectado que no se liberaba correctamente las conexiones abiertas con OpenOffice.org ypor tanto se ha añadido un método terminate() en la clase OpenSheetManager.

El ejemplo realizado como prueba de concepto es el que ha servido para validar que lahistoria ha sido completada según lo especificado en el campo cómo probarlo:

1. Generar un pequeño ejemplo Java que ejecute un script al que se le inyecta un objetode la API y lo use para operar con él.

5.5.2. Historia 2.2 - Comando para ejecutar scriptsPara empezar a crear los test que sirven para realizar la implementación de la historia, se ha


1. Si se pasan propiedades especiales sin el formato adecuado se produce un fallo.

2. Si se pasa un fichero de propiedades invalido se produce un fallo.

3. Realizar pruebas con cada uno de los tipos especiales especificados para el fichero dedatos.

4. Ejecutar un fichero de script con datos válidos y comprobar que se usan los valoresinyectados.

Para las pruebas realizas en esta historia se ha hecho uso del framework Mockito ?? y Po-werMock ??, para permitir comprobar que dentro de un método se realizan sólo las llamadasque se deben realizar, de manera que se defina y al mismo tiempo se compruebe el correctoflujo del programa, y además, para generar mocks u objetos que simulan el comportamientode objetos de la API de OpenSheet, para generar objetos reales sólo en aquellos casos en losse considera necesario.


Pruebas unitarias de los parámetros pasados al comando y de su comportamiento. Apartir de la refactorización de las pruebas se han creado los métodos verifyInvokeShow-

HelpInfo y checkSetParamsCommandInvalidParamsException que realizan las com-probaciones comunes evitando duplicar código en las pruebas, y se han creado méto-dos auxiliares.

Pruebas unitarias para comprobar la operación de ejecución del comando, y el controlde las diferentes excepciones, donde de la refactorización de las pruebas se ha obtenidoel método checkOpenSheetRunScriptException que ha permitido reducir el código en

5. RESULTADOS 85

otros test en los que sólo deben pasar un objeto de una clase de excepción e indicar sise debe invocar al método de crear el objeto que ejecutará el test.

Pruebas unitarias del comportamiento en la asignación de valores extraídos y objetosespeciales (listas, objetos de la API de OpenSheet) del fichero de datos a variablesde un script de Groovy. Donde la refactorización de los tests ha generado el métodocheckBindingPropertiesFile.

Pruebas unitarias de la ejecución de scripts de Groovy y de la recuperación de valoresde variables.


OpenSheetCommand: es el objeto que representa al comando, y el encargado de com-probar los parámetros pasados y crear los objetos necesarios para realizar la ejecuciónde un script de Groovy.

ScriptExecuter: es el objeto encargado de ejecutar un script de Groovy y de realizar lainyección de dependencias, es decir, a partir de la lectura del fichero de datos, obtenerlos valores y los objetos indicados y asignarlos a las variables del script. Tambiénpermite recuperar los valores de las variables una vez finalizada la ejecución del script.

LoadOpenSheetDataFileException: excepción que se lanza cuando hay algún pro-blema al intentar abrir un fichero de datos.

OpenSheetCommandInvalidParamsException: excepción que se lanza cuando losparámetros pasados al comando son inválidos.

OpenSheetRunScriptException: excepción que se lanza cuando se produce un erroral ejecutar un script de Groovy.

OpenSheetPropertyFormatException: excepción que se lanza cuando en el ficherode datos alguna propiedad no tiene el formato correcto.


5.5.3. Resumen de sprintEn el sprint se han completado las dos historias planificadas en el plazo establecido. En el


En el gráfico se puede observar que al comienzo de cada historia el avance es más lento ypoco a poco se ha ido aumentando la velocidad hasta alcanzar el compromiso establecido.

86 5. RESULTADOS


En este sprint como resultado se ha obtenido la primera versión del comando que tienela funcionalidad de necesaria para ejecutar scripts permitiendo la inyección de dependenciasde las variables establecidas en el fichero de datos. Sólo falta el tener scripts en Groovy paraoperar. En la figura 5.10 se puede ver el diseño de clases resultante.


5. RESULTADOS 87

5.6. Sprint 5: Script genérico para el comandoEn este sprint la historia de producto planificada ha sido:

Historia 2.3: Script Genérico

Esta historia forma parte de la historia 2, al igual que el sprint anterior, pero en este casono se obtendrá un comando con mayor funcionalidad si no un script en Groovy que permitarealizar las tareas pensadas en un principio para el comando y que será el distribuido pordefecto con el mismo. La información resumen de las historia planificada se puede ver en latabla 5.6.

ID Nombre Descripción Estimación Importancia Notas2.3 Script Gené-

ricoCrear un Script que permita: 1)Crear un nuevo documento oabrir uno existente 2) Insertarnuevas hojas de cálculo al do-cumento. 3) Eliminar hojas decálculo al documento. 4) Inser-tar valores a celdas del docu-mentos. 5) Extraer valores de lasceldas del documento y expor-tarlos a un fichero. 6) Guardar eldocumento o exportarlo a los fi-cheros soportados.

4 ptos 380 Necesitatener anteslas historias2.1 y 2.2


En este caso se la historia asignada son 4 puntos de historia a realizar en el sprint, que eslo que se ha considerado una carga normal.

A partir de la historia planificada se define el objetivo del sprint. El objetivo perseguidopor este sprint es el realizar un script genérico en Groovy para dotar al comando de las opera-ciones básicas de manipulación con hojas de cálculo cambiando sólo el fichero de datos.

A continuación, se va a detallar el desarrollo de la historias planificada en este sprint.

5.6.1. Historia 2.3 - Script GenéricoPara empezar a crear los test que sirven para realizar la implementación de la historia, se ha


1. Crear un nuevo documento y salvarlo.

2. Abrir un documento y borrar 3 hojas usando su nombre.

88 5. RESULTADOS

3. Abrir un documento, añadir 3 hojas nuevas y borrar 3 hojas por posición.

4. Abrir un documento, añadir 3 hojas nuevas, insertar valores a las celdas, extraer valoresde las celdas (exportándolas a un fichero) y exportar el documento a PDF.

Las pruebas realizadas basadas en el campo cómo probarlo se han realizado parte en otroscript en Groovy y parte en clases de Java, y han sido las siguientes:

Prueba unitarias para las diferentes operaciones básicas para tratar los valores inyecta-dos a las variables del script. Esto se ha comprobado a través de un script en Groovy.

Pruebas unitarias para los cambios necesarios en la clase CellPosition para permitirgenerar objetos a partir del nombre de la celda.

Pruebas unitarias para la ejecución del script.


OpenSheetScript.groovy: es el script de Groovy resultante de la historia.

Main: es la clase con el método main del jar del comando. El jar autoejecutable simple-mente crea un objeto comando, le asigna los mismos parámetros que se le han pasadopor línea de ordenes y ejecuta el run del comando.

CellNameException: excepción que se produce cuando se un nombre incorrecto parahacer referencia a la posición de una celda.

OverwriteSpreadSheetException: excepción que se produce cuando se intenta so-breescribir una hoja de cálculo que ya existe en el documento.


CellPosition(String cellName): es un nuevo constructor para la clase CellPosition quepermite crear posiciones de celda a partir de un nombre válido.

equals(Object obj): se ha sobreescrito el método de comparación porque era necesarioen las pruebas.

containsSpreadSheet(String name): es el método de IOpenSheetDocument que indicasi contiene una hoja de cálculo con ese nombre.

addSpreadSheet(String spreadSheetName): se ha modificado este método de IOpenS-heetDocument para que lance una excepción en el caso en el que ya exista una hojadentro del documento con el nombre de la nueva hoja de cálculo que se quiere crear.

5. RESULTADOS 89


5.6.2. Resumen de sprintEn el sprint se ha completado las historia con una velocidad de 2 en lugar de 4, lo que ha

hecho que no se cumpla la planificación, tardando el doble de lo estimado. En el gráfico deburndown, ver la figura 5.11, se puede ver la evolución del mismo.


En el gráfico se puede observar que el avance ha ido muy lento durante todo el sprint loque ha hecho que se tarde dos semanas en lugar de una. La principal causa de esto es queno se estimo correctamente la historia, pues el diseño del script para permitir realizar todaslas operaciones de inserción, modificación y extracción de datos en documentos de hojas decálculo según el fichero que se usase era complicado y ha llevado más tiempo del previsto.Además, el desconocimiento de la sintaxis de Groovy, aunque sea muy parecida a Java, hahecho que se necesite más tiempo del esperado. Junto a todo lo anterior el desarrollo usandoel algoritmo de TDD ha resultado más difícil que en puntos anteriores, principalmente debidoa la falta de experiencia con esta metodología.

En este sprint se han completado todas las tareas restantes de la historia 2 y como resul-tado se ha obtenido la versión completa del comando que permite a partir de un fichero dedatos (un fichero .properties) y un script, realizar ejecutar el script con la inyección de de-pendencias del fichero de datos de manera que se pueda usar la librería o API de OpenSheetpara trabajar con documentos de hojas de cálculo. En este caso el diagrama de clases del

90 5. RESULTADOS

comando coincide con el del sprint anterior, ver figura 5.10.

5.7. Sprint 6: Servicio webA partir de los cambios en los requisitos iniciales del comando, se han llevado también

hasta la historia 3, el servicio web. Este a partir del uso de la librería o API de OpenSheet debepermitir la manipulación de hojas de cálculo, basándose en el mismo funcionamiento que elcomando, es decir, debe permitir al usuario seleccionar un script, de entre los disponiblespara usar con el servicio web, y a de esa selección, un fichero de datos y un documento dehojas de cálculo, sólo cuando sea necesario, realizará las operaciones del script y devolveráel documento con los cambios realizados.

Aunque se ha aumentado la funcionalidad pues se hace mucho más flexible el servicioweb al permitir ejecutar diferentes scripts, el número de historias se reduce de tres a dos, yla estimación pasa de 9.5 puntos de historia a 4, pues se va a reutilizar parte de las clasesgeneradas para el comando.


Historia 3.1: Operación de listado de scripts

Historia 3.2: Operación de selección y ejecución de un script sobre un documento

Ambas historias forman parte de la historia 3, por tanto como resultado de este sprint se ob-tendrá el servicio web que a través de la librería obtenida en la historia 1 permite la manipula-ción de documentos de hojas de cálculo. La funcionalidad del servicio web será completadaen este sprint, pues se hará uso del script básico generado para el comando.

La funcionalidad del servicio web resultante será la proporcionada por cada una de lashistorias planificadas. La información resumen de las historias planificadas se puede ver enla tabla 5.7.

A partir de las historias planificadas se define el objetivo del sprint. El objetivo perseguidopor este sprint es el de generar el servicio web para trabajar con documentos de hojas decálculo.


5.7.1. Historia 3.1 - Operación de listado de scriptsPara empezar a crear los test que sirven para realizar la implementación de la historia, se ha


5. RESULTADOS 91

ID Nombre Descripción Estimación Importancia Notas3.1 Operación

de listado descripts

Debe existir una operación en laque se pueda recuperar la infor-mación de todos los scripts quese pueden utilizar y la descrip-ción de los mismos. Además,debe implementarse el mecanis-mo necesario para que median-te configuración se pueda indi-car cuales van ser los scripts per-mitidos para usarse y su descrip-ción.

1 ptos 310 Con esta ope-ración se de-be crear tam-bién el servi-cio web.

3.2 Operaciónde seleccióny ejecuciónde un scriptsobre undocumento

La operación debe recibir siem-pre un fichero de datos y el iden-tificador del script a ejecutar, yde manera opcional un docu-mento. Se ejecutará el script y sedevolverá el resultado de la eje-cución.

3 ptos 300


1. Configurar varios scripts con sus descripciones.

2. Recuperar la lista de scripts permitidos y comprobar que coincide con los publicados.

Para las pruebas realizas en esta historia se ha hecho uso del framework Mockito ??, parapermitir comprobar que dentro de un método se realizan sólo las llamadas que se deben reali-zar, de manera que se defina y al mismo tiempo se compruebe el correcto flujo del programa,y además, para generar mocks u objetos que simulan el comportamiento de objetos, comopor ejemplos objetos que representan directorios o ficheros.


Pruebas unitarias de los métodos auxiliares para recuperar información de los scripts.En este caso la refactorización ha dado lugar a un método checkScriptInfoValue quepermite comprobar si el objeto ScriptInfo y la información esperada coinciden.


OpenSheetWebService: es el objeto que representa al servicio web, y que pública losmétodos que hacen de operaciones. Para su construcción se ha usado JAX-WS ??

ScriptInfoUtils: es la clase con los métodos estáticos necesarios para poder recuperarla información de los scripts a partir de sus ficheros.

92 5. RESULTADOS

ScriptInfo: es el objeto que representa la información necesaria para usar un script: elnombre, la ruta, la descripción, las variables que hacen referencia a ficheros de saliday la variable donde se inyecta el directorio temporal.


5.7.2. Historia 3.2 - Operación de selección y ejecución de un scriptsobre un documento

Para empezar a crear los test que sirven para realizar la implementación de la historia, se hautilizado como base el campo de la historia cómo probarlo donde se especifican las pruebasque se deben cumplir para determinar que la historia se ha implementado correctamente:

Ejecutar el script de base con las siguientes opciones:

1. Enviar sólo fichero de datos y crear un documento que se devuelva al cliente del servi-cio web.

2. Enviar documento sobre el que aplicar modificaciones que se salven y comprobar queel documento recibido en el cliente es el esperado.

3. Enviar un documento operar sobre él y devolver el resultado de convertir dicho docu-mento a otro formato.

4. Convertir un documento enviado a formato PDF.

5. Enviar un documento y extraer valores sobre él.

6. Enviar un documento modificarlo y extraer valores sobre él, se debe recibir los valoresextraídos y el documento modificado.

Para las pruebas realizas en esta historia se ha hecho uso del framework Mockito ??, parapermitir comprobar que dentro de un método se realizan sólo las llamadas que se debenrealizar, de manera que se defina y al mismo tiempo se compruebe el correcto flujo delprograma, y además, para generar mocks u objetos que simulan el comportamiento de objetosde la API de OpenSheet, para generar objetos reales sólo en aquellos casos en los se consideranecesario.


Pruebas unitarias de los métodos auxiliares para la operación de ejecutar un script.

5. RESULTADOS 93

Pruebas unitarias para establecer el comportamiento de la operación isEmpty de laclase Document, que índica si el objeto es un documento vacío.

Pruebas unitarias de la ejecución de scripts, es decir, pruebas de los parámetros pasa-dos, del parseo inicial de variables del fichero de datos, y del comportamiento en laejecución. A partir de la refactorización de las pruebas se ha creado el método checkE-

xecuteScriptWithDocument que realiza las comprobaciones comunes evitando duplicarcódigo en las pruebas.

Se ha cambiado las pruebas del ScriptExecuter del comando para cambiar el cons-tructor y que también permita usar directamente un objeto Properties además de unfichero de propiedades. Para evitar repetir código en los tests para probar con am-bos constructores se ha hecho uso un mecanismo que ofrece JUnit con las anotaciones@RunWith(Parameterized.class) y @Parameters de manera que se lancen los tests dosveces cambiando un parámetro que hace que se elija un constructor primero y luego elotro, evitando así una gran repetición de código en las pruebas.


OperationUtils: es la clase con los métodos estáticos auxiliares necesarios para poderrealizar la operación de ejecutar un script.

Document: es el objeto que representa un documento o fichero binario. Este objeto esel que se usa para poder enviar y recibir ficheros con sus nombres y extensiones, en laoperación del servicio web, para poder trabajar con ellos según su extensión.

ScriptVariable: debido a un problema de JAX-WS para usar mapas de variables, de-tectado al crear el cliente de pruebas de integración, ha sido necesario crear este tipode objeto que representa un par clave/valor, de manera que a la operación se le paseuna lista de objetos de este tipo en lugar de un mapa de variables.

ExecuteScriptOperation: es el objeto que representa una operación de ejecución descript. Una vez se le pasan los parámetros necesarios, parsea las variables del ficherode datos para adaptarlas al ScriptExecuter, y se queda preparado para la ejecución delscript. Cuando se ejecuta el script se devuelve como resultado una lista con todos losdocumentos a devolver.

OpenSheetOperationInvalidParamsException: excepción que se lanza cuando losparámetros pasados a la operación no son válidos.

OpenSheetWebServiceException: excepción genérica que se lanza cuando se produ-ce un error en alguna operación del servicio web. Esta operación sirve para encapsularotras excepciones y lanzarlas al cliente.

94 5. RESULTADOS


ScriptExecuter(OpenSheetManager openSheetManager, Properties properties): es unnuevo método constructor de ScriptExecuter que permite crear directamente un objetosin necesidad de leer las variables de un ficheros .properties, facilitando su uso desdeel servicio web. Para evitar la repetición de código en el nuevo constructor a partir dela refactorización, ha surgido un nuevo método privado InitScriptExecuter al que llamacada constructor.

setCellValue(CellPosition position, String value): es el método de ISpreadSheet quepermite insertar una cadena en una celda identificada por su posición X e Y.

setRangeValue(CellPosition firstCellPosition, CellPosition lastCellPosition, double va-

lue): es el método de ISpreadSheet que permite insertar en todas la celdas de un rangoun valor numérico.

setRangeValue(CellPosition firstCellPosition, CellPosition lastCellPosition, String va-

lue): es el método de ISpreadSheet que permite insertar en todas la celdas de un rangouna cadena.

save(): es el método de IOpenSheetDocument que permite recuperar salvar los cam-bios realizados en un documento de hojas de cálculo.

Para comprobar que los elementos creados a partir de las pruebas y la refactorizacióncumplen con lo especificado, en este caso ha sido necesario crear un cliente del servicio webmuy básico que llama a las dos operaciones publicadas. Gracias a estas pruebas a través deun cliente se han detectado diferentes problemas, el primero ha sido la incapacidad de JAX-WS para manejar mapas de variables, como ya se ha comentado antes, lo que ha obligadoa modificar las interfaces, algunas pruebas y métodos; y además han aparecido problemascon el despliegue del servicio web en el contenedor de servlets, que se han solucionado ydocumentado en el manual de usuario para que si a algún usuario le sucede alguno de esosproblemas sepa como resolverlos.

5.7.3. Resumen de sprintEn el sprint se han completado las dos historias planificadas con tres días de retraso. En el


En el gráfico se puede observar que en el comienzo del sprint se ha ido más lento de losesperado, esto es debido a que el diseño y las pruebas para las operaciones que se han reali-zado estaban subestimadas, luego una vez se ha definido como llevar a cabo las operacionesy se han ido realizando más pruebas, se ha ido aumentando la velocidad. El último repunte

5. RESULTADOS 95


en la gráfica casi al final del desarrollo ha sido provocado por los problemas encontrados alrealizar las pruebas con el cliente del servicio web creado para validar que las historias esta-ban completas. Esto problemas han sido por un lado con el framework utilizado, JAX-WS, ypor otro con el contenedor de servlets.

En este sprint como resultado se ha obtenido el servicio web completo con sus dos opera-ciones. En la figura 5.13 se puede ver el diseño de clases resultante.

5.8. Sprints 7-10: DocumentaciónEn esta sección se va a resumir el desarrollo de la ultima historia del proyecto, la historia

4 que se corresponde con la realización de la documentación o memoria del proyecto. Ladocumentación se ha dividido en 6 subhistorias, cada correspondiente a un capítulo de lamemoria, con una estimación inicial de 18 puntos planificados en 4 sprints. A continuaciónse va a explicar cada uno de los sprints.

5.8.1. Sprint 7: Documentación 1 - AntecedentesEn este sprint se ha planificado la historia 4.2, como se puede ver en la tabla 5.8, puesto

que el dueño de producto ha dado menos prioridad a la historia 4.1 al decidir que debecompletarse una vez se tenga el resto de la memoria completada.

ID Nombre Descripción Estimación Importancia Notas4.2 Antecedentes Estudio del estado del arte. 4 ptos 290


96 5. RESULTADOS


En completar la historia se ha tardado prácticamente 4 semanas en lugar de una que era loplanificado. El principal problema que ha provocado este retraso ha sido la subestimación dela realización de esta historia, donde los puntos reales han sido 11, y la sobrestimación de lavelocidad para realizarla que ha sido de 3 puntos por semana, en lugar de 4 pues el comienzode la documentación siempre lleva un esfuerzo adicional, y en este caso más al no conocerLATEX.

5.8.2. Sprint 8: Documentación 2 - Objetivos y Método de TrabajoEn este sprint se ha planificado las historia 4.3 y 4.4, como se puede ver en la tabla 5.9.

ID Nombre Descripción Estimación Importancia Notas4.3 Objetivos

PCF2 ptos 280

4.4 Método detrabajo

3 ptos 270


Este sprint se ha completado en el tiempo planificado debido que se ha podido aumentarel tiempo a dedicar por un lado, y por otro a que la historia 4.3 se había sobrestimado siendosu duración real 1 punto, y por tanto la velocidad real y necesaria para completar este sprintha sido de 4 puntos.

5. RESULTADOS 97

5.8.3. Sprint 9: Documentación 3 - ResultadosEn este sprint se ha planificado la historia 4.5 como se puede ver en la tabla 5.10.

ID Nombre Descripción Estimación Importancia Notas4.5 Resultado 5 ptos 260


Esta historia también ha sido subestimada siendo su estimación real de 12 puntos, y parapoder completarla con tan sólo un retraso de 4 días, ha sido necesario gastar varios días devacaciones para aumentar el tiempo de dedicación.

5.8.4. Sprint 10: Documentación 4 - Conclusiones e IntroducciónEn este sprint se ha planificado las historia 4.6 y 4.1 como se puede ver en la tabla 5.11.

ID Nombre Descripción Estimación Importancia Notas4.6 Conclusiones 2 ptos 2004.1 Introducción 2 ptos 140


Esta historia aun no se ha empezado pues corresponde justo al sprint siguiente a la conclu-sión del capítulo que se está redactando, pero tras la experiencia de los tiempos y velocidadesanteriores utilizados para las diferentes subhistorias de la historia 4, parece que el tiempo realde estimación será inferior al calculado en la planificación, pasando de 4 a 2 puntos, lo queva a permitir completarlo antes de lo esperado.

5.9. API OpenSheetA partir de la historia 1 y de las mejoras detectadas durante la ejecución de los sprints

de las historias 2 y 3, se ha obtenido una API para trabajar con documentos de hojas decálculo.

Para su construcción se han utilizado las siguientes clases de tests:

OpenSheetDocumentTest: es la clase que contiene todas las pruebas relacionadas conlos documentos de hojas de cálculo, es decir, con la interfaz que IOpenSheetDocumenty la clase que la implementa OpenSheetDocument. A través de sus 97 tests se hadefinido el comportamiento que se espera que tenga cada una de las operaciones deestas clases.

SpreadSheetTest: es la clase que contiene todas las pruebas relacionadas con las hojasde cálculo de un documento, es decir, con la interfaz que ISpreadSheet y la clase que

98 5. RESULTADOS

la implementa SpreadSheet. A través de sus 64 tests se ha definido el comportamientoque se espera que tenga cada una de las operaciones de estas clases.

CellPositionTest: es la clase que contiene las pruebas para las operaciones que usancadenas como identificadores de la posición de una celda y operaciones de compara-ción para la clase CellPositionTest. A través de sus 22 tests se ha definido el compor-tamiento que se espera que tengan las operaciones probadas.

Sprint3Test: es una clase usada para comprobar que una vez creada la API se cumplencon lo pedido en el sprint 3 para demostrar la completitud de la historias planificadasen ese sprint, por tanto sus 16 test no han sido usados dentro del algoritmo de TDD

para el diseño.

Los tests diseñados hacen uso directo de OpenOffice.org Calc a través UNO, y del sistemade ficheros, pero se aseguran antes de empezar cada test que no existe ningún fichero quepueda provocar errores en las pruebas y de restaurar todo una vez finalizan.

Figura 5.14: Diagrama de clases de la API de OpenSheet

La API de OpenSheet permite usar OpenOffice.org Calc de manera transparente al usuario,de manera que es la librería la que busca la instalación en la máquina y levanta una instanciadel proceso de OpenOffice.org para conectarse a él y poder hacer uso de su funcionalidad.Para ello el desarrollador que use OpenSheet tan sólo debe usar la factoría OpenSheetMa-nager tanto para crear un nuevo documento como para abrir uno existente, y a través de las

5. RESULTADOS 99

interfaces ofrecidas IOpenSheetDocument para los documentos e ISpreadSheet para las ho-jas de cálculo, realizar las operaciones ofrecidas. El diagrama de clases completo obtenido apartir de la aplicación del algoritmo de TDD es el que se puede ver en la figura 5.14.

5.10. Comando OpenSheetA partir de la historia 2 y de las mejoras detectadas durante la ejecución de los sprints de

la historia 3, se ha obtenido una comando que permite ejecutar scripts e inyectarles depen-dencias para permitir trabajar con documentos de hojas de cálculo.


OpenSheetCommandTest: es la clase que contiene todas las pruebas relacionadascon la clase que representa al comando, es decir, OpenSheetCommand. A través desus 18 tests se ha definido el comportamiento que se espera que tenga cada una de lasoperaciones de esta clase.

ScriptExecuterTest: es la clase que contiene todas las pruebas relacionadas con laclase encargada de ejecutar scripts de Groovy e inyectarle las dependencias leidas delfichero de datos, es decir, con la clase ScriptExecuter. A través de sus 44 tests se hadefinido el comportamiento que se espera que tenga cada una de las operaciones deesta clase.

OpenSheetScriptTest: es la clase que contiene todas las pruebas relacionadas conel script genérico creado para la manipulación de documentos de hojas de cálculo,es decir, OpenSheetScript.groovy. A través de sus 4 tests y el script OpenSheetU-tilsTest.groovy, que contiene tests de métodos auxiliares del script, se ha definido elcomportamiento que se espera que tenga cada una de las operaciones de este script.

TestUtils: es una clase con métodos auxiliares estáticos usados para llevar a cabo al-guno de los pasos necesarios en las pruebas.

Los tests diseñados en algunos casos hacen uso directo de OpenOffice.org Calc a travésUNO, y del sistema de ficheros, pero siempre se aseguran antes de empezar cada test que noexiste ningún fichero que pueda provocar errores en las pruebas y de restaurar todo una vezfinalizan.

El comando de OpenSheet permite usar la API de OpenSheet generada en la historia 1dentro de scripts del lenguaje Groovy. El comando permite ejecutar un script escrito enGroovy inyectándole las dependencias leídas de un fichero de datos pasado por paramétroen la llamada al comando; de esta manera un mismo script se puede reutilizar simplementecambiando el fichero de datos. El comando al estar preparado para ejecutarse en un terminal

100 5. RESULTADOS

y permitir cambiar su comportamiento según el fichero de datos, permite ser usado pararealizar tareas por lotes. Además también se puede usar para planificar y automatizar ciertastareas de manera sencilla a través de las herramientas que ofrecen los sistemas operativos.Para permitir realizar las operaciones de la API sin necesidad de tener que crear un script,se ha generado uno, que según el contenido del fichero de datos realiza unas operaciones uotras, ofreciendo una gran versatilidad.

El diagrama de clases completo, obtenido a partir de la aplicación del algoritmo de TDD

para las historias del comando, es el que se puede ver en la figura 5.15.

Figura 5.15: Diagrama de clases del Comando de OpenSheet

5.11. Servicio web OpenSheetA partir de la historia 3 se ha obtenido un servicio web que permite de manera remota

seleccionar y ejecutar scripts, a los que se les inyectan las dependencias leídas de las propie-dades pasadas, para permitir trabajar con documentos de hojas de cálculo.


ScriptInfoUtilsTest: es la clase que contiene todas las pruebas relacionadas con losmétodos auxiliares que permiten recuperar la información de los scripts. A través de

5. RESULTADOS 101

sus 5 tests se ha definido el comportamiento que se espera que tenga cada una de lasoperaciones usadas como base para la operación del servicio web que devuelve unalista de objetos ScriptInfo.

OperationUtilsTest: es la clase que contiene todas las pruebas relacionadas con losmétodos auxiliares que permiten realizar parte de las tareas necesarias para llevar acabo la operación de ejecución de un script haciendo uso del ScriptExecuter creado enla historia 2. A través de sus 9 tests se ha definido el comportamiento que se esperaque tenga cada una de las operaciones usadas como base para la operación del servicioweb.

DocumentTest: es la clase que contiene todas las pruebas relacionadas con la opera-ción que comprueba si un objeto de tipo Document es vacío. A través de sus 5 tests seha definido el comportamiento que debe tener dicho método.

ExecuteScriptOperationTest: es la clase que contiene todas las pruebas relacionadascon las operaciones de ejecución de scripts, es decir, con la clase ExecuteScriptOpera-tion. A través de sus 17 tests se ha definido el comportamiento que se espera que tengacada una de las operaciones de estas clase.

Figura 5.16: Diagrama de clases del Servicio Web de OpenSheet

Los tests diseñados en algunos casos hacen uso directo de OpenOffice.org Calc a travésUNO, y del sistema de ficheros, pero siempre se aseguran antes de empezar cada test que no

102 5. RESULTADOS

existe ningún fichero que pueda provocar errores en las pruebas y de restaurar todo una vezfinalizan.

El servicio web de OpenSheet permite usar la API de OpenSheet generada en la historia 1dentro de scripts del lenguaje Groovy. Para ello es necesario configurar el directorio donde seencuentran los scripts y definir un fichero de propiedades con las características de los scripts.El servicio web permite la misma funcionalidad que el comando de la historia 2 pero a travésde los scripts configurado para ello, así se evitan posibles problemas de seguridad.

El diagrama de clases completo, obtenido a partir de la aplicación del algoritmo de TDD

para las historias del servicio web, es el que se puede ver en la figura 5.16.

5.12. DocumentaciónA partir de la historia 4 se ha obtenido la memoria del proyecto que debe cumplir con la

normativa académica.

Además de la memoria del proyecto, se ha generado también la siguiente documentacióna lo largo del desarrollo del proyecto:

Documentación de la API de OpenSheet generada con Javadoc

Manual de usuario del comando de OpenSheet.

Manual de usuario del servicio web de OpenSheet.

Los manuales de usuario creados se han añadido como apéndices a la memoria del pro-yecto.

5.13. Estadísticas del proyectoPara terminar con el capítulo de resultados, se van a presentar unas estadísticas del pro-

yecto y a comentar las diferencias entre el esfuerzo invertido y el planificado.

Para medir las líneas de código o SLOC, tanto del código de producción como del depruebas, se ha hecho uso de la aplicación SLOCCount. Para ello se ha realizado la ejecuciónpara medir por separado el código de producción y el código de pruebas.

En la tabla 5.12 se puede ver los resultados de la ejecución de SLOCCount con el códigode producción. En dicha tabla se puede observar entre otros datos obtenidos que el número delíneas correspondientes a dicho código son 2592. Además, en la tabla también se hace refe-rencia a las métricas del modelo COCOMO que ha generado la herramienta SLOCCount.

En la tabla 5.13 se puede ver los resultados de la ejecución de SLOCCount con el código depruebas. En dicha tabla se puede observar entre otros datos obtenidos que el número de líneas

5. RESULTADOS 103

Medida ValorTotal Physical Source Lines of Code (SLOC) 2,592Development Effort Estimate, Person-Years (Person-Months) 0.54 (6.52)(Basic COCOMO model, Person-Months = 2.4 ∗ (KSLOC∗∗1.05))Schedule Estimate, Years (Months) 0.42 (5.10)(Basic COCOMO model, Months = 2.5 ∗ (person-months∗∗0.38))Estimated Average Number of Developers (Effort/Schedule) 1.28Total Estimated Cost to Develop $ 73,444(average salary = $56,286/year, overhead = 2.40)

Cuadro 5.12: Resultado de ejecución de SLOCCount con el código de producción

correspondientes a dicho código son 4047. Además, en la tabla también se hace referencia alas métricas del modelo COCOMO que ha generado la herramienta SLOCCount.

Entre las dos tablas anteriores podemos ver que el número de líneas de codigo total en-tre pruebas y código de producción suman 6639, de las cuales 4047 son las referentes alcódigo usado en los test. Esto índica que aproximadamente el 61 % de las líneas de códigocorresponden a la realización de los test, es decir, ese porcentaje corresponde al esfuerzo delproyecto dedicado a las pruebas.

Medida ValorTotal Physical Source Lines of Code (SLOC) 4,047Development Effort Estimate, Person-Years (Person-Months) 0.87 (10.42)(Basic COCOMO model, Person-Months = 2.4 ∗ (KSLOC∗∗1.05))Schedule Estimate, Years (Months) 0.51 (6.09)(Basic COCOMO model, Months = 2.5 ∗ (person-months∗∗0.38))Estimated Average Number of Developers (Effort/Schedule) 1.71Total Estimated Cost to Develop $ 117,255(average salary = $56,286/year, overhead = 2.40)

Cuadro 5.13: Resultado de ejecución de SLOCCount con el código de pruebas

Al haber usado durante el desarrollo la metodología TDD, el esfuerzo realizado para laspruebas no sólo ha sido invertido para asegurar que funciona correctamente el código deproducción, si no también ha sido invertido para el diseño y estructura del código, pues estese genera a partir de cada una de las pruebas realizadas.

También hay que señalar que el código repetido se ha reducido al máximo a través de lasrefactorizaciones continuas que se realizan con el algoritmo de TDD, en ambos casos.

El tiempo aproximado invertido en el proyecto han sido de unos 4 meses de trabajo conuna media de 27 horas semanales, por tanto se han empleado 432 horas.

El esfuerzo estimado en la última planificación con los cambios en los requisitos realizadoses de 52.5 puntos, correspondiendo como ya se explicó, 4 puntos a 27 horas semanales. Por

104 5. RESULTADOS

tanto el tiempo estimado ha sido de 354 horas.

Por tanto ha habido una desviación de 78 horas entre el tiempo real y el planificado, enpuntos es una desviación de 11.5 puntos, principalmente debido a la subestimación que seha hecho para la realización de la memoria del proyecto.

Capítulo 6

Conclusiones

E N este capítulo se muestran los objetivos alcanzados, es decir, se realiza un análisisde los resultados obtenidos durante el desarrollo del proyecto, descritos en el anterior

capítulo, y se proponen posibles mejoras y ampliaciones para desarrollar en un futuro. Ade-más al final se realizará un comentario con las conclusiones personales del autor sobre eldesarrollo del proyecto y las metodologías utilizadas.

6.1. Objetivos alcanzadosSe va a analizar cada uno de los objetivos marcados al comienzo del proyecto y cómo se

han cumplido.

Objetivo general: El objetivo general ha sido ampliamente cubierto a través de lostres artefactos software generados: la API o librería, el comando y el servicio web;pues todos ellos proporcionan un mecanismo para insertar y extraer datos de un docu-mento de hojas de cálculo soportando los principales formatos del mercado, tanto deMicrosoft Excel como de OpenOffice.org.

Objetivo específico 1: Los formatos de documentos de hojas de cálculo permitidos porlos artefactos software generados son: xls, xlt, xlsx, ods y ots. Por tanto se ha cumplidocon el objetivo, y cualquier otro formato ha sido considerado fuera del alcance delproyecto y por tanto tratado como un formato no válido.

Objetivo específico 2: Las operaciones con documentos de hojas de cálculo estableci-das por este objetivo también se cumplen por los tres artefactos software creados. Lasoperaciones son:

1. Creación y apertura de documentos de hojas de cálculo. Estas operaciones serealizan de manera sencilla al identificarse automáticamente el formato del do-cumento usando la extensión del fichero.

2. Extracción e inserción de datos en celdas. Estas operaciones se pueden realizarde manera que se diferencia el tipo de datos (numéricos o texto) a insertar en la

105

106 6. CONCLUSIONES

celda, y además se ofrece la posibilidad de llevar a cabo dichas operaciones conrangos de celdas.

3. Creación y eliminación de hojas de cálculo. Nuevamente estas operaciones sepermiten tanto en la API como en el comando y en el servicio web, ofreciendola posibilidad de referenciar a las hojas con las que se quiere operar usando elnombre o la posición.

Objetivo específico 3: Se permiten realizar operaciones de salvado con la posibilidadde realizar conversiones de formato, entre los formatos fijados como válidos por elobjetivo 2, en cada uno de los artefactos software generados. Para ello simplementees necesario cambiar la extensión del fichero al guardar el documento, de esta maneratoda la conversión se realiza de manera automática y transparente al usuario.

Objetivo específico 4: La exportación de un documento al formato PDF se permite enla API a través de una operación específica, y también se soporta en el comando y elservicio web.

Objetivo específico 5: Al utilizar Java y OpenOffice.org todos los artefactos generadosson multiplataforma, sin diferencia de uso para el desarrollador en caso de usar la API

o para el usuario si usa el comando o el servicio web. Sólo hay que tener en cuenta unadependencia que en sistemas GNU/Linux no se tiene y si en sistemas Windows, y esque es necesario tener una dll que permite acceder al registro para buscar el directoriode instalación OpenOffice.org; no obstante, esta dll se distribuirá siempre por defectosea cual sea la plataforma a utilizar.

Objetivo específico 6: El API de OpenSheet generada cumple con este objetivo, yademás su incorporación en las otras dos aplicaciones creadas, comando y servicioweb, validan su uso en otras aplicaciones y proyectos.

Objetivo específico 7: El comando generado está preparado para ser ejecutado desdeun terminal y no sólo permite hacer uso de las operaciones de la API a través delscript básico proporcionado, si no que permite utilizarse para múltiples propósitos,para ello basta con ampliar su funcionalidad simplemente creando un script escritoen Groovy, y aprovechando sus capacidades de inyección de dependencias desde unfichero .properties de datos.

Objetivo específico 8: El servicio web generado no sólo ofrece las funcionalidadesde la librería de manera remota, si no que al igual que el comando, permite ampliarsu funcionalidad a través de scripts escritos en Groovy y registrados. De esta maneraun usuario puede seleccionar que script desea utilizar y enviar una lista de variablesque serán inyectadas como dependencias a dicho script, para una vez finalizada laejecución devolver los ficheros resultantes.

6. CONCLUSIONES 107

Como se puede ver se ha cumplido ampliamente tanto con el objetivo general como concada uno de los ocho objetivos específicos marcados al comienzo del proyecto.

6.2. Posibles mejoras y ampliacionesAunque en la sección anterior se ha visto que se ha cumplido ampliamente con los objeti-

vos marcados al inicio del proyecto, durante el desarrollo del mismo se han detectado posi-bles mejoras y ampliaciones de funcionalidad que no han sido abordadas por estar fuera delalcance del proyecto, pero que son ahora propuestas como posibles desarrollos futuros.

Las posibles mejoras y ampliaciones detectadas han sido las siguientes:

6.2.1. Uso de OpenOffice.org remotoActualmente la API o librería OpenSheet, y por tanto las aplicaciones que la usan, nece-

sitan que en la máquina donde se vayan a utilizar esté instalada la suite ofimática OpenOffi-ce.org. Una de las posibilidades que permite la alternativa de usar OpenOffice.org, a travésde UNO, es la de conectarse por socket a un proceso remoto y hacer uso de sus funcionalida-des sin necesidad de tener instalada la suite en la máquina local donde se está ejecutando laaplicación que la va a usar.

Para permitir usar la API sin necesidad de tener instalada en la misma máquina la suiteofimática, se podría ampliar la funcionalidad de OpenSheet para que por configuración sepueda elegir el modo de conectarse a OpenOffice.org, ya sea a través de una tubería o pipe

para una conexión local, o a través de un socket por conexión remota.

Esta ampliación en la funcionalidad es sencilla de implementar pues sólo es necesariomodificar la clase Bootstrap, que se incluye en la API, para que lea de algun fichero deconfiguración la opción elegida y ya establezca el mecanismo de comunicación elegido conOpenOffice.org.

6.2.2. Soporte para fórmulasA través de OpenSheet se permite insertar y extraer datos de celdas, concretamente se

permite trabajar con datos numéricos y con cadenas de texto; pero OpenOffice.org ofreceotras posibilidades como trabajar con fórmulas.

Se podría incluir en la API de OpenSheet las operaciones para trabajar con fórmulas, yluego incorporar los mecanismos necesarios para usarlos en el comando y el servicio web.Las operaciones que se podrían implementar son:

Inserción de fórmula: permite insertar una fórmula a una celda o rango de celdas.

Extracción de fórmula: permite recuperar de una celda una fórmula asignada. Además,

108 6. CONCLUSIONES

también permitir la recuperación de todas las fórmulas de un rango.

Validación de fórmula: permite realizar la comprobación de si una fórmula es correctasintácticamente.

Esta ampliación de funcionalidad tiene un alcance mayor que la propuesta anterior pues esnecesario realizar cambios en el objeto SpreadSheet y en su interfaz ISpreadSheet. Ademássi se quiere usar desde el comando y el servicio web es necesario incluir cambios en el scriptcreado, de manera que se puedan incluir las fórmulas en el fichero de datos para permitir suuso.

6.2.3. Añadir nuevos tipos para la inserción de dependenciasEl objeto ScriptExecuter, usado tanto en el comando como en servicio web, es capaz de

interpretar algunas variables especiales definidas en un objeto Properties para crear objetos einyectarlos a un script. Actualmente los tipos de variables especiales que se soportan son:

@number;: se transforma en un objeto de tipo Double.

@list;: genera una lista de cadenas con los valores que le acompañan.

@OpenSheetManager;: inyecta el objeto OpenSheetManager para que sea utilizadopor el script.

@OpenSheetDocument;: permite crear o abrir un documento creando un objeto OpenS-heetDocument que es inyectado a la variable correspondiente del script.

Aunque se puede delegar a los scripts que a partir de la cadena de texto recuperada lainterpreten y generen los objetos que necesiten, sería bueno ampliar los tipos de variablesespeciales que se soportan, algunos tipos que podrían ser útiles:

Lista heterogénea: definir una lista que sea capaz de contener a su vez otras variablesespeciales de manera que se puedan crear listas heterogéneas. Por ejemplo una listaque contenga objetos de tipo cadena y de tipo numérico.

Mapa básico: permitir crear mapas de clave/valor donde ambos sean tratados comocadenas.

Mapa heterogéneo: permitir crear mapas donde la clave sea una cadena y el valorpueda ser cualquier tipo de las variables especiales.

El implementar estos mecanismos no es complejo, la dificultad viene dada por la necesidadde diseñar una sintaxis sencilla, que permita escribir como el valor de una propiedad todo lo

6. CONCLUSIONES 109

necesario para crear objetos de esos tipos. La sintaxis sencilla es imprescindible puesto queestos tipos serán usados en los ficheros de datos o lista de variables que en la mayoría de loscasos serán escritos por usuarios.

6.2.4. Crear nuevos scripts para uso generalLa característica más destacada de las aplicaciones generadas, tanto el comando como

el servicio web, son las posibilidades que permiten gracias a la capacidad de ejecución descripts de Groovy y la capacidad de inyección de dependencias. Como muestra de esto se hacreado un script para uso genérico que en función de los datos recibidos realiza una serie deoperaciones sobre hojas de cálculo, pero las posibles funciones de estos artefactos softwarevan más allá, simplemente creando nuevos scripts en lenguaje Groovy.

Algunas ideas que pueden contener los scripts son:

Envío de correo electrónicos: se puede añadir en los scripts por ejemplo para progra-mar una tarea que compruebe el contenido de determinadas celdas de documentos dehojas de cálculo y según ciertos valores enviar correos electrónicos con algún aviso.Por ejemplo, en una empresa donde el control de gestión o la contabilidad se almaceneen documentos de hojas de cálculo, se programe una tarea que lance el comando condicho script de manera que se comprueben las celdas que contienen los valores clave yque si hay alguna anomalía envíe un correo a los departamentos y personas indicadas.

Consultas a bases de datos: se puede añadir en los scripts la posibilidad de conectarsea bases de datos para integrar su uso con el de las hojas de cálculo. Por ejemplo, pararealizar una migración en la que se quieren almacenar todos los datos almacenados enhojas de cálculo a una base de datos.

Conectividad por socket: se puede añadir la manera de comunicarse con otras ope-raciones a través de sockets para obtener datos a insertar en documentos y viceversapara enviar datos leídos.

Ejecución de otras aplicaciones: se puede añadir la posibilidad de que se indique enel fichero de datos la ruta de las aplicaciones a ejecutar, de manera que haciendo usode los objetos de OpenSheet se extraigan datos de documentos de hojas de cálculo yse usen como argumentos en la ejecución.

6.2.5. Permitir dependencias entre scriptsActualmente el ScriptExecuter tiene la limitación de que no permite que el script a ejecutar

tenga dependencias de otros scripts, de manera que si existen funciones en otros scripts deGroovy estos no se resuelven correctamente y falla.

110 6. CONCLUSIONES

El resolver esta limitación permitiría reutilizar con OpenSheet aquellos scripts escritos enGroovy para otros propósitos que estuvieran divididos en diferentes ficheros.

6.3. Conclusiones personalesA continuación se exponen las conclusiones personales del autor sobre las experiencias

que se han tenido durante el desarrollo del proyecto.

6.3.1. Conclusiones sobre la metodología de planificaciónLas conclusiones personales sobre el uso de la adaptación de la metodología ágil Scrum y

de las características del entorno de este proyecto son las siguientes:

1. Utilizar desarrolladores para llevar a cabo un proyecto o las partes principales sin quetengan una dedicación completa aumenta la dificultad tanto de gestión como de plani-ficación.

2. La metodología de planificación usada permite detectar enseguida las desviaciones delas planificaciones y actuar en consecuencia.

3. El cambiar los requisitos durante el desarrollo del proyecto se ha realizado de manerasencilla, permitiendo adaptar rápidamente la planificación a las nuevas necesidades.Creo que a día de hoy ofrece más posibilidades la rápida adaptación de los requisitos,que el tratar de prever todas las posibles necesidades cuando no se tiene todo el cono-cimiento de la solución, pues normalmente durante el desarrollo se adquieren nuevosconocimientos que permiten a su vez detectar nuevos requisitos.

6.3.2. Conclusiones sobre la metodología de desarrolloLas conclusiones personales sobre el uso de TDD como metodología de desarrollo han

sido las siguientes:

1. El uso de TDD es complejo para desarrollares que estén acostumbrados a implementarprimero la solución y a realizar las pruebas después, lo que aumenta en algunos casosel tiempo de desarrollo.

2. El realizar el diseño a partir de las pruebas garantiza que todo el código va a estarprobado. De esta manera se evita que una vez realizado el código haya que modificarlopara poder probarlo. Esto sucede cuando es necesario realizar cambios en la visibilidadde métodos o es necesario añadir nuevos métodos para poder inyectar mocks para poderrealizar pruebas unitarias.

6. CONCLUSIONES 111

3. Todos los tipos de pruebas son importantes, y aunque se cumplan todas las pruebas uni-tarias siempre pueden aparecer problemas ocultos a través de la realización de pruebasde integración o de sistema.

4. La refactorización que define el algoritmo de TDD permite eliminar el código repetido,y por tanto innecesario, en cuanto se crea, obligando a tener código más limpio ymantenible. Esta refactorización se aplica tanto en el código de la aplicación como enlas pruebas, donde habitualmente se un uso inadecuado del copiar y pegar.

5. Es imprescindible tener conocimientos de patrones de diseño y tener un buen criteriopara estructurar aplicaciones cuando se realiza el paso de refactorización. Pues es lamanera de poder obtener buenos diseños como resultados de aplicar este paso delalgoritmo de TDD.

6. La refactorización no es un paso automático pues necesita que se apliquen los criteriosnecesarios para que de ella de como resultado un buen diseño, pero si es un pasofundamental.

ANEXOS

Anexo A

Manual de usuario

A.1. OpenSheet CommandOpenSheet Command es una herramienta escrita en Java que permite operar con docu-

mentos de hojas de cálculo de manera automática a partir de los datos contenidos en unfichero .properties pasado en la ejecución y de un script de acciones seleccionado. Esta he-rramienta esta diseñada para ser ejecutada desde un terminal o consola del sistema, y haceuso de OpenSheet API y OpenOffice.org Calc.

OpenSheet Commnad, a través del script que proporciona, permite realizar las siguientesoperaciones según los valores asignados en el fichero de datos a usar en la ejecución:

Inserción y extracción de datos de celdas.

Añadir y eliminar hojas de cálculo a un documento.

Conversión de un documento a cualquiera de los formatos de hojas de cálculo sopor-tados (xls, xlt, xlsx, ods, odt).

Exportar un documento de hojas de cálculo a PDF.

A.1.1. InstalaciónLa instalación de OpenSheet Command es muy simple pues basta con descomprimir el

fichero distribuido en el directorio deseado. De esa manera se tendrá el propio comandoOpenSheetCommand.jar y otros directorios que necesita el comando, por tanto para garanti-zar su correcto funcionamiento es necesario mantener la estructura que genera el fichero trassu descompresión.

Para poder usar el comando es necesario tener instalados los siguientes requisitos:

Sistema operativo Windows o GNU/Linux

Java JRE 6

OpenOffice.org 3.0 o superior.

115

116 A. MANUAL DE USUARIO

A.1.2. OperaciónPara ejecutar el comando se debe escribir en un terminal o consola del sistema lo siguien-

te:

java -jar OpenSheetCommand.jar -script={script_file} -data={data_file}

Listado A.1: Ejecución OpenSheet Command

En lo indicado en el listado A.1 se deben sustituir los valores entre llaves por los ficherosque correspondan. La descripción de los argumentos es la siguiente:

-script= : Es el argumento utilizado para indicar el script a ejecutar, en lugar de {script_file}se debe poner la ruta al script que se desea ejecutar. Este argumento es obligatorio.

-data= : Es el argumento utilizado para indicar el fichero de datos .properties que contienennombres de las variables y los valores a inyectar en el script seleccionado. En lugarde {data_file} se debe poner la ruta al fichero .properties que se desea utilizar. Esteargumento es obligatorio.

A continuación, se describirá el formato genérico de los ficheros de datos.

A.1.3. Formato de fichero de datosEl fichero de datos es un fichero .properties de Java, es decir, es un fichero con pares

clave/valor sensibles a mayúsculas, donde la clave es el identificador de la variable a la quese le va a inyectar el valor.

El comando por cada clave definida, asigna una cadena con el valor a la variable del scriptque tiene como nombre el mismo que el de la clave.

Existen unos valores reservados para asignar a las claves, de manera que a la variable delscript en lugar de asignarle una cadena con el valor, se le inyecta un objeto. Todo valor re-servado tiene la siguiente sintaxis: @palabra_reservada; seguido de los valores necesariossegún la variable especial a utilizar.

Las variables especiales para inyectar objetos son:

@OpenSheetManager; : Permite inyectar el objeto OpenSheetManager para poder crear yabrir documentos de hojas de cálculo desde el script. Un ejemplo de uso es:

manager = @OpenSheetManager;

Listado A.2: Ejemplo de uso de variable especial @OpenSheetManager;

A. MANUAL DE USUARIO 117

Con el listado A.2 se inyectará el objeto OpenSheetManager a la variable manager delscript que se va a ejecutar.

@OpenSheetDocument;create,ruta_fichero : Crea un nuevo documento de hojas de cálcu-lo en la ruta indicada, representado por un objeto IOpenSheetDocument que será in-yectado a la variable del script indicada. Un ejemplo de uso es:

documento1 = @OpenSheetDocument;create,contabilidad1.ods

Listado A.3: Ejemplo de uso de variable especial @OpenSheetDocument; para crear undocumento

Con el listado A.3 se creará un documento en la ruta de ejecución de tipo ods con elnombre indicado y además se inyectará el objeto OpenSheetDocument, que permitetrabajar con dicho documento, a la variable documento1 del script que se va a ejecutar.

@OpenSheetDocument;open,ruta_fichero : Abre un documento de hojas de cálculo quese encuentra en la ruta indicada, representado por un objeto IOpenSheetDocument queserá inyectado a la variable del script indicada. Un ejemplo de uso es:

documento1 = @OpenSheetDocument;open,movimientos.xls

Listado A.4: Ejemplo de uso de variable especial @OpenSheetDocument; para abrir undocumento

Con el listado A.4 se abrirá el documento movimientos.xls almancenado en la rutade ejecución y de tipo xls y además se inyectará el objeto OpenSheetDocument, quepermite trabajar con dicho documento, a la variable documento1 del script que se va aejecutar.

@number;numero : Permite crear objetos de tipo Double. Algunos ejemplos de uso son:

interes = @number;2.5

Listado A.5: Ejemplo de uso de variable especial @number;

Con el listado A.5 se creará un objeto de tipo Double con el valor de 2.5 que seráinyectado en la variable interes del script que se va a ejecutar.

@list;valor1,valor2 : Permite crear un objeto List, concretamente una lista de cadenas, don-de cada valor va separado por una coma. Hay que tener en cuenta las siguientes carac-terísticas:

1. Todos los espacios entre los separadores de valores son añadidos a la cadena.


2. Para insertar un elemento con la cadena vacía basta con poner el separador sinningún contenido dentro.

3. Para usar la coma como valor dentro del elemento cadena a añadir en la lista, sedebe escapar usando //,

Algunos ejemplos de uso:

laborables = @list;lunes,martes,miercoles,jueves,viernes

Listado A.6: Ejemplo de uso de variable especial @list;

Con el listado A.6 se creará un objeto de tipo List con cinco objetos String (“lunes”,“martes”, “miércoles”, “jueves”, “viernes”) que será inyectado en la variable labora-

bles del script que se va a ejecutar.

vacaciones = @list;1//,2//,3 y 4 de enero,15//,16 y 17 de agosto

Listado A.7: Ejemplo de uso de variable especial @list; con escape del separador

Con el listado A.7 se inyectará un objeto List con dos objetos String (“1,2,3 y 4 deenero”, “15,16 y 17 de agosto”) a la variable vacaciones del script que se va a ejecutar.

var1 = @list;,ok,,ok

Listado A.8: Ejemplo de uso de variable especial @list; con cadenas vacias

Con el listado A.8 se inyectará un objeto List con cuatro objetos String (“”, “ok”, “”,“ok”) a la variable var1 del script que se va a ejecutar.

A.1.4. Uso del script OpenSheetScript.groovyCon la aplicación OpenSheet Command se distribuye un script, OpenSheetScript.groovy,

preparado para realizar las principales operaciones con documentos de hojas de cálculo, quepermite la API de OpenSheet, a través de la asignación de valores a una variables definidaspor dicho script. Las operaciones que permite realizar el script son:

Inserción y extracción de datos de celdas.

Añadir y eliminar hojas de cálculo a un documento.

Conversión de un documento a cualquiera de los formatos de hojas de cálculo sopor-tados (xls, xlt, xlsx, ods, odt).


Exportar un documento de hojas de cálculo a PDF.

Para indicar al script que operaciones se desean realizar, es necesario hacerlo a través delfichero de datos .properties. Para ello es necesario que el fichero contenga todas las clavesdefinidas por el script, aunque a algunas no se les asigne ningún valor. Las claves o variablesdefinidas por el script son las siguientes:

1. openSheetDocument: Es la variable que contiene el objeto OpenSheetDocument conel que debe trabajar. Siempre debe llevar valor, y debe ser la variable especial de co-mando @OpenSheetDocument; con los parámetros deseados.

2. logFileName: Es la variable donde se le puede especificar la ruta y el nombre del fi-chero de log. Si no se le asigna valor, por defecto crea un fichero en la ruta de ejecucióncon el nombre opensheet.log.

3. deleteSheets: Es la variable donde se le indica el nombre de las hojas de cálculo quese quieren borrar en el documento. Si no se asigna valor no realizará la operación deborrado por nombre.

4. deleteSheetsByPosition: Es la variable donde se le especifica la posición de las hojasde cálculo que se quieren borrar en el documento. Si no se asigna valor no realizará laoperación de borrado por posición.

5. addSheets: Es la variable donde se le asigna el nombre de las hojas de cálculo que sequieren añadir al documento. Si no se asigna valor no realizará la operación de añadirhojas de cálculo.

6. insertCellsValues: Es la variable donde se asigna cada uno de los valores a insertar enceldas como texto, usando el nombre de las hojas de cálculo para referenciarlas. Si nose asigna valor a la variable no realizará la operación que representa.

7. insertCellsValuesBySheetPosition: Es la variable donde se asigna cada uno de losvalores a insertar en celdas como texto, usando la posición de las hojas de cálculopara referenciarlas. Si no se asigna valor a la variable no realizará la operación querepresenta.

8. insertCellsNumericValues: Es la variable donde se le asigna cada uno de los valoresa insertar en celdas como valores numéricos, usando el nombre de las hojas de cálculopara referenciarlas. Si no se asigna valor a la variable no realizará la operación querepresenta.

9. insertCellsNumericValuesBySheetPosition: Es la variable donde se le asigna cadauno de los valores a insertar en celdas como valores numéricos, usando la posición de


las hojas de cálculo para referenciarlas. Si no se asigna valor a la variable no realizarála operación que representa.

10. extractCellsValues: Es la variable donde se le especifica las celdas que de las que sequiere extraer su valor a un fichero, usando el nombre de las hojas de cálculo para refe-renciarlas. Si no se asigna valor a la variable no realizará la operación que representa.

11. extractCellsValuesBySheetPosition: Es la variable donde se le especifica las celdasque de las que se quiere extraer su valor a un fichero, usando la posición de las hojas decálculo para referenciarlas. Si no se asigna valor a la variable no realizará la operaciónque representa.

12. extractCellsValuesFile: Es la variable donde se le puede especificar la ruta y el nom-bre del fichero donde se deben guardar los valores extraídos de las celdas. Si no se leasigna valor, por defecto crea un fichero en la ruta de ejecución con el nombre opens-heet.out.

13. saveDocumentTo: Es la variable donde se le puede especificar que guarde el docu-mento modificado con otro nombre y formato. Es decir, se puede usar para realizaruna conversión de formato, para ello basta con usar un nombre de fichero con la ex-tensión del formato al que se desea convertir. Además, también permite la exportacióna PDF. Si no se le asigna valor entonces realiza el salvado en el fichero de origenindicado en la variable openSheetDocument.

Hay que tener en cuenta que siempre deben estar definidas todas las variables en el fiche-ro de datos, en el caso de que no se quiera realizar alguna acción, basta con no asignarlevalor.

A continuación, se explicará en mayor de detalle cada una de las variables del script.

Variable openSheetDocumentEs la variable donde el script espera recibir el objeto de tipo OpenSheetDocument con el

que debe trabajar; es decir, se le debe asignar la variable especial, explicada en el apartadodel formato del fichero de datos, @OpenSheetDocument; con los parámetros adecuadossegún si se quiere crear un nuevo documento de hojas de cálculo o abrir uno ya existente.Es obligatorio que esta variable tenga siempre un valor válido asignado. Unos ejemplos deasignación de valores a esta variable son:

openSheetDocument = @OpenSheetDocument;create,doc.ods

Listado A.9: Ejemplo de asignación de nuevo documento a la variable openSheetDocumentde OpenSheetScript


En el listado A.9 se muestra un ejemplo para asignarle a la variable un nuevo documentollamado doc.ods para trabajar con OpenSheetScript.

openSheetDocument = @OpenSheetDocument;open,doc.ods

Listado A.10: Ejemplo de asignación de un documento a la variable openSheetDocument deOpenSheetScript

En el listado A.10 se muestra un ejemplo para asignar a la variable un documento de hojasde cálculo ya existente llamado doc.ods para trabajar con OpenSheetScript.

Variable logFileNameEs la variable donde se le puede indicar al script el nombre y ruta donde se desea guardar

el fichero de log que genera durante su ejecución. En el caso de que no se asigne valor, pordefecto, crea un fichero de log en el directorio de ejecución con el nombre opensheet.log.Unos ejemplos de asignación de valores a esta variable son:

logFileName =

Listado A.11: Ejemplo de uso por defecto de la variable logFileName

En el listado A.11 se muestra un ejemplo para usar el fichero de log por defecto, es decir,que no se ha asignado ningún valor a la variable.

logFileName = prueba.log

Listado A.12: Ejemplo de asignación de un fichero a la variable logFileName deOpenSheetScript

En el listado A.12 se muestra un ejemplo para asignar a la variable el nombre de ficheroprueba.log que debe utilizar para crear el log; en ese caso se creará en el mismo directoriode ejecución.

Variable deleteSheetsEs la variable donde el script espera recibir la información para realizar el borrado de

hojas de cálculo a partir de los nombres de estas. Si no se asigna ningún valor a esta variableno se realizará la acción relacionada con ella. El valor a introducir en el caso de quererrealizar la acción de borrado debe ser cada una de las hojas de cálculo a borrar separadas porpunto y coma. Una cosa a tener en cuenta, es que para permitir borrar todas las hojas de undocumento el script siempre realiza antes la operación de añadir hojas de cálculo, es decir,si crea un documento de hojas de cálculo nuevo y se desea borrar las tres hojas por defecto,se puede hacer añadiendo hojas a través de la variable adecuada en el fichero de datos. Unejemplo de asignación de valores a esta variable es:


deleteSheets = hoja1;facturas enero;borrador

Listado A.13: Ejemplo de asignación de valores a la variable deleteSheets deOpenSheetScript

En el listado A.13 se muestra un ejemplo para asignarle a la variable los nombres para queborre tres hojas de cálculo del documento: hoja1, facturas enero y borrador.

Variable deleteSheetsByPositionEs la variable donde el script espera recibir la información para realizar el borrado de hojas

de cálculo a partir de la posición de estas. Si no se asigna ningún valor a esta variable no serealizará la acción relacionada con ella. El valor a introducir en el caso de querer realizar laacción de borrado debe ser cada una de las posiciones de hojas de cálculo a borrar separadaspor punto y coma. Es importante tener en cuenta tres cosas, la primera es que las posicionesempiezan con el 0; la segunda es que una vez que se borra una hoja de cálculo, todas lashojas que estaban detrás de la eliminada reducen su posición en uno; la tercera cosa a teneren cuenta, es que para permitir borrar todas las hojas de un documento el script siemprerealiza antes la operación de añadir hojas de cálculo. Uns ejemplos de asignación de valoresa esta variable son:

deleteSheets = 2;1;0

Listado A.14: Ejemplo de asignación de valores a la variable deleteSheetsByPosition deOpenSheetScript

En el listado A.14 se muestra un ejemplo para borrar las hojas de las posiciones 2, 1 y0. Al colocar las variables en el orden inverso, el borrado se puede realizar sin problemas,puesto que al borrar la 2 no afectará al orden de la 1 y de la 0, y así sucede con la 1.

deleteSheets = 0;0;0

Listado A.15: Ejemplo de asignación de valores repetidos a la variabledeleteSheetsByPosition de OpenSheetScript

En el listado A.15 se muestra un ejemplo que da el mismo resultado que el ejemplo dellistado A.14, es decir, primero se borrará la primera hoja de cálculo, por lo que la segundapasará a ser la primera, y la tercera la segunda y así sucesivamente; después, se borrará laprimera hoja de cálculo que en realidad era la segunda en el original, y después se volverá aborrar la primera que era la tercera en el orden original.

Variable addSheetsEs la variable donde el script espera recibir la información para añadir nuevas hojas de

cálculo a partir de los nombres de estas. Si no se asigna ningún valor a esta variable no se


realizará la acción relacionada con ella. El valor a introducir en el caso de querer realizarla acción de añadir hojas de cálculo debe ser el nombre de cada una de las hojas de cálculoa añadir separadas por punto y coma. Una cosa a tener en cuenta es que siempre se realizaantes la operación de añadir hojas de cálculo que las de borrado, esto permite poder borrartodas las hojas de cálculo existentes o por defecto. Un ejemplo de asignación de valores aesta variable es:

addSheets = hoja1;facturas enero;borrador

Listado A.16: Ejemplo de asignación de valores a la variable addSheets de OpenSheetScript

En el listado A.16 se muestra un ejemplo para asignarle a la variable los nombres para queañada tres hojas de cálculo al documento: hoja1, facturas enero y borrador.

Variable insertCellsValuesEs la variable donde el script espera recibir la información para insertar valores de tipo

texto o cadena a celdas de las diferentes hojas de cálculo del documento, referenciadas pornombre. Si no se asigna ningún valor a esta variable no se realizará la acción relacionada conella. El valor a introducir en el caso de querer realizar la acción de insertar valores de tipotexto es nombre_hoja_calculo:celda1=valor1,celda2=valor2 y separado por punto y comapara las diferentes hojas de cálculo. Un ejemplo de asignación de valores a esta variable es:

insertCellsValues = hoja1:c6=Resumen mensual,d5=Del 1 al20;facturas enero:aa1=Diferencial,a2=11/04/2011;listado:b12=Generadomensualmente

Listado A.17: Ejemplo de asignación de valores a la variable insertCellsValues deOpenSheetScript

En el listado A.17 se muestra un ejemplo para asignarle a la variable el valor para que aña-da diferentes textos a celdas de tres hojas de cálculo, concretamente, en la hoja de cálculollamada hoja1 se insertarán en la celda c6 el texto “Resumen mensual” y en la celda d5 eltexto “Del 1 al 20”; en la hoja facturas enero se insertarán en la celda aa1 el texto “Diferen-cial” y en la celda a2 “11/04/2011”; por último, en la celda b12 de la hoja listado se insertaráel texto “Generado mensualmente”.

Variable insertCellsValuesBySheetPositionEs la variable donde el script espera recibir la información para insertar valores de tipo

texto o cadena a celdas de las diferentes hojas de cálculo del documento, referenciadas porposición. Si no se asigna ningún valor a esta variable no se realizará la acción relacionadacon ella. El valor a introducir en el caso de querer realizar la acción de insertar valores detipo texto es posicion_hoja_calculo:celda1=valor1,celda2=valor2 y separado por punto ycoma para las diferentes hojas de cálculo. La primera posición se corresponde con el 0. Unejemplo de asignación de valores a esta variable es:


insertCellsValuesBySheetPosition = 0:c6=Resumen mensual,d5=Del 1 al20;2:aa1=Diferencial,a2=11/04/2011;1:b12=Generadomensualmente


En el listado A.18 se muestra un ejemplo para asignarle a la variable el valor para queañada diferentes textos a celdas de tres hojas de cálculo, concretamente, en la hoja de cálculocon la primera posición se insertarán en la celda c6 el texto “Resumen mensual” y en la celdad5 el texto “Del 1 al 20”; en la hoja con la tercera posición se insertarán en la celda aa1 eltexto “Diferencial” y en la celda a2 “11/04/2011”; por último, en la celda b12 de la hoja consegunda posición se insertará el texto “Generado mensualmente”.

Variable insertCellsNumericValuesEs la variable donde el script espera recibir la información para insertar valores de tipo nu-

mérico a celdas de las diferentes hojas de cálculo del documento, referenciadas por nombre.Si no se asigna ningún valor a esta variable no se realizará la acción relacionada con ella. Elvalor a introducir en el caso de querer realizar la acción de insertar valores de tipo numéricoes nombre_hoja_calculo:celda1=valor1,celda2=valor2 y separado por punto y coma paralas diferentes hojas de cálculo. Un ejemplo de asignación de valores a esta variable es:

insertCellsNumericValues = hoja1:c6=12.45,d5=1050;facturasenero:aa1=275589,a2=23;listado:b12=31


En el listado A.19 se muestra un ejemplo para asignarle a la variable el valor para queañada diferentes valores numéricos a celdas de tres hojas de cálculo, concretamente, en lahoja de cálculo llamada hoja1 se insertarán en la celda c6 el valor numérico 12.45 y en lacelda d5 1050; en la hoja facturas enero se insertarán en la celda aa1 el valor numérico275589 y en la celda a2 23; por último, en la celda b12 de la hoja listado se insertará el valornumérico 31.

Variable insertCellsNumericValuesBySheetPositionEs la variable donde el script espera recibir la información para insertar valores de tipo nu-

mérico a celdas de las diferentes hojas de cálculo del documento, referenciadas por posición.Si no se asigna ningún valor a esta variable no se realizará la acción relacionada con ella. Elvalor a introducir en el caso de querer realizar la acción de insertar valores de tipo numéricoes posicion_hoja_calculo:celda1=valor1,celda2=valor2 y separado por punto y coma paralas diferentes hojas de cálculo. La primera posición se corresponde con el 0. Un ejemplo deasignación de valores a esta variable es:


insertCellsNumericValuesBySheetPosition = 0:c6=12.45,d5=1050;2:aa1=275589,a2=23;1:b12=31

mensualmente


En el listado A.18 se muestra un ejemplo para asignarle a la variable el valor para queañada diferentes valores numéricos a celdas de tres hojas de cálculo, concretamente, en lahoja de cálculo con la primera posición se insertarán en la celda c6 el valor numérico 12.45y en la celda d5 1050; en la hoja con la tercera posición se insertarán en la celda aa1 el valornumérico 275589 y en la celda a2 23; por último, en la celda b12 de la hoja con segundaposición se insertará el valor numérico 31.

Variable extractCellsValuesEs la variable donde el script espera recibir la información para extraer los de celdas de

las diferentes hojas de cálculo del documento, referenciadas por nombre. Si no se asignaningún valor a esta variable no se realizará la acción relacionada con ella. El valor a in-troducir en el caso de querer realizar la acción de extracción de valores es nombre_hoja_-calculo:celda1,celda2 y separado por punto y coma para las diferentes hojas de cálculo. Losvalores extraídos se guardarán en el fichero que contenga la variable extractCellsValuesFile.Un ejemplo de asignación de valores a esta variable es:

extractCellsValues = hoja1:c6,d5;facturas enero:aa1,a2;listado:b12

Listado A.21: Ejemplo de asignación de valores a la variable extractCellsValues deOpenSheetScript

En el listado A.21 se muestra un ejemplo para asignarle a la variable el valor para queextraiga de diferentes celdas los valores que contengan, concretamente de celdas de treshojas de cálculo: de la hoja de cálculo llamada hoja1 se extraerán los valores almacenadosen las celdas c6 y d5; de la hoja facturas enero se extraerán los valores de las celdas aa1 ya2; por último, se extraerá el valor de la celda b12 de la hoja listado.

Variable extractCellsValuesBySheetPositionEs la variable donde el script espera recibir la información para extraer los de celdas de las

diferentes hojas de cálculo del documento, referenciadas por posición. Si no se asigna nin-gún valor a esta variable no se realizará la acción relacionada con ella. El valor a introduciren el caso de querer realizar la acción de extracción de valores es posicion_hoja_calcu-lo:celda1,celda2 y separado por punto y coma para las diferentes hojas de cálculo; teniendoen cuenta que la primera posición se corresponde con el 0. Los valores extraídos se guarda-rán en el fichero que contenga la variable extractCellsValuesFile. Un ejemplo de asignaciónde valores a esta variable es:


extractCellsValues = 0:c6,d5;2:aa1,a2;1:b12

Listado A.22: Ejemplo de asignación de valores a la variableextractCellsValuesBySheetPosition de OpenSheetScript

En el listado A.22 se muestra un ejemplo para asignarle a la variable el valor para queextraiga de diferentes celdas los valores que contengan, concretamente de celdas de treshojas de cálculo: de la hoja de cálculo que se encuentra en la primera posición se extraeránlos valores almacenados en las celdas c6 y d5; de la tercera hojas se extraerán los valores delas celdas aa1 y a2; por último, se extraerá el valor de la celda b12 de la segunda hoja.

Variable extractCellsValuesFileEs la variable donde se le puede indicar al script el nombre y ruta donde se desea guardar el

fichero con los datos extraídos de las celdas. En el caso de que no se asigne valor, por defecto,crea un fichero en el directorio de ejecución con el nombre opensheet.out. El fichero creadotiene la estructura de un fichero .properties, donde como clave escribe el nombre de la hoja decálculo y a continuación la celda, ambas separadas por un punto. Un ejemplo sería “hoja1.d2= 23” donde se indica que la celda d2 de la hoja 1 tiene un valor de 23. Hay que tener encuenta que si el nombre de la hoja de cálculo contiene espacios entonces no se generará unfichero de propiedades válido. Unos ejemplos de asignación de valores a esta variable son:

extractCellsValuesFile =

Listado A.23: Ejemplo de uso por defecto de la variable extractCellsValuesFile

En el listado A.23 se muestra un ejemplo para usar el fichero de extracción por defecto, esdecir, que no se ha asignado ningún valor a la variable.

extractCellsValuesFile = resultados_doc1

Listado A.24: Ejemplo de asignación de un fichero a la variable extractCellsValuesFile deOpenSheetScript

En el listado A.24 se muestra un ejemplo para asignar a la variable el nombre de fiche-ro resultados_doc1 que debe utilizar para crear el fichero donde se almacenarán los datosextraídos de las celdas del documento; en ese caso se creará en el mismo directorio de eje-cución.

Variable saveDocumentToEs la variable donde se le puede indicar al script un nuevo nombre y ruta donde se desea

guardar el fichero con el que ha estado trabajando el script. Si el nombre de fichero indicadotiene otra extensión se realizará la conversión a ese formato, y si la extensión es PDF se


realizará la exportación. En el caso de que no se asigne valor, por defecto, realizará la ope-ración de salvado sobre el fichero pasado a través de la variable openSheetDocument. Unosejemplos de asignación de valores a esta variable son:

saveDocumentTo =

Listado A.25: Ejemplo de uso por defecto de la variable saveDocumentTo

En el listado A.25 se muestra un ejemplo para salvar las modificaciones sobre el docu-mento de entrada, es decir, que no se ha asignado ningún valor a la variable.

saveDocumentTo = doc2.xls

Listado A.26: Ejemplo de asignación de un fichero a la variable saveDocumentTo deOpenSheetScript

En el listado A.26 se muestra un ejemplo para asignar a la variable el nombre de ficherodoc2.xls, que será el fichero en el que se guardarán los cambios realizados en el fichero deentrada. Si el fichero de entrada usado tiene una extensión distinta al asignado, de maneraautomática se realizará la conversión al formato del fichero asignado.

saveDocumentTo = resultados.pdf

Listado A.27: Ejemplo de asignación de un fichero con extensión PDF a la variablesaveDocumentTo de OpenSheetScript

En el listado A.27 se muestra un ejemplo para asignar a la variable el nombre de ficheroresultados.pdf, de manera que el contenido del documento será exportado a un documentode tipo PDF, y en el documento de entrada no se guardarán los cambios realizados.

A.1.5. Ejemplo de uso de OpenSheet CommandEn este apartado se va a mostrar un ejemplo para usar OpenSheet Command, haciendo

uso del script con el que se distribuye el comando.

Los supuestos del ejemplo son los siguientes: en una empresa se tiene un documentode Excel que se quiere usar a modo de plantilla, es decir, insertar los datos de facturas yguardarlos en otro documento sin modificar el que se usa como plantilla.

La plantilla cuenta con una hoja de cálculo por cada mes, y otra más llamada totales. Sequiere insertar los datos relativos a una factura, concretamente hay que insertar los siguientesdatos:


En la hoja enero hay que insertar en la fila 2 desde la columna A hasta la E, el nombrede la empresa, el NIF, nombre producto, cantidad y precio por unidad.

En la hoja totales hay que insertar el nombre de la empresa concretamente en la celdaaa2.

Además se quieren extraer los datos de la celda A7 de la hoja enero y de la celda ab55 de lahoja totales.

Si los datos a insertar son de los siguientes:

Nombre empresa : Tapones S.A

NIF : A-762222

Producto : Corchos PAF-QA1

Cantidad : 105000

Precio unidad : 0,015

El fichero de datos que hay que generar es el siguiente:

openSheetDocument = @OpenSheetDocument;open,factura_plantilla.xlslogFileName = factura_plantilla.logdeleteSheets =deleteSheetsByPosition =addSheets =insertCellsValues = enero:a2=Tapones S.A,b2=A-762222,c2=Corchos PAF-QA1;

totales:aa2=Tapones S.AinsertCellsValuesBySheetPosition =insertCellsNumericValues = enero:d2=105000,e2=0,015insertCellsNumericValuesBySheetPosition =extractCellsValues = enero:a7;totales:ab55extractCellsValuesBySheetPosition =extractCellsValuesFile = extracto_insercion.txtsaveDocumentTo = factura_enero.xls

Listado A.28: Ejemplo de fichero de datos

En el fichero de datos del listado A.28 se han asignado valores sólo a las acciones quese desean realizar, por ejemplo no se van a añadir ni borrar hojas de cálculo, ni a insertaro a extraer valores a través de la posición de hojas de cálculo puesto que en este caso sólose conoce el nombre. Además de realizar las inserciones y extracciones correspondientes,se va a crear un fichero de log con el nombre factura_plantilla.log y otro con los datosextraídos, llamado extracto_insercion.txt. Además, todas las modificaciones realizadas seguardarán en un documento del mismo formato llamado factura_enero.xls sin modificar elfichero original.


Por último habría que ejecutar el comando pasandole el fichero de datos generado y elscript OpenSheetScript.groovy.

A.2. OpenSheet Web ServiceOpenSheet Web Service es un servicio web escrito en Java usando JAX-WS que permite

operar con documentos de hojas de cálculo a partir de la selección de un script de Groovy yuna lista de variables o pares clave/valor. Este servicio hace uso de OpenSheet API y Ope-nOffice.org Calc.

OpenSheet Web Service proporciona dos operaciones:

Operación listScripts: Esta operación devuelve una lista de objetos ScriptInfo con lainformación necesaria para utilizar cada uno de los scripts disponibles.

Operación executeScript: Esta operación permite ejecutar un script pasándole unalista de variables y un objeto Document que puede ser vacío; y una vez ejecutado elscript se devolverán los objetos Document que indiquen las variables de salida confi-guradas en la información del script.

A.2.1. RequisitosPara poder usar el comando es necesario tener instalados los siguientes requisitos:

Sistema operativo Windows o GNU/Linux

Java JRE 6

OpenOffice.org 3.0 o superior.

Contenedor de servlets Java (Tomcat por ejemplo)

A.2.2. DespliegueOpenSheet Web Service se distribuye en un fichero .war que hay que desplegar en el

contenedor de servlets que tenga instalado el usuario. Para más información se debe consultarel manual del propio contenedor.

A.2.3. Fichero web.xmlEn el fichero web.xml de OpenSheet Web Service se deben configurar dos variables:

OPENSHEET_SCRIPTS_DIRECTORY: es el directorio que escaneará el servicio weben cada arranque para localizar cada uno de los scripts de Groovy disponibles. Estos


scripts deben tener además un fichero de propiedades con el mismo nombre del scriptpero con extensión .properties, donde se indiquen las propiedades que necesita el ser-vicio para construir un ScriptInfo, esto se explicará con más detalle más adelante.

OPENSHEET_CACHE_DIRECTORY: es el directorio donde se guardarán los direc-torios temporales creados para cada llamada a la operación de ejecución de un script.Para evitar que dos llamadas al mismo script en el mismo momento pueda provocarsobreescrituras, el servicio crea un directorio con un nombre único en el momento derecibir la llamada y ahí es donde le indica al script que debe guardar todos los recur-sos. Este directorio único lo crea dentro del directorio temporal, y lo elimina cuandotermina la operación de ejecución.

A.2.4. Activar scriptsPor motivos de seguridad, sólo se pueden usar aquellos scripts de Groovy que se encuen-

tren dentro del directorio configurado en el fichero web.xml, y que además tengan un ficheroProperties con el mismo nombre que el script, pero con extensión .properties, con las si-guientes propiedades configuradas:

description: es la propiedad donde se debe explicar qué hace el script y cómo se usa,para que los clientes sepan que variables deben pasar al ejecutarlo.

outputVariables: son los nombres de variables del script que contienen la ruta de losficheros que deben ser devueltos tras la ejecución del script, separados por punto ycoma.

temporalDirectoryVariable: es el nombre de la variable del script donde el servicioweb debe indicarle que directorio temporal tiene asignado para que genere dentro deél los ficheros que necesite con el fin de evitar conflictos entre diferentes llamadas alscript.

Si un script de Groovy se encuentra en el directorio de scripts pero no existe un fichero consu nombre y la extensión .properties que contenga la información indicada, entonces no seráconsiderado un script válido para usarlo desde la operación de ejecución del servicio web.Esto obliga a que se defina siempre como usar el script, evitando así que se copien scriptsdirectamente en el directorio sin crear el fichero de información.

Para aquellas variables que contengan nombres de ficheros, puesto que el servicio webasigna un directorio temporal para cada ejecución, se debe utilizar sólo el nombre y no unaruta.

Cuando el servicio web lee en las propiedades un valor especial con @OpenSheetDocu-ment; lo preprocesa y le añade al nombre la ruta al directorio temporal.


Ejemplo de activación de script

En este ejemplo se va a configurar el script que se distribuye por defecto con OpenSheetCommand, OpenSheetScript.groovy.

Para usar el script lo primero es copiarlo en el directorio de scripts configurado en elfichero web.xml, en la variable OPENSHEET_SCRIPTS_DIRECTORY. A continuación, sedebe crear un fichero OpenSheetScript.properties con los siguientes valores:

description=OpenSheetScript es el script por defecto que permite realizarlas

operaciones basicas de la API. Para saber como se debe usar consultar elmanual

de usuario.outputVariables=saveDocumentTo;extractCellsValuesFiletemporalDirectoryVariable=tempDir

Listado A.29: Ejemplo de fichero Properties para script de servicio web

En el listado A.29 se puede ver que se ha añadido una descripción para explicar qué haceel script y cómo usarlo, se han indicado que variables contienen los ficheros que se debendevolver como resultados, en este caso la variable de salvar el fichero y la que contiene elnombre del fichero con los datos extraídos. Por último, se indica a que variable debe asignarel servicio web el directorio temporal para que el script lo use.

A.2.5. Clientes de OpenSheet Web ServiceNo se distribuyen clientes con el servicio web, no obstante es sencillo crear clientes para

este servicio a partir del uso de JAX-WS. Si se desea ampliar la información se debe consultarel manual de desarrollo.

Anexo B

Manual de desarrollo

Este manual está orientado tanto para aquellos desarrolladores que quieren hacer uso dela API de OpenSheet en sus aplicaciones como para los que quieren ampliar la funcionalidadde OpenSheet Command o Web Service a través de la creación de nuevos scripts.

B.1. Direcciones de interés

B.1.1. RepositorioEl proyecto OpenSheet cuenta con un repositorio donde siempre estará el último código

disponible para ser descargado por cualquier persona que así lo desee. La URL del reposito-rio es la siguiente: https://arco.esi.uclm.es/svn/public/prj/opensheet/En el directorio raíz del repositorio del proyecto se encuentran tres directorios:

trunk: Aquí es donde se puede encontrar el código principal que será usado para sacarlas versiones a distribuir de los diferentes componentes del proyecto. Si se desea tenerel código más actual y que vaya a formar parte de la siguiente versión, se puede cogerel código del trunk.

branches: Aquí es donde se generan diferentes ramas del proyecto para desarrollar enparalelo funcionalidades que en principio no se desean incorporar directamente al pro-yecto, y de hecho puede que no se lleguen a incorporar a ninguna versión del producto.Si alguno de los desarrollos que se alojan en este directorio se van a usar, entonces serealizará la operación de merge con el trunk, y por tanto, siempre se recomienda to-mar el código del trunk, dejando el código de este directorio a los desarrolladores delproyecto.

tags: En este directorio por cada versión sacada se realiza una instantánea del reposi-torio y se crea un directorio con el nombre de la versión. Este es el directorio donde sepueden obtener el código de alguna de las versiones distribuidas.

Dentro del directorio trunk la distribución del proyecto es la siguiente:

133

https://arco.esi.uclm.es/svn/public/prj/opensheet/

134 B. MANUAL DE DESARROLLO

doc: Es el directorio que contiene la documentación del proyecto. En este directorio seencuentra el documento de hojas de cálculo usado para la planificación, el anteproyectoy los ficheros de latex que corresponden a la memoria del proyecto, en los que seincluyen los manuales de usuario y de desarrollo.

src: Es el directorio donde se encuentra el código fuente del proyecto dividido en losdiferentes paquetes Java. Dentro del directorio src/org/opensheet/ se encuentra a su vezun directorio para los componentes del proyecto y para los scripts:

• api: Contiene el código referente a la API de OpenSheet.

• command: Contiene el código referente a OpenSheet Command y la clase paraejecutar scripts que también es compartida por el servicio web.

• webservice: contiene el código de OpenSheet Web Service, excepto la clase deejecución de scripts que se encuentra en el paquete del comando.

• scripts: contiene los scripts escritos en Groovy que se distribuyen con las versio-nes del comando y los scripts que sirven de test de estos. Actualmente sólo se hagenerado un script: OpenSheetScript.groovy.

test: Contiene el código de todos los tests del proyecto, y la estructura es la misma quela del directorio src, salvo porque no tiene el directorio scripts y en su lugar tiene undirectorio utils para las clases de utilidades de las pruebas.

B.1.2. Gestión de incidencias y peticiones de mejoraEl proyecto cuenta con una herramienta de seguimiento de errores o bugs, y de peticiones

de mejora para que los usuarios puedan abrir incidencias de los problemas encontrados ysolicitar mejoras. Esta herramienta se encuentra dentro de la aplicación Redmine, la URL eshttps://arco.esi.uclm.es:3000/projects/opensheet.

Además, desde la dirección de Redmine se puede ver la actividad del proyecto y realizarcomparación entre versiones desde la propia web.

B.2. OpenSheet APILa librería o API de OpenSheet permite incorporar al desarrollador la funcionalidad nece-

saria para trabajar con documentos de hojas de cálculo en Java de una manera sencilla, tantoen sistemas Windows como GNU/Linux.

OpenSheet API hace uso de OpenOffice.org Calc por lo que necesita que esté instalado enla máquina donde se va a usar, es necesario que la versión de la suite ofimática OpenOffi-ce.org sea 3.0 o superior. Al usar OpenOffice.org Calc se garantiza una gran compatibilidadentre los formatos soportados, un amplio soporte y madurez.

https://arco.esi.uclm.es:3000/projects/opensheet

B. MANUAL DE DESARROLLO 135

OpenSheet API es compatible con los formatos xls, xlt, xlsx, ods y odt. Y permite realizarlas siguientes operaciones:

Crear nuevos documentos con cualquiera de los formatos soportados.

Abrir documentos ya existentes de los formatos soportados.

Insertar datos numéricos o de texto a celdas o rango de celdas.

Extraer datos numéricos y de texto de celdas y rangos.

Crear nuevas hojas de cálculo en un documento.

Eliminar hojas de cálculo de un documento.

Realizar conversiones entre documentos de diferente formato.

Exportar un documento a PDF.

B.2.1. Ejemplos de usoA continuación se muestran diferentes fragmentos de código donde se muestra como llevar

a cabo las operaciones comentadas más arriba, con la intención de mostrar al desarrolladorla facilidad de uso de OpenSheet API.

OpenSheetManager oSheetManager = new OpenSheetManager();IOpenSheetDocument oDoc = oSheetManager.createDocument("balance.xls");

Listado B.1: Crear un nuevo documento con OpenSheet API

El listado B.1 se realiza la operación de creación de un nuevo documento, simplemente hayque crear el OpenSheetManager que se encarga de localizar la instalación de OpenOffice.org,arrancar el proceso y conectarse a él de manera totalmente transparente y automática; ydespués solicitarle al objeto creado que cree un documento con la ruta y el nombre que sedesee. La interfaz IOpenSheetDocument es la que nos permite trabajar con los documentosde hojas de cálculo.

OpenSheetManager oSheetManager = new OpenSheetManager();IOpenSheetDocument oDoc = oSheetManager.openDocument("balance.xls");

Listado B.2: Abrir un documento con OpenSheet API

El listado B.2 se muestra como abrir un documento de hojas de cálculo ya existente, dondeal igual que en el ejemplo anterior basta con crear el objeto OpenSheetManager y usar el mé-todo openDocument con la ruta y el fichero que se quiere abrir, de manera que nos devuelvela interfaz IOpenSheetDocument para trabajar con él.



ISpreadSheet sheet1 = oSheetDoc.getSpreadSheet(0);ISpreadSheet sheetJunio = oSheetDoc.getSpreadSheet("Junio");

sheet1.setCellValue(new CellPosition(0,0), "Revisado");sheet1.setCellValue(new CellPosition("a2"), "Proyecto A-T");sheet1.setCellValue(new CellPosition(2,1), 1500.0);sheetJunio.setCellValue(new CellPosition("a2"), 23.45);

Listado B.3: Insertar datos a celdas con OpenSheet API

El listado B.3 se muestra como insertar datos en celdas de las hojas de cálculo de un docu-mento, para ello se realiza la apertura de un documento balance.xls y se obtienen las interfa-ces ISpreadSheet con la llamada a getSpreadSheet para trabajar con dos hojas de cálculo, lahoja de la primera posición y otra con el nombre Junio. En las hojas se insertan los datos detexto o numéricos usando el método setCellValue con el objeto que representa la posición dela celda. Este objeto CellPosition puede ser creado mediante las posiciones X e Y o medianteel nombre de columna y fila.


ISpreadSheet sheet1 = oSheetDoc.getSpreadSheet(0);ISpreadSheet sheetJunio = oSheetDoc.getSpreadSheet("Junio");

sheet1.setRangeValue(new CellPosition(0,0), new CellPosition(0,7), "Revisado");

sheet1.setRangeValue(new CellPosition("c1"), new CellPosition("d6"), "OK");

sheet1.setRangeValue(new CellPosition(1,0), new CellPosition(1,7),1500.0);

sheetJunio.setCellValue(new CellPosition("aa2"),new CellPosition("aa6"),23.45);

Listado B.4: Insertar datos a rangos con OpenSheet API

El listado B.4 se muestra como insertar datos en rangos de celdas en las hojas de cálculode un documento, para ello se realiza la apertura de un documento balance.xls y se obtienenlas interfaces ISpreadSheet con la llamada a getSpreadSheet para trabajar con dos hojas decálculo, la hoja de la primera posición y otra con el nombre Junio. En las hojas se insertan losdatos de texto o numéricos usando el método setRangeValue con los objetos que representanlas posición de las celdas que definen el rango, la superior izquierda y la inferior derecha.Este objeto CellPosition puede ser creado mediante las posiciones X e Y o mediante elnombre de columna y fila. La operación setRangeValue inserta el mismo valor a todas lasceldas del rango.



ISpreadSheet sheet = oSheetDoc.getSpreadSheet("Nominas");

double salario = sheet.getCellValue(new CellPosition("d34"));String empleado = sheet.getCellText(new CellPosition("c34"));Object celdaAA1 = sheet.getCellContent(new CellPosition("aa1"));

Listado B.5: Extraer datos de celdas con OpenSheet API

El listado B.5 se muestra como extraer datos de celdas de una hoja de cálculo de un docu-mento, para ello se realiza la apertura de un documento balance.xls y se obtiene la interfazISpreadSheet con la llamada a getSpreadSheet para trabajar con la hoja de cálculo con elnombre Nominas. De la hoja se extraen valores de diferentes celdas, usando diferentes mé-todos: getCellValue para obtener los valores numéricos, getCellText para extraer las cadenasde texto y getCellContent que extrae lo que contenga la celda sea un valor numérico o textoy lo devuelve como un Object.


ISpreadSheet sheet = oSheetDoc.getSpreadSheet("Nominas");

List<Double> salarios = sheet.getRangeValues(new CellPosition("d34"), newCellPosition("d289"));List<String> empleados = sheet.getRangeTexts(new CellPosition("c34"), newCellPosition("c289"));List<Object> celdasAA1_AB23 = sheet.getRangeContent(new CellPosition("aa1

"),newCellPosition("ab23"));

Listado B.6: Extraer datos de rangos de celdas con OpenSheet API

El listado B.6 se muestra como extraer datos de rangos de celdas de una hoja de cálculode un documento, para ello se realiza la apertura de un documento balance.xls y se obtienela interfaz ISpreadSheet con la llamada a getSpreadSheet para trabajar con la hoja de cálculocon el nombre Nominas. De la hoja se extraen diferentes listas de valores de los diferentesrangos de celdas, usando distintos métodos: getRangeValues para obtener la lista con losvalores numéricos, getRangeTexts para extraer una lista con las cadenas de texto de las celdasy getRangeContent que extrae lo que contenga cada una de las celdas del rango sea un valornumérico o texto y lo devuelve como una lista de Object.

El listado B.7 se muestra como añadir nuevas hojas de cálculo a un documento, paraello se realiza la apertura de un documento balance.xls y añaden hojas a través del método



ISpreadSheet sheetNueva = oSheetDoc.addSpreadSheet();ISpreadSheet sheetCierre = oSheetDoc.addSpreadSheet("Cierre");

Listado B.7: Añadir hojas de cálculo con OpenSheet API

addSpreadSheet. Si se llama al método sin nombre la crea con uno por defecto, y si se lepasa un nombre crea una nueva hoja con dicho nombre.


oSheetDoc.deleteSpreadSheet(0);oSheetDoc.deleteSpreadSheet("Balance 2009");

Listado B.8: Borrar hojas de cálculo con OpenSheet API

El listado B.8 se muestra como borrar hojas de cálculo de un documento, para ello se rea-liza la apertura de un documento balance.xls y borran las hojas deseadas a través del métododeleteSpreadSheet, bien pasándole la posición de la hoja en el documento o el nombre de lahoja.

OpenSheetManager oSheetManager = new OpenSheetManager();IOpenSheetDocument oDoc = oSheetManager.openDocument("balance.xls");oDoc.saveAs("balance.ods");

Listado B.9: Convertir un documento de un formato a otro con OpenSheet API

El listado B.9 se muestra como convertir un documento de un formato a otro, para ellobasta con salvar un documento de hojas de cálculo a través del método saveAs usando laextensión deseada.

El listado B.10 se muestra como exportar un documento de un formato a PDF, para ellobasta con llamar al método exportToPDF con la ruta y el nombre del fichero que se desee ycon la extensión .pdf.

B.2.2. Clases y métodos principalesEn este apartado se explican las clases y métodos principales que permiten al desarrollador

hacerse una idea de las herramientas de las que dispone, pero para entrar en más detalles sedebe consultar la documentación en Javadoc del proyecto OpenSheet que se distribuye conla propia OpenSheet API o bien generarlo a partir del código disponible en el repositorio.


OpenSheetManager oSheetManager = new OpenSheetManager();IOpenSheetDocument oDoc = oSheetManager.openDocument("balance.xls");oDoc.exportToPDF("balance.pdf");

Listado B.10: Exportar un documento a formato PDF con OpenSheet API

OpenSheet API tiene las siguientes clases principales:

OpenSheetManager: Es la clase factoría que permite crear objetos con la interfazIOpenSheetDocument, es decir, los objetos que representan los documentos de hojasde cálculo. Cuando se crea un objeto de esta clase, se realiza una búsqueda de lainstalación de OpenOffice.org en la máquina para arrancar el servicio y conectarsea él, todo de manera automática y transparente, haciendo uso de la clase modificadaBootstrap del SDK de UNO. Esta clase tiene los siguientes métodos:

• createDocument(String documentPath): Crea un documento con el nombre en laruta indicada, y devuelve la interfaz IOpenSheetDocument para trabajar con él.

• openDocument(String documentPath): Abre un documento en el path indicado,y devuelve la interfaz IOpenSheetDocument para trabajar con él.

• terminate(): Es la operación que permite liberar los recursos de OpenOffice.org.Al dejar de trabajar con los objetos de OpenSheet API se debe llamar siemprea este método, por lo tanto se debe guardar la instancia de OpenSheetManagerhasta que se llame a este método.

IOpenSheetDocument: Es la interfaz que permite trabajar con un documento de hojasde cálculo. Las operaciones que permite son:

• getSpreadSheetsNames(): Devuelve un array con los nombres de todas las hojasde cálculo del documento.

• getSpreadSheet: Mediante la sobrecarga de métodos permite recuperar el objetoISpreadSheet, que representa una hoja de cálculo, bien indicando su posición enel documento o indicando su nombre.

• addSpreadSheet: Mediante la sobrecarga de métodos permite añadir una nuevahoja de cálculo con un nombre por defecto o dándole un nombre específico.

• deleteSpreadSheet: Mediante la sobrecarga de métodos permite eliminar una hojade cálculo a través de su posición o de su nombre.

• save(): Este método permite salvar los cambios realizados en un documento.

• saveAs(String documentPath): Permite tanto salvar el documento actual con otronombre, como realizar una conversión de formato si se usa otra extensión.


• exportToPDF(String documenPath): Permite exportar un documento al formatoPDF.

• containsSpreadSheet(String name): Permite comprobar si el documento contieneuna hoja de cálculo con el nombre indicado por parámetro.

• close(): Cierra el documento y el fichero asociado. Este método debe llamarsesiempre después de trabajar con un documento.

ISpreadSheet: Es la interfaz que permite trabajar con un hoja de cálculo de un docu-mento y sus celdas. Las operaciones que permite son:

• setCellValue: A través de la sobrecarga de métodos permite insertar un valornumérico o un texto a una celda representada por el objeto CellPosition.

• setRangeValue: A través de la sobrecarga de métodos permite insertar un valornumérico o un texto a un rango de celdas representado por dos objetos CellPosi-tion, el primero que indica la celda de la esquina superior izquierda, y el segundoque indica la celda de la esquina inferior derecha.

• getCellValue(CellPosition position): Permite recuperar un double de una celdarepresentada por el objeto CellPosition.

• getCellText(CellPosition position): Permite recuperar un String de una celda re-presentada por el objeto CellPosition.

• getRangeValues(CellPosition firstCellPosition, CellPosition lastCellPosition): Per-mite recuperar una lista de double de un rango de celdas representado por dos ob-jetos CellPosition, el primero que indica la celda de la esquina superior izquierda,y el segundo que indica la celda de la esquina inferior derecha.

• getRangeTexts(CellPosition firstCellPosition, CellPosition lastCellPosition): Per-mite recuperar una lista de String de un rango de celdas representado por dos ob-jetos CellPosition, el primero que indica la celda de la esquina superior izquierda,y el segundo que indica la celda de la esquina inferior derecha.

• getCellContent(CellPosition position): Permite recuperar un Object que contieneel valor de una celda, representada por el objeto CellPosition, sea numérico otexto.

• getRangeContent(CellPosition firstCellPosition, CellPosition lastCellPosition): Per-mite recuperar una lista de Object que contiene los valores de las celdas de unrango representado por dos objetos CellPosition, el primero que indica la celdade la esquina superior izquierda, y el segundo que indica la celda de la esquinainferior derecha, independientemente de que el contenido sea numérico o texto.

• getName(): Devuelve el nombre de la hoja de cálculo.


• rename(String spreadSheetNewName): Permite cambiar el nombre de la hoja decálculo.

B.3. OpenSheet CommandOpenSheet Command es una herramienta escrita en Java que permite operar con docu-

mentos de hojas de cálculo de manera automática a partir de los datos contenidos en unfichero .properties pasado en la ejecución y de un script, escrito en Groovy, de acciones se-leccionado. Esta herramienta esta diseñada para ser ejecutada desde un terminal o consoladel sistema, y hace uso de OpenSheet API y OpenOffice.org Calc.

La configuración y uso del comando se puede consultar en el manual de usuario. En estemanual se explicará como ampliar su funcionalidad a través de scripts escritos en Groovy.

B.3.1. Clases y métodos principalesLas clases que componen el comando no son necesarias explicarlas para poder ampliar su

funcionalidad, puesto que basta con entender como funciona la inyección de dependencias ycrear un script en Groovy. Si se desea conocer como funciona el comando para realizar mejo-ras o modificaciones se debe consultar la documentación en Javadoc del proyecto OpenSheetque se distribuye con la propia OpenSheet API o bien generarlo a partir del código disponibleen el repositorio.

B.3.2. Creación de nuevos scriptsLa principal característica de OpenSheet Command es la posibilidad de ampliar su funcio-

nalidad a través de scripts a los que se les inyecta las cadenas leídas de un fichero de datos uobjetos si se han usado valores especiales.

El script debe identificar a que variables se les va a inyectar valores del fichero de datos,y si esperan cadenas o alguno de los objetos que se pueden inyectar al usar los valoresreservados.

Todo valor reservado tiene la sintaxis @palabra_reservada; seguido de los valores nece-sarios según la variable especial a utilizar. Existen los siguientes valores reservados:

@OpenSheetManager;: Permite inyectar el objeto OpenSheetManager para podercrear y abrir documentos de hojas de cálculo desde el script.

@OpenSheetDocument;create,ruta_fichero: Crea un nuevo documento de hojas decálculo en la ruta indicada, representado por un objeto IOpenSheetDocument que seráinyectado a la variable del script indicada.

@OpenSheetDocument;open,ruta_fichero: Abre un documento de hojas de cálculo


que se encuentra en la ruta indicada, representado por un objeto IOpenSheetDocumentque será inyectado a la variable del script indicada.

@list;valor1,valor2: Permite crear un objeto List, concretamente una lista de cadenas,donde cada valor va separado por una coma.

@number;numero: Permite crear objetos de tipo Double.

Utilizando esos valores y luego mediante el análisis de las cadenas pasadas se puede con-seguir recibir los elementos necesarios para realizar cualquier acción de manera que puedacambiar según el fichero de datos utilizado.

Es necesario que las variables a las que se les vaya a inyectar un valor estén definidas ysean usadas pero sin realizar ninguna asignación, porque la asignación sobreescribe el valorinyectado.

Se recomienda analizar el script que se distribuye por defecto con el comando, OpenS-heetScript.groovy y leerse el manual de usuario para entender como funciona y así tener unejemplo de uso de scripts.

Limitación de uso de scripts

Existe la limitación de que actualmente OpenSheet Command no permite ejecutar scriptsde Groovy con dependencias a otros ficheros.

B.4. OpenSheet Web ServiceOpenSheet Web Service es un servicio web escrito en Java usando JAX-WS que permite

operar con documentos de hojas de cálculo a partir de la selección de un script de Groovy yuna lista de variables o pares clave/valor. Este servicio hace uso de OpenSheet API y Ope-nOffice.org Calc.

OpenSheet Web Service proporciona dos operaciones:

Operación listScripts: Esta operación devuelve una lista de objetos ScriptInfo con lainformación necesaria para utilizar cada uno de los scripts disponibles.

Operación executeScript: Esta operación permite ejecutar un script pasándole unalista de variables y un objeto Document que puede ser vacío; y una vez ejecutado elscript se devolverán los objetos Document que indiquen las variables de salida confi-guradas en la información del script.

OpenSheet Web Service por tanto permite ejecutar scripts de Groovy de manera remotapara operar con documentos de hojas de cálculo, al igual que se hace con el comando pero eneste caso hay teniendo en cuenta la problemática de la invocación desde fuera del sistema:


1. Los scripts que se pueden ejecutar son aquellos que se encuentran en el directorioconfigurado y que además tienen un fichero .properties con su mismo nombre, quecontiene las variables con la información necesaria para generar objetos ScriptInfonecesarios para la operación listScripts, y las variables que necesita el servicio web.Al impedir que se puedan ejecutar scripts enviados por el usuario y limitarlos a undirectorio donde se además se añada un fichero con la información de uso, se evitanproblemas de seguridad.

2. Ahora existe el problema de que el mismo script puede ser invocado a la vez y quelos documentos que envía el cliente del servicio web deben almacenarse sin sobrees-cribir otros y además que se puedan identificar desde la lista de variables enviada, quesustituye al fichero de datos. Para ello el servicio web en el directorio temporal, creaun nuevo directorio para cada llamada a la operación de ejecución donde se almacenael documento enviado, y que se le asigna al script para que lo use cuando tenga queguardar ficheros.

3. Antes de enviar las variables para ejecutar el script, el servicio web debe parsear losvalores de la variables especiales @OpenSheetDocument; tanto create como open

para que el nombre del documento incluya el directorio temporal creado por el servicioweb.

4. Se deben identificar todos los ficheros de salida que el servicio web debe enviar alcliente, y no borrar dichos ficheros. Estos deben almacenarse en el directorio temporalhaciendo uso de la valor que el servicio web inyectará a la variable configurada paraello, de esta forma una vez leídos los ficheros de salida, el servicio web puede borrartodo el contenido del directorio temporal.

B.4.1. Clases y métodos principalesLas clases que componen el servicio web no son necesarias explicarlas para poder ampliar

su funcionalidad, puesto que basta con entender como funciona la inyección de dependen-cias y crear un script en Groovy. Si se desea conocer como funciona el servicio web pararealizar mejoras o modificaciones se debe consultar la documentación en Javadoc del pro-yecto OpenSheet que se distribuye con la propia OpenSheet API o bien generarlo a partir delcódigo disponible en el repositorio.

B.4.2. Creación de nuevos scriptsLa principal característica de OpenSheet Web Service es que permite la posibilidad de

ampliar su funcionalidad a través de scripts, al igual que OpenSheet Command, a los que seles inyecta las cadenas leídas de una lista de variables enviadas como parámetros u objetossi se han usado valores especiales.


El script debe identificar a que variables se les va a inyectar valores del fichero de datos,y si esperan cadenas o alguno de los objetos que se pueden inyectar al usar los valoresreservados.

Todo valor reservado tiene la sintaxis @palabra_reservada; seguido de los valores nece-sarios según la variable especial a utilizar, estos son los mismos que los usados en OpenSheetCommnad.

Para los scripts creados para usar desde el servicio web hay que tener en cuenta que esnecesario tener una variable donde se inyecte la ruta del directorio temporal creado paracada ejecución, y que será donde se deben almacenar los ficheros que se generen. Además,las variables que se ha configurado en la variable outputVariables del fichero .propertiesdeben contener la ruta a los ficheros que el servicio web debe devolver al cliente que invocóla operación, y estos ficheros no deben ser borrados, si no que serán eliminados junto con eldirectorio temporal por el servicio web.

Se recomienda analizar el script que se distribuye por defecto con el comando, OpenS-heetScript.groovy y leerse el manual de usuario para entender como funciona y como sedebe configurar para usarse desde el servicio web.

A continuación se explican los pasos de una ejecución de un script para que se comprendamejor el proceso.

B.4.3. Pasos de la operación executeScriptEl servicio web cuando tiene recibe una petición a la operación executeScript para ejecutar

un script realiza los siguientes pasos:

1. Se Genera el directorio temporal único para esa llamada.

2. Si se envía un documento con datos, este se guarda en el directorio temporal creado.

3. Se preprocesan las variables de la lista enviada, añadiendo al nombre del documentoasignado a las directivas @OpenSheetDocument;create y @OpenSheetDocument;open

la ruta del directorio temporal creado.

4. Se crea la instancia de ScriptExecuter, que es el mismo objeto que ejecuta scripts en elcomando, con los valores preprocesados del paso anterior.

5. Se inyecta el valor del directorio temporal a la variable temporalDirectoryVariableconfigurada en el fichero .properties del script.

6. Se ejecuta el script.

7. Se leen todos los ficheros a los que apuntan las variables configuradas en el fichero.properties del script a través de la variable outputVariables.


8. Se borra el directorio temporal.

9. Se envía la respuesta.

Con la ejecución de estos pasos se entiende mejor la necesidad de configurar en el ficherode .properties del script las variables temporalDirectoryVariable y outputVariables.

B.4.4. Cliente de ejemploEn este apartado se muestra un ejemplo muy básico de un cliente del servicio web que

hace uso del script OpenSheetScript.groovy usando siempre el mismo valor de las variablesal estar escritas directamente en el código.

Para poder configurar OpenSheetScript.groovy para poder ser usado como script del ser-vicio web es necesario añadir un fichero .properties junto a él dentro del directorio de scriptsconfigurado en el web.xml. El fichero .properties debe contener la información del lista-do B.11.

description=OpenSheetScript es el script por defecto que permite realizarlas

operaciones basicas de la API. Para saber como se debe usar consultar elmanual

de usuario.outputVariables=saveDocumentTo;extractCellsValuesFiletemporalDirectoryVariable=tempDir

Listado B.11: Ejemplo de fichero Properties para script de servicio web

Al usar el saveDocumentTo como variable de salida, si se quiere recuperar ese documentotras la ejecución se le debe asignar un valor en la lista de variables en cada llamada.

A continuación, se muestra un ejemplo de cliente del servicio web generado automáti-camente a partir del WSDL del servicio usando un plugin que trae Netbeans para trabajarcon aplicaciones web. Concretamente se muestran los métodos añadidos al código generadoautomáticamente.

En el listado B.12 se puede en el método main que primero se llama a la operación listS-

cripts() del servicio web, imprimiendo por pantalla la información recibida. A continuación,se construye un mapa de propiedades que se transformará posteriormente en una lista deScriptVariable; en esas propiedades se meten los valores para realizar las siguientes opera-ciones:

1. Crear un nuevo documento llamado salida.ods

2. Añadir al documento tres hojas de cálculo One_Sheet, tab1 y spread.1


3. Insertar valores diferentes celdas de las hojas de cálculo del documento, referencián-dolas tanto por nombre como por posición.

4. Extraer los valores insertados a un fichero.

Después de crear las propiedades se llama a la operación executeScript del servicio web,pasándole un documento vacío, puesto que se va a crear en el servidor, la lista de variablescomentada antes y el nombre del primer script encontrado al listarlos, en este caso al con-figurar sólo uno sería el OpenSheetScript.groovy. Con los documentos recibidos se ejecutauna operación que permite salvarlos a disco. En el listado B.13 se pueden ver los métodos au-xiliares empleados para pasar las propiedades a lista de variables que necesita la operación,y para almacenar los objetos Document como ficheros.


public class Main {public static void main(String[] args) throws Exception{

OpenSheetWebServiceService service = newOpenSheetWebServiceService();

OpenSheetWebService port = service.getOpenSheetWebServicePort();List<ScriptInfo> listScripts = port.listScripts();for (ScriptInfo sInfo : listScripts){

System.out.println("name:"+sInfo.getName());System.out.println("descr:"+sInfo.getDescription());System.out.println("output size:"+sInfo.getOutputVariables().

size());if (sInfo.getOutputVariables().size() > 0)

System.out.println("output 0:"+sInfo.getOutputVariables().get(0));

}

HashMap propertiesData = new HashMap();propertiesData.put("openSheetDocument", "@OpenSheetDocument;

create,salida.ods");propertiesData.put("logFileName", "");propertiesData.put("deleteSheets", "");propertiesData.put("deleteSheetsByPosition", "");propertiesData.put("addSheets", "One_Sheet;tab1;spread.1");propertiesData.put("insertCellsValues", "tab1:c6=hola mundo!,d5=

hello world!;spread.1:aa1=Welcome,a2=11/04/2011");propertiesData.put("insertCellsValuesBySheetPosition", "0:a1=

sheet with position 0;1:a2= Bienvenido,c7=OpenSheet;2:cc1=Nat");

propertiesData.put("insertCellsNumericValues", "tab1:a11=2.45;One_Sheet:b2=10.0,c1=345.678");

propertiesData.put("insertCellsNumericValuesBySheetPosition", "0:a11=11.12;3:b22=23.0,c2=987.6543");

propertiesData.put("extractCellsValues", "tab1:c6,d5,a11;spread.1:aa1,a2;One_Sheet:b2,c1");

propertiesData.put("extractCellsValuesBySheetPosition", "0:a1,a11;1:a2,c7;2:cc1;3:b22,c2");

propertiesData.put("extractCellsValuesFile", "");propertiesData.put("saveDocumentTo", "salida1.ods");

List<Document> documents = port.executeScript(new Document(),getScriptVariables(propertiesData), listScripts.get(0).getName());

saveDocuments(documents);}

}

Listado B.12: Ejemplo de cliente de OpenSheet Web Service - Parte 1


public static List <ScriptVariable> getScriptVariables(Map<String,String> variablesMap)

{List<ScriptVariable> list = new ArrayList<ScriptVariable>();

for (String key : variablesMap.keySet()){

ScriptVariable var = new ScriptVariable();var.setName(key);var.setValue(variablesMap.get(key));list.add(var);

}return list;

}

private static void saveDocuments(List<Document> documents) throwsIOException

{for (Document doc : documents){

System.out.println("\nSave document ’"+doc.getName()+"’");saveDocument(doc);

}}

public static void saveDocument(Document document) throws IOException{

FileOutputStream fos = null;try{

File documentFile = new File(document.getName());fos = new FileOutputStream(documentFile);fos.write(document.getContent());

}finally{

fos.close();}

}

Listado B.13: Ejemplo de cliente de OpenSheet Web Service - Parte 2

Anexo C

GNU Free Documentation License

Version 1.3, 3 November 2008

Copyright c© 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc. <http://fsf.org/>

Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.

0. PREAMBLEThe purpose of this License is to make a manual, textbook, or other functional and useful document “free” in the sense of freedom: to

assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially.Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsiblefor modifications made by others.

This License is a kind of “copyleft”, which means that derivative works of the document must themselves be free in the same sense. Itcomplements the GNU General Public License, which is a copyleft license designed for free software.

We have designed this License in order to use it for manuals for free software, because free software needs free documentation: afree program should come with manuals providing the same freedoms that the software does. But this License is not limited to softwaremanuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend thisLicense principally for works whose purpose is instruction or reference.

1. APPLICABILITY AND DEFINITIONSThis License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be

distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that workunder the conditions stated herein. The “Document”, below, refers to any such manual or work. Any member of the public is a licensee,and is addressed as “you”. You accept the license if you copy, modify or distribute the work in a way requiring permission under copyrightlaw.

A “Modified Version” of the Document means any work containing the Document or a portion of it, either copied verbatim, or withmodifications and/or translated into another language.

A “Secondary Section” is a named appendix or a front-matter section of the Document that deals exclusively with the relationship ofthe publishers or authors of the Document to the Document’s overall subject (or to related matters) and contains nothing that could falldirectly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain anymathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial,philosophical, ethical or political position regarding them.

The “Invariant Sections” are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the noticethat says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowedto be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sectionsthen there are none.

The “Cover Texts” are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that saysthat the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25words.

A “Transparent” copy of the Document means a machine-readable copy, represented in a format whose specification is available to thegeneral public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels)generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for

149

http://fsf.org/

150 C. GNU FREE DOCUMENTATION LICENSE

automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file formatwhose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent.An image format is not Transparent if used for any substantial amount of text. A copy that is not “Transparent” is called “Opaque”.

Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format,SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modifi-cation. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be readand edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available,and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.

The “Title Page” means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the materialthis License requires to appear in the title page. For works in formats which do not have any title page as such, “Title Page” means the textnear the most prominent appearance of the work’s title, preceding the beginning of the body of the text.

The “publisher” means any person or entity that distributes copies of the Document to the public.

A section “Entitled XYZ” means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parenthesesfollowing text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as “Acknow-ledgements”, “Dedications”, “Endorsements”, or “History”.) To “Preserve the Title” of such a section when you modify the Documentmeans that it remains a section “Entitled XYZ” according to this definition.

The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. TheseWarranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any otherimplication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.

2. VERBATIM COPYINGYou may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the

copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no otherconditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying ofthe copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough numberof copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and you may publicly display copies.

3. COPYING IN QUANTITYIf you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and

the Document’s license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these CoverTexts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identifyyou as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible.You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of theDocument and satisfy these conditions, can be treated as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) onthe actual cover, and continue the rest onto adjacent pages.

If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readableTransparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the generalnetwork-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, freeof added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies inquantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time youdistribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.

It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, togive them a chance to provide you with an updated version of the Document.

4. MODIFICATIONSYou may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you

release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensingdistribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the

C. GNU FREE DOCUMENTATION LICENSE 151

Modified Version:

A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions(which should, if there were any, be listed in the History section of the Document). You may use the same title as a previousversion if the original publisher of that version gives permission.

B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the ModifiedVersion, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five),unless they release you from this requirement.

C. State on the Title page the name of the publisher of the Modified Version, as the publisher.

D. Preserve all the copyright notices of the Document.

E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.

F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Versionunder the terms of this License, in the form shown in the Addendum below.

G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document’s licensenotice.

H. Include an unaltered copy of this License.

I. Preserve the section Entitled “History”, Preserve its Title, and add to it an item stating at least the title, year, new authors, andpublisher of the Modified Version as given on the Title Page. If there is no section Entitled “History” in the Document, create onestating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the ModifiedVersion as stated in the previous sentence.

J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, andlikewise the network locations given in the Document for previous versions it was based on. These may be placed in the “History”section. You may omit a network location for a work that was published at least four years before the Document itself, or if theoriginal publisher of the version it refers to gives permission.

K. For any section Entitled “Acknowledgements” or “Dedications”, Preserve the Title of the section, and preserve in the sectionall the substance and tone of each of the contributor acknowledgements and/or dedications given therein.

L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalentare not considered part of the section titles.

M. Delete any section Entitled “Endorsements”. Such a section may not be included in the Modified Version.

N. Do not retitle any existing section to be Entitled “Endorsements” or to conflict in title with any Invariant Section.

O. Preserve any Warranty Disclaimers.

If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no materialcopied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to thelist of Invariant Sections in the Modified Version’s license notice. These titles must be distinct from any other section titles.

You may add a section Entitled “Endorsements”, provided it contains nothing but endorsements of your Modified Version by variousparties—for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of astandard.

You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the endof the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by(or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added byyou or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, onexplicit permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assertor imply endorsement of any Modified Version. 5. COMBINING DOCUMENTS

152 C. GNU FREE DOCUMENTATION LICENSE

You may combine the Document with other documents released under this License, under the terms defined in section 4 above formodified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified,and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a singlecopy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique byadding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Makethe same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.

In the combination, you must combine any sections Entitled “History” in the various original documents, forming one section Entitled“History”; likewise combine any sections Entitled “Acknowledgements”, and any sections Entitled “Dedications”. You must delete allsections Entitled “Endorsements”.

5. COLLECTIONS OF DOCUMENTSYou may make a collection consisting of the Document and other documents released under this License, and replace the individual

copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules ofthis License for verbatim copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copyof this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.

6. AGGREGATION WITH INDEPENDENT WORKSA compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a

storage or distribution medium, is called an “aggregate” if the copyright resulting from the compilation is not used to limit the legal rightsof the compilation’s users beyond what the individual works permit. When the Document is included in an aggregate, this License doesnot apply to the other works in the aggregate which are not themselves derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one halfof the entire aggregate, the Document’s Cover Texts may be placed on covers that bracket the Document within the aggregate, or theelectronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the wholeaggregate.

7. TRANSLATIONTranslation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4.

Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translationsof some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of thisLicense, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original Englishversion of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and theoriginal version of this License or a notice or disclaimer, the original version will prevail.

If a section in the Document is Entitled “Acknowledgements”, “Dedications”, or “History”, the requirement (section 4) to Preserve itsTitle (section 1) will typically require changing the actual title.

8. TERMINATIONYou may not copy, modify, sublicense, or distribute the Document except as expressly provided under this License. Any attempt

otherwise to copy, modify, sublicense, or distribute it is void, and will automatically terminate your rights under this License.

However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally,unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails tonotify you of the violation by some reasonable means prior to 60 days after the cessation.

Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violationby some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyrightholder, and you cure the violation prior to 30 days after your receipt of the notice.

Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from youunder this License. If your rights have been terminated and not permanently reinstated, receipt of a copy of some or all of the same material

C. GNU FREE DOCUMENTATION LICENSE 153

does not give you any rights to use it.

9. FUTURE REVISIONS OF THIS LICENSEThe Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time.

Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Seehttp://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version ofthis License “or any later version” applies to it, you have the option of following the terms and conditions either of that specified versionor of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a versionnumber of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. If the Documentspecifies that a proxy can decide which future versions of this License can be used, that proxy’s public statement of acceptance of a versionpermanently authorizes you to choose that version for the Document.

10. RELICENSING“Massive Multiauthor Collaboration Site” (or “MMC Site”) means any World Wide Web server that publishes copyrightable works and

also provides prominent facilities for anybody to edit those works. A public wiki that anybody can edit is an example of such a server. A“Massive Multiauthor Collaboration” (or “MMC”) contained in the site means any set of copyrightable works thus published on the MMCsite.

“CC-BY-SA” means the Creative Commons Attribution-Share Alike 3.0 license published by Creative Commons Corporation, a not-for-profit corporation with a principal place of business in San Francisco, California, as well as future copyleft versions of that licensepublished by that same organization.

“Incorporate” means to publish or republish a Document, in whole or in part, as part of another Document.

An MMC is “eligible for relicensing” if it is licensed under this License, and if all works that were first published under this Licensesomewhere other than this MMC, and subsequently incorporated in whole or in part into the MMC, (1) had no cover texts or invariantsections, and (2) were thus incorporated prior to November 1, 2008.

The operator of an MMC Site may republish an MMC contained in the site under CC-BY-SA on the same site at any time before

August 1, 2009, provided the MMC is eligible for relicensing.

Bibliografía

[Arg93] D. Arganbright. Practical Handbook of Spreadsheet Curves and Geometric Construc-

tions. CRC Press, 1993.

[BBvB+01] K. Beck, M. Beedle, A. van Bennekum, A. Cockburn, W. Cunningham, M. Fowler,

J. Grenning, J. Highsmith, A. Hunt, R. Jeffries, J. Kern, B. Marick, R. C. Martin, S. Me-

llor, K. Schwaber, J. Sutherland, y D. Thomas. Manifesto for Agile Software Develop-

ment. 2001. Disponible en: http://agilemanifesto.org/.

[BFJLP06] K. R. Baker, L. Foster-Johnson, B. Lawson, y S. G. Powell. A Survey of

MBA Spreadsheet Users. Spreadsheet Engineering Research Project, 2006. Dis-

ponible en: http://mba.tuck.dartmouth.edu/spreadsheet/product_

pubs_files/SurveyPaper.doc.

[BFJLP07] K. R. Baker, L. Foster-Johnson, B. Lawson, y S. G. Powell. Spreadsheet Risk,

Awareness, and Control. Spreadsheet Engineering Research Project, 2007. Dis-


pubs_files/SSrisk.doc.

[Bra] H.Merijn Brand. Spreadsheet::Read. Disponible en: http://search.cpan.org/

~hmbrand/Spreadsheet-Read-0.41/Read.pm.

[Byt] ByteScout. Spreadsheet SDK. Disponible en: http://www.bytescout.com/

products/developer/spreadsheetsdk/bytescoutspreadsheetsdk.

html.

[Car10] Carlos Blé. Diseño Ágil con TDD. jan 2010. Disponible en: http://www.

dirigidoportests.com/el-libro.

[com] GlassFish community. JAX-WS. Disponible en: http://jax-ws.java.net/.

[Cor84] Lotus Development Corporation. Worksheet File Format From LOTUS. Diciembre

1984. Disponible en: http://www.schnarff.com/file-formats/index.

html.

[CPA] CPAN. CPAN. Disponible en: http://search.cpan.org/.

[CTC06] P.E. Craig T. Christy. Engineering with the Spreadsheet: Structural Engieering Templa-

tes Using Excel. ASCE, 2006.

155

http://agilemanifesto.org/

http://mba.tuck.dartmouth.edu/spreadsheet/product_pubs_files/SurveyPaper.doc

http://mba.tuck.dartmouth.edu/spreadsheet/product_pubs_files/SurveyPaper.doc

http://mba.tuck.dartmouth.edu/spreadsheet/product_pubs_files/SSrisk.doc

http://mba.tuck.dartmouth.edu/spreadsheet/product_pubs_files/SSrisk.doc

http://search.cpan.org/~hmbrand/Spreadsheet-Read-0.41/Read.pm

http://search.cpan.org/~hmbrand/Spreadsheet-Read-0.41/Read.pm

http://www.bytescout.com/products/developer/spreadsheetsdk/bytescoutspreadsheetsdk.html



http://www.dirigidoportests.com/el-libro

http://www.dirigidoportests.com/el-libro

http://jax-ws.java.net/

http://www.schnarff.com/file-formats/index.html

http://www.schnarff.com/file-formats/index.html

http://search.cpan.org/

156 BIBLIOGRAFÍA

[dIU07] Escuela Superior de Informática (UCLM). Normativa del Proyecto Fin de Carrera.

2007. Disponible en: http://www.esi.uclm.es:8081/www/documentos/

Normativas/NormativaPFC2007.pdf.

[Fab] S. Faber. Mockito. Disponible en: http://mockito.org/.

[Foua] The Apache Software Foundation. The Apache POI Project. Disponible en: http:

//poi.apache.org/.

[Foub] The Apache Software Foundation. Apache Subversion. Disponible en: http://

subversion.apache.org/.

[Fouc] The Apache Software Foundation. Apache Tomcat. Disponible en: http://tomcat.

apache.org/.

[Foud] The Apache Software Foundation. POI-HSSF and POI-XSSF - Java API To Ac-

cess Microsoft Excel Format Files. Disponible en: http://poi.apache.org/

spreadsheet/index.html.

[Foue] The Eclipse Foundation. Eclipse. Disponible en: http://www.eclipse.org/.

[Fre92] H. Freiser. Concepts & Calculations in Analytical Chemistry: A Spreadsheet Approach.

CRC Press, 1992.

[Gou] J.M. Gouarne. OpenOffice::OODoc. Disponible en: http://search.cpan.org/

~jmgdoc/OpenOffice-OODoc-2.125/OODoc/Intro.pod.

[Gro] European Spreadsheet Risks Interest Group. Spreadsheet Horror Stories. Disponible

en: www.eusprig.org/stories.htm.

[ink] Inkscape. Disponible en: http://inkscape.org/.

[Jay] Jayway. PowerMock. Disponible en: http://code.google.com/p/

powermock/.

[KB] E. Gamma K. Beck. JUnit. Disponible en: http://www.junit.org/.

[Kni07] H. Kniberg. Scrum y XP desde las Trincheras. Cómo hacemos Scrum. C4Media, 2007.

[LBPFJ07] B. Lawson, K. R. Baker, S. G. Powell, y L. Foster-Johnson. A comparison

of spreadsheet users with different levels of experience. Omega, 2007. Dis-


pubs_files/Comparison.pdf.

[McN] J. McNamara. Spreadsheet::WriteExcel. Disponible en: http://search.

cpan.org/~jmcnamara/Spreadsheet-WriteExcel-2.37/lib/

Spreadsheet/WriteExcel.pm.

[Mic07] Microsoft. How to automate Excel from C++ without using MFC or #import. may 2007.

Disponible en: http://support.microsoft.com/kb/216686/en-us.

http://www.esi.uclm.es:8081/www/documentos/Normativas/NormativaPFC2007.pdf

http://www.esi.uclm.es:8081/www/documentos/Normativas/NormativaPFC2007.pdf

http://mockito.org/

http://poi.apache.org/

http://poi.apache.org/

http://subversion.apache.org/

http://subversion.apache.org/

http://tomcat.apache.org/

http://tomcat.apache.org/

http://poi.apache.org/spreadsheet/index.html

http://poi.apache.org/spreadsheet/index.html

http://www.eclipse.org/

http://search.cpan.org/~jmgdoc/OpenOffice-OODoc-2.125/OODoc/Intro.pod

http://search.cpan.org/~jmgdoc/OpenOffice-OODoc-2.125/OODoc/Intro.pod

www.eusprig.org/stories.htm

http://inkscape.org/

http://code.google.com/p/powermock/

http://code.google.com/p/powermock/

http://www.junit.org/

http://mba.tuck.dartmouth.edu/spreadsheet/product_pubs_files/Comparison.pdf

http://mba.tuck.dartmouth.edu/spreadsheet/product_pubs_files/Comparison.pdf

http://search.cpan.org/~jmcnamara/Spreadsheet-WriteExcel-2.37/lib/Spreadsheet/WriteExcel.pm



http://support.microsoft.com/kb/216686/en-us

BIBLIOGRAFÍA 157

[Mic08a] Microsoft. Microsoft Office Excel 2007 Binary File Format Specification [*.xlsb].

Junio 2008. Disponible en: http://www.microsoft.com/interop/docs/

officebinaryformats.mspx.

[Mic08b] Microsoft. Microsoft Office Excel 97-2007 Binary File Format Specification [*.xls

(97-2007) format]. Junio 2008. Disponible en: http://www.microsoft.com/

interop/docs/officebinaryformats.mspx.

[Mic08c] Microsoft. Office Automation Using Visual C++. mar 2008. Disponible en: http:

//support.microsoft.com/kb/196776/EN-US/.

[Mic10a] Microsoft. MS-OODF2: Office Implementation Information for ODF 1.1 Version 2 Stan-

dard Compliance. Junio 2010. Disponible en: http://msdn.microsoft.com/

en-us/library/ee908651(v=office.12).aspx.

[Mic10b] Microsoft. MS-XLSX: Excel Extensions to the Office Open XML SpreadsheetML

File Format (.xlsx) Specification. Junio 2010. Disponible en: http://msdn.

microsoft.com/en-us/library/dd922181(v=office.12).aspx.

[NR99] J. Batson N. Read. Spreadsheet Modelling Best Practice. Business Dynamics, apr 1999.

Disponible en: http://www.eusprig.org/smbp.pdf.

[oas] OASIS Consortium. Disponible en: http://www.oasis-open.org.

[OAS07] OASIS. Open Document Format for Office Applications (OpenDocument) Specification

v1.1. Febrero 2007. Disponible en: http://docs.oasis-open.org/office/

v1.1/OS/OpenDocument-v1.1.pdf.

[OAS10] OASIS. Open Document Format for Office Applications (OpenDocument)

Version 1.2 (Committee Draft 04-Rev 09). Junio 2010. Disponible en:

http://www.oasis-open.org/committees/download.php/38239/

OpenDocument-v1.2-part1-cd04-rev09.odt.

[OKvLV] O. Ojala, K. Karlsson, B. von Loesch, y T. Arne Vestb. Texlipse. Disponible en: http:

//texlipse.sourceforge.net/.

[ooo] OpenOffice.org Draw. Disponible en: http://www.openoffice.org/

product/draw.html.

[ope] OpenOffice.org. Disponible en: http://www.openoffice.org.

[Oraa] Oracle. JDK Java Development Kit. Disponible en: http://www.oracle.com/

technetwork/java/javase/downloads/index.html.

[Orab] Oracle. NetBeans IDE. Disponible en: http://netbeans.org/.

[Orac] Oracle. OpenOffice.org Calc. Disponible en: http://www.openoffice.org/

product/calc.html.

http://www.microsoft.com/interop/docs/officebinaryformats.mspx




http://support.microsoft.com/kb/196776/EN-US/

http://support.microsoft.com/kb/196776/EN-US/

http://msdn.microsoft.com/en-us/library/ee908651(v=office.12).aspx

http://msdn.microsoft.com/en-us/library/ee908651(v=office.12).aspx

http://msdn.microsoft.com/en-us/library/dd922181(v=office.12).aspx

http://msdn.microsoft.com/en-us/library/dd922181(v=office.12).aspx

http://www.eusprig.org/smbp.pdf

http://www.oasis-open.org

http://docs.oasis-open.org/office/v1.1/OS/OpenDocument-v1.1.pdf

http://docs.oasis-open.org/office/v1.1/OS/OpenDocument-v1.1.pdf

http://www.oasis-open.org/committees/download.php/38239/OpenDocument-v1.2-part1-cd04-rev09.odt

http://www.oasis-open.org/committees/download.php/38239/OpenDocument-v1.2-part1-cd04-rev09.odt

http://texlipse.sourceforge.net/

http://texlipse.sourceforge.net/

http://www.openoffice.org/product/draw.html

http://www.openoffice.org/product/draw.html

http://www.openoffice.org

http://www.oracle.com/technetwork/java/javase/downloads/index.html

http://www.oracle.com/technetwork/java/javase/downloads/index.html

http://netbeans.org/

http://www.openoffice.org/product/calc.html

http://www.openoffice.org/product/calc.html

158 BIBLIOGRAFÍA

[Orad] Oracle. OpenOffice.org SDK. Disponible en: http://download.openoffice.

org/sdk/.

[Ora10] Oracle. OpenOffice.org Developer’s Guide. aug 2010. Disponible en:

http://wiki.services.openoffice.org/wiki/Documentation/

DevGuide/OpenOffice.org_Developers_Guide.

[Pal07] J. Palacio. Flexibilidad con Scrum. safe creative, oct 2007. Disponible en: http:

//www.navegapolis.net/files/Flexibilidad_con_Scrum.pdf.

[Pro] The LaTex3 Project. LaTex. Disponible en: http://www.latex-project.org/.

[RA08] M. Erwig R. Abraham. Test-Driven Goal-Directed Debugging in Spreads-

heets. 2008. Disponible en: http://web.engr.oregonstate.edu/~erwig/

papers/TestDrivenDebugging_VLHCC08.pdf.

[RA09] M. Erwig R. Abraham, M. M. Burnett. Spreadsheet Programming. 2009.

Disponible en: http://web.engr.oregonstate.edu/~erwig/papers/

SpreadsheetProgramming_ECSE09.pdf.

[SL99] S.E. Margolis S.J. Liebowitz. Winners, Losers, and Microsoft: How Technology Markets

Choose Products. Independent Institute, may 1999.

[Sof] GemBox Software. GemBox.Spreadsheet. Disponible en: http://www.

gemboxsoftware.com/GBSpreadsheet.htm.

[Spr] Groovy Community SpringSource. Groovy. Disponible en: http://groovy.

codehaus.org/.

[Tak] K. Takanori. Spreadsheet::ParseExcel. Disponible en: http://search.cpan.

org/~kwitknr/Spreadsheet-ParseExcel-0.2602/ParseExcel.pm.

[Tea] The Gimp Team. Gimp. Disponible en: http://www.gimp.org/.

[umb] Umbrello UML Modeller. Disponible en: http://uml.sourceforge.net/.

[Wal10] J. Walkenbach. Excel 2010 Power Programming with VBA. Wiley Publishing, 2010.

http://download.openoffice.org/sdk/

http://download.openoffice.org/sdk/

http://wiki.services.openoffice.org/wiki/Documentation/DevGuide/OpenOffice.org_Developers_Guide

http://wiki.services.openoffice.org/wiki/Documentation/DevGuide/OpenOffice.org_Developers_Guide

http://www.navegapolis.net/files/Flexibilidad_con_Scrum.pdf

http://www.navegapolis.net/files/Flexibilidad_con_Scrum.pdf

http://www.latex-project.org/

http://web.engr.oregonstate.edu/~erwig/papers/TestDrivenDebugging_VLHCC08.pdf

http://web.engr.oregonstate.edu/~erwig/papers/TestDrivenDebugging_VLHCC08.pdf

http://web.engr.oregonstate.edu/~erwig/papers/SpreadsheetProgramming_ECSE09.pdf

http://web.engr.oregonstate.edu/~erwig/papers/SpreadsheetProgramming_ECSE09.pdf

http://www.gemboxsoftware.com/GBSpreadsheet.htm

http://www.gemboxsoftware.com/GBSpreadsheet.htm

http://groovy.codehaus.org/

http://groovy.codehaus.org/

http://search.cpan.org/~kwitknr/Spreadsheet-ParseExcel-0.2602/ParseExcel.pm

http://search.cpan.org/~kwitknr/Spreadsheet-ParseExcel-0.2602/ParseExcel.pm

http://www.gimp.org/

http://uml.sourceforge.net/

O S : L - ARCO Researcharco.esi.uclm.es/public/pfc/carlos.ruiz.pdf · 2011-06-30 ·...

Documents

Transcript of O S : L - ARCO Researcharco.esi.uclm.es/public/pfc/carlos.ruiz.pdf · 2011-06-30 ·...