Add stubs for engines that are not implemented yet

Author: fileformat

src/app/advanced/[engine]/not-found.tsx

@@ -3,7 +3,7 @@ import Link from 'next/link'
 import { redirect, useParams } from 'next/navigation' 
 import { EngineButton } from '@/components/EngineButton';
 import { RegexEngine } from '@/engines/RegexEngine';
-import { getEngines } from '@/engines';
+import { getWorkingEngines } from '@/engines';
 
 const niceNames = new Map<string, string>([
   ["javascript", "JavaScript"],
@@ -68,7 +68,7 @@ export default function NotFound() {
     return redirect(`/advanced/${handle.toLowerCase()}/index.html`);
   }
 
-  const engines = getEngines().filter(engine => engine.notfound && engine.notfound.includes(handle));
+  const engines = getWorkingEngines().filter(engine => engine.notfound && engine.notfound.includes(handle));
 
   if (engines.length == 1) {
     return redirect(`/advanced/${engines[0].handle}/index.html`);

src/app/page.tsx

@@ -1,16 +1,16 @@
 /* eslint-disable @next/next/no-img-element */
 import { EngineButton } from '@/components/EngineButton';
-import { getEngines } from '@/engines';
+import { getWorkingEngines } from '@/engines';
 import { Metadata } from 'next';
 
 export const metadata: Metadata = {
   title: "RegexPlanet",
-  description: `Regular expression (regex/regexp) testing and debugging for ${getEngines().map(x => x.short_name).join(', ')}.`,
+  description: `Regular expression (regex/regexp) testing and debugging for ${getWorkingEngines().map(x => x.short_name).join(', ')}.`,
 };
 
 export default function Home() {
 
-  const buttons = getEngines().map((engine) => {
+  const buttons = getWorkingEngines().map((engine) => {
     return (<EngineButton key={engine.handle} engine={engine} />);
   });
 

src/app/sitemap.xml/route.ts

@@ -1,5 +1,5 @@
 
-import { getEngines } from "@/engines";
+import { getWorkingEngines } from "@/engines";
 
 const ROOT = "https://www.regexplanet.com";
 
@@ -13,7 +13,7 @@ export async function GET() {
     `/support/index.html`,
   ];
 
-  getEngines().forEach((engine) => {
+  getWorkingEngines().forEach((engine) => {
     urls.push(`/advanced/${engine.handle}/index.html`);
     urls.push(`/advanced/${engine.handle}/options.html`);
   });

src/app/status.html/ResultsTable.tsx

@@ -8,7 +8,10 @@ import fetchJsonp from 'fetch-jsonp';
 import { EngineStatus } from '@/types/EngineStatus';
 
 
-function getHost(test_url: string) {
+function getHost(test_url: string|undefined) {
+    if (!test_url) {
+        return <i>(not configured)</i>
+    }
     const urlObj = new URL(test_url);
     if (urlObj.host.endsWith(".gcr.regexplanet.com")) {
         return <Link href="https://cloud.google.com/run/">Cloud Run</Link>;
@@ -113,8 +116,8 @@ export function ResultsTable() {
 
     const fetchAllResults = useCallback(() => {
         console.log("Fetching all results");
-        getEngines().map((engine, index) => {
-            fetchOneResult(engine.status_url)
+        getEngines().filter((engine) => engine.status_url).map((engine, index) => {
+            fetchOneResult(engine?.status_url || "")    // hack since TS doesn't understand the filter above
                 .then((result) => {
                     console.log(`Got result for ${engine.short_name}`, result, index);
                     setState(prevResult => {
@@ -153,7 +156,7 @@ export function ResultsTable() {
                     </tr>
                 </thead>
                 <tbody>
-                    {getEngines().map((engine, index) => (
+                    {getEngines().filter(engine => engine.status_url).map((engine, index) => (
                         <tr key={engine.handle}>
                             <td>
                                 <img className="pe-2" src={engine.logo_icon} alt={engine.short_name} style={{ "height": "1.25em" }} />

src/app/support/index.html/page.tsx

@@ -15,6 +15,7 @@ export default function Page() {
         <>
             <h1>Official Documentation Links</h1>
             <hr />
+            <div className="alert alert-info">You can find patterns and other resources at the <a className="alert-link" href="https://www.regex.zone/">Regex Zone</a>!</div>
             {getEngines().map((engine, index) => (
                 <div className="card m-3 d-inline-block" key={`key${index}`} style={{ "width": "18rem" }}>
                     <div className="card-header bg-body-tertiary d-flex align-items-center">

src/engines/RegexEngine.ts

@@ -24,18 +24,18 @@ type RegexEngine = {
   help_label: string; // text for the help button on the testing page
   help_url: string; // URL destination for the help button on the testing page
   handle: string; // unique identifier for the language or engine used as the slug in URLs
-  level: "alpha" | "beta" | "golden";
+  level: "alpha" | "beta" | "golden" | "notimplemented"; // The level of support for this engine
   links: Record<string, string>; // A map of (name: url) for other help links. These will be displayed on the support page under “Official Documentation”
   logo_icon: string; // SVG icon (just the logo, no text) in a square
   logo_ar21: string; // SVG logo (including language name) in a 2:1 aspect ratio
-  nodeping_url: string; // URL of the nodeping status page
+  nodeping_url?: string; // URL of the nodeping status page
   notfound?: string[]; // A list of handles that this is a substitute for (i.e. nodejs is a substitute for javascript)
   options: RegexOption[]; // A list of which options it supports.
   option_notes?: string; // Notes to display on the options page (html allowed)
   short_name: string; // Name of the language or engine
-  source_url: string; // URL of source code
-  status_url: string; // URL of the status endpoint
-  test_url: string; // URL of the test endpoint
+  source_url?: string; // URL of source code
+  status_url?: string; // URL of the status endpoint
+  test_url?: string; // URL of the test endpoint
 };
 
 export { type RegexEngine };

src/engines/index.ts

@@ -1,7 +1,12 @@
 import { TestOutput } from "@/types/TestOutput";
 import type { RegexEngine } from "./RegexEngine";
+
+import { dotnet } from "./dotnet";
+import { erlang } from "./erlang";
 import { go } from "./go";
+import { haskell } from "./haskell";
 import { java } from "./java";
+import { mysql } from "./mysql";
 import { nodejs } from "./nodejs";
 import { perl } from "./perl";
 import { php } from "./php";
@@ -13,8 +18,12 @@ import { tcl } from "./tcl";
 import { xregexp } from "./xregexp";
 
 const engineMap = new Map<string, RegexEngine>([
+  [erlang.handle, erlang],
   [go.handle, go],
+  [haskell.handle, haskell],
   [java.handle, java],
+  [mysql.handle, mysql],
+  [dotnet.handle, dotnet],
   [nodejs.handle, nodejs],
   [perl.handle, perl],
   [php.handle, php],
@@ -38,6 +47,14 @@ class EngineNotFoundError extends Error {
   handle: string;
 }
 
+class EngineNotImplementedError extends Error {
+  constructor(handle: string) {
+    super("Engine not implemented");
+    this.handle = handle;
+  }
+  handle: string;
+}
+
 function getEngineOrThrow(handle: string): RegexEngine {
   const theEngine = engineMap.get(handle);
   if (!theEngine) {
@@ -50,10 +67,30 @@ function getEngines(): Array<RegexEngine> {
   return Array.from(engineMap.values());
 }
 
+function getWorkingEngineOrThrow(handle: string): RegexEngine {
+  const theEngine = engineMap.get(handle);
+  if (!theEngine) {
+    throw new EngineNotFoundError(handle);
+  }
+  if (!theEngine.test_url) {
+    throw new EngineNotImplementedError(handle);
+  }
+  return theEngine;
+}
+
+function getWorkingEngines(): Array<RegexEngine> {
+  return Array.from(engineMap.values()).filter((engine) => engine.test_url);
+} 
+
 async function runTest(
   engine: RegexEngine,
   testInput: FormData
 ): Promise<TestOutput> {
+
+  if (!engine.test_url) {
+    throw new EngineNotImplementedError(engine.handle);
+  }
+  
   // this is a bogus 'as', but next build insists on it
   const postData = new URLSearchParams(
     testInput as unknown as Record<string, string>
@@ -72,4 +109,11 @@ async function runTest(
 }
 
 
-export { getEngines, getEngine, getEngineOrThrow, runTest };
+export {
+  getEngines,
+  getEngine,
+  getEngineOrThrow,
+  getWorkingEngines,
+  getWorkingEngineOrThrow,
+  runTest,
+};