Alloy model of unfolding iCalendar documents - alloy

Question

Below is an Alloy model that I created of unfolding the lines in iCalendar documents. I am wondering if there is a better -- simpler -- model?
Here is a brief description of iCalendar and unfolding, followed by my Alloy model.
iCalendar is a computer file format which allows Internet users to send meeting requests and tasks to other Internet users by sharing or sending files in this format. Wikipedia
An iCalendar file consists of a series of lines. Each line cannot be longer than 75 characters (actually 75 octets, but that’s irrelevant for this discussion). If a line exceeds that length, the line must be “folded” onto the next line. A space character at the start of a line indicates that it is a continuation of the previous line.
The process of moving from the folded representation to its single-line representation is called "unfolding". Unfolding is accomplished by removing the CRLF and the space character that immediately follows … When parsing a content line, folded lines must first be unfolded. RFC5545
Here is a sample iCalendar file:
BEGIN:VCALENDAR
VERSION:2.0
CALSCALE:GREGORIAN
BEGIN:VEVENT
DESCRIPTION;ALTREP="cid:part1.0001#example.org":The Fall'98 Wild
Wizards Conference - - Las Vegas\, NV\, USA
END:VEVENT
END:VCALENDAR
The value of the DESCRIPTION property is folded to the next line, as indicated by the space at the start of Wizards Conference ...
The following is an Alloy model of unfolding lines in iCalendar documents.
These are the key abstractions that I identified in this problem: documents, lines, space, data, and unfolding. Specifically, there is a document containing lines. Each line has data. If a line starts with a space, then it is a continuation line and must be merged with the previous line. An unfolding operation must be repetitively applied to the document. The resulting document must have no folded lines.
An ordered set of documents represents the states of the document during the unfolding process:
open util/ordering[Document]
The document contains a set of lines. Each line has a next line (except the last line, of course). Each line has data. After unfolding, a line will have its data plus the data from the next line. Thus, a line has a set of data. One of the lines, obviously, is the first.
sig Document {
lines: Line -> lone Line,
content: Line -> set Data,
firstLine: Line
} {
firstLine in lines.Line
// No Line maps to firstLine, i.e., firstLine is the first line
no line: Line | lines[line] = firstLine
// All lines are reachable from firstLine
(lines.Line + lines[Line] - firstLine) in firstLine.^lines
// The lines are sequential, i.e., lines are acyclic
no ^lines & iden
// No space at start of first line
no firstLine.spaceAtStart
}
A Line may have a space at its start.
sig Line {
spaceAtStart: lone Space
}
Space is represented by a singleton set. Data is a set of values.
one sig Space {}
sig Data {}
Each time the unfold operation is called, it unfolds one line in the document.
Example of an Unfold Operation: Suppose the document contains this sequence of lines:
Line0, Line1, Line2
Suppose Line1 has a space at the start. That means Line0 is continued on Line1; unfolding merges the two lines into one. After unfolding, the document has this:
Line0', Line2
where Line0' contains the data from Line0 plus Line1.
pred unfold (doc, doc': Document, line: doc.lines) {
// precondition: “line” has a next line (i.e., it's not the last line)
some line[Line]
// precondition: the next line starts with a space
some line[Line].spaceAtStart
let line1 = line.Line, line2 = line[Line], line3 = doc.lines[line2] {
// Merge line1 and line2. Set line3 to follow line1.
// Add the content of line2 to line1. Delete line2 -> line3.
// Unless ... no line follows line2. Then the unfold
// results in no line following line1. Remove line1 -> line2.
some doc.lines[line2] => doc'.lines = doc.lines ++ (line1 -> line3) - (line2 -> line3)
else doc'.lines = doc.lines - (line1 -> line2)
doc'.content = doc.content ++ (line1 -> (doc.content[line1] + doc.content[line2]))
doc'.firstLine = doc.firstLine
}
}
Initialize the document with some lines. Give each line unique data. Make some lines that will require unfolding.
pred init (doc: Document) {
some doc.lines
let allLines = doc.lines[Line] + doc.lines.Line {
all line: allLines | let data = doc.content[line] | one data and
all otherLine: allLines - line | doc.content[otherLine] != data
some allLines.spaceAtStart
}
}
At each step of the execution trace, execute the unfold operation if there is at least one line that needs unfolding. Otherwise, do nothing to the document (i.e., do a skip).
fact traces {
init [first]
all doc: Document - last | let doc' = doc.next {
// If spaces exist in the document, do an unfold operation.
// Otherwise, do nothing (i.e., skip).
let allLines = doc.lines[Line] + doc.lines.Line {
some allLines.spaceAtStart => not skip [doc, doc']
some line: doc.lines | unfold [doc, doc', line] or skip [doc, doc']
}
}
}
"skip" means no change to the document, i.e., the next state of the document is the same as the last state.
pred skip (doc, doc': Document) {
doc'.lines = doc.lines
doc'.content = doc.content
doc'.firstLine = doc.firstLine
}
Assert: The final state of the Document has no lines folded.
assert no_lines_are_folded {
let allLines = last.lines[Line] + last.lines.Line |
no allLines.spaceAtStart
}
check no_lines_are_folded for 6
The Alloy Analyzer finds no counterexamples. Yea!