Use obj / mor ids rather than human names

.

Author: Kris Brown

packages/algjulia-interop/ext/CatlabExt.jl

@@ -66,12 +66,12 @@ Receiver of the data already knows the schema, so the JSON payload to CatColab
 just includes the columns of data. Every part is named, so we use the names 
 (including for primary key columns) rather than numeric indices.
 """
-function acset_to_json(X::ACSet, S::Schema, names::Dict{Symbol, Vector{String}}
+function acset_to_json(X::ACSet, S::Schema, ids::Dict{String, Symbol}, names::Dict{Symbol, Vector{String}}
                       )::AbstractDict
-  Dict{Symbol, Vector{String}}(
-    [t => names[t] for t in types(S)] 
-    ∪ [f => names[c][X[f]] for (f,_,c) in homs(S)] 
-    ∪ [f => names[c][getvalue.(X[f])] for (f,_,c) in attrs(S)] )
+  Dict{String, Vector{String}}(
+    [findfirst(==(t), ids) => names[t] for t in types(S)] 
+    ∪ [findfirst(==(f), ids) => names[c][X[f]] for (f,_,c) in homs(S)] 
+    ∪ [findfirst(==(f), ids) => names[c][getvalue.(X[f])] for (f,_,c) in attrs(S)] )
 end
 
 """
@@ -107,13 +107,13 @@ Top level function called by CatColab. Computes an ACSet colimit of a
 function endpoint(::Val{:ACSetColim})
   @post "/acsetcolim" function(req::HTTP.Request)
     payload = json(req, ModelDiagram)
-    schema, names = model_to_schema(payload.model)
-    data = diagram_to_data(payload.diagram, names)
+    schema, ids = model_to_schema(payload.model)
+    data = diagram_to_data(payload.diagram, ids)
     acset_type = AnonACSet(
       schema; type_assignment=Dict(a=>Nothing for a in schema.attrtypes))
     y = yoneda(constructor(acset_type))
     names, res = colimit_representables(data, y)
-    acset_to_json(res, schema, make_names(res, names))
+    acset_to_json(res, schema, ids, make_names(res, names))
   end
 end
 

packages/frontend/src/stdlib/analyses/tabular_view.tsx

@@ -37,33 +37,28 @@ function createTable(headers: Array<string>, data: Array<Array<string>>) {
     and a particular object `obname` in the schema, create an HTML table with
     the outgoing homs/attributes from that object.
 */
-function createACSetTable(model: DblModel, rawdata: Record<string, string[]>, obname: string) {
+function createACSetTable(model: DblModel, rawdata: Record<string, string[]>, obId: string) {
     // The primary key of this table is given by `rawdata[obname]`
-    const rows: Array<string> = rawdata[obname as keyof typeof rawdata];
+    const rows: Array<string> = rawdata[obId] || [];
+    const obname: string = model.obGeneratorLabel(obId)?.toString() || "";
 
     // Get the homs and attrs with source `obname`
     const outhoms = model
         .morGenerators()
-        .filter(
-            (m) =>
-                obname ===
-                model
-                    .obGeneratorLabel(model.morPresentation(m)?.dom.content.toString() || "")
-                    ?.toString(),
-        );
+        .filter((m) => obId === model.morPresentation(m)?.dom.content.toString());
 
     // Convert morgenerators to user-friendly names
     const headers = [obname].concat(
         outhoms.map((m) => model.morGeneratorLabel(m)?.join(".") ?? ""),
     );
 
     // Data for column from indexing rawdata
-    const columnardata: Array<Array<string>> = headers.map(
-        (m: string) => rawdata[m as keyof typeof rawdata] || [""],
-    );
+    const columnardata: Array<Array<string>> = [obId]
+        .concat(outhoms)
+        .map((m: string) => rawdata[m as keyof typeof rawdata] || [""]);
 
     // Convert columnar data to row data
-    const data = Array.from(rows.keys()).map((colIndex) =>
+    const data = Array.from(rows?.keys()).map((colIndex) =>
         columnardata.map((row) => row[colIndex] || ""),
     );
 
@@ -75,11 +70,7 @@ function createACSet(model: DblModel, rawdata: Record<string, string[]>) {
     return (
         <div class="simulation">
             <PanelHeader title="Tabular view" />
-            <For each={model?.obGenerators()}>
-                {(ob) =>
-                    createACSetTable(model, rawdata, model.obGeneratorLabel(ob)?.toString() || "")
-                }
-            </For>
+            <For each={model?.obGenerators()}>{(ob) => createACSetTable(model, rawdata, ob)}</For>
         </div>
     );
 }
@@ -135,7 +126,7 @@ export default function TabularView(
             </Match>
             <Match when={res()}>
                 {(data) => {
-                    let result = data();
+                    const result = data();
                     return <div>{createACSet(result.model, result.data)}</div>;
                 }}
             </Match>

packages/frontend/src/stdlib/theories/simple-schema.ts

@@ -1,22 +1,20 @@
 import { ThSchema } from "catlog-wasm";
-import { Theory, type TheoryMeta, DiagramAnalysisMeta } from "../../theory";
+import { type DiagramAnalysisMeta, Theory, type TheoryMeta } from "../../theory";
 import * as analyses from "../analyses";
 import styles from "../styles.module.css";
 import svgStyles from "../svg_styles.module.css";
 import textStyles from "../text_styles.module.css";
 
 export default function createSchemaTheory(theoryMeta: TheoryMeta): Theory {
     const thSchema = new ThSchema();
-    let diagramAnalyses: DiagramAnalysisMeta[] = [];
-
-    diagramAnalyses.push(
+    let diagramAnalyses: DiagramAnalysisMeta[] = [
         analyses.diagramGraph({
             id: "graph",
             name: "Visualization",
             description: "Visualize the instance as a graph",
             help: "visualization",
         }),
-    );
+    ];
 
     if (import.meta.env.DEV) {
         diagramAnalyses.push(