Support ids and indexes, ordered

This is broken though, since it will cause dependency collision

Author: dragonstyle

src/core/handlers/include-notebook.ts

@@ -38,103 +38,112 @@ import {
 
 import { dirname, extname } from "path/mod.ts";
 
+const kLabel = "label";
+
 export interface NotebookAddress {
   path: string;
-  cellIds: string[] | undefined;
-  params: Record<string, string>;
+  ids?: string[];
+  indexes?: number[];
 }
 
-const resolveCellIds = (hash?: string) => {
-  if (hash && hash.indexOf(",") > 0) {
-    return hash.split(",");
-  } else {
-    return hash;
-  }
-};
+const kHashRegex = /(.*?)#(.*)/;
+const kIndexRegex = /(.*)\[([0-9,-]*)\]/;
 
-// tag specified in yaml
-// label in yaml
 // notebook.ipynb#cellid1
 // notebook.ipynb#cellid1
 // notebook.ipynb#cellid1,cellid2,cellid3
 // notebook.ipynb[0]
 // notebook.ipynb[0,1]
 // notebook.ipynb[0-2]
+// notebook.ipynb[2,0-1]
+export function parseNotebookPath(path: string): NotebookAddress | undefined {
+  const isNotebook = (path: string) => {
+    return extname(path) === ".ipynb";
+  };
 
-// If the path is a notebook path, then process it separately.
-export function parseNotebookPath(path: string) {
-  const hasHash = path.indexOf("#") !== -1;
-  const hash = hasHash ? path.split("#")[1] : undefined;
-  path = path.split("#")[0];
+  // This is a hash based path
+  const hashResult = path.match(kHashRegex);
+  if (hashResult) {
+    const path = hashResult[1];
+    if (isNotebook(path)) {
+      return {
+        path,
+        ids: resolveCellIds(hashResult[2]),
+      };
+    } else {
+      return undefined;
+    }
+  }
 
-  if (extname(path) === ".ipynb") {
-    const cellIds = resolveCellIds(hash);
+  // This is an index based path
+  const indexResult = path.match(kIndexRegex);
+  if (indexResult) {
+    const path = indexResult[1];
+    if (isNotebook(path)) {
+      return {
+        path,
+        indexes: resolveCellRange(indexResult[2]),
+      };
+    } else {
+      return undefined;
+    }
+  }
+
+  // This is the path to a notebook
+  if (isNotebook(path)) {
     return {
       path,
-      cellIds,
-    } as NotebookAddress;
+    };
   } else {
     return undefined;
   }
 }
 
-const kLabel = "label";
-
 export function notebookForAddress(
-  nbInclude: NotebookAddress,
+  nbAddress: NotebookAddress,
   filter?: (cell: JupyterCell) => JupyterCell,
 ) {
   try {
-    const nb = jupyterFromFile(nbInclude.path);
-    const cells: JupyterCell[] = [];
-
-    // If cellIds are present, filter the notebook to only include
-    // those cells (cellIds can eiher be an explicitly set cellId, a label in the
-    // cell metadata, or a tag on a cell that matches an id)
-    if (nbInclude.cellIds) {
-      for (const cell of nb.cells) {
-        // cellId can either by a literal cell Id, or a tag with that value
-        const hasId = cell.id ? nbInclude.cellIds.includes(cell.id) : false;
-        if (hasId) {
-          // It's an ID
-          cells.push(cell);
+    const nb = jupyterFromFile(nbAddress.path);
+
+    if (nbAddress.ids) {
+      // If cellIds are present, filter the notebook to only include
+      // those cells (cellIds can eiher be an explicitly set cellId, a label in the
+      // cell metadata, or a tag on a cell that matches an id)
+      const theCells = nbAddress.ids.map((id) => {
+        const cell = cellForId(id, nb);
+        if (cell === undefined) {
+          throw new Error(
+            `The cell ${id} does not exist in notebook`,
+          );
         } else {
-          // Check for label in options
-          const cellWithOptions = jupyterCellWithOptions(
-            nb.metadata.kernelspec.language.toLowerCase(),
-            cell,
+          return cell;
+        }
+      });
+      nb.cells = theCells;
+    } else if (nbAddress.indexes) {
+      // Filter and sort based upon cell index
+      nb.cells = nbAddress.indexes.map((idx) => {
+        if (idx < 0 || idx >= nb.cells.length) {
+          throw new Error(
+            `The cell index ${idx} isn't within the range of cells`,
           );
-          const hasLabel = cellWithOptions.options[kLabel]
-            ? nbInclude.cellIds.includes(cellWithOptions.options[kLabel])
-            : false;
-
-          if (hasLabel) {
-            // It matches a label
-            cells.push(cell);
-          } else {
-            // Check tags
-            const hasTag = cell.metadata.tags
-              ? cell.metadata.tags.find((tag) =>
-                nbInclude.cellIds?.includes(tag)
-              ) !==
-                undefined
-              : false;
-            if (hasTag) {
-              cells.push(cell);
-            }
-          }
         }
-      }
-      nb.cells = cells;
+        return nb.cells[idx];
+      });
     }
 
+    // If there is a cell filter, apply it
     if (filter) {
       nb.cells = nb.cells.map(filter);
     }
 
     return nb;
   } catch (ex) {
-    throw new Error(`Failed to read included notebook ${nbInclude.path}`, ex);
+    throw new Error(
+      `Failed to read notebook ${nbAddress.path}\n${ex.message || ""}`,
+      ex,
+    );
   }
 }
 
@@ -184,3 +193,105 @@ export async function notebookMarkdown(
     return undefined;
   }
 }
+
+function cellForId(id: string, nb: JupyterNotebook) {
+  for (const cell of nb.cells) {
+    // cellId can either by a literal cell Id, or a tag with that value
+    const hasId = cell.id ? id === cell.id : false;
+    if (hasId) {
+      // It's an ID
+      return cell;
+    } else {
+      // Check for label in options
+      const cellWithOptions = jupyterCellWithOptions(
+        nb.metadata.kernelspec.language.toLowerCase(),
+        cell,
+      );
+      const hasLabel = cellWithOptions.options[kLabel]
+        ? id === cellWithOptions.options[kLabel]
+        : false;
+
+      if (hasLabel) {
+        // It matches a label
+        return cell;
+      } else {
+        // Check tags
+        const hasTag = cell.metadata.tags
+          ? cell.metadata.tags.find((tag) => id === tag) !==
+            undefined
+          : false;
+        if (hasTag) {
+          return cell;
+        }
+      }
+    }
+  }
+}
+
+function cellInIdList(ids: string[], cell: JupyterCell, nb: JupyterNotebook) {
+  // cellId can either by a literal cell Id, or a tag with that value
+  const hasId = cell.id ? ids.includes(cell.id) : false;
+  if (hasId) {
+    // It's an ID
+    return true;
+  } else {
+    // Check for label in options
+    const cellWithOptions = jupyterCellWithOptions(
+      nb.metadata.kernelspec.language.toLowerCase(),
+      cell,
+    );
+    const hasLabel = cellWithOptions.options[kLabel]
+      ? ids.includes(cellWithOptions.options[kLabel])
+      : false;
+
+    if (hasLabel) {
+      // It matches a label
+      return cell;
+    } else {
+      // Check tags
+      const hasTag = cell.metadata.tags
+        ? cell.metadata.tags.find((tag) => ids.includes(tag)) !==
+          undefined
+        : false;
+      if (hasTag) {
+        return cell;
+      }
+    }
+  }
+}
+
+const resolveCellIds = (hash?: string) => {
+  if (hash && hash.indexOf(",") > 0) {
+    return hash.split(",");
+  } else if (hash) {
+    return [hash];
+  } else {
+    return undefined;
+  }
+};
+
+const resolveCellRange = (rangeRaw?: string) => {
+  if (rangeRaw) {
+    const result: number[] = [];
+
+    const ranges = rangeRaw.split(",");
+    ranges.forEach((range) => {
+      if (range.indexOf("-") > -1) {
+        // This is range
+        const parts = range.split("-");
+        const start = parseInt(parts[0]);
+        const end = parseInt(parts[1]);
+        const step = start > end ? -1 : 1;
+        for (let i = start; step > 0 ? i <= end : i >= end; i = i + step) {
+          result.push(i);
+        }
+      } else {
+        // This is raw value
+        result.push(parseInt(range));
+      }
+    });
+    return result;
+  } else {
+    return undefined;
+  }
+};