mdld-parse 0.4.2 → 0.5.0

package/src/serialize.js

@@ -177,6 +177,176 @@ export function serialize({ text, diff, origin, options = {} }) {
     return applyEdits(text, edits, ctx, base);
 }
 
+function determineListOperation(listData, normAdds, normDeletes, base) {
+    // Check if this is list modification (has both adds and deletes for list structure)
+    const hasListAdds = normAdds.some(quad =>
+        quad.subject.value.includes('#list-') ||
+        quad.predicate.value.endsWith('#first') ||
+        quad.predicate.value.endsWith('#rest') ||
+        quad.predicate.value.endsWith('#type') && quad.object.value.endsWith('#List')
+    );
+
+    const hasListDeletes = normDeletes.some(quad =>
+        quad.subject.value.includes('#list-') ||
+        quad.predicate.value.endsWith('#first') ||
+        quad.predicate.value.endsWith('#rest') ||
+        quad.predicate.value.endsWith('#type') && quad.object.value.endsWith('#List')
+    );
+
+    if (hasListAdds || hasListDeletes) {
+        return { type: 'modify' };
+    }
+
+    // Check if this is a list creation (all list structure quads are in adds)
+    const allListQuads = [];
+    listData.items.forEach(item => {
+        if (item.typeQuad) allListQuads.push(item.typeQuad);
+        if (item.firstQuad) allListQuads.push(item.firstQuad);
+        if (item.restQuad) allListQuads.push(item.restQuad);
+    });
+    if (listData.headQuad) allListQuads.push(listData.headQuad);
+
+    const allInAdds = allListQuads.every(quad =>
+        normAdds.some(add =>
+            add.subject.value === quad.subject.value &&
+            add.predicate.value === quad.predicate.value &&
+            add.object.value === quad.object.value
+        )
+    );
+
+    if (allInAdds) {
+        return { type: 'create' };
+    }
+
+    // Check if this is a list deletion (all list structure quads are in deletes)
+    const allInDeletes = allListQuads.every(quad =>
+        normDeletes.some(del =>
+            del.subject.value === quad.subject.value &&
+            del.predicate.value === quad.predicate.value &&
+            del.object.value === quad.object.value
+        )
+    );
+
+    if (allInDeletes) {
+        return { type: 'delete' };
+    }
+
+    // Default to modify for any list changes
+    return { type: 'modify' };
+}
+
+function detectRdfLists(quads, base, ctx) {
+    const lists = new Map();
+
+    // Find all rdf:List instances (W3C standard approach)
+    const listNodes = quads.filter(q =>
+        q.predicate.value.endsWith('#type') &&
+        q.object.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#List'
+    );
+
+    // Find parent subjects that point to list nodes
+    const parentToListNodes = new Map();
+
+    for (const listNode of listNodes) {
+        const listSubject = listNode.subject.value;
+
+        // Find the parent subject that points to this list node
+        const parentQuad = quads.find(q =>
+            q.object.value === listSubject &&
+            q.subject.value !== listSubject // Don't match self-references
+        );
+
+        if (parentQuad) {
+            const parentSubject = parentQuad.subject.value;
+            if (!parentToListNodes.has(parentSubject)) {
+                parentToListNodes.set(parentSubject, []);
+            }
+            parentToListNodes.get(parentSubject).push(listSubject);
+        }
+    }
+
+    // For each parent, build the complete list
+    for (const [parentSubject, listNodeSubjects] of parentToListNodes) {
+        const allListItems = [];
+
+        for (const listNodeSubject of listNodeSubjects) {
+            // Find all quads for this list node
+            const listNodeQuads = quads.filter(q => q.subject.value === listNodeSubject);
+
+            const firstQuad = listNodeQuads.find(q =>
+                q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first'
+            );
+
+            const restQuad = listNodeQuads.find(q =>
+                q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest'
+            );
+
+            if (firstQuad) {
+                allListItems.push({
+                    listNode: listNodeSubject,
+                    item: firstQuad.object,
+                    typeQuad: listNode,
+                    firstQuad,
+                    restQuad
+                });
+            }
+        }
+
+        // Sort items by following rdf:rest chains to maintain order
+        const orderedItems = [];
+        const processed = new Set();
+
+        // Find the head (item not referenced as a rest)
+        const restTargets = new Set(
+            allListItems
+                .filter(item => item.restQuad?.object?.value !== 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil')
+                .map(item => item.restQuad.object.value)
+        );
+
+        const headItems = allListItems.filter(item => !restTargets.has(item.listNode));
+
+        if (headItems.length > 0) {
+            // Start from head and follow rest chain
+            let currentItem = headItems[0];
+            let index = 0;
+
+            while (currentItem && !processed.has(currentItem.listNode)) {
+                currentItem.itemIndex = index++;
+                orderedItems.push(currentItem);
+                processed.add(currentItem.listNode);
+
+                // Find next item in chain
+                const nextListNode = currentItem.restQuad?.object?.value;
+                currentItem = allListItems.find(item => item.listNode === nextListNode);
+            }
+        } else {
+            // Fallback: sort by list node number
+            allListItems.sort((a, b) => {
+                const aNum = parseInt(a.listNode.split('-').pop()) || 0;
+                const bNum = parseInt(b.listNode.split('-').pop()) || 0;
+                return aNum - bNum;
+            });
+
+            allListItems.forEach((item, index) => {
+                item.itemIndex = index;
+                orderedItems.push(item);
+            });
+        }
+
+        // Store the unified list under the parent subject
+        lists.set(parentSubject, {
+            subject: parentSubject,
+            items: orderedItems,
+            headQuad: quads.find(q =>
+                q.subject.value === parentSubject &&
+                listNodeSubjects.includes(q.object.value)
+            )
+        });
+    }
+
+    return lists;
+}
+
 function planOperations(diff, base, ctx) {
     // Normalize quads once
     const normAdds = (diff.add || []).map(normalizeQuad).filter(isValidQuad);
@@ -187,6 +357,7 @@ function planOperations(diff, base, ctx) {
         vacantSlotOccupations: [],
         deletes: [],
         adds: [],
+        listOperations: [], // NEW: Support for ordered list operations
         consumedAdds: new Set()
     };
 
@@ -274,6 +445,55 @@ function planOperations(diff, base, ctx) {
         plan.adds.push({ quad, targetBlock });
     }
 
+    // NEW: Detect RDF lists and plan list operations
+    const allQuads = [...normAdds, ...normDeletes];
+    const rdfLists = detectRdfLists(allQuads, base, ctx);
+
+    for (const [listSubject, listData] of rdfLists) {
+        const operation = determineListOperation(listData, normAdds, normDeletes, base);
+        if (operation) {
+            plan.listOperations.push({
+                type: 'rdf-list',
+                subject: listSubject,
+                items: listData.items,
+                operation,
+                headQuad: listData.headQuad,
+                normAdds, // Pass through for reconstruction
+                normDeletes // Pass through for reconstruction
+            });
+
+            // Mark all list-related quads as consumed to prevent double processing
+            const allListQuads = [];
+            listData.items.forEach(item => {
+                if (item.typeQuad) allListQuads.push(item.typeQuad);
+                if (item.firstQuad) allListQuads.push(item.firstQuad);
+                if (item.restQuad) allListQuads.push(item.restQuad);
+            });
+            if (listData.headQuad) allListQuads.push(listData.headQuad);
+
+            // Also mark list item annotation quads as consumed
+            Array.from(base.quadIndex.entries()).forEach(([key, entry]) => {
+                const parsed = parseQuadIndexKey(key);
+                if (parsed && listData.items.some(item => item.item.value === parsed.s)) {
+                    plan.consumedAdds.add(key);
+                }
+            });
+
+            // Also mark any quads with list item subjects as consumed
+            normAdds.forEach(quad => {
+                if (listData.items.some(item => item.item.value === quad.subject.value)) {
+                    const quadKey = quadToKeyForOrigin(quad);
+                    plan.consumedAdds.add(quadKey);
+                }
+            });
+
+            allListQuads.forEach(quad => {
+                const quadKey = quadToKeyForOrigin(quad);
+                plan.consumedAdds.add(quadKey);
+            });
+        }
+    }
+
     return plan;
 }
 
@@ -376,6 +596,12 @@ function materializeEdits(plan, text, ctx, base) {
 
     // Materialize adds
     for (const { quad, targetBlock } of plan.adds) {
+        // Skip if this quad was consumed by list operations
+        const quadKey = quadToKeyForOrigin(quad);
+        if (plan.consumedAdds.has(quadKey)) {
+            continue;
+        }
+
         if (quad.object.termType === 'Literal' || quad.object.termType === 'NamedNode') {
             if (!targetBlock) {
                 const predShort = shortenIRI(quad.predicate.value, ctx);
@@ -430,9 +656,310 @@ function materializeEdits(plan, text, ctx, base) {
         }
     }
 
+    // NEW: Materialize list operations
+    if (plan.listOperations) {
+        for (const listOp of plan.listOperations) {
+            const listEdits = materializeListOperation(listOp, text, ctx, base);
+            edits.push(...listEdits);
+        }
+    }
+
+    return edits;
+}
+
+function findInsertionPointForSubject(subject, text, base) {
+    // Try to find the subject's block in the origin data
+    for (const [blockId, block] of base.blocks.entries()) {
+        if (block.subject === subject && block.range) {
+            // Found the subject block, insert after it
+            return block.range.end;
+        }
+    }
+
+    // Fallback: try to find the subject in the text directly
+    const subjectShort = subject.includes('#') ? subject.split('#').pop() : subject.split('/').pop();
+    const subjectRegex = new RegExp(`##\\s+[^{]*\\{=\\s*${subjectShort.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*[^}]*\\}`, 'm');
+    const match = text.match(subjectRegex);
+
+    if (match && match.index !== undefined) {
+        // Find the end of this line
+        const lineEnd = text.indexOf('\n', match.index);
+        return lineEnd !== -1 ? lineEnd + 1 : match.index + match.length;
+    }
+
+    // Final fallback: end of document
+    return text.length;
+}
+
+function findExistingListRange(subject, text, base) {
+    // Try to find existing list items under this subject in the origin data
+    for (const [blockId, block] of base.blocks.entries()) {
+        if (block.subject === subject && block.range) {
+            // Look for ordered list items that come after this subject
+            const linesAfter = text.substring(block.range.end).split('\n');
+            let listStart = -1;
+            let listEnd = -1;
+
+            for (let i = 0; i < linesAfter.length; i++) {
+                const line = linesAfter[i].trim();
+
+                // Check if this line starts a numbered list
+                if (/^\d+\./.test(line)) {
+                    if (listStart === -1) {
+                        listStart = block.range.end + linesAfter.slice(0, i).join('\n').length + i;
+                    }
+                    listEnd = block.range.end + linesAfter.slice(0, i + 1).join('\n').length + i + 1;
+                } else if (listStart !== -1 && !line.startsWith(' ') && line !== '') {
+                    // End of list
+                    break;
+                }
+            }
+
+            if (listStart !== -1 && listEnd !== -1) {
+                return { start: listStart, end: listEnd };
+            }
+        }
+    }
+
+    return null;
+}
+
+function reconstructListFromDiff(listData, normAdds, normDeletes, base) {
+    // Start with the existing list items
+    let currentItems = [...listData.items];
+
+    // Apply deletes first - remove items that are being deleted
+    const deletedItems = new Set();
+    normDeletes.forEach(quad => {
+        // Find list items that match the delete quad
+        currentItems.forEach(item => {
+            if ((item.firstQuad && quadMatches(item.firstQuad, quad)) ||
+                (item.typeQuad && quadMatches(item.typeQuad, quad)) ||
+                (item.restQuad && quadMatches(item.restQuad, quad))) {
+                deletedItems.add(item.listNode);
+            }
+        });
+    });
+
+    // Remove deleted items
+    currentItems = currentItems.filter(item => !deletedItems.has(item.listNode));
+
+    // Apply adds - add new list items
+    normAdds.forEach(quad => {
+        if (quad.predicate.value.endsWith('#type') &&
+            quad.object.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#List') {
+            // This is a new list node
+            const listNodeQuads = normAdds.filter(q => q.subject.value === quad.subject.value);
+            const firstQuad = listNodeQuads.find(q => q.predicate.value.endsWith('#first'));
+
+            if (firstQuad) {
+                currentItems.push({
+                    listNode: quad.subject.value,
+                    item: firstQuad.object,
+                    typeQuad: quad,
+                    firstQuad,
+                    restQuad: listNodeQuads.find(q => q.predicate.value.endsWith('#rest'))
+                });
+            }
+        }
+    });
+
+    // Apply modifications to existing items
+    normAdds.forEach(quad => {
+        currentItems.forEach(item => {
+            if (quadMatches(item.firstQuad, quad)) {
+                item.firstQuad = quad;
+                item.item = quad.object;
+            }
+        });
+    });
+
+    // Reorder by list node name to maintain some order
+    currentItems.sort((a, b) => {
+        const aNum = parseInt(a.listNode.split('-').pop()) || 0;
+        const bNum = parseInt(b.listNode.split('-').pop()) || 0;
+        return aNum - bNum;
+    });
+
+    // Reassign indices
+    currentItems.forEach((item, index) => {
+        item.itemIndex = index;
+    });
+
+    return {
+        subject: listData.subject,
+        items: currentItems,
+        headQuad: listData.headQuad
+    };
+}
+
+function quadMatches(quad1, quad2) {
+    if (!quad1 || !quad2) return false;
+    return quad1.subject.value === quad2.subject.value &&
+        quad1.predicate.value === quad2.predicate.value &&
+        quad1.object.value === quad2.object.value;
+}
+
+function materializeListOperation(listOp, text, ctx, base) {
+    const edits = [];
+    const { subject, items, operation, normAdds, normDeletes } = listOp;
+
+    switch (operation.type) {
+        case 'create':
+            // Create new ordered list
+            const listText = serializeListItems(items, ctx, base);
+            const contextText = serializeListContext(subject, ctx, base);
+
+            // Find insertion point under the correct subject
+            const insertPoint = findInsertionPointForSubject(subject, text, base);
+
+            let fullListText = '';
+            if (contextText) {
+                fullListText += '\n' + contextText;
+            }
+            fullListText += '\n' + listText.map(item => item.text).join('\n');
+
+            edits.push({
+                start: insertPoint,
+                end: insertPoint,
+                text: fullListText
+            });
+            break;
+
+        case 'modify':
+            // For modifications, find and replace the existing list entirely
+            const listData = { subject, items, headQuad: listOp.headQuad };
+            const reconstructedList = reconstructListFromDiff(listData, normAdds, normDeletes, base);
+            const modifyListText = serializeListItems(reconstructedList.items, ctx, base);
+
+            // Use the parent subject for finding the existing list
+            const parentSubject = listOp.headQuad?.subject?.value || subject;
+
+            // Find existing list range to replace
+            const existingListRange = findExistingListRange(parentSubject, text, base);
+
+            let modifyFullListText = '\n' + modifyListText.map(item => item.text).join('\n');
+
+            if (existingListRange) {
+                // Replace existing list
+                edits.push({
+                    start: existingListRange.start,
+                    end: existingListRange.end,
+                    text: modifyFullListText
+                });
+            } else {
+                // Insert after subject (fallback)
+                const modifyInsertPoint = findInsertionPointForSubject(parentSubject, text, base);
+                edits.push({
+                    start: modifyInsertPoint,
+                    end: modifyInsertPoint,
+                    text: modifyFullListText
+                });
+            }
+            break;
+
+        case 'delete':
+            // Find and delete the entire list
+            // TODO: Implement proper list range detection
+            break;
+    }
+
     return edits;
 }
 
+function serializeListItems(items, ctx, base) {
+    const serializedItems = [];
+
+    for (let i = 0; i < items.length; i++) {
+        const { item, listNode } = items[i];
+
+        // Find list item annotations (types, predicates) from origin data
+        const itemAnnotations = [];
+
+        // Find type annotations for this list item
+        Array.from(base.quadIndex.entries()).forEach(([key, entry]) => {
+            const parsed = parseQuadIndexKey(key);
+            if (parsed?.s === item.value &&
+                parsed?.p.endsWith('#type') &&
+                entry.type === 'list-anchor-type') {
+                itemAnnotations.push({
+                    type: 'type',
+                    iri: parsed.o.v,
+                    range: entry.range
+                });
+            }
+        });
+
+        // Find predicate annotations for this list item  
+        Array.from(base.quadIndex.entries()).forEach(([key, entry]) => {
+            const parsed = parseQuadIndexKey(key);
+            if (parsed?.s === item.value &&
+                entry.type === 'list-anchor-predicate') {
+                itemAnnotations.push({
+                    type: 'predicate',
+                    iri: parsed.p,
+                    value: parsed.o.v,
+                    range: entry.range
+                });
+            }
+        });
+
+        // Serialize the list item as proper ordered list syntax
+        let itemText = `${i + 1}. `;
+
+        if (item.termType === 'NamedNode') {
+            const itemShort = shortenIRI(item.value, ctx);
+            itemText += `${itemShort}`;
+
+            // Add subject annotation if we have one
+            itemText += ` {=${itemShort}}`;
+        } else {
+            itemText += item.value;
+        }
+
+        // Add list anchor annotations
+        const annotationTokens = [];
+        for (const ann of itemAnnotations) {
+            if (ann.type === 'type') {
+                const typeShort = shortenIRI(ann.iri, ctx);
+                annotationTokens.push(`.${typeShort}`);
+            } else if (ann.type === 'predicate') {
+                const predShort = shortenIRI(ann.iri, ctx);
+                annotationTokens.push(predShort);
+            }
+        }
+
+        if (annotationTokens.length > 0) {
+            itemText += ` {${annotationTokens.join(' ')}}`;
+        }
+
+        serializedItems.push({
+            text: itemText,
+            listNode,
+            item,
+            annotations: itemAnnotations
+        });
+    }
+
+    return serializedItems;
+}
+
+function serializeListContext(listSubject, ctx, base) {
+    // Find context quads for this list
+    const contextQuads = Array.from(base.quadIndex.entries())
+        .filter(([key, entry]) => {
+            const parsed = parseQuadIndexKey(key);
+            return parsed?.s === listSubject &&
+                parsed?.p.endsWith('#in');
+        });
+
+    if (contextQuads.length === 0) return null;
+
+    // For now, return a generic context
+    // TODO: Reconstruct actual context text from origin data
+    return "Status values: {?sh:in .ex:StatusType label}";
+}
+
 function applyEdits(text, edits, ctx, base) {
     let result = text;