Universo Santa Tecla
[email protected]

Índice

1. Objetivos
   • 1.1. Modelo del dominio
2. Disciplina de Requisitos
   2.1. Actores y casos de uso
   2.2. Contexto
   2.3. Prototipo de Interfaz
   • 2.3.1. Gramática del lenguaje
   • 2.3.2. Semántica de comandos
3. Disciplina de Analisis
   3.1. Arquitectura de análisis
   3.2. Análisis de casos de uso
   • 3.2.1. Add Member
   • 3.2.2. Add Relation
4. Disciplina de Diseño
   4.1. Arquitectura del sistema de diseño
   4.2. Diseño de casos de uso
   4.3. Arquitectura Hexagonal
   4.4. Ingenieria Directa: Interpreters
   4.5. Ingenieria Inversa: Arquitectura
5. Disciplina de Pruebas
6. Disciplina de Despliegue

Los objetivos principales de este proyecto son, por un lado, aunar correctamente los diferentes conocimientos adquiridos a lo largo del Máster en Ingeniería Web y, por otro lado, facilitar la generación de documentación para los proyectos software. Los conocimientos utilizados a destacar serían los aprendidos en las asignaturas:

• Ingeniería Web Visión General.
• Arquitectura y Patrones para Aplicaciones Web.
• Front-end para Navegadores Web.
• Back-end con Tecnologías de Código Abierto.
• Metodologías de desarrollo web.

Para ello se desarrollará una aplicación web utilizando la metodología de desarrollo de software Rational Unified Process, el framework Spring para el desarrollo de la capa de negocio, el framework Angular para el desarrollo de la capa de presentación y MongoDB para la capa de datos. Añadir que otro objetivo importante es trabajar en equipo para así simular un proyecto real. Para ello, este proyecto se desarrollará conjuntamente con (Nombres de los demás) ampliando así sus funcionalidades como se puede ver en su TFM (Nombre TFM).

También nos hemos propuesto implementar el proyecto siguiendo una arquitectura hexagonal y los principios de código limpio como SOLID, evitar smell codes, etc. así como aplicar patrones de diseño que aumenten la extensibilidad y legibilidad del código.

La aplicación web a desarrollar será USTUML, la cual consiste en permitir la generación efectiva de diagramas UML a través de ingeniería directa y de ingeniería inversa para así poder mejorar la gestión de cualquier proyecto software. La ingeniería directa se realizará mediante técnica declarativa, concretamente a través de la ejecución de comandos, y la ingeniería inversa a partir de código fuente en java, alojado en GitHub.

Se ha elegido el desarrollo de esta aplicación web debido a que nos planteaba un reto importante: la idea del proyecto venía dada por nuestro tutor, hecho que nos obligaba a interpretar sus ideas y transformarlas en algo tangible, como si de un cliente real se tratase. Esto desembocó en que el análisis contemplase un solo actor y diversos casos de uso que se especificarán posteriormente en este documento.

UST_UML:

no references

openCommand:

referenced by:

• UST_UML

addCommand:

referenced by:

• UST_UML

addMembers:

referenced by:

• addCommand
• addPackage
• addProject

addProject:

referenced by:

• addMembers

project:

referenced by:

• addProject
• deleteMembers
• modifyMembers

addPackage:

referenced by:

• addMembers

package:

referenced by:

• addPackage
• deleteMembers
• modifiers
• modifyMembers

addClass:

referenced by:

• addMembers

class:

referenced by:

• addClass
• deleteMembers
• modifyMembers

identifier:

referenced by:

• class
• definition
• package
• project
• relations
• type

modifiers:

referenced by:

• addClass

classMembers:

referenced by:

• addClass

definition:

referenced by:

• classMembers

type:

referenced by:

• definition

relations:

referenced by:

• addClass
• addCommand
• addPackage
• addProject
• deleteCommand
• modifyCommand

modifyCommand:

referenced by:

• UST_UML

modifyMembers:

referenced by:

• modifyCommand

deleteCommand:

referenced by:

• UST_UML

deleteMembers:

referenced by:

• deleteCommand

importCommand:

referenced by:

• UST_UML

• Todos los comandos desarrollados son autoexplicativos y estructurados
• Siguen una composicion sistemática

open: Member

close:

User account context

add:
  members:
    - project: Project1
    - project: Project2
      members: 
        - package: package
          members:
            - class: class

modify:
  members:
    - project: Project
      set: NewProject

delete:
  members:
    - project: Project 

Project & Package context

add:
    members:
       - package: package
       - class: class
         modifiers: public abstract
       - enum: enum
       - interface: interface
    relations:
       - inheritance: Member
         role: role
       - composition: Member
       - aggregation: Member
         role: role
       - association: Member
       - use: Member

modify:
  members:
    - class: Class
      set: NewClass
  relations:
    - inheritance: Member
      set: NewMember
      role: newRole

delete:
  members:
    - interface: Interface
  relations:
    - composition: Member 

Class & Interface context

add:
    members:
      - member: private static int attribute
      - member: public abstract String method(int param1, String param2)
    relations:
      - association: Member 

modify:
  modifiers: package
  set: public abstract
  members:
    - member: private static int attribute
      set: public String newAttribute
    - member: public abstract String method(int param1, String param2)
      set: private int newMethod()
  relations:
    - use: Member
      set: NewMember
      role: newRole

delete:
  members:
    - member: public String newAttribute
    - member: private int newMethod()
  relations:
    - composition: Member 

Enum context

• Adicional a los comandos de las clases y las interfaces

add:
  objects:
    - object: OBJECT

modify:
  objects:
    - object: OBJECT
      set: NEWOBJECT

delete:
  objects:
    - object: OBJECT

Account context

import: urlGitHubRepository

• Debido a la sistematicidad ya comentada de los comandos no fue necesario seguir haciendo análisis para los distintos casos de uso de los comandos restantes.

En la capa de negocio se va seguir la arquitectura hexagonal, para así cumplir con el objetivo de extensibilidad del sistema.

Diagrama de Objetos del estado añadir clase a un paquete.

Carpeta Interpreters

@Override
public void add(Command command) {
        super.add(command);
        Package pakage = (Package) this.member;
        for (Command memberCommand : command.getCommands(Command.MEMBERS)) {
            MemberParser memberParser = memberCommand.getMemberType().create();
            pakage.add(memberParser.get(memberCommand));
        }
        this.addRelations(command);
        this.member = this.packagePersistence.update(pakage);
    }

Carpeta reverseEngineering

• Las tecnologías utilizadas en el desarrollo de las pruebas ha sido:

  • Back-end:
    • Junit5
    • Mockito
    • Base de datos embebida para mongoDB
  • Front-end:
    • Jasmine
    • Karma

• El objetivo principal de las pruebas de ingeniería directa ha sido ejercitar los diferentes comandos del lenguaje en cada uno de los contextos, y así poder medir la calidad del software, validar que el sistema funciona como se espera y que los requisitos son implementados correctamente.

• Para la realización de las pruebas en la parte de ingeniería inversa, se han ejercitado los parseadores con proyecto de prueba que contenía código que simula los distintos escenarios a tener en cuenta para la generación de los miembros y sus relaciones.