From 8997f7f94a8bbe1aafd4efb8003974f3bfb28e3e Mon Sep 17 00:00:00 2001 From: Hans Dijkema Date: Sat, 15 Aug 2026 15:01:50 +0200 Subject: [PATCH] namespaces added and documentation --- README.md | 31 +- info.rkt | 2 +- main.rkt | 4 + private/attachment-references.rkt | 14 +- private/auth.rkt | 4 + private/config.rkt | 4 + private/database.rkt | 8 + private/http-util.rkt | 4 + private/migrations.rkt | 25 +- private/setup.rkt | 4 + private/storage.rkt | 206 ++++++++----- private/todo.rkt | 4 + private/vendor.rkt | 4 + scrbl/racket-wiki.scrbl | 14 +- server.rkt | 26 +- setup-vendor.rkt | 4 + static/css/wiki.css | 17 ++ static/index.html | 4 + static/js/wiki.js | 461 +++++++++++++++++++++++++----- translate.rkt | 14 +- 20 files changed, 696 insertions(+), 158 deletions(-) diff --git a/README.md b/README.md index 6f39a8f..cbfc069 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ # racket-wiki -Version 0.2.30 tightens implicit wiki links to classic WikiWords: only letter-only CamelCase words with at least two capitalized word segments are treated as implicit links. Version-like identifiers and words containing digits or punctuation are not WikiWords. +Version 0.2.31 adds page namespaces as database metadata and extends wiki references to forms such as `RWS:ModelTreeWalker` and `[roadmap](racket:roadmap)`. Todo items and bookmarks are grouped by namespace. The source has also been documented more thoroughly, especially `static/js/wiki.js`. -Current development version: **0.2.29**. +Current development version: **0.2.31**. A small self-hosted wiki with a Racket backend and an HTML5/CSS/JavaScript frontend. @@ -198,6 +198,33 @@ When the site is served through HTTPS, add `--secure-cookie` so the session cook The `--create-admin` command-line option remains available for recovery or scripted administration, but it is no longer part of the normal first-run procedure. + +## Page namespaces + +Every page has a namespace and a page slug. Existing pages are migrated to the root namespace. The external page reference is compact: + +```text +roadmap +racket:roadmap +RWS:model-tree-walker +``` + +The editor exposes the namespace as page metadata. The slug is still generated from the title when a page is first created and remains stable afterwards. The combination of namespace and slug is unique in PostgreSQL. + +Explicit Markdown links may use the compact form directly: + +```markdown +[roadmap](racket:roadmap) +``` + +Classic WikiWords may also be namespace-qualified: + +```text +RWS:ModelTreeWalker +``` + +The WikiWord portion still follows the strict letter-only classic rule. Todo and Bookmark views group their entries by namespace; bookmark user sections remain available as a second grouping level. + ## Editing EasyMDE supplies the Markdown editor, Markdown-aware styling while editing, line numbers, keyboard shortcuts, preview, side-by-side mode and fullscreen mode. On a normal desktop-sized window racket-wiki opens the editor in side-by-side mode by default. EasyMDE is configured with `sideBySideFullscreen: false`, so split editing remains inside the normal wiki page rather than taking over the complete browser window. diff --git a/info.rkt b/info.rkt index 51f4a89..0d8b068 100644 --- a/info.rkt +++ b/info.rkt @@ -1,7 +1,7 @@ #lang info (define pkg-authors '(hnmdijkema)) -(define version "0.2.30") +(define version "0.2.31") (define license 'MIT) (define collection "racket-wiki") (define pkg-desc diff --git a/main.rkt b/main.rkt index 03f90d3..f8d1bde 100644 --- a/main.rkt +++ b/main.rkt @@ -1,5 +1,9 @@ #lang racket/base +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Command-line and programmatic entry points for racket-wiki. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + (require racket/cmdline racket/path "private/auth.rkt" diff --git a/private/attachment-references.rkt b/private/attachment-references.rkt index 24a4b16..37d9967 100644 --- a/private/attachment-references.rkt +++ b/private/attachment-references.rkt @@ -1,5 +1,9 @@ #lang racket/base +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Tracking current and historical references to uploaded files. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + (require db racket/string) @@ -14,7 +18,7 @@ (define (attachment-rows db) (query-rows db #<6! db) + ;; Namespace is added here as well so a fresh migration chain can rebuild + ;; attachment URLs before schema 7 creates the namespace indexes. + (query-exec db "ALTER TABLE pages ADD COLUMN IF NOT EXISTS namespace TEXT NOT NULL DEFAULT ''") (query-exec db #<7! db) + (query-exec db "ALTER TABLE pages ADD COLUMN IF NOT EXISTS namespace TEXT NOT NULL DEFAULT ''") + (query-exec db "ALTER TABLE pages DROP CONSTRAINT IF EXISTS pages_slug_key") + (query-exec db "CREATE UNIQUE INDEX IF NOT EXISTS pages_namespace_slug_idx ON pages(namespace, slug)") + (query-exec db "CREATE INDEX IF NOT EXISTS pages_namespace_idx ON pages(lower(namespace), lower(title), title)") + (record-schema-version! db 7)) + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; goal : Bring a racket-wiki PostgreSQL database to the current schema. ; pre : db is a writable PostgreSQL connection and config identifies the @@ -290,6 +310,9 @@ SQL (define after-todo-reindex (database-schema-version db)) (when (= after-todo-reindex 5) (migrate-5->6! db)) + (define after-attachment-references (database-schema-version db)) + (when (= after-attachment-references 6) + (migrate-6->7! db)) (define resulting-version (database-schema-version db)) (when (> resulting-version current-schema-version) (error 'migrate-database! diff --git a/private/setup.rkt b/private/setup.rkt index 45db0f7..807ede2 100644 --- a/private/setup.rkt +++ b/private/setup.rkt @@ -1,5 +1,9 @@ #lang racket/base +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; First-run setup state and web setup processing. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + (require crypto net/uri-codec racket/path diff --git a/private/storage.rkt b/private/storage.rkt index 55d7195..431101b 100644 --- a/private/storage.rkt +++ b/private/storage.rkt @@ -1,5 +1,9 @@ #lang racket/base +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; PostgreSQL-backed page, history, search, bookmark and upload storage. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + (require db json racket/file @@ -13,6 +17,9 @@ (provide ensure-wiki-data! valid-slug? + valid-page-reference? + page-reference + split-page-reference title->slug list-pages read-page @@ -38,6 +45,10 @@ ; post : The data directory and writable static directory exist. ; result : void. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Supporting functions +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + (define (ensure-wiki-data! config) (for ((directory (in-list (list (wiki-config-data-dir config) (data-static-directory config))))) @@ -66,6 +77,42 @@ (valid-slug-character? char)) (not (member slug '("." ".."))))) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; goal : Build the external wiki reference for a namespace and slug. +; pre : namespace and slug are strings; slug is a valid page slug. +; post : No state is changed. +; result : slug for the root namespace, otherwise namespace:slug. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(define (page-reference namespace slug) + (if (string=? (string-trim namespace) "") + slug + (string-append (string-trim namespace) ":" slug))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; goal : Split an external page reference into namespace and slug. +; pre : reference is a string. +; post : No state is changed. +; result : Two values: namespace and slug. The namespace is empty for root pages. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(define (split-page-reference reference) + (define match (regexp-match #px"^([^:]+):(.*)$" reference)) + (if match + (values (list-ref match 1) (list-ref match 2)) + (values "" reference))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; goal : Check whether a namespace-qualified page reference is valid. +; pre : reference is a string. +; post : No state is changed. +; result : #t for root slugs or namespace:slug references with letter/number namespaces. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(define (valid-page-reference? reference) + (define-values (namespace slug) (split-page-reference reference)) + (and (valid-slug? slug) + (or (string=? namespace "") + (and (valid-slug? namespace) + (<= (string-length namespace) 80))))) + (define (title->slug title) (define normalized (string-downcase @@ -101,8 +148,12 @@ (if (list? value) value '()))) (define (row->page row [include-markdown? #t]) + (define namespace (vector-ref row 9)) + (define slug (vector-ref row 0)) (define result - (hash 'slug (vector-ref row 0) + (hash 'slug (page-reference namespace slug) + 'pageSlug slug + 'namespace namespace 'title (vector-ref row 1) 'createdAt (vector-ref row 3) 'updatedAt (vector-ref row 4) @@ -115,7 +166,7 @@ result)) (define page-columns - "slug, title, markdown, created_at, updated_at, created_by, updated_by, tags, current_version") + "slug, title, markdown, created_at, updated_at, created_by, updated_by, tags, current_version, namespace") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; goal : List current wiki page metadata. @@ -130,7 +181,7 @@ (for/list ((row (in-list (query-rows db (string-append "SELECT " page-columns - " FROM pages WHERE archived = FALSE ORDER BY lower(title), title"))))) + " FROM pages WHERE archived = FALSE ORDER BY lower(namespace), namespace, lower(title), title"))))) (row->page row #f))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -139,18 +190,19 @@ ; post : The pages table has only been read. ; result : Page metadata with Markdown, or #f when the page does not exist. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(define (read-page config slug) - (if (not (valid-slug? slug)) +(define (read-page config reference) + (if (not (valid-page-reference? reference)) #f - (call-with-wiki-database - config - (λ (db) - (define row - (query-maybe-row db - (string-append "SELECT " page-columns - " FROM pages WHERE slug = $1 AND archived = FALSE") - slug)) - (if row (row->page row) #f))))) + (let-values (((namespace slug) (split-page-reference reference))) + (call-with-wiki-database + config + (λ (db) + (define row + (query-maybe-row db + (string-append "SELECT " page-columns + " FROM pages WHERE namespace = $1 AND slug = $2 AND archived = FALSE") + namespace slug)) + (if row (row->page row) #f)))))) (define (replace-todos! db page-id markdown) @@ -178,7 +230,8 @@ SQL ; post : Current page state and version 1 are committed atomically. ; result : The new page metadata with Markdown. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(define (create-page! config slug title markdown author [summary "Created page"] [tags '()]) +(define (create-page! config reference title markdown author [summary "Created page"] [tags '()]) + (define-values (namespace slug) (split-page-reference reference)) (call-with-wiki-database config (λ (db) @@ -189,20 +242,20 @@ SQL (define page-id (query-value db #<text tags) now author)) + namespace slug title markdown (tags->text tags) now author)) (define page-version-id (insert-version! db page-id 1 title markdown author "create" summary now tags)) (replace-todos! db page-id markdown) (replace-current-attachment-references! db page-id markdown now) (record-version-attachment-references! db page-id page-version-id markdown now))))) - (read-page config slug)) + (read-page config reference)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; goal : Save a new version of an existing wiki page. @@ -210,7 +263,8 @@ SQL ; post : Current page and version history are committed atomically. ; result : The updated page metadata with Markdown. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(define (update-page! config slug title markdown author base-version [summary "Edited page"] [tags #f]) +(define (update-page! config reference title markdown author base-version [summary "Edited page"] [tags #f] [new-namespace #f]) + (define-values (namespace slug) (split-page-reference reference)) (call-with-wiki-database config (λ (db) @@ -219,8 +273,8 @@ SQL (λ () (define row (query-maybe-row db - "SELECT id, current_version, tags FROM pages WHERE slug = $1 AND archived = FALSE FOR UPDATE" - slug)) + "SELECT id, current_version, tags, namespace FROM pages WHERE namespace = $1 AND slug = $2 AND archived = FALSE FOR UPDATE" + namespace slug)) (unless row (error 'update-page! "unknown page: ~a" slug)) (define current-version (vector-ref row 1)) @@ -232,25 +286,33 @@ SQL (error 'update-page! "version-conflict")) (define page-tags (if tags tags (text->tags (vector-ref row 2)))) + (define target-namespace + (if (eq? new-namespace #f) + (vector-ref row 3) + (string-trim new-namespace))) + (unless (or (string=? target-namespace "") + (and (valid-slug? target-namespace) + (<= (string-length target-namespace) 80))) + (error 'update-page! "invalid namespace: ~a" target-namespace)) (define next-version (+ current-version 1)) (define now (current-seconds)) (query-exec db #<text page-tags) next-version now author (vector-ref row 0)) + title markdown (tags->text page-tags) next-version now author target-namespace (vector-ref row 0)) (define page-id (vector-ref row 0)) (define page-version-id (insert-version! db page-id next-version title markdown author "edit" summary now page-tags)) (replace-todos! db page-id markdown) (replace-current-attachment-references! db page-id markdown now) (record-version-attachment-references! db page-id page-version-id markdown now))))) - (read-page config slug)) + (read-page config (page-reference (if (eq? new-namespace #f) namespace (string-trim new-namespace)) slug))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; goal : Archive an existing wiki page. @@ -258,7 +320,8 @@ SQL ; post : The page is marked archived while its versions and attachments remain stored. ; result : void. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(define (archive-page! config slug author) +(define (archive-page! config reference author) + (define-values (namespace slug) (split-page-reference reference)) (call-with-wiki-database config (λ (db) @@ -267,10 +330,10 @@ SQL #<number version))) (and version-number @@ -336,9 +402,9 @@ SQL SELECT v.version, v.title, v.markdown, v.author, v.action, v.summary, v.tags, v.created_at FROM page_versions v JOIN pages p ON p.id = v.page_id -WHERE p.slug = $1 AND p.archived = FALSE AND v.version = $2 +WHERE p.namespace = $1 AND p.slug = $2 AND p.archived = FALSE AND v.version = $3 SQL - slug version-number)) + namespace slug version-number)) (and row (hash 'version (vector-ref row 0) 'title (vector-ref row 1) @@ -369,7 +435,8 @@ SELECT p.slug, p.title, ts_rank(p.search_document, q.query) AS rank, ts_headline('simple', p.markdown, q.query, - 'StartSel=[[[, StopSel=]]], MaxWords=28, MinWords=8, ShortWord=2') AS snippet + 'StartSel=[[[, StopSel=]]], MaxWords=28, MinWords=8, ShortWord=2') AS snippet, + p.namespace FROM pages p, q WHERE p.archived = FALSE AND p.search_document @@ q.query @@ -377,7 +444,8 @@ ORDER BY rank DESC, lower(p.title), p.title LIMIT 50 SQL query-text)))) - (hash 'slug (vector-ref row 0) + (hash 'slug (page-reference (vector-ref row 4) (vector-ref row 0)) + 'namespace (vector-ref row 4) 'title (vector-ref row 1) 'rank (vector-ref row 2) 'snippet (vector-ref row 3))))))) @@ -395,14 +463,15 @@ SQL (for/list ((row (in-list (query-rows db #<jsexpr user) (hash 'id (wiki-user-id user) 'username (wiki-user-username user) @@ -244,7 +252,7 @@ CSS (require-role config req 'reader (λ (_session) - (define page (and (valid-slug? slug) (read-page config slug))) + (define page (and (valid-page-reference? slug) (read-page config slug))) (if page (json-response page) (json-error 404 "Page not found"))))) @@ -264,20 +272,22 @@ CSS (with-handlers ((exn:fail? (λ (e) (json-error 400 (exn-message e))))) (define body (request-json req)) (define requested-slug (hash-ref body 'slug #f)) + (define namespace (string-trim (hash-ref body 'namespace ""))) (define title (hash-ref body 'title "")) (define markdown (hash-ref body 'markdown "")) (define tags (request-tags body)) (define summary (hash-ref body 'summary "Created page")) (define slug - (if requested-slug - requested-slug - (title->slug title))) + (cond + (requested-slug requested-slug) + ((string=? namespace "") (title->slug title)) + (else (page-reference namespace (title->slug title))))) (cond ((string=? (string-trim title) "") (json-error 400 "Title is required")) ((string=? slug "") (json-error 400 "The title cannot be converted to a page slug")) - ((not (valid-slug? slug)) + ((not (valid-page-reference? slug)) (json-error 400 "Invalid page address")) ((read-page config slug) (json-error 409 "A page with this address already exists")) @@ -303,6 +313,7 @@ CSS (json-error 400 (exn-message e)))))) (define body (request-json req)) (define title (hash-ref body 'title "")) + (define namespace (hash-ref body 'namespace #f)) (define markdown (hash-ref body 'markdown "")) (define tags (request-tags body)) (define base-version (hash-ref body 'baseVersion "")) @@ -315,7 +326,8 @@ CSS (wiki-user-username (wiki-session-user session)) base-version summary - tags)))))) + tags + namespace)))))) (define (page-delete-handler config req slug) (require-write-role @@ -594,7 +606,7 @@ CSS (cond ((not session) (redirect-response "/login")) - ((and slug (valid-slug? slug)) + ((and slug (valid-page-reference? slug)) (let ((page (read-page config slug))) (cond (page diff --git a/setup-vendor.rkt b/setup-vendor.rkt index 84a2ca8..e9683e3 100644 --- a/setup-vendor.rkt +++ b/setup-vendor.rkt @@ -1,5 +1,9 @@ #lang racket/base +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Manual command for installing pinned frontend dependencies. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + (require racket/cmdline racket/path "private/config.rkt" diff --git a/static/css/wiki.css b/static/css/wiki.css index e30c4fb..f5c2f2f 100644 --- a/static/css/wiki.css +++ b/static/css/wiki.css @@ -1201,3 +1201,20 @@ body.editor-mode .editor-metadata-row { margin: 4px 0 0 18px; padding: 0; } + +/* Namespace is page metadata; keep it compact beside the title editor. */ +.editor-namespace-row { + display: flex; + align-items: center; + gap: .6rem; + margin: .3rem 0; + font-size: .9rem; +} +.editor-namespace-row input { + max-width: 18rem; +} +.namespace-heading { + margin: 1rem 0 .35rem; + font-size: 1rem; + font-weight: 600; +} diff --git a/static/index.html b/static/index.html index e2db088..2fa6e06 100644 --- a/static/index.html +++ b/static/index.html @@ -78,6 +78,10 @@
+
+ + +
diff --git a/static/js/wiki.js b/static/js/wiki.js index 7c95ad3..5372c8e 100644 --- a/static/js/wiki.js +++ b/static/js/wiki.js @@ -1,6 +1,16 @@ (() => { "use strict"; + /* + * racket-wiki browser application. + * + * The source is deliberately kept as one direct script instead of a client + * framework. Larger functions are documented with goal/pre/post/result-style + * comments, following the same readability rules as the Racket sources. + * Markdown source remains authoritative; Todo markup, WikiWords, namespace + * references and image options are expanded only for rendering. + */ + const state = { session: null, pages: [], @@ -19,6 +29,10 @@ let easyMDE = null; + //////////////////////////////////////////////////////////////////////////////// + // General UI and HTTP support + //////////////////////////////////////////////////////////////////////////////// + const $ = (id) => document.getElementById(id); function show(viewId) { @@ -53,6 +67,38 @@ .replaceAll('"', """); } + /** + * goal : Split a wiki page reference into namespace and page slug. + * pre : reference is a string such as "roadmap" or "racket:roadmap". + * post : No application state is changed. + * result : An object with namespace and slug fields. + */ + function splitPageReference(reference) { + const value = String(reference || ""); + const separator = value.indexOf(":"); + if (separator < 0) return { namespace: "", slug: value }; + return { namespace: value.slice(0, separator), slug: value.slice(separator + 1) }; + } + + /** + * goal : Build the compact external reference for a wiki page. + * pre : namespace and slug are already suitable wiki identifiers. + * post : No application state is changed. + * result : slug for root pages, otherwise namespace:slug. + */ + function pageReference(namespace, slug) { + const cleanNamespace = String(namespace || "").trim(); + return cleanNamespace ? `${cleanNamespace}:${slug}` : slug; + } + + function pageRoute(reference) { + return `#/${encodeURIComponent(reference)}`; + } + + function namespaceLabel(namespace) { + return namespace || tr("root-namespace", "Root"); + } + function expandTodoMarkup(markdown, pageSlug = null) { let inFence = false; let todoNumber = 0; @@ -92,6 +138,12 @@ }); } + /** + * goal : Perform one authenticated API request and decode its response. + * pre : path identifies a racket-wiki API route. + * post : CSRF and JSON headers are applied when needed; 401 redirects to login. + * result : Decoded JSON/text response or a thrown Error. + */ async function api(path, options = {}) { const headers = new Headers(options.headers || {}); if (options.body && !(options.body instanceof Blob) && !(options.body instanceof ArrayBuffer)) { @@ -114,6 +166,10 @@ return body; } + //////////////////////////////////////////////////////////////////////////////// + // Markdown rendering and wiki-link syntax + //////////////////////////////////////////////////////////////////////////////// + function applyImageWidthMarkup(html) { const imageOptionsSuffix = /(]*>)\s*\{\s*width\s*=\s*([0-9]+(?:\.[0-9]+)?)(%|px)?(?:\s+(left|center|right))?(?:\s+(float))?(?:\s+float\s*=\s*(left|right))?\s*\}/gi; @@ -164,24 +220,33 @@ return value.match(/\p{Lu}\p{Ll}+/gu) || []; } - function camelCaseTarget(text, aliases) { + /** + * goal : Resolve a classic WikiWord to an existing page or a new page target. + * pre : text contains only the candidate WikiWord and aliases is built from state.pages. + * post : No page is created; this only creates a render target. + * result : {slug,title} or null when text is not a valid WikiWord. + */ + function camelCaseTarget(text, aliases, namespace = "") { const parts = wikiWordParts(text); if (parts.length === 0) return null; - const existing = aliases.get(normalizeMentionText(text)); + const aliasKey = `${String(namespace || "").toLocaleLowerCase()}:${normalizeMentionText(text)}`; + const existing = aliases.get(aliasKey); if (existing) { return { slug: existing.slug, title: existing.title }; } + const pageSlug = parts.map((part) => part.toLocaleLowerCase()).join("-"); return { - slug: parts.map((part) => part.toLocaleLowerCase()).join("-"), + slug: pageReference(namespace, pageSlug), title: parts.join(" ") }; } function mentionAliases(page) { const aliases = new Set(); - const values = [page.title, slugTitle(page.slug), page.slug.replaceAll("-", " ")]; + const rawSlug = page.pageSlug || splitPageReference(page.slug).slug; + const values = [page.title, slugTitle(rawSlug), rawSlug.replaceAll("-", " ")]; for (const value of values) { if (!value) continue; aliases.add(value); @@ -194,15 +259,30 @@ .filter((alias) => alias.key.length >= 5); } + /** + * goal : Build an ambiguity-aware lookup table for WikiWords. + * pre : state.pages contains the current page metadata. + * post : No state is changed. + * result : Map keys include the page namespace, so equal names may exist in different namespaces. + */ function pageMentionMap(currentSlug = null) { const map = new Map(); for (const page of state.pages) { if (page.slug === currentSlug) continue; + const namespace = String(page.namespace || "").toLocaleLowerCase(); for (const alias of mentionAliases(page)) { - if (!map.has(alias.key)) { - map.set(alias.key, page); - } else if (map.get(alias.key)?.slug !== page.slug) { - map.set(alias.key, null); + const namespacedKey = `${namespace}:${alias.key}`; + if (!map.has(namespacedKey)) { + map.set(namespacedKey, page); + } else if (map.get(namespacedKey)?.slug !== page.slug) { + map.set(namespacedKey, null); + } + + const rootKey = `:${alias.key}`; + if (!map.has(rootKey)) { + map.set(rootKey, page); + } else if (map.get(rootKey)?.slug !== page.slug) { + map.set(rootKey, null); } } } @@ -235,11 +315,48 @@ } + /** + * goal : Rewrite explicit Markdown targets such as (racket:roadmap) to the internal hash route. + * pre : markdown is source text; fenced code must remain untouched. + * post : Only explicit wiki-looking link destinations are rewritten for rendering. + * result : Render-only Markdown; stored Markdown is never changed. + */ + function expandNamespacedMarkdownLinks(markdown) { + const lines = String(markdown || "").split("\n"); + const result = []; + let fence = null; + + for (const line of lines) { + const fenceMatch = line.match(/^\s*(```+|~~~+)/); + if (fenceMatch) { + const marker = fenceMatch[1].charAt(0); + fence = fence === null ? marker : (fence === marker ? null : fence); + result.push(line); + continue; + } + if (fence !== null || /^\s{4}/.test(line)) { + result.push(line); + continue; + } + + result.push(line.replace(/(!?\[[^\]\n]*\]\()([\p{L}\p{N}._-]+):([\p{L}\p{N}._-]+)(\))/gu, + (_match, before, namespace, slug, after) => `${before}${pageRoute(pageReference(namespace, slug))}${after}`)); + } + return result.join("\n"); + } + + /** + * goal : Expand classic WikiWords to temporary Markdown links before Marked renders them. + * pre : markdown may contain paragraphs, lists, tables, quotes and headings. + * post : Code, Todo markers, URLs and existing Markdown links remain unchanged. + * result : Render-only Markdown with WikiWord links. + */ function expandWikiMentions(markdown, currentSlug = null) { const aliases = pageMentionMap(currentSlug); const lines = String(markdown || "").split("\n"); const result = []; let fence = null; + const wikiWordPattern = /(?= 0; index -= 1) { const replacement = replacements[index]; - const link = `[${replacement.page.title}](#/${encodeURIComponent(replacement.page.slug)})`; + const link = `[${replacement.page.title}](${pageRoute(replacement.page.slug)})`; expanded = expanded.slice(0, replacement.start) + link + expanded.slice(replacement.end); } result.push(expanded); @@ -291,8 +399,15 @@ return result.join("\n"); } + /** + * goal : Render wiki Markdown using the same EasyMDE/Marked pipeline everywhere. + * pre : markdown is source text; pageSlug is optional context for Todo links. + * post : The returned HTML is sanitized with DOMPurify. + * result : Safe HTML for preview, reader view or history view. + */ function renderMarkdown(markdown, pageSlug = null) { - const withWikiLinks = expandWikiMentions(markdown || "", pageSlug); + const withExplicitWikiLinks = expandNamespacedMarkdownLinks(markdown || ""); + const withWikiLinks = expandWikiMentions(withExplicitWikiLinks, pageSlug); const withTodos = expandTodoMarkup(withWikiLinks, pageSlug); const html = easyMDE.markdown(withTodos); const withImages = applyImageWidthMarkup(html); @@ -300,13 +415,18 @@ } function slugTitle(slug) { - return (slug || "") + const pageSlug = splitPageReference(slug || "").slug; + return pageSlug .split("-") .filter(Boolean) .map((part) => part.charAt(0).toUpperCase() + part.slice(1)) .join(" "); } + //////////////////////////////////////////////////////////////////////////////// + // Page display and navigation + //////////////////////////////////////////////////////////////////////////////// + function setPageActionVisibility(pageExists) { if (!can("editor")) return; $("edit-page").classList.remove("hidden"); @@ -336,11 +456,15 @@ const details = $("page-details"); details.replaceChildren(); - const fields = [ + const fields = []; + if (page.namespace) { + fields.push(`${tr("namespace", "Namespace")}: ${page.namespace}`); + } + fields.push( `${tr("created", "Created")} ${pageDisplayDate(page.createdAt)} ${tr("by", "by")} ${page.createdBy}`, `${tr("modified", "Modified")} ${pageDisplayDate(page.updatedAt)} ${tr("by", "by")} ${page.updatedBy}`, `${tr("version", "Version")} ${page.currentVersion}` - ]; + ); for (const text of fields) { const span = document.createElement("span"); @@ -377,7 +501,7 @@ candidate = href.slice(1); } else if (href.startsWith("./") && href.indexOf("/", 2) === -1 && !href.includes("?") && !href.includes("#")) { candidate = href.slice(2); - } else if (!href.includes("/") && !href.includes(":") && !href.includes("#") && !href.includes("?")) { + } else if (!href.includes("/") && !href.includes("#") && !href.includes("?")) { candidate = href; } @@ -416,6 +540,10 @@ }; } + //////////////////////////////////////////////////////////////////////////////// + // EasyMDE editor setup and editing support + //////////////////////////////////////////////////////////////////////////////// + function initializeHighlighting() { if (!window.hljs) return; if (typeof window.hljs.registerAliases === "function" && window.hljs.getLanguage("scheme")) { @@ -435,6 +563,11 @@ easyMDE.codemirror.refresh(); } + /** + * goal : Configure the single EasyMDE instance used for page editing. + * pre : Vendor scripts and the editor textarea are loaded. + * post : easyMDE is ready with toolbar, uploads, Raw mode and live TOC updates. + */ function initializeEditor() { if (!window.EasyMDE) { throw new Error("EasyMDE is not installed. Open /setup to repair the frontend setup."); @@ -535,6 +668,11 @@ container.style.setProperty("--editor-status-height", `${statusHeight}px`); } + /** + * goal : Show the editor and synchronize its sticky chrome and TOC. + * pre : easyMDE has been initialized. + * post : Editor view is visible and sized for the current viewport. + */ function activateEditor() { show("editor-view"); renderEditorToc(); @@ -635,6 +773,11 @@ } } + /** + * goal : Build the reader TOC from rendered headings and Markdown source lines. + * pre : state.currentPage and #markdown-preview represent the same page. + * post : TOC navigation scrolls below sticky chrome; editors get section-edit links. + */ function renderPageToc() { const article = $("markdown-preview"); const usedIds = new Set(); @@ -766,6 +909,11 @@ } } + /** + * goal : Render the sticky history breadcrumb as real navigation links. + * pre : items are ordered from wiki home to the current context. + * post : #breadcrumbs contains clickable previous page locations. + */ function renderBreadcrumbs(items) { const breadcrumbs = $("breadcrumbs"); breadcrumbs.replaceChildren(); @@ -806,6 +954,11 @@ }); } + /** + * goal : Build the page breadcrumb from the per-tab visit history. + * pre : state.pages and breadcrumbTrail are current. + * post : The sticky breadcrumb shows Home, previous pages and optional suffix. + */ function pageBreadcrumbs(page, suffix = null) { const firstPage = startPage(); const items = []; @@ -862,6 +1015,11 @@ document.title = state.siteTitle; } + /** + * goal : Return to the first/start page from every normal or special view. + * pre : Page metadata has been loaded. + * post : Breadcrumb history is cleared and the start page is opened. + */ async function goHome() { const firstPage = startPage(); clearBreadcrumbTrail(); @@ -878,23 +1036,38 @@ } } + /** + * goal : Render the secondary page list grouped by namespace. + * pre : state.pages contains current page metadata. + * post : #page-list reflects the current page set. + */ function renderPageList() { const list = $("page-list"); list.replaceChildren(); + let previousNamespace = null; for (const page of state.pages) { + const namespace = page.namespace || ""; + if (namespace !== previousNamespace) { + const heading = document.createElement("div"); + heading.className = "namespace-heading"; + heading.textContent = namespaceLabel(namespace); + list.append(heading); + previousNamespace = namespace; + } const link = document.createElement("a"); - link.href = `#/${encodeURIComponent(page.slug)}`; + link.href = pageRoute(page.slug); link.className = "page-link"; link.textContent = page.title; link.classList.toggle("active", state.currentPage?.slug === page.slug); - link.addEventListener("click", (event) => { - event.preventDefault(); - location.hash = `#/${encodeURIComponent(page.slug)}`; - }); list.append(link); } } + /** + * goal : Refresh current page metadata from PostgreSQL through the API. + * pre : The user is authenticated. + * post : state.pages, site identity, page list and template list are refreshed. + */ async function loadPages() { const result = await api("/api/pages"); state.pages = result.pages; @@ -905,7 +1078,7 @@ function templatePages() { - return state.pages.filter((page) => page.slug.toLocaleLowerCase().startsWith("template-")); + return state.pages.filter((page) => (page.pageSlug || splitPageReference(page.slug).slug).toLocaleLowerCase().startsWith("template-")); } function updateTemplateSelect() { @@ -928,6 +1101,11 @@ select.value = Array.from(select.options).some((option) => option.value === selected) ? selected : ""; } + /** + * goal : Replace editor Markdown with a selected template-* wiki page. + * pre : slug identifies a readable template page. + * post : Editor contents are replaced after confirmation when necessary. + */ async function applyTemplate(slug) { if (!slug) return; const template = await api(`/api/pages/${encodeURIComponent(slug)}`); @@ -969,6 +1147,11 @@ updateBookmarkAction(); } + /** + * goal : Open one page in reader mode. + * pre : slug is a root or namespace-qualified page reference. + * post : Current page state, breadcrumb, TOC and bookmark action are updated. + */ async function openPage(slug) { const page = await api(`/api/pages/${encodeURIComponent(slug)}`); state.currentPage = page; @@ -988,23 +1171,33 @@ } function updateEditorSlugInfo() { + const namespace = $("editor-namespace")?.value.trim() || ""; if (!state.editingNew && state.currentPage) { - $("editor-slug-info").textContent = `${tr("page-address", "Page address")}: /${state.currentPage.slug}`; + const rawSlug = state.currentPage.pageSlug || splitPageReference(state.currentPage.slug).slug; + $("editor-slug-info").textContent = `${tr("page-address", "Page address")}: ${pageReference(namespace, rawSlug)}`; return; } if (state.newPageSlug) { - $("editor-slug-info").textContent = `${tr("page-address", "Page address")}: /${state.newPageSlug}`; + const requested = splitPageReference(state.newPageSlug); + $("editor-slug-info").textContent = `${tr("page-address", "Page address")}: ${pageReference(namespace || requested.namespace, requested.slug)}`; return; } $("editor-slug-info").textContent = tr("page-address-generated", "Page address will be generated from the title when you save."); } + /** + * goal : Open an empty editor for a not-yet-existing page reference. + * pre : requestedSlug is null or a compact root/namespaced page reference. + * post : Namespace, title, template and Markdown controls are initialized for creation. + */ function beginNewPage(requestedSlug = null) { state.editingNew = true; state.currentPage = null; state.newPageSlug = requestedSlug; const translationPage = requestedSlug && requestedSlug === state.translationPage; $("editor-title").value = translationPage ? tr("translations", "Translations") : ""; + $("editor-namespace").value = requestedSlug ? splitPageReference(requestedSlug).namespace : ""; + $("editor-namespace").disabled = Boolean(translationPage); $("editor-tags").value = ""; if (translationPage) { easyMDE.value(state.translationTemplate || ""); @@ -1019,6 +1212,11 @@ $("editor-title").focus(); } + /** + * goal : Open the current page in EasyMDE. + * pre : state.currentPage is a current page, or newPageSlug identifies a missing page. + * post : Editor fields contain the page title, namespace, tags and Markdown. + */ function beginEditPage() { if (!state.currentPage) { if (state.newPageSlug) { @@ -1029,6 +1227,8 @@ state.editingNew = false; state.newPageSlug = null; $("editor-title").value = state.currentPage.title; + $("editor-namespace").value = state.currentPage.namespace || ""; + $("editor-namespace").disabled = state.currentPage.slug === state.translationPage; $("editor-tags").value = (state.currentPage.tags || []).join(", "); easyMDE.value(state.currentPage.markdown); $("edit-summary").value = ""; @@ -1038,8 +1238,14 @@ activateEditor(); } + /** + * goal : Save the current editor contents as a new or updated wiki page. + * pre : EasyMDE is active and title/namespace fields contain editor input. + * post : A successful save refreshes page metadata and opens the stored page. + */ async function savePage() { const title = $("editor-title").value.trim(); + const namespace = $("editor-namespace").value.trim(); const currentSlug = state.editingNew ? state.newPageSlug : state.currentPage?.slug; const markdown = easyMDE.value(); const tags = parseTags($("editor-tags").value); @@ -1050,12 +1256,14 @@ if (state.editingNew) { const body = { title, + namespace, markdown, tags, summary: summary || tr("created-page", "Created page") }; if (state.newPageSlug) { - body.slug = state.newPageSlug; + const requested = splitPageReference(state.newPageSlug); + body.slug = pageReference(namespace || requested.namespace, requested.slug); } page = await api("/api/pages", { method: "POST", @@ -1067,6 +1275,7 @@ method: "PUT", body: JSON.stringify({ title, + namespace, markdown, tags, baseVersion: state.currentPage.currentVersion, @@ -1130,6 +1339,11 @@ return result.url; } + /** + * goal : Upload dropped/selected files and insert Markdown references at the cursor. + * pre : The current page has already been saved once. + * post : Uploaded files are stored through the API and referenced from the editor. + */ async function uploadFiles(files) { const fileList = Array.from(files || []); if (fileList.length === 0) return; @@ -1319,6 +1533,11 @@ } } + /** + * goal : Show immutable versions of the current page and diff actions. + * pre : state.currentPage identifies an existing page. + * post : History view contains newest-first versions. + */ async function showHistory() { if (!state.currentPage) return; state.previousView = "page-view"; @@ -1382,6 +1601,11 @@ return `${(bytes / (1024 * 1024)).toFixed(1)} MB`; } + /** + * goal : Show uploads no current page references and their last historical uses. + * pre : Current user has the admin role. + * post : Admin view offers safe deletion only for orphaned uploads. + */ async function loadOrphanedUploadsAdmin() { renderBreadcrumbs([ { label: state.siteTitle, href: "/" }, @@ -1451,6 +1675,11 @@ } } + /** + * goal : Render user administration from the current server-side user list. + * pre : Current user has the admin role. + * post : User rows allow supported create/update/delete operations. + */ async function loadUsersAdmin() { renderBreadcrumbs([ { label: state.siteTitle, href: "/" }, @@ -1544,6 +1773,11 @@ renderPageList(); } + /** + * goal : Resolve the current hash route to a normal or special wiki view. + * pre : Session and page metadata have been loaded. + * post : Exactly one application view is made active. + */ async function route() { const todoMatch = location.hash.match(/^#todo\/([^/]+)\/(\d+)$/); if (todoMatch) { @@ -1592,6 +1826,10 @@ return date.toLocaleString(state.language || undefined); } + //////////////////////////////////////////////////////////////////////////////// + // Special wiki views: Recent, Bookmarks and Todo + //////////////////////////////////////////////////////////////////////////////// + async function showRecent() { state.previousView = state.currentPage ? "page-view" : "recent-view"; renderBreadcrumbs([ @@ -1642,6 +1880,11 @@ await loadBookmarks(); } + /** + * goal : Show bookmarks grouped first by page namespace and then user section. + * pre : The user is authenticated. + * post : The Bookmarks special view contains the latest bookmark state. + */ async function showBookmarks() { state.previousView = state.currentPage ? "page-view" : "bookmarks-view"; renderBreadcrumbs([ @@ -1662,53 +1905,71 @@ return; } - const groups = new Map(); + const namespaceGroups = new Map(); for (const bookmark of state.bookmarks) { + const namespace = bookmark.namespace || ""; + if (!namespaceGroups.has(namespace)) namespaceGroups.set(namespace, new Map()); + const sections = namespaceGroups.get(namespace); const section = bookmark.section || ""; - if (!groups.has(section)) groups.set(section, []); - groups.get(section).push(bookmark); + if (!sections.has(section)) sections.set(section, []); + sections.get(section).push(bookmark); } - for (const [section, bookmarks] of groups.entries()) { - const sectionElement = document.createElement("section"); - sectionElement.className = "bookmark-section"; - const heading = document.createElement("h2"); - heading.textContent = section || tr("bookmarks", "Bookmarks"); - sectionElement.append(heading); + for (const [namespace, sections] of namespaceGroups.entries()) { + const namespaceSection = document.createElement("section"); + const namespaceHeading = document.createElement("h2"); + namespaceHeading.textContent = namespaceLabel(namespace); + namespaceSection.append(namespaceHeading); - for (const bookmark of bookmarks) { - const row = document.createElement("div"); - row.className = "bookmark-row"; - const link = document.createElement("a"); - link.href = `#/${encodeURIComponent(bookmark.slug)}`; - link.textContent = bookmark.title; - const actions = document.createElement("span"); - actions.className = "bookmark-section-actions"; - const move = document.createElement("a"); - move.href = "#"; - move.textContent = tr("move", "Move"); - move.addEventListener("click", async (event) => { - event.preventDefault(); - await saveBookmark(bookmark.slug, bookmark.section || ""); - await showBookmarks(); - }); - const separator = document.createTextNode(" · "); - const remove = document.createElement("a"); - remove.href = "#"; - remove.textContent = tr("remove", "Remove"); - remove.addEventListener("click", async (event) => { - event.preventDefault(); - await removeBookmark(bookmark.slug); - await showBookmarks(); - }); - actions.append(move, separator, remove); - row.append(link, actions); - sectionElement.append(row); + for (const [section, bookmarks] of sections.entries()) { + const sectionElement = document.createElement("section"); + sectionElement.className = "bookmark-section"; + if (section) { + const heading = document.createElement("h3"); + heading.textContent = section; + sectionElement.append(heading); + } + + for (const bookmark of bookmarks) { + const row = document.createElement("div"); + row.className = "bookmark-row"; + const link = document.createElement("a"); + link.href = pageRoute(bookmark.slug); + link.textContent = bookmark.title; + const actions = document.createElement("span"); + actions.className = "bookmark-section-actions"; + const move = document.createElement("a"); + move.href = "#"; + move.textContent = tr("move", "Move"); + move.addEventListener("click", async (event) => { + event.preventDefault(); + await saveBookmark(bookmark.slug, bookmark.section || ""); + await showBookmarks(); + }); + const separator = document.createTextNode(" · "); + const remove = document.createElement("a"); + remove.href = "#"; + remove.textContent = tr("remove", "Remove"); + remove.addEventListener("click", async (event) => { + event.preventDefault(); + await removeBookmark(bookmark.slug); + await showBookmarks(); + }); + actions.append(move, separator, remove); + row.append(link, actions); + sectionElement.append(row); + } + namespaceSection.append(sectionElement); } - target.append(sectionElement); + target.append(namespaceSection); } } + /** + * goal : Show Todo items grouped by the namespace of their source page. + * pre : Todo index is available through /api/todos. + * post : Optional target Todo is scrolled into view and highlighted. + */ async function showTodos(targetSlug = null, targetNumber = null) { state.previousView = state.currentPage ? "page-view" : "todo-view"; renderBreadcrumbs([ @@ -1727,12 +1988,21 @@ list.append(empty); return; } + let todoNamespace = null; for (const item of result.items) { + const namespace = item.namespace || ""; + if (namespace !== todoNamespace) { + const heading = document.createElement("h2"); + heading.className = "namespace-heading"; + heading.textContent = namespaceLabel(namespace); + list.append(heading); + todoNamespace = namespace; + } const row = document.createElement("article"); row.className = "todo-item"; row.id = `todo-${item.slug}-${item.number}`; const link = document.createElement("a"); - link.href = `#/${encodeURIComponent(item.slug)}`; + link.href = pageRoute(item.slug); link.textContent = item.title; const text = document.createElement("div"); text.className = "todo-item-text"; @@ -1753,6 +2023,10 @@ } } + //////////////////////////////////////////////////////////////////////////////// + // Wiki graph support + //////////////////////////////////////////////////////////////////////////////// + function pageLinks(markdown) { const container = document.createElement("div"); container.innerHTML = renderMarkdown(markdown || ""); @@ -1766,6 +2040,12 @@ return links; } + /** + * goal : Build the wiki link graph from current rendered page links. + * pre : state.pages contains current pages. + * post : No page state is changed. + * result : Graph nodes and directed edges. + */ async function loadGraphData() { const pageSlugs = new Set(state.pages.map((page) => page.slug)); const edges = []; @@ -1785,6 +2065,11 @@ return { nodes: state.pages, edges }; } + /** + * goal : Render a clickable SVG graph for all or contextual wiki pages. + * pre : data contains graph nodes/edges using compact page references. + * post : #graph-view contains the new graph; node clicks navigate to pages. + */ function renderWikiGraph(data, focusSlug = null) { const svg = $("wiki-graph"); svg.replaceChildren(); @@ -1854,6 +2139,11 @@ svg.append(nodeLayer); } + /** + * goal : Open the complete wiki graph special view. + * pre : User can read pages. + * post : Full graph data is loaded and rendered. + */ async function showGraph() { state.previousView = state.currentPage ? "page-view" : "graph-view"; renderBreadcrumbs([ @@ -1871,6 +2161,11 @@ renderWikiGraph(data); } + /** + * goal : Open the graph containing the current page and its direct neighbours. + * pre : state.currentPage identifies an existing page. + * post : Context graph is rendered with the current page highlighted. + */ async function showContextGraph() { if (!state.currentPage) return; @@ -1928,11 +2223,21 @@ } } + /** + * goal : Start periodic connectivity checks for the wiki backend. + * pre : Browser application initialization has completed. + * post : Offline/online state is updated approximately every 15 seconds. + */ function startKeepAlive() { window.setInterval(pingServer, 15000); pingServer(); } + /** + * goal : Bootstrap the authenticated browser application. + * pre : index.html and all pinned vendor scripts are loaded. + * post : Session, translations, pages, editor, navigation and keep-alive are ready. + */ async function initialize() { state.session = await api("/api/session"); if (!state.session.authenticated) { @@ -2037,6 +2342,8 @@ route(); }); $("save-page").addEventListener("click", savePage); + $("editor-namespace").addEventListener("input", updateEditorSlugInfo); + $("template-select").addEventListener("change", (event) => { applyTemplate(event.target.value).catch((error) => { $("save-status").textContent = error.message; diff --git a/translate.rkt b/translate.rkt index 36e4472..19b19b6 100644 --- a/translate.rkt +++ b/translate.rkt @@ -1,5 +1,9 @@ #lang racket/base +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Built-in UI translations and wiki-page translation overrides. +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + (require db racket/file racket/list @@ -14,10 +18,14 @@ translation-page-slug translation-page-template) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Supporting functions +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + (define english (hash 'users "Users" 'translations "Translations" 'orphaned-uploads "Orphaned uploads" 'no-orphaned-uploads "No orphaned uploads." 'uploaded-by "uploaded by" 'last-used "Last used" 'never-referenced "Never referenced by a saved page." 'delete-orphaned-upload-confirm "Delete this orphaned upload?" 'recent "Recent" 'recent-changes "Recent changes" 'bookmarks "Bookmarks" 'bookmark "Bookmark" 'bookmarked "Bookmarked" 'bookmark-section "Bookmark section" 'move "Move" 'remove "Remove" 'no-bookmarks "No bookmarks yet." 'no-recent-pages "No recent pages." 'changed-by "changed by" 'todo "Todo" 'todo-list "Todo list" 'graph "Graph" 'wiki-graph "Wiki graph" 'graph-summary "{pages} pages, {links} links" 'context "context" 'context-graph "Context graph" 'context-graph-summary "{pages} related pages, {links} links" 'admin "Admin" 'role-reader "reader" 'role-editor "editor" 'role-admin "admin" - 'search-wiki "Search wiki" 'contents "Contents" 'pages "Pages" + 'search-wiki "Search wiki" 'contents "Contents" 'pages "Pages" 'namespace "Namespace" 'namespace-placeholder "RWS" 'root-namespace "Root" 'edit "Edit" 'edit-section "Edit section" 'template "Template" 'no-template "No template" 'replace-with-template "Replace the current page content with template {template}?" 'history "History" 'delete "Delete" 'page-not-found "Page not found" 'cancel "Cancel" 'save "Save" 'page-title "Page title" 'tags "Tags (comma separated)" 'version-summary "Version summary (optional)" 'search "Search" 'page-history "Page history" @@ -50,7 +58,7 @@ (define dutch (hash 'users "Gebruikers" 'translations "Vertalingen" 'orphaned-uploads "Verweeste uploads" 'no-orphaned-uploads "Geen verweeste uploads." 'uploaded-by "geüpload door" 'last-used "Laatst gebruikt" 'never-referenced "Nooit door een opgeslagen pagina gerefereerd." 'delete-orphaned-upload-confirm "Deze verweeste upload verwijderen?" 'recent "Recent" 'recent-changes "Recent gewijzigd" 'bookmarks "Bookmarks" 'bookmark "Bookmark" 'bookmarked "Gebookmarkt" 'bookmark-section "Bookmark-hoofdstuk" 'move "Verplaatsen" 'remove "Verwijderen" 'no-bookmarks "Nog geen bookmarks." 'no-recent-pages "Nog geen recent gewijzigde pagina's." 'changed-by "gewijzigd door" 'todo "Todo" 'todo-list "Todo-lijst" 'graph "Graph" 'wiki-graph "Wiki-graaf" 'graph-summary "{pages} pagina's, {links} links" 'context "context" 'context-graph "Contextgraaf" 'context-graph-summary "{pages} gerelateerde pagina's, {links} links" 'admin "Admin" 'role-reader "lezer" 'role-editor "redacteur" 'role-admin "admin" - 'search-wiki "Wiki doorzoeken" 'contents "Inhoud" 'pages "Pagina's" + 'search-wiki "Wiki doorzoeken" 'contents "Inhoud" 'pages "Pagina's" 'namespace "Namespace" 'namespace-placeholder "RWS" 'root-namespace "Hoofdnamespace" 'edit "Bewerken" 'edit-section "Sectie bewerken" 'template "Sjabloon" 'no-template "Geen sjabloon" 'replace-with-template "De huidige pagina-inhoud vervangen door sjabloon {template}?" 'history "Geschiedenis" 'delete "Verwijderen" 'page-not-found "Pagina niet gevonden" 'cancel "Annuleren" 'save "Opslaan" 'page-title "Paginatitel" 'tags "Tags (komma-gescheiden)" 'version-summary "Versiesamenvatting (optioneel)" 'search "Zoeken" 'page-history "Paginageschiedenis" @@ -202,7 +210,7 @@ (λ (db) (define markdown (query-maybe-value db - "SELECT markdown FROM pages WHERE slug = $1 AND archived = FALSE" + "SELECT markdown FROM pages WHERE namespace = '' AND slug = $1 AND archived = FALSE" (translation-page-slug))) (if markdown (parse-overrides markdown) (hash)))))))