wip

bikeshed/Spec.py

@@ -32,6 +32,7 @@
     markdown,
     mdn,
     metadata,
+    multipage,
     refs,
     retrieve,
     shorthands,
@@ -383,16 +384,32 @@ def finish(self, outputFilename: str | None = None, newline: str | None = None)
         catchArgparseBug(outputFilename)
         self.printResultMessage()
         outputFilename = self.fixMissingOutputFilename(outputFilename)
-        rendered = self.serialize()
-        if rendered and not constants.dryRun:
-            try:
-                if outputFilename == "-":
-                    sys.stdout.write(rendered)
-                else:
-                    with open(outputFilename, "w", encoding="utf-8", newline=newline) as f:
-                        f.write(rendered)
-            except Exception as e:
-                m.die(f"Something prevented me from saving the output document to {outputFilename}:\n{e}")
+        if not self.md.multipage:
+            rendered = self.serialize()
+            if rendered and not constants.dryRun:
+                try:
+                    if outputFilename == "-":
+                        sys.stdout.write(rendered)
+                    else:
+                        with open(outputFilename, "w", encoding="utf-8", newline=newline) as f:
+                            f.write(rendered)
+                except Exception as e:
+                    m.die(f"Something prevented me from saving the output document to {outputFilename}:\n{e}")
+        else:
+            if outputFilename == "-":
+                m.die(f"Can't do multipage output to stdout.")
+                return
+            pages = multipage.serializePages(self, outputFilename)
+            if pages and not constants.dryRun:
+                for filename, rendered in pages.items():
+                    try:
+                        if filename == "-":
+                            sys.stdout.write(rendered)
+                        else:
+                            with open(filename, "w", encoding="utf-8", newline=newline) as f:
+                                f.write(rendered)
+                    except Exception as e:
+                        m.die(f"Something prevented me from saving the output document to {filename}:\n{e}")
 
     def printResultMessage(self) -> None:
         # If I reach this point, I've succeeded, but maybe with reservations.

bikeshed/metadata.py

@@ -114,6 +114,7 @@ def __init__(self) -> None:
         self.maxToCDepth: int | float | None = float("inf")
         self.metadataInclude: config.BoolSet = config.BoolSet(default=True)
         self.metadataOrder: list[str] = ["*", "!*"]
+        self.multipage: bool = False
         self.noAbstract: bool = False
         self.noEditor: bool = False
         self.noteClass: str = "note"
@@ -1458,6 +1459,7 @@ def parseLiteralList(key: str, val: str, lineNum: str | int | None) -> list[str]
         partial(parseBoolishList, default=True),
     ),
     "Metadata Order": Metadata("Metadata Order", "metadataOrder", joinValue, parseMetadataOrder),
+    "Multipage": Metadata("Multipage", "multipage", joinValue, parseBoolean),
     "No Abstract": Metadata("No Abstract", "noAbstract", joinValue, parseBoolean),
     "No Editor": Metadata("No Editor", "noEditor", joinValue, parseBoolean),
     "Note Class": Metadata("Note Class", "noteClass", joinValue, parseLiteral),

bikeshed/multipage/__init__.py

@@ -0,0 +1 @@
+from .main import serializePages

bikeshed/multipage/main.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from .. import h, t
+from .. import messages as m
+
+
+def serializePages(doc: t.SpecT, mainFilename: str) -> dict[str, str]:
+    main = h.find("main", doc)
+    pages = collectIntoPages(list(h.childNodes(main, clear=True)), mainFilename)
+    ret = {}
+    serializer = h.Serializer(doc.md.opaqueElements, doc.md.blockElements)
+    for filename, nodes in pages.items():
+        h.replaceContents(main, nodes)
+        ret[filename] = serializer.serialize(doc.document)
+        print(filename + " " + str(len(nodes)) + " nodes; " + str(len(ret[filename].split("\n"))) + " lines")
+        #print(ret[filename][0:80])
+    return ret
+
+
+def collectIntoPages(nodes: list[t.NodeT], mainFilename: str) -> dict[str, list[t.NodeT]]:
+    pages: dict[str, list[t.NodeT]] = {}
+    filename = mainFilename
+    pages[filename] = []
+    for node in nodes:
+        if h.isElement(node) and meaningfulHeading(node) and headingLevel(node) == 2:
+            id = node.get("id")
+            if not id:
+                m.die("Heading doesn't have a useful ID, can't split on it.", el=node)
+                return {}
+            filename = id + ".html"
+            pages[filename] = []
+        #if h.isElement(node):
+        #    print(f"{filename} {h.tagName(node)} {node.get('bs-line-number')}")
+        pages[filename].append(node)
+    return pages
+
+
+def meaningfulHeading(el: t.ElementT) -> bool:
+    if h.tagName(el) not in ("h1", "h2", "h3", "h4", "h5", "h6"):
+        return False
+    lineNum = el.get("bs-line-number", "")
+    if parsesAsInt(lineNum):
+        return True
+    else:
+        num, _, rest = lineNum.partition(":")
+        return parsesAsInt(num) and parsesAsInt(rest)
+
+
+def parsesAsInt(s: str) -> bool:
+    try:
+        int(s)
+        return True
+    except:
+        return False
+
+
+def headingLevel(el: t.ElementT) -> int:
+    tag = h.tagName(el)
+    if tag not in ("h1", "h2", "h3", "h4", "h5", "h6"):
+        return 0
+    return int(tag[1])

docs/index.bs

@@ -11,6 +11,7 @@ Abstract: Bikeshed is a spec-generating tool that takes in lightly-decorated Mar
 Markup Shorthands: css no, markdown yes
 Ignored Terms: h1, h2, h3, h4, h5, h6, xmp
 Default Highlight: html
+Multipage: yes
 </pre>
 
 <pre class=link-defaults>