Merge pull request #19 from croque-scp/scp-head

[HEAD] New article

Author: rossjrw

Diff for: .github/workflows/preview.yml

@@ -16,17 +16,27 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
-      - name: Install & build projects
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Determine changed projects
+        id: changes
+        run: |
+          CHANGED_PROJECTS=$(git diff --name-only origin/${{ github.event.pull_request.base.ref }}...HEAD -- 'source/*' | cut -d/ -f2 | sort -u)
+          echo "CHANGED_PROJECTS=$CHANGED_PROJECTS" >> $GITHUB_ENV
+
+      - name: Install & build changed projects
         run: |
           mkdir dist
-          for project in $(cd source && ls -d */); do
+          for project in $CHANGED_PROJECTS; do
             pushd source/$project
             npm install
             npm run build
             popd
             cp -r source/$project/dist dist/$project
           done
+
       - name: Deploy preview
         uses: rossjrw/pr-preview-action@v1
         with:

Diff for: source/scp-head/.prettierrc.json

@@ -0,0 +1 @@
+{}

Diff for: source/scp-head/assets/README.md

@@ -0,0 +1,23 @@
+#!/usr/bin/env sh
+
+set -e
+
+rm -rf resized
+mkdir -p resized
+
+for image in *.jpg; do
+  # Convert to PNG to enable transparency
+  convert "$image" resized/temp.png
+
+  convert -resize 1000x\> "$image" resized/temp.png
+  # When a WEBP without transparency is loaded as an overlay to another image, it starts blanked out as the overlay starts to load - add 1% transparency to a pixel to prevent that
+  mogrify -alpha on -channel A -fx 'j==h-1 && i==w-1 ? A*0.99 : A' resized/temp.png
+  cwebp -q 80 resized/temp.png -o "resized/${image%%.jpg}-$(identify -format '%wx%h' resized/temp.png).webp"
+
+  # Make small-size WEBP at 300px
+  convert -resize 300x\> "$image" resized/temp.png
+  cwebp -q 80 resized/temp.png -o "resized/${image%%.jpg}-$(identify -format '%wx%h' resized/temp.png).webp"
+
+  # Clean up
+  rm resized/temp.png
+done

Diff for: source/scp-head/assets/head-bertie.jpg

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+const patterns = {
+  inlineStatement: /(?:\{.*?\})+/g,
+  blockStatement: /(?:\{\{\{[\s\S]*?\}\}\}\n?)+/g,
+  contradiction: /\{=[A-Z0-9?^,]+\}/g,
+};
+const defaultChannel = "B";
+
+if (require.main === module) main();
+
+async function main() {
+  let source = "";
+  for await (const chunk of process.stdin) source += chunk;
+
+  if (!source || !process.env.SCOUTFILE) {
+    if (!source) console.error("No input source");
+    if (!process.env.SCOUTFILE) console.error("No scout file specified");
+    console.error(
+      "Usage: (export SCOUTFILE=/scout.html; cat sourcefile | ./convert-shorthand.cjs)"
+    );
+    process.exit(1);
+  }
+
+  source = replaceShorthand(source, process.env.SCOUTFILE);
+
+  process.stdout.write(source);
+}
+
+module.exports = { replaceShorthand };
+
+/**
+ * Replaces shorthand syntax with wikitext.
+ *
+ * @param {string} source
+ * @param {string} scoutFile - URL of the scout iframe
+ * @returns {string}
+ */
+function replaceShorthand(source, scoutFile) {
+  return source
+    .replace(
+      /(SCP-[0-9]{4}-[0-9])\[([a-z]+)\]/g,
+      "{A1 croqstyle-img-footnote img-head-$2-angle: $1}{A6 croqstyle-img-footnote img-head-$2-straight: $1}{A7 croqstyle-img-footnote img-head-$2-angle: $1}"
+    )
+    .replace(patterns.contradiction, (match) =>
+      replaceContradiction(match, scoutFile)
+    )
+    .replace(patterns.inlineStatement, replaceInlineStatement)
+    .replace(/\[\[tt\]\]/g, "{{")
+    .replace(/\[\[\/tt\]\]/g, "}}")
+    .trim();
+}
+
+/**
+ * Replaces inline statement shorthand with markup.
+ *
+ * @param {string} match - Matched inline statement
+ * @returns {string} - Converted inline statement
+ */
+function replaceInlineStatement(match) {
+  console.error("Replacing inline statement", match);
+  const assertions = parseStatement(match.split(/{|}/));
+  return [
+    `[[span class="ch_${assertions[0].channel}"]]`,
+    ...assertions
+      .sort((a, b) => b.stage - a.stage)
+      .map((assertion) => {
+        if (assertion.text.trim().length === 0) {
+          // Zero-content spans are invalid wikitext - add a space and hide it later with a class
+          return `[[span class="a_${assertion.stage} empty"]]_[[/span]]`;
+        }
+
+        return `[[span class="a_${assertion.stage}${
+          assertion.classes ? " " + assertion.classes.trim() : ""
+        }"]]${assertion.text}[[/span]]`;
+      }),
+    "[[/span]]",
+  ].join("");
+}
+
+/**
+ * Replaces contradiction shorthand with corresponding scout.
+ *
+ * @param {string} match
+ * @param {string} scoutFile - URL of the scout iframe
+ * @returns {string}
+ */
+function replaceContradiction(match, scoutFile) {
+  console.error("Replacing contradiction", match);
+  const conditionPattern = /[A-Z]?[0-9]+/;
+  const singleContradictionPattern = new RegExp(
+    conditionPattern.source + "(?:\\?" + conditionPattern.source + ")?\\^?"
+  );
+  const multiConditionPattern = new RegExp(
+    singleContradictionPattern.source +
+      "(?:," +
+      singleContradictionPattern.source +
+      ")*"
+  );
+  const contradictionShorthandPattern = new RegExp(
+    "^\\{=" + multiConditionPattern.source + "\\}$"
+  );
+  if (!contradictionShorthandPattern.test(match)) {
+    console.error({ match });
+    throw new Error("Invalid contradiction");
+  }
+  const contradictions = match.slice(2, -1);
+  return [
+    "[[embed]]",
+    `<iframe src="${scoutFile}?contradiction=${contradictions}" loading="lazy" class="scout"></iframe>`,
+    "[[/embed]]",
+  ].join("\n");
+}
+
+/**
+ * Parses a statement to an assertions list.
+ *
+ * @param {Array.<string>} phrases - Text source of each phrase of the statement
+ * @returns {Array.<{ stage: number, text: string }>} - List of assertions
+ */
+function parseStatement(phrases) {
+  let statementChannel = null;
+  const assertions = phrases
+    .filter((s) => /\S/.test(s))
+    .map((assertion) => {
+      console.error("Parsing assertion", JSON.stringify(assertion));
+      const match = assertion.match(
+        /(?:\s*([A-Z]?)([0-9]*)(?:( [ a-zA-Z0-9_-]+))?:\n?\s*)?([\s\S]*?)$/
+      );
+      const channel = String(match[1] || defaultChannel);
+      const stage = Number(match[2]) || 10;
+      const classes = String(match[3] || "");
+      const text = String(match[4] || "");
+
+      if (statementChannel === null) statementChannel = channel;
+      else if (statementChannel !== channel) {
+        console.error({ match, statementChannel, channel, stage, text });
+        throw new Error("Inconsistent channel in statement");
+      }
+      return { stage, classes, text, channel: statementChannel };
+    });
+
+  // Verify that all assertions have unique stages
+  const stages = new Set();
+  assertions.forEach((assertion) => {
+    if (stages.has(assertion.stage)) {
+      console.error({ assertion, assertions, phrases });
+      throw new Error("Duplicate stage in statement");
+    }
+    stages.add(assertion.stage);
+  });
+
+  return assertions;
+}

Diff for: source/scp-head/assets/head-brian-angle.jpg

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+
+const { replaceShorthand } = require("./convert-shorthand.cjs");
+
+function verify(it) {
+  for (let [description, [source, expected]] of Object.entries(it)) {
+    console.log(`\t - it ${description} `);
+    source = source.replace(/\n +/g, "\n").trim();
+    let result;
+    try {
+      result = replaceShorthand(source, "/scout.html");
+    } catch (err) {
+      if (expected === Error) {
+        continue;
+      }
+      console.log(`Input: ${source}`);
+      throw err;
+    }
+    expected = expected.replace(/\n +/g, "\n").trim();
+    if (result === expected) {
+      continue;
+    }
+    console.log(`Input: ${source}`);
+    console.log(`Expected: ${expected}`);
+    console.log(`Got:      ${result}`);
+    throw new Error("Test failed");
+  }
+}
+
+const it = {
+  "doesn't convert stuff that's not shorthand": [`Normal text`, `Normal text`],
+  "converts inline statements": [
+    `{A10: A}{A11: B}{A12: C}`,
+    `[[span class="ch_A"]][[span class="a_12"]]C[[/span]][[span class="a_11"]]B[[/span]][[span class="a_10"]]A[[/span]][[/span]]`,
+  ],
+  "assumes default channel if none is specified": [
+    `{10: A}{11: B}`,
+    `[[span class="ch_B"]][[span class="a_11"]]B[[/span]][[span class="a_10"]]A[[/span]][[/span]]`,
+  ],
+  "fails if assertions do not share a channel": [`{A10: A}{B11: B}`, Error],
+  "fails if assertions share a stage": [`{10: A}{10: B}`, Error],
+  "converts multiple separate inline statements": [
+    `test {A}{11: B} test {C}{12: D} test`,
+    `test [[span class="ch_B"]][[span class="a_11"]]B[[/span]][[span class="a_10"]]A[[/span]][[/span]] test [[span class="ch_B"]][[span class="a_12"]]D[[/span]][[span class="a_10"]]C[[/span]][[/span]] test`,
+  ],
+  "can create an empty assertion": [
+    `{test7}{28:}`,
+    `[[span class="ch_B"]][[span class="a_28 empty"]]_[[/span]][[span class="a_10"]]test7[[/span]][[/span]]`,
+  ],
+  "doesn't fuck up syntax inside/outside block statements": [
+    `[[span]]test[[/span]]
+
+    [[div class="ch_B"]]
+    [[div class="a_11"]]
+    B
+
+    [[div class="test"]]
+    [[/div]]
+    [[/div]]
+    [[div class="a_10"]]
+    A
+    [[/div]]
+    [[/div]]
+
+    [[span]]test[[/span]]`,
+    `[[span]]test[[/span]]
+
+    [[div class="ch_B"]]
+    [[div class="a_11"]]
+    B
+
+    [[div class="test"]]
+    [[/div]]
+    [[/div]]
+    [[div class="a_10"]]
+    A
+    [[/div]]
+    [[/div]]
+
+    [[span]]test[[/span]]`,
+  ],
+  "supports inline statements inside block statements": [
+    `[[div class="ch_B"]]
+    [[div class="a_25"]]
+    test4 {test5}{11: test6}
+    [[/div]]
+    [[div class="a_20"]]
+    test3
+    [[/div]]
+    [[div class="a_10"]]
+    test2
+    [[/div]]
+    [[/div]]`,
+    `[[div class="ch_B"]]
+    [[div class="a_25"]]
+    test4 [[span class="ch_B"]][[span class="a_11"]]test6[[/span]][[span class="a_10"]]test5[[/span]][[/span]]
+    [[/div]]
+    [[div class="a_20"]]
+    test3
+    [[/div]]
+    [[div class="a_10"]]
+    test2
+    [[/div]]
+    [[/div]]`,
+  ],
+  "lets you put separate inline statements near each other": [
+    `{10:}{11:}{12:} {A10:}{A11:}`,
+    `[[span class="ch_B"]][[span class="a_12 empty"]]_[[/span]][[span class="a_11 empty"]]_[[/span]][[span class="a_10 empty"]]_[[/span]][[/span]] [[span class="ch_A"]][[span class="a_11 empty"]]_[[/span]][[span class="a_10 empty"]]_[[/span]][[/span]]`,
+  ],
+  "converts contradictions right": [
+    `{=10}
+    {=11}
+    {=12^}
+    {=13
+    {=14?15^,16}`,
+    `[[embed]]
+    <iframe src="/scout.html?contradiction=10" loading="lazy"></iframe>
+    [[/embed]]
+    [[embed]]
+    <iframe src="/scout.html?contradiction=11" loading="lazy"></iframe>
+    [[/embed]]
+    [[embed]]
+    <iframe src="/scout.html?contradiction=12^" loading="lazy"></iframe>
+    [[/embed]]
+    {=13
+    [[embed]]
+    <iframe src="/scout.html?contradiction=14?15^,16" loading="lazy"></iframe>
+    [[/embed]]`,
+  ],
+};
+verify(it);

Diff for: source/scp-head/assets/head-brian-straight.jpg

@@ -0,0 +1,16 @@
+{
+  "version": "0.0.0",
+  "scripts": {
+    "build:cleanup": "rm -rf dist && mkdir dist",
+    "build:sass": "sass src/assertions.scss dist/assertions-v$(echo $npm_package_version | cut -d. -f1).css",
+    "build:minify": "csso dist/assertions-v$(echo $npm_package_version | cut -d. -f1).css -o dist/assertions-v$(echo $npm_package_version | cut -d. -f1).css",
+    "build:html": "for file in src/*.html; do cp $file dist/$(basename ${file%.html})-v$(echo $npm_package_version | cut -d. -f1).html; done",
+    "build:assets": "cp assets/resized/*.webp dist",
+    "build": "npm run build:cleanup && npm run build:sass && npm run build:minify && npm run build:html && npm run build:assets",
+    "dev": "npm run build:cleanup && npm run build:sass && npm run build:html && npm run build:assets"
+  },
+  "devDependencies": {
+    "csso-cli": "^4.0.2",
+    "sass": "^1.77.2"
+  }
+}