From 3d3635834576f10e1d843872467e624e0b58cc24 Mon Sep 17 00:00:00 2001
From: AndresPlata0411 <dplataa@uninorte.edu.co>
Date: Mon, 2 Dec 2024 23:46:30 -0500
Subject: [PATCH 1/3] Imp base de clases

Falta cardinalidad uno a muchos
---
 plantumlToUML.js |   0
 script.js        | 123 +++++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 113 insertions(+), 10 deletions(-)
 create mode 100644 plantumlToUML.js

diff --git a/plantumlToUML.js b/plantumlToUML.js
new file mode 100644
index 0000000..e69de29
diff --git a/script.js b/script.js
index 998df90..12ac868 100644
--- a/script.js
+++ b/script.js
@@ -1,25 +1,128 @@
-document.getElementById('generateBtn').addEventListener('click', function() {
+document.getElementById('generateBtn').addEventListener('click', function () {
     const umlInput = document.getElementById('umlInput').value;
-    const classList = extractClasses(umlInput);
+    const classList = extractClassesAndRelations(umlInput);
 
     const classListElement = document.getElementById('classList');
-    classListElement.innerHTML = '';
+    classListElement.innerHTML = ''; // Limpia la lista previa
 
-    classList.forEach(className => {
+    classList.forEach(classData => {
         const listItem = document.createElement('li');
-        listItem.textContent = className + '.java';
+
+        // Crear un elemento <pre> para mostrar el código Java
+        const pre = document.createElement('pre');
+        pre.textContent = generateJavaCode(classData);
+
+        listItem.appendChild(pre);
         classListElement.appendChild(listItem);
     });
 });
 
-function extractClasses(umlText) {
-    const classPattern = /class\s+([a-zA-Z0-9_]+)/g;
-    let classNames = [];
+function extractClassesAndRelations(umlText) {
+    // Validar delimitadores de PlantUML
+    if (!umlText.trim().startsWith('@startuml') || !umlText.trim().endsWith('@enduml')) {
+        alert('El diagrama debe comenzar con @startuml y terminar con @enduml.');
+        return [];
+    }
+
+    const classPattern = /(?:abstract\s+)?class\s+([a-zA-Z0-9_]+)(?:\s+extends\s+([a-zA-Z0-9_]+))?\s*\{([\s\S]*?)\}/g;
+    
+    // Atributos: Captura atributos tipo +int nombre, pero no captura los métodos que contienen ()
+    const attributePattern = /([+|-])\s*([\w\*]+)\s+([\w]+)/g;
+
+    // Métodos: Captura métodos tipo +void hacerSonido() o +void hacerSonido(param1)
+    const methodPattern = /([+|-])\s*(void|[\w]+)\s+([\w]+)\(\s*\)/g;
+
+    const relationPattern = /([a-zA-Z0-9_]+)\s*(--\|>)\s*([a-zA-Z0-9_]+)/g; // Solo herencia '--|>'
+
+    const classes = [];
     let match;
 
     while ((match = classPattern.exec(umlText)) !== null) {
-        classNames.push(match[1]);
+        const className = match[1];
+        const body = match[3] || '';
+        const isAbstract = umlText.includes(`abstract class ${className}`);
+        const attributes = [];
+        const methods = [];
+
+        // Extraer métodos primero (evitar que sean capturados como atributos)
+        let methodMatch;
+        while ((methodMatch = methodPattern.exec(body)) !== null) {
+            methods.push({
+                visibility: methodMatch[1] === '-' ? 'private' : 'public',
+                returnType: methodMatch[2],  // Ahora guarda 'void' o el tipo adecuado
+                name: methodMatch[3] // Nombre del método
+            });
+        }
+
+        // Extraer atributos después de los métodos (evitar duplicación)
+        let attrMatch;
+        while ((attrMatch = attributePattern.exec(body)) !== null) {
+            // Si el atributo es un método (porque tiene paréntesis), lo ignoramos
+            if (body.includes(`${attrMatch[3]}()`)) continue; // Ignorar los que ya son métodos
+
+            const type = attrMatch[2].includes('*') ? attrMatch[2].replace('*', '[]') : attrMatch[2];  // Convertir '*' a '[]'
+            attributes.push({
+                visibility: attrMatch[1] === '-' ? 'private' : 'public',
+                name: attrMatch[3],
+                type: type
+            });
+        }
+
+        classes.push({
+            className,
+            isAbstract,
+            parentClass: null,  // Inicialmente no tiene clase padre
+            attributes,
+            methods
+        });
+    }
+
+    // Extraer relaciones de herencia '--|>'
+    const relations = [];
+    let relationMatch;
+    while ((relationMatch = relationPattern.exec(umlText)) !== null) {
+        const childClass = relationMatch[1];
+        const parentClass = relationMatch[3];
+
+        // Asignar la clase padre a la clase hija correspondiente
+        const classData = classes.find(cls => cls.className === childClass);
+        if (classData) {
+            classData.parentClass = parentClass;
+        }
     }
 
-    return classNames;
+    return classes;
+}
+
+function generateJavaCode(classData) {
+    let code = '';
+
+    // Si la clase es abstracta
+    if (classData.isAbstract) {
+        code += `public abstract class ${classData.className}`;
+    } else {
+        code += `public class ${classData.className}`;
+    }
+
+    // Si la clase tiene herencia
+    if (classData.parentClass) {
+        code += ` extends ${classData.parentClass}`;
+    }
+
+    code += ' {\n';
+
+    // Generar atributos
+    classData.attributes.forEach(attr => {
+        code += `    ${attr.visibility} ${attr.type} ${attr.name};\n`;
+    });
+
+    // Generar métodos
+    classData.methods.forEach(method => {
+        code += `    ${method.visibility} ${method.returnType} ${method.name}() {\n`;
+        code += `        // Implementación aqui\n`;
+        code += `    }\n`;
+    });
+
+    code += '}\n';
+    return code;
 }

From ba89100fc542bc5bad471a720ab7519a5373dfb2 Mon Sep 17 00:00:00 2001
From: AndresPlata0411 <dplataa@uninorte.edu.co>
Date: Wed, 4 Dec 2024 14:00:27 -0500
Subject: [PATCH 2/3] Update script.js

---
 script.js | 52 ++++++++++++++++++++++------------------------------
 1 file changed, 22 insertions(+), 30 deletions(-)

diff --git a/script.js b/script.js
index 12ac868..cc1fe05 100644
--- a/script.js
+++ b/script.js
@@ -18,25 +18,15 @@ document.getElementById('generateBtn').addEventListener('click', function () {
 });
 
 function extractClassesAndRelations(umlText) {
-    // Validar delimitadores de PlantUML
-    if (!umlText.trim().startsWith('@startuml') || !umlText.trim().endsWith('@enduml')) {
-        alert('El diagrama debe comenzar con @startuml y terminar con @enduml.');
-        return [];
-    }
-
     const classPattern = /(?:abstract\s+)?class\s+([a-zA-Z0-9_]+)(?:\s+extends\s+([a-zA-Z0-9_]+))?\s*\{([\s\S]*?)\}/g;
-    
-    // Atributos: Captura atributos tipo +int nombre, pero no captura los métodos que contienen ()
     const attributePattern = /([+|-])\s*([\w\*]+)\s+([\w]+)/g;
-
-    // Métodos: Captura métodos tipo +void hacerSonido() o +void hacerSonido(param1)
     const methodPattern = /([+|-])\s*(void|[\w]+)\s+([\w]+)\(\s*\)/g;
-
-    const relationPattern = /([a-zA-Z0-9_]+)\s*(--\|>)\s*([a-zA-Z0-9_]+)/g; // Solo herencia '--|>'
+    const relationPattern = /([a-zA-Z0-9_]+)\s*(--|<\|-|-->|\*--|\|>)\s*"?([*0-9]+)?"?\s*([a-zA-Z0-9_]+)/g;
 
     const classes = [];
     let match;
 
+    // Extraer clases
     while ((match = classPattern.exec(umlText)) !== null) {
         const className = match[1];
         const body = match[3] || '';
@@ -44,23 +34,20 @@ function extractClassesAndRelations(umlText) {
         const attributes = [];
         const methods = [];
 
-        // Extraer métodos primero (evitar que sean capturados como atributos)
+        // Extraer métodos
         let methodMatch;
         while ((methodMatch = methodPattern.exec(body)) !== null) {
             methods.push({
                 visibility: methodMatch[1] === '-' ? 'private' : 'public',
-                returnType: methodMatch[2],  // Ahora guarda 'void' o el tipo adecuado
-                name: methodMatch[3] // Nombre del método
+                returnType: methodMatch[2],
+                name: methodMatch[3]
             });
         }
 
-        // Extraer atributos después de los métodos (evitar duplicación)
+        // Extraer atributos
         let attrMatch;
         while ((attrMatch = attributePattern.exec(body)) !== null) {
-            // Si el atributo es un método (porque tiene paréntesis), lo ignoramos
-            if (body.includes(`${attrMatch[3]}()`)) continue; // Ignorar los que ya son métodos
-
-            const type = attrMatch[2].includes('*') ? attrMatch[2].replace('*', '[]') : attrMatch[2];  // Convertir '*' a '[]'
+            const type = attrMatch[2].includes('*') ? attrMatch[2].replace('*', '[]') : attrMatch[2];
             attributes.push({
                 visibility: attrMatch[1] === '-' ? 'private' : 'public',
                 name: attrMatch[3],
@@ -71,23 +58,28 @@ function extractClassesAndRelations(umlText) {
         classes.push({
             className,
             isAbstract,
-            parentClass: null,  // Inicialmente no tiene clase padre
+            parentClass: null,
             attributes,
             methods
         });
     }
 
-    // Extraer relaciones de herencia '--|>'
-    const relations = [];
+    // Extraer relaciones
     let relationMatch;
     while ((relationMatch = relationPattern.exec(umlText)) !== null) {
-        const childClass = relationMatch[1];
-        const parentClass = relationMatch[3];
-
-        // Asignar la clase padre a la clase hija correspondiente
-        const classData = classes.find(cls => cls.className === childClass);
-        if (classData) {
-            classData.parentClass = parentClass;
+        const classA = relationMatch[1];
+        const classB = relationMatch[4];
+        const cardinality = relationMatch[3];
+
+        if (cardinality === "*") {
+            const classData = classes.find(cls => cls.className === classA);
+            if (classData) {
+                classData.attributes.push({
+                    visibility: 'public',
+                    name: classB.toLowerCase(),
+                    type: `${classB}[]`
+                });
+            }
         }
     }
 

From 55226efa0b13a9178784206260d9e242f0f284b0 Mon Sep 17 00:00:00 2001
From: AndresPlata0411 <dplataa@uninorte.edu.co>
Date: Wed, 4 Dec 2024 14:26:53 -0500
Subject: [PATCH 3/3] last update

---
 README.md        | 36 ++++++++++++++++++++++++++++++++++++
 plantumlToUML.js |  0
 2 files changed, 36 insertions(+)
 delete mode 100644 plantumlToUML.js

diff --git a/README.md b/README.md
index a5f1d7a..35e3740 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,39 @@
 ## UN Code Generator
 
 It takes as input a PlantUML class diagram and outputs the JAVA classes that match it
+
+
+/////
+
+Integrantes del grupo: Andres Plata 200177477
+
+Pasos para Ejecutar:
+
+    1. descargar la extension ESLint
+
+    2. Click derecho en el archivo 'index.html'
+
+    3. Open With Live Server (Esto abrira una pestaña de google con la pagina)
+    
+    4. ingresar como input el diagrama en PlantUML
+
+        Ejemplo:                        (Todo dentro de @startuml y @enduml )
+                @startuml
+                class Profesor {
+                    +String nombre
+                }
+
+                class Curso {
+                    +String titulo
+                }
+
+                Profesor --> "*" Curso
+                @enduml
+
+    5. Click en 'Generate Java Files'
+
+
+
+
+
+
diff --git a/plantumlToUML.js b/plantumlToUML.js
deleted file mode 100644
index e69de29..0000000