@graphty/graph-io 0.3.40 → 0.3.42

package/src/common/attributes.ts

@@ -132,22 +132,7 @@ export const DICT_SAMPLE_ROWS = 1024;
 export function declareAttribute(input: AttributeDeclarationInput): DeclaredAttribute {
     const issues: DeclarationIssue[] = [];
     const listSyntax = input.listSyntax ?? "gexf";
-    let spec: DeclaredTypeSpec;
-    if (input.type === null) {
-        spec = stringSpec(null);
-    } else {
-        const mapped = mapDeclaredType(input.format, input.type, input.long);
-        if (mapped === null) {
-            spec = stringSpec(input.type);
-            issues.push({
-                category: "unsupported",
-                code: UNKNOWN_TYPE_CODE,
-                message: `${input.format} type "${input.type}" is not supported; values kept as text`,
-            });
-        } else {
-            spec = mapped;
-        }
-    }
+    let spec = declaredSpec(input, issues);
     const { name, renamed } = resolveName(input);
     if (renamed) {
         issues.push({
@@ -179,20 +164,7 @@ export function declareAttribute(input: AttributeDeclarationInput): DeclaredAttr
     }
     const optionsText = input.optionsText ?? null;
     if (optionsText !== null) {
-        try {
-            const options = splitListText(optionsText, listSyntax).map((item) => parseItem(item, spec));
-            decl.options = options;
-            if (spec.dtype === "string" && !spec.list && options.every((o) => typeof o === "string")) {
-                decl.dtype = "dict";
-                spec = { ...spec, dtype: "dict" };
-            }
-        } catch (err) {
-            issues.push({
-                category: "validation-error",
-                code: BAD_OPTIONS_CODE,
-                message: `options "${optionsText}" of attribute "${name}" do not parse as ${spec.declared}: ${messageOf(err)}`,
-            });
-        }
+        spec = declareOptions(decl, spec, optionsText, listSyntax, issues);
     }
     const defaultText = input.defaultText ?? null;
     if (defaultText !== null) {
@@ -210,6 +182,63 @@ export function declareAttribute(input: AttributeDeclarationInput): DeclaredAttr
     return { decl, spec, listSyntax, companion, renamed, issues };
 }
 
+/**
+ * The value spec of a declared type: string for no type, string with UNKNOWN_TYPE_CODE for a type
+ * the format does not define.
+ * @param input - what the file declares
+ * @param issues - receives the unknown-type warning
+ * @returns the spec
+ */
+function declaredSpec(input: AttributeDeclarationInput, issues: DeclarationIssue[]): DeclaredTypeSpec {
+    if (input.type === null) {
+        return stringSpec(null);
+    }
+    const mapped = mapDeclaredType(input.format, input.type, input.long);
+    if (mapped !== null) {
+        return mapped;
+    }
+    issues.push({
+        category: "unsupported",
+        code: UNKNOWN_TYPE_CODE,
+        message: `${input.format} type "${input.type}" is not supported; values kept as text`,
+    });
+    return stringSpec(input.type);
+}
+
+/**
+ * Put the parsed options of an attribute on its declaration; a plain string attribute whose
+ * options are all strings becomes a dict column.
+ * @param decl - the declaration to complete
+ * @param spec - the value spec
+ * @param optionsText - the options text
+ * @param listSyntax - the list syntax the options are split with
+ * @param issues - receives BAD_OPTIONS_CODE when the options do not parse
+ * @returns the spec, with dtype dict when the column became a dict
+ */
+function declareOptions(
+    decl: ColumnDecl,
+    spec: DeclaredTypeSpec,
+    optionsText: string,
+    listSyntax: ListSyntax,
+    issues: DeclarationIssue[],
+): DeclaredTypeSpec {
+    try {
+        const options = splitListText(optionsText, listSyntax).map((item) => parseItem(item, spec));
+        decl.options = options;
+        if (spec.dtype === "string" && !spec.list && options.every((o) => typeof o === "string")) {
+            decl.dtype = "dict";
+            return { ...spec, dtype: "dict" };
+        }
+    } catch (err) {
+        issues.push({
+            category: "validation-error",
+            code: BAD_OPTIONS_CODE,
+            message: `options "${optionsText}" of attribute "${decl.name}" do not parse as ${spec.declared}: ${messageOf(err)}`,
+        });
+    }
+    return spec;
+}
+
 /**
  * Parse a value text by a declaration: a scalar, or a list split by the syntax with each item
  * parsed by the item kind.
@@ -326,29 +355,12 @@ export function declareResolved(
                 throw err;
             }
             if (err.code === "E_COLUMN_EXISTS" && !renamed) {
-                const taken = takenIn(sink, domain);
-                const id = current.origin?.id ?? null;
-                const name = uniqueColumnName(current.name, id, taken);
-                report.warning(
-                    "coercion",
-                    COLUMN_RENAMED_CODE,
-                    `${domain} column "${current.name}" renamed to "${name}": the sink already holds that name with another shape`,
-                    { ...where, element: where?.element ?? current.name },
-                );
-                current = { ...current, name };
+                current = renameColumn(sink, domain, current, report, where);
                 renamed = true;
                 continue;
             }
             if (err.code === "E_DUPLICATE_ROLE" && current.role !== undefined && !roleDropped) {
-                const holder = typeof err.details.holder === "string" ? err.details.holder : "another column";
-                report.warning(
-                    "coercion",
-                    ROLE_TAKEN_CODE,
-                    `${domain} column "${current.name}" loses the ${current.role} role: "${holder}" already holds it`,
-                    { ...where, element: where?.element ?? current.name },
-                );
-                const { role: _role, ...withoutRole } = current;
-                current = withoutRole;
+                current = dropRole(err, domain, current, current.role, report, where);
                 roleDropped = true;
                 continue;
             }
@@ -357,6 +369,63 @@ export function declareResolved(
     }
 }
 
+/**
+ * The declaration under a name the sink does not hold yet, recording W_COLUMN_RENAMED.
+ * @param sink - the sink
+ * @param domain - node or edge
+ * @param decl - the declaration whose name clashed
+ * @param report - the report
+ * @param where - the line and element, when known
+ * @returns the renamed declaration
+ */
+function renameColumn(
+    sink: GraphSink,
+    domain: "node" | "edge",
+    decl: ColumnDecl,
+    report: ImportReportBuilder,
+    where: IssueLocation | undefined,
+): ColumnDecl {
+    const taken = takenIn(sink, domain);
+    const id = decl.origin?.id ?? null;
+    const name = uniqueColumnName(decl.name, id, taken);
+    report.warning(
+        "coercion",
+        COLUMN_RENAMED_CODE,
+        `${domain} column "${decl.name}" renamed to "${name}": the sink already holds that name with another shape`,
+        { ...where, element: where?.element ?? decl.name },
+    );
+    return { ...decl, name };
+}
+
+/**
+ * The declaration without the role another column holds, recording W_ROLE_TAKEN.
+ * @param err - the sink's E_DUPLICATE_ROLE error
+ * @param domain - node or edge
+ * @param decl - the declaration whose role clashed
+ * @param role - its role
+ * @param report - the report
+ * @param where - the line and element, when known
+ * @returns the declaration without its role
+ */
+function dropRole(
+    err: GraphFormatError,
+    domain: "node" | "edge",
+    decl: ColumnDecl,
+    role: ColumnRole,
+    report: ImportReportBuilder,
+    where: IssueLocation | undefined,
+): ColumnDecl {
+    const holder = typeof err.details.holder === "string" ? err.details.holder : "another column";
+    report.warning(
+        "coercion",
+        ROLE_TAKEN_CODE,
+        `${domain} column "${decl.name}" loses the ${role} role: "${holder}" already holds it`,
+        { ...where, element: where?.element ?? decl.name },
+    );
+    const { role: _role, ...withoutRole } = decl;
+    return withoutRole;
+}
+
 /**
  * Declare the companion text column of a temporal column. A table holds at
  * most one column per role, so when another companion already carries `timeText` this one is