@graphty/graph-io 0.3.39 → 0.3.41

package/src/formats/csv/exporter.ts

@@ -407,6 +407,25 @@ function nodeTableNote(names: readonly string[], table: string, notes: LossNote[
     }
 }
 
+/**
+ * The number of node ids whose text an earlier id already has (a number and a string).
+ * @param ids - the snapshot's ids
+ * @returns the collisions
+ */
+function idTextCollisions(ids: GraphSnapshot["ids"]): number {
+    const seen = new Set<string>();
+    let collisions = 0;
+    for (let i = 0; i < ids.size; i++) {
+        const text = String(ids.idOf(i));
+        if (seen.has(text)) {
+            collisions++;
+        } else {
+            seen.add(text);
+        }
+    }
+    return collisions;
+}
+
 /**
  * The id notes: text collisions are fatal (export() throws E_INVALID_ID); type changes under the
  * canonical re-read are reported.
@@ -421,16 +440,7 @@ function idNotes(
 ): void {
     const { ids } = snapshot;
     if (ids.kind === "mixed") {
-        const seen = new Set<string>();
-        let collisions = 0;
-        for (let i = 0; i < ids.size; i++) {
-            const text = String(ids.idOf(i));
-            if (seen.has(text)) {
-                collisions++;
-            } else {
-                seen.add(text);
-            }
-        }
+        const collisions = idTextCollisions(ids);
         if (collisions > 0) {
             note(
                 CSV_LOSS.ID_TEXT_COLLISION,
@@ -699,40 +709,81 @@ function attributeColumns(
         if (role !== null && SKIPPED_ROLES.has(role)) {
             continue;
         }
-        const low = lower(name);
         const set = column.length - column.nullCount;
-        const isIdName = domain === "edge" ? findColumn([name], EDGE_ID_NAMES) >= 0 : false;
-        if (reserved.has(low) || isIdName || (idColumn !== null && lower(idColumn.meta.name) === low)) {
-            note?.(
-                CSV_LOSS.RESERVED_NAME,
-                `${domain} column "${name}" is not written: the name is reserved for the ${isIdName ? "edge id" : low} column`,
-                name,
-                set,
-            );
+        if (isReservedName(name, domain, reserved, idColumn, set, note)) {
             continue;
         }
-        if (findColumn([name], LABEL_NAMES) >= 0) {
-            if (labelColumn !== null) {
-                note?.(
-                    CSV_LOSS.RESERVED_NAME,
-                    `${domain} column "${name}" is not written: the name is reserved for the label column`,
-                    name,
-                    set,
-                );
-                continue;
-            }
-            note?.(
-                CSV_LOSS.ROLE_ASSUMED,
-                `${domain} column "${name}" reads back with the label role (string)`,
-                name,
-                set,
-            );
+        if (findColumn([name], LABEL_NAMES) >= 0 && !labelNameWritten(name, domain, labelColumn, set, note)) {
+            continue;
         }
         out.push({ column, header: name });
     }
     return out;
 }
 
+/**
+ * Whether an attribute column's name is reserved for a structural column (a dialect header, an
+ * edge id name, the id column's name), with its note.
+ * @param name - the column name
+ * @param domain - node or edge, for messages
+ * @param reserved - lower-case header names the dialect writes for structure
+ * @param idColumn - the table's id role column, or null
+ * @param set - the column's set cells
+ * @param note - the recorder, or null when this table's notes are not wanted
+ * @returns true when the column is not written
+ */
+function isReservedName(
+    name: string,
+    domain: "node" | "edge",
+    reserved: ReadonlySet<string>,
+    idColumn: Column | null,
+    set: number,
+    note: ((code: string, message: string, column?: string | null, count?: number | null) => void) | null,
+): boolean {
+    const low = lower(name);
+    const isIdName = domain === "edge" ? findColumn([name], EDGE_ID_NAMES) >= 0 : false;
+    if (reserved.has(low) || isIdName || (idColumn !== null && lower(idColumn.meta.name) === low)) {
+        note?.(
+            CSV_LOSS.RESERVED_NAME,
+            `${domain} column "${name}" is not written: the name is reserved for the ${isIdName ? "edge id" : low} column`,
+            name,
+            set,
+        );
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Whether an attribute column with a label header name is written, with its note: not when the
+ * table has a label column (the name is reserved for it), else it reads back with the label role.
+ * @param name - the column name
+ * @param domain - node or edge, for messages
+ * @param labelColumn - the table's label role column, or null
+ * @param set - the column's set cells
+ * @param note - the recorder, or null when this table's notes are not wanted
+ * @returns true when the column is written
+ */
+function labelNameWritten(
+    name: string,
+    domain: "node" | "edge",
+    labelColumn: Column | null,
+    set: number,
+    note: ((code: string, message: string, column?: string | null, count?: number | null) => void) | null,
+): boolean {
+    if (labelColumn !== null) {
+        note?.(
+            CSV_LOSS.RESERVED_NAME,
+            `${domain} column "${name}" is not written: the name is reserved for the label column`,
+            name,
+            set,
+        );
+        return false;
+    }
+    note?.(CSV_LOSS.ROLE_ASSUMED, `${domain} column "${name}" reads back with the label role (string)`, name, set);
+    return true;
+}
+
 /**
  * Notes about a role column (id or label): a name the importer does not map to the role, and a
  * dtype other than string / dict (read back as string).
@@ -912,6 +963,22 @@ function neighbourCell(id: string, weight: string | null): string {
     return id.includes(":") ? `${id}:` : id;
 }
 
+/**
+ * The end of the run of consecutive edge rows that share the source of row `r`.
+ * @param src - the edge sources by edge index
+ * @param edgeRows - the edges in write order
+ * @param r - the run's first row
+ * @returns the index after the run's last row
+ */
+function sourceRunEnd(src: ArrayLike<number>, edgeRows: ArrayLike<number>, r: number): number {
+    const source = src[edgeRows[r]];
+    let end = r;
+    while (end < edgeRows.length && src[edgeRows[end]] === source) {
+        end++;
+    }
+    return end;
+}
+
 /**
  * The rows of the adjacency table (design section 8.5: the order survives the importer's first-
  * appearance numbering). Consecutive edges with one source share a row, so the edge order is kept;
@@ -953,10 +1020,7 @@ function* adjacencyLines(snapshot: GraphSnapshot, plan: Plan): Generator<string,
     let r = 0;
     while (r < edgeRows.length) {
         const source = list.src[edgeRows[r]];
-        let end = r;
-        while (end < edgeRows.length && list.src[edgeRows[end]] === source) {
-            end++;
-        }
+        const end = sourceRunEnd(list.src, edgeRows, r);
         // the nodes this row introduces, in the order the importer meets them; in index order from
         // `next` they need nothing more
         const fresh: number[] = [];

package/src/formats/csv/importer.ts

@@ -575,6 +575,22 @@ function isUnset(text: string, quoted: boolean | undefined): boolean {
     return quoted !== true && isBlank(text);
 }
 
+/**
+ * The number of set neighbor cells of an adjacency row (every cell after the first).
+ * @param row - the cells
+ * @param quoted - whether each cell was quoted
+ * @returns the set neighbor cells
+ */
+function setNeighborCells(row: readonly string[], quoted: readonly boolean[]): number {
+    let neighbors = 0;
+    for (let k = 1; k < row.length; k++) {
+        if (!isUnset(row[k], quoted[k])) {
+            neighbors++;
+        }
+    }
+    return neighbors;
+}
+
 /** Rows between two checks of the cancellation signal on an in-memory input. */
 const ABORT_CHECK_INTERVAL = 64;
 
@@ -1520,12 +1536,7 @@ class TableReader {
         const { where } = this;
         where.line = line;
         where.element = null;
-        let neighbors = 0;
-        for (let k = 1; k < row.length; k++) {
-            if (!isUnset(row[k], quoted[k])) {
-                neighbors++;
-            }
-        }
+        const neighbors = setNeighborCells(row, quoted);
         if (isUnset(row[0], quoted[0])) {
             report.error("missing-value", MISSING_ID_CODE, `blank node cell`, { line });
             counts.skippedNodes++;

package/src/formats/csv/records.ts

@@ -410,16 +410,7 @@ export function sniffDelimiter(
         if (rows.length === 0) {
             continue;
         }
-        let total = 0;
-        let delta = 0;
-        for (let i = 0; i < rows.length; i++) {
-            const count = rows[i].length;
-            total += count;
-            if (i > 0) {
-                delta += Math.abs(count - rows[i - 1].length);
-            }
-        }
-        const average = total / rows.length;
+        const { average, delta } = rowWidths(rows);
         if (average > 1.99 && delta < bestDelta) {
             best = delimiter;
             bestDelta = delta;
@@ -428,6 +419,24 @@ export function sniffDelimiter(
     return best;
 }
 
+/**
+ * The average width of the rows and the sum of the width changes from each row to the next.
+ * @param rows - the rows (at least one)
+ * @returns the average and the delta
+ */
+function rowWidths(rows: readonly (readonly string[])[]): { average: number; delta: number } {
+    let total = 0;
+    let delta = 0;
+    for (let i = 0; i < rows.length; i++) {
+        const count = rows[i].length;
+        total += count;
+        if (i > 0) {
+            delta += Math.abs(count - rows[i - 1].length);
+        }
+    }
+    return { average: total / rows.length, delta };
+}
+
 /**
  * Whether a parsed row is a blank line: one cell holding only whitespace.
  * @param row - the row
@@ -739,125 +748,169 @@ class RecordScanner {
      * @returns the position after the last character consumed
      */
     scan(chunk: string, from: number): number {
-        const { quoteCode, delimiterCode } = this;
+        const { delimiterCode } = this;
         const n = chunk.length;
         let i = from;
         this.segment = from;
         while (i < n) {
             const c = chunk.charCodeAt(i);
-            if (this.state === COMMENT) {
-                if (c === LF || c === CR) {
-                    this.comment = this.grow(this.comment, chunk.slice(this.segment, i));
-                    this.reader.leadingComments.push(this.comment);
-                    this.reader.leadingCommentLines.push(this.line);
-                    this.comment = "";
-                    this.state = START;
-                    this.endLine(c);
-                    this.segment = i + 1;
-                }
+            const { state } = this;
+            if (state === COMMENT) {
+                this.commentChar(chunk, i, c);
                 i++;
                 continue;
             }
-            if (this.state === QUOTED) {
-                // jump to the next quote; the run in between is field text whose line breaks are counted
-                const q = chunk.indexOf(this.quoteText, i);
-                const end = q < 0 ? n : q;
-                if (end > i) {
-                    this.countLineBreaks(chunk, i, end);
-                }
-                if (q < 0) {
-                    i = n;
-                    break;
-                }
-                this.field = this.grow(this.field, chunk.slice(this.segment, q));
-                this.state = CLOSING;
-                this.lastWasCr = false;
-                i = q + 1;
+            if (state === QUOTED) {
+                i = this.quotedRun(chunk, i);
                 continue;
             }
             const isDelimiter = c === delimiterCode || (this.collapse && c === TAB);
-            if (this.state === CLOSING) {
-                if (c === quoteCode) {
-                    this.field = this.grow(this.field, this.quoteText);
-                    this.segment = i + 1;
-                    this.state = QUOTED;
-                    this.lastWasCr = false;
-                    i++;
-                    continue;
-                }
-                if (!isDelimiter && c !== LF && c !== CR) {
-                    this.reader.badQuote(this.startLine, this.count + 1);
-                }
-                this.state = AFTER_QUOTED;
-                this.segment = i;
-                // fall through to the delimiter / line-end handling below without consuming c
-            }
-            if (isDelimiter || c === LF || c === CR) {
-                if (c === LF && this.lastWasCr) {
-                    // the second half of a CRLF already ended the record
-                    this.lastWasCr = false;
-                    this.segment = i + 1;
-                    i++;
-                    continue;
-                }
-                if (this.state === UNQUOTED) {
-                    this.field = this.grow(this.field, chunk.slice(this.segment, i));
-                }
-                if (isDelimiter && this.collapse && this.state === START) {
-                    // a run of whitespace, or indentation: one separator
-                    this.lastWasCr = false;
-                    this.segment = i + 1;
-                    i++;
-                    continue;
-                }
-                if (isDelimiter) {
-                    this.push();
-                    this.state = START;
-                    this.lastWasCr = false;
-                    this.segment = i + 1;
-                    i++;
-                    continue;
-                }
-                // a line ending right after a whitespace run in the whitespace dialect ends no field
-                if (!(this.state === START && (this.count === 0 || this.collapse))) {
-                    this.push();
-                }
-                if (this.count > 0) {
-                    this.ready = true;
-                    this.recordLine = this.startLine;
-                }
-                this.state = START;
-                this.endLine(c);
-                this.segment = i + 1;
-                i++;
+            if (state === CLOSING || isDelimiter || c === LF || c === CR) {
+                i = this.boundary(chunk, i, c, isDelimiter);
                 if (this.ready) {
                     return i;
                 }
                 continue;
             }
+            this.fieldChar(c, i);
+            i++;
+        }
+        return i;
+    }
+
+    /**
+     * One character of a leading comment line: a line break ends the comment.
+     * @param chunk - the chunk
+     * @param i - the character's index
+     * @param c - the character's code
+     */
+    private commentChar(chunk: string, i: number, c: number): void {
+        if (c !== LF && c !== CR) {
+            return;
+        }
+        this.comment = this.grow(this.comment, chunk.slice(this.segment, i));
+        this.reader.leadingComments.push(this.comment);
+        this.reader.leadingCommentLines.push(this.line);
+        this.comment = "";
+        this.state = START;
+        this.endLine(c);
+        this.segment = i + 1;
+    }
+
+    /**
+     * Inside a quoted field: jump to the next quote; the run in between is field text whose line
+     * breaks are counted.
+     * @param chunk - the chunk
+     * @param i - where the run starts
+     * @returns the position after the quote, or the chunk end when there is none
+     */
+    private quotedRun(chunk: string, i: number): number {
+        const q = chunk.indexOf(this.quoteText, i);
+        const end = q < 0 ? chunk.length : q;
+        if (end > i) {
+            this.countLineBreaks(chunk, i, end);
+        }
+        if (q < 0) {
+            return chunk.length;
+        }
+        this.field = this.grow(this.field, chunk.slice(this.segment, q));
+        this.state = CLOSING;
+        this.lastWasCr = false;
+        return q + 1;
+    }
+
+    /**
+     * The character after a quote inside a quoted field, a delimiter or a line break: a doubled
+     * quote, the end of a field, or the end of a record.
+     * @param chunk - the chunk
+     * @param i - the character's index
+     * @param c - the character's code
+     * @param isDelimiter - whether it separates fields
+     * @returns the position after the character
+     */
+    private boundary(chunk: string, i: number, c: number, isDelimiter: boolean): number {
+        if (this.state === CLOSING) {
+            if (c === this.quoteCode) {
+                this.field = this.grow(this.field, this.quoteText);
+                this.segment = i + 1;
+                this.state = QUOTED;
+                this.lastWasCr = false;
+                return i + 1;
+            }
+            if (!isDelimiter && c !== LF && c !== CR) {
+                this.reader.badQuote(this.startLine, this.count + 1);
+            }
+            this.state = AFTER_QUOTED;
+            this.segment = i;
+        }
+        if (c === LF && this.lastWasCr) {
+            // the second half of a CRLF already ended the record
             this.lastWasCr = false;
-            if (this.state === START) {
-                if (this.leading && this.count === 0 && this.commentCodes.includes(c)) {
-                    this.state = COMMENT;
-                    this.segment = i;
-                    i++;
-                    continue;
-                }
-                this.leading = false;
-                if (c === quoteCode) {
-                    this.state = QUOTED;
-                    this.fieldQuoted = true;
-                    this.segment = i + 1;
-                } else {
-                    this.state = UNQUOTED;
-                    this.segment = i;
-                }
-            } else if (c === quoteCode && this.state === UNQUOTED && this.reader.strayQuoteLine === 0) {
+            this.segment = i + 1;
+            return i + 1;
+        }
+        if (this.state === UNQUOTED) {
+            this.field = this.grow(this.field, chunk.slice(this.segment, i));
+        }
+        if (isDelimiter) {
+            // in the whitespace dialect a run of whitespace, or indentation, is one separator
+            if (!(this.collapse && this.state === START)) {
+                this.push();
+                this.state = START;
+            }
+            this.lastWasCr = false;
+            this.segment = i + 1;
+            return i + 1;
+        }
+        this.lineEnd(c);
+        this.segment = i + 1;
+        return i + 1;
+    }
+
+    /**
+     * A line break that ends a record (or a blank line).
+     * @param c - the LF or CR
+     */
+    private lineEnd(c: number): void {
+        // a line ending right after a whitespace run in the whitespace dialect ends no field
+        if (!(this.state === START && (this.count === 0 || this.collapse))) {
+            this.push();
+        }
+        if (this.count > 0) {
+            this.ready = true;
+            this.recordLine = this.startLine;
+        }
+        this.state = START;
+        this.endLine(c);
+    }
+
+    /**
+     * Any other character outside a quoted field: the start of a field or a comment, or field text.
+     * @param c - the character's code
+     * @param i - its index
+     */
+    private fieldChar(c: number, i: number): void {
+        this.lastWasCr = false;
+        if (this.state !== START) {
+            if (c === this.quoteCode && this.state === UNQUOTED && this.reader.strayQuoteLine === 0) {
                 this.reader.strayQuoteLine = this.startLine;
             }
-            i++;
+            return;
+        }
+        if (this.leading && this.count === 0 && this.commentCodes.includes(c)) {
+            this.state = COMMENT;
+            this.segment = i;
+            return;
+        }
+        this.leading = false;
+        if (c === this.quoteCode) {
+            this.state = QUOTED;
+            this.fieldQuoted = true;
+            this.segment = i + 1;
+        } else {
+            this.state = UNQUOTED;
+            this.segment = i;
         }
-        return i;
     }
 
     /**