Assembling pages

This is the thirteenth post in the Mostly Oberon series. Mostly Oberon documents my exploration of the Oberon Language, Oberon System and the various rabbit holes I will inevitably fall into.

Pandoc and JSON

I use Pandoc to process Markdown documents. I like to keep my front matter in JSON rather than Pandoc’s YAML. Fortunately Pandoc does support working with JSON as a metadata file include. Normally I would manually split the JSON front matter and the rest of the markup into two separate files, then process with Pandoc and other tooling like LunrJS. AssemblePage automates this process.

Example shell usage:

  2.    AssemblePage MyText.txt \
  3.       metadata=document.json \
  4.       document=document.md
  5.    pandoc --from markdown --to html \
  6.       --metadata-file document.json \
  7.       --standalone \
  8.       document.md >MyText.html

Source code for AssemblePage.Mod

  2. MODULE AssemblePage;
  3.   IMPORT Out, Strings, Files, Args := extArgs;
  5. VAR
  6.   srcName, metaName, docName : ARRAY 1024 OF CHAR;
  8. (* FrontMatter takes a "read" Rider, r, and a "write" Rider "w".
  9. If the first character read by r is an opening curly bracket
  10. (the start of the front matter) it writes it out with w, until
  11. it finds a matching closing curly bracket or the file ends. *)
  12. PROCEDURE FrontMatter*(VAR r : Files.Rider; VAR w : Files.Rider);
  13.   VAR c : BYTE; cCnt : INTEGER;
  14. BEGIN
  15.   (* Scan for opening JSON front matter *)
  16.   cCnt := 0;
  17.   REPEAT
  18.     Files.Read(r, c);
  19.     IF r.eof = FALSE THEN
  20.       IF c = ORD("{") THEN
  21.         cCnt := cCnt + 1;
  22.       ELSIF c = ORD("}") THEN
  23.         cCnt := cCnt - 1;
  24.       END;
  25.       Files.Write(w, c);
  26.     END;
  27.   UNTIL (r.eof = TRUE) OR (cCnt = 0);
  28.   IF cCnt # 0 THEN
  29.     Out.String("ERROR: mis matched '{' and '}' in front matter");
  30.     ASSERT(FALSE);
  31.   END;
  32. END FrontMatter;
  34. (* CopyIO copies the characters from a "read" Rider to a "write" Rider *)
  35. PROCEDURE CopyIO*(VAR r : Files.Rider; VAR w: Files.Rider);
  36.   VAR c : BYTE;
  37. BEGIN
  38.   REPEAT
  39.     Files.Read(r, c);
  40.     IF r.eof = FALSE THEN
  41.       Files.Write(w, c);
  42.     END;
  43.   UNTIL r.eof = TRUE;
  44. END CopyIO;
  46. PROCEDURE ProcessParameters(VAR sName, mName, dName : ARRAY OF CHAR);
  47.   VAR
  48.     arg : ARRAY 1024 OF CHAR;
  49.     i, res : INTEGER;
  50. BEGIN
  51.   mName := "document.json";
  52.   dName := "document.txt";
  53.   arg := "";
  54.   FOR i := 0 TO (Args.count - 1) DO
  55.     Args.Get(i, arg, res);
  56.     IF Strings.Pos("metadata=", arg, 0) = 0 THEN
  57.       Strings.Extract(arg, 9, Strings.Length(arg), mName);
  58.     ELSIF Strings.Pos("document=", arg, 0) = 0 THEN
  59.       Strings.Extract(arg, 9, Strings.Length(arg), dName);
  60.     ELSE
  61.       Strings.Extract(arg, 0, Strings.Length(arg), sName);
  62.     END;
  63.   END;
  64. END ProcessParameters;
  66. PROCEDURE AssemblePage(srcName, metaName, docName : ARRAY OF CHAR);
  67. VAR
  68.   src, meta, doc : Files.File;
  69.   reader, writer : Files.Rider;
  70. BEGIN
  71.   src := Files.Old(srcName);
  72.   IF src # NIL THEN
  73.     Files.Set(reader, src, 0);
  74.     IF metaName # "" THEN
  75.       meta := Files.New(metaName);
  76.       Files.Register(meta);
  77.       Files.Set(writer, meta, 0);
  78.       FrontMatter(reader, writer);
  79.       Files.Close(meta);
  80.     END;
  81.     IF docName # "" THEN
  82.       doc := Files.New(docName);
  83.       Files.Register(doc);
  84.       Files.Set(writer, doc, 0);
  85.       CopyIO(reader, writer);
  86.       Files.Close(doc);
  87.     END;
  88.   ELSE
  89.     Out.String("ERROR: Could not read ");Out.String(srcName);Out.Ln();
  90.     ASSERT(FALSE);
  91.   END;
  92.   Files.Close(src);
  93. END AssemblePage;
  95. BEGIN
  96.   ProcessParameters(srcName, metaName, docName);
  97.   AssemblePage(srcName, metaName, docName);
  98. END AssemblePage.

Next, Previous