First commit

script.js

@@ -0,0 +1,136 @@
+function compareSchemas() {
+    const text = document.getElementById("schemaText").value;
+    const result = parseSchemas(text);
+    if (result) {
+        displayResult(result);
+    }
+}
+
+function parseSchemas(text) {
+    const oldSchemaMatch = text.match(/Previous: StructType\(\[(.*)\]\)/s);
+    const newSchemaMatch = text.match(/StructType\(\[(.*)\]\) \| Previous:/s);
+
+    if (!oldSchemaMatch || !newSchemaMatch) {
+        alert("Invalid input. Please ensure the text contains both old and new schema definitions.");
+        return null;
+    }
+
+    const oldSchema = parseFields(oldSchemaMatch[1]);
+    const newSchema = parseFields(newSchemaMatch[1]);
+
+    console.log('New Schema:', newSchema);
+    console.log('Old Schema:', oldSchema);
+
+    const added = findDifferences(newSchema, oldSchema);
+    const removed = findDifferences(oldSchema, newSchema);
+    const modified = findModifiedFields(oldSchema, newSchema);
+
+    return { added, removed, modified };
+}
+
+function parseFields(fieldsText) {
+    const fields = [];
+    const regex = /StructField\('(\w+)',\s*([^,]+),\s*(True|False)\)/gs;
+    let match;
+
+    while ((match = regex.exec(fieldsText)) !== null) {
+        const [_, name, type, nullable] = match;
+
+        if (type.startsWith('StructType')) {
+            const nestedFieldsMatch = type.match(/StructType\(\[(.*)\]\)/s);
+            fields.push({
+                name: name,
+                type: 'StructType',
+                nullable: nullable === 'True',
+                nested: nestedFieldsMatch ? parseFields(nestedFieldsMatch[1]) : []
+            });
+        } else {
+            fields.push({
+                name: name,
+                type: type,
+                nullable: nullable === 'True'
+            });
+        }
+    }
+
+    return fields;
+}
+
+function findDifferences(schema1, schema2) {
+    const differences = [];
+
+    schema1.forEach(field => {
+        const matchingField = schema2.find(f => f.name === field.name);
+        if (!matchingField) {
+            differences.push(field);
+        } else if (field.nested) {
+            const nestedDifferences = findDifferences(field.nested, matchingField.nested || []);
+            nestedDifferences.forEach(nestedField => {
+                differences.push({
+                    name: `${field.name}.${nestedField.name}`,
+                    type: nestedField.type,
+                    nullable: nestedField.nullable,
+                    nested: nestedField.nested
+                });
+            });
+        }
+    });
+
+    return differences;
+}
+
+function findModifiedFields(oldSchema, newSchema) {
+    const modified = [];
+
+    newSchema.forEach(field => {
+        const oldField = oldSchema.find(f => f.name === field.name);
+        if (oldField && JSON.stringify(oldField) !== JSON.stringify(field)) {
+            if (field.nested) {
+                const nestedModified = findModifiedFields(oldField.nested || [], field.nested);
+                nestedModified.forEach(nestedField => {
+                    modified.push({
+                        name: `${field.name}.${nestedField.name}`,
+                        type: nestedField.type,
+                        nullable: nestedField.nullable,
+                        nested: nestedField.nested
+                    });
+                });
+            } else {
+                modified.push(field);
+            }
+        }
+    });
+
+    return modified;
+}
+
+function displayResult(result) {
+    document.getElementById("result").style.display = "block";
+
+    const addedTable = document.getElementById("addedTable");
+    const removedTable = document.getElementById("removedTable");
+    const modifiedTable = document.getElementById("modifiedTable");
+
+    populateTable(addedTable, result.added);
+    populateTable(removedTable, result.removed);
+    populateTable(modifiedTable, result.modified);
+}
+
+function populateTable(table, data) {
+    table.innerHTML = `
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Nullable</th>
+            <th>Nested Fields</th>
+        </tr>
+    `;
+
+    data.forEach(field => {
+        const row = table.insertRow();
+        row.insertCell(0).textContent = field.name;
+        row.insertCell(1).textContent = field.type;
+        row.insertCell(2).textContent = field.nullable;
+        row.insertCell(3).textContent = field.nested ? JSON.stringify(field.nested) : 'None';
+    });
+}