commit b025e693d980e4bcc5a29e7b829dba01ec361bae Author: Mikko Ahlroth Date: Sun Sep 17 19:48:31 2023 +0300 WIP mess diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b592780 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +*.beam +*.ez +build +erl_crash.dump +/data +/static +/output diff --git a/.tool-versions b/.tool-versions new file mode 100644 index 0000000..bd2d3fd --- /dev/null +++ b/.tool-versions @@ -0,0 +1,2 @@ +nodejs 18.16.0 +gleam 0.30.2 diff --git a/README.md b/README.md new file mode 100644 index 0000000..e669f14 --- /dev/null +++ b/README.md @@ -0,0 +1,24 @@ +# pilkahdus + +[![Package Version](https://img.shields.io/hexpm/v/pilkahdus)](https://hex.pm/packages/pilkahdus) +[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/pilkahdus/) + +A Gleam project + +## Quick start + +```sh +gleam run # Run the project +gleam test # Run the tests +gleam shell # Run an Erlang shell +``` + +## Installation + +If available on Hex this package can be added to your Gleam project: + +```sh +gleam add pilkahdus +``` + +and its documentation can be found at . diff --git a/gleam.toml b/gleam.toml new file mode 100644 index 0000000..dd2c7f8 --- /dev/null +++ b/gleam.toml @@ -0,0 +1,12 @@ +name = "gloss" +version = "1.0.0" +description = "A static blog generator" +target = "javascript" +gleam = ">= 0.30.0" + +[dependencies] +gleam_stdlib = "~> 0.30" +glemplate = "~> 5.0" +gleam_javascript = "~> 0.4" + +[dev-dependencies] diff --git a/manifest.toml b/manifest.toml new file mode 100644 index 0000000..bfba47d --- /dev/null +++ b/manifest.toml @@ -0,0 +1,15 @@ +# This file was generated by Gleam +# You typically do not need to edit this file + +packages = [ + { name = "gleam_javascript", version = "0.4.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_javascript", source = "hex", outer_checksum = "E0E8D33461776BFCC124838183F85E430D3A71D7318F210C9DE0CFB52E5AC8DE" }, + { name = "gleam_stdlib", version = "0.30.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "03710B3DA047A3683117591707FCA19D32B980229DD8CE8B0603EB5B5144F6C3" }, + { name = "glemplate", version = "5.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib", "glentities", "nibble"], otp_app = "glemplate", source = "hex", outer_checksum = "48EB0FDD937B19460D8A095370515C1157632A8218539A77E73DDA208F193B46" }, + { name = "glentities", version = "5.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "glentities", source = "hex", outer_checksum = "4D3AE91ECB088C853302643C4F256BEF7B8F8EC7650A7DA6B2ACAF4550113BE2" }, + { name = "nibble", version = "0.2.3", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "nibble", source = "hex", outer_checksum = "C9EB428EAC11007414C2FBA5B39F0E8DB27FDAB26534F2AD607D5AA6FCF32559" }, +] + +[requirements] +gleam_javascript = { version = "~> 0.4" } +gleam_stdlib = { version = "~> 0.30" } +glemplate = { version = "~> 5.0" } diff --git a/package.json b/package.json new file mode 100644 index 0000000..6d8ddb1 --- /dev/null +++ b/package.json @@ -0,0 +1,16 @@ +{ + "name": "gloss", + "version": "1.0.0", + "description": "Glossy blog generator", + "repository": { + "type": "git", + "url": "git+https://gitlab.com/Nicd/gloss.git" + }, + "author": "Mikko Ahlroth ", + "license": "AGPL-3.0-or-later", + "bugs": { + "url": "https://gitlab.com/Nicd/gloss/issues" + }, + "homepage": "https://gitlab.com/Nicd/gloss#readme", + "private": true +} diff --git a/priv/templates/base.html.glemp b/priv/templates/base.html.glemp new file mode 100644 index 0000000..e113288 --- /dev/null +++ b/priv/templates/base.html.glemp @@ -0,0 +1,35 @@ + + + + + + + <%= title %> + + + + +

+ + <%= blog_name %> + +

+ +

+ <%= raw inner_content %> +

+ + + + + diff --git a/priv/templates/list.html.glemp b/priv/templates/list.html.glemp new file mode 100644 index 0000000..16ab4df --- /dev/null +++ b/priv/templates/list.html.glemp @@ -0,0 +1,11 @@ +

+ <% for post in posts %> + <% render "list_post.html.glemp" post: post, urls: urls %> + <% end %> + + +

diff --git a/priv/templates/list_post.html.glemp b/priv/templates/list_post.html.glemp new file mode 100644 index 0000000..8a7147d --- /dev/null +++ b/priv/templates/list_post.html.glemp @@ -0,0 +1,21 @@ +

+ <%= post.title %> +

+ +

+ <% if post.short_content %> + <%= raw post.short_content %> + + + Read more… + + <% else %> + <%= raw post.content %> + <% end %> +

+ + +

diff --git a/priv/templates/navigation.html.glemp b/priv/templates/navigation.html.glemp new file mode 100644 index 0000000..b361afa --- /dev/null +++ b/priv/templates/navigation.html.glemp @@ -0,0 +1,15 @@ +

+ <% if previous %> + « + <% else %> + + <% end %> +

+ +

+ <% if next %> + » + <% else %> + + <% end %> +

diff --git a/priv/templates/single_post.html.glemp b/priv/templates/single_post.html.glemp new file mode 100644 index 0000000..977abdc --- /dev/null +++ b/priv/templates/single_post.html.glemp @@ -0,0 +1,13 @@ +

+ <%= title %> +

+ +

+ <%= raw content %> +

+ + +

'
+        + (escaped ? code : escape(code, true))
+        + '

\n'; + } + + return '

'
+      + (escaped ? code : escape(code, true))
+      + '

\n'; + } + + /** + * @param {string} quote + */ + blockquote(quote) { + return `

\n${quote}

\n`; + } + + html(html, block) { + return html; + } + + /** + * @param {string} text + * @param {string} level + * @param {string} raw + * @param {any} slugger + */ + heading(text, level, raw, slugger) { + if (this.options.headerIds) { + const id = this.options.headerPrefix + slugger.slug(raw); + return `${text}\n`; + } + + // ignore IDs + return `${text}\n`; + } + + hr() { + return this.options.xhtml ? '

\n' : '

\n'; + } + + list(body, ordered, start) { + const type = ordered ? 'ol' : 'ul', + startatt = (ordered && start !== 1) ? (' start="' + start + '"') : ''; + return '<' + type + startatt + '>\n' + body + '\n'; + } + + /** + * @param {string} text + */ + listitem(text) { + return `

${text}

\n`; + } + + checkbox(checked) { + return ' '; + } + + /** + * @param {string} text + */ + paragraph(text) { + return `

${text}

\n`; + } + + /** + * @param {string} header + * @param {string} body + */ + table(header, body) { + if (body) body = `${body}`; + + return '\n' + + '\n' + + header + + '\n' + + body + + '

' : '>'; + return out; + } + + text(text) { + return text; + } +} + +/** + * TextRenderer + * returns only the textual part of the token + */ +class TextRenderer { + // no need for block level renderers + strong(text) { + return text; + } + + em(text) { + return text; + } + + codespan(text) { + return text; + } + + del(text) { + return text; + } + + html(text) { + return text; + } + + text(text) { + return text; + } + + link(href, title, text) { + return '' + text; + } + + image(href, title, text) { + return '' + text; + } + + br() { + return ''; + } +} + +/** + * Slugger generates header id + */ +class Slugger { + constructor() { + this.seen = {}; + } + + /** + * @param {string} value + */ + serialize(value) { + return value + .toLowerCase() + .trim() + // remove html tags + .replace(/<[!\/a-z].*?>/ig, '') + // remove unwanted chars + .replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, '') + .replace(/\s/g, '-'); + } + + /** + * Finds the next safe (unique) slug to use + * @param {string} originalSlug + * @param {boolean} isDryRun + */ + getNextSafeSlug(originalSlug, isDryRun) { + let slug = originalSlug; + let occurenceAccumulator = 0; + if (this.seen.hasOwnProperty(slug)) { + occurenceAccumulator = this.seen[originalSlug]; + do { + occurenceAccumulator++; + slug = originalSlug + '-' + occurenceAccumulator; + } while (this.seen.hasOwnProperty(slug)); + } + if (!isDryRun) { + this.seen[originalSlug] = occurenceAccumulator; + this.seen[slug] = 0; + } + return slug; + } + + /** + * Convert string to unique id + * @param {object} [options] + * @param {boolean} [options.dryrun] Generates the next unique slug without + * updating the internal accumulator. + */ + slug(value, options = {}) { + const slug = this.serialize(value); + return this.getNextSafeSlug(slug, options.dryrun); + } +} + +/** + * Parsing & Compiling + */ +class Parser { + constructor(options) { + this.options = options || defaults; + this.options.renderer = this.options.renderer || new Renderer(); + this.renderer = this.options.renderer; + this.renderer.options = this.options; + this.textRenderer = new TextRenderer(); + this.slugger = new Slugger(); + } + + /** + * Static Parse Method + */ + static parse(tokens, options) { + const parser = new Parser(options); + return parser.parse(tokens); + } + + /** + * Static Parse Inline Method + */ + static parseInline(tokens, options) { + const parser = new Parser(options); + return parser.parseInline(tokens); + } + + /** + * Parse Loop + */ + parse(tokens, top = true) { + let out = '', + i, + j, + k, + l2, + l3, + row, + cell, + header, + body, + token, + ordered, + start, + loose, + itemBody, + item, + checked, + task, + checkbox, + ret; + + const l = tokens.length; + for (i = 0; i < l; i++) { + token = tokens[i]; + + // Run any renderer extensions + if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) { + ret = this.options.extensions.renderers[token.type].call({ parser: this }, token); + if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(token.type)) { + out += ret || ''; + continue; + } + } + + switch (token.type) { + case 'space': { + continue; + } + case 'hr': { + out += this.renderer.hr(); + continue; + } + case 'heading': { + out += this.renderer.heading( + this.parseInline(token.tokens), + token.depth, + unescape(this.parseInline(token.tokens, this.textRenderer)), + this.slugger); + continue; + } + case 'code': { + out += this.renderer.code(token.text, + token.lang, + token.escaped); + continue; + } + case 'table': { + header = ''; + + // header + cell = ''; + l2 = token.header.length; + for (j = 0; j < l2; j++) { + cell += this.renderer.tablecell( + this.parseInline(token.header[j].tokens), + { header: true, align: token.align[j] } + ); + } + header += this.renderer.tablerow(cell); + + body = ''; + l2 = token.rows.length; + for (j = 0; j < l2; j++) { + row = token.rows[j]; + + cell = ''; + l3 = row.length; + for (k = 0; k < l3; k++) { + cell += this.renderer.tablecell( + this.parseInline(row[k].tokens), + { header: false, align: token.align[k] } + ); + } + + body += this.renderer.tablerow(cell); + } + out += this.renderer.table(header, body); + continue; + } + case 'blockquote': { + body = this.parse(token.tokens); + out += this.renderer.blockquote(body); + continue; + } + case 'list': { + ordered = token.ordered; + start = token.start; + loose = token.loose; + l2 = token.items.length; + + body = ''; + for (j = 0; j < l2; j++) { + item = token.items[j]; + checked = item.checked; + task = item.task; + + itemBody = ''; + if (item.task) { + checkbox = this.renderer.checkbox(checked); + if (loose) { + if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') { + item.tokens[0].text = checkbox + ' ' + item.tokens[0].text; + if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') { + item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text; + } + } else { + item.tokens.unshift({ + type: 'text', + text: checkbox + }); + } + } else { + itemBody += checkbox; + } + } + + itemBody += this.parse(item.tokens, loose); + body += this.renderer.listitem(itemBody, task, checked); + } + + out += this.renderer.list(body, ordered, start); + continue; + } + case 'html': { + out += this.renderer.html(token.text, token.block); + continue; + } + case 'paragraph': { + out += this.renderer.paragraph(this.parseInline(token.tokens)); + continue; + } + case 'text': { + body = token.tokens ? this.parseInline(token.tokens) : token.text; + while (i + 1 < l && tokens[i + 1].type === 'text') { + token = tokens[++i]; + body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text); + } + out += top ? this.renderer.paragraph(body) : body; + continue; + } + + default: { + const errMsg = 'Token with "' + token.type + '" type was not found.'; + if (this.options.silent) { + console.error(errMsg); + return; + } else { + throw new Error(errMsg); + } + } + } + } + + return out; + } + + /** + * Parse Inline Tokens + */ + parseInline(tokens, renderer) { + renderer = renderer || this.renderer; + let out = '', + i, + token, + ret; + + const l = tokens.length; + for (i = 0; i < l; i++) { + token = tokens[i]; + + // Run any renderer extensions + if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) { + ret = this.options.extensions.renderers[token.type].call({ parser: this }, token); + if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(token.type)) { + out += ret || ''; + continue; + } + } + + switch (token.type) { + case 'escape': { + out += renderer.text(token.text); + break; + } + case 'html': { + out += renderer.html(token.text); + break; + } + case 'link': { + out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer)); + break; + } + case 'image': { + out += renderer.image(token.href, token.title, token.text); + break; + } + case 'strong': { + out += renderer.strong(this.parseInline(token.tokens, renderer)); + break; + } + case 'em': { + out += renderer.em(this.parseInline(token.tokens, renderer)); + break; + } + case 'codespan': { + out += renderer.codespan(token.text); + break; + } + case 'br': { + out += renderer.br(); + break; + } + case 'del': { + out += renderer.del(this.parseInline(token.tokens, renderer)); + break; + } + case 'text': { + out += renderer.text(token.text); + break; + } + default: { + const errMsg = 'Token with "' + token.type + '" type was not found.'; + if (this.options.silent) { + console.error(errMsg); + return; + } else { + throw new Error(errMsg); + } + } + } + } + return out; + } +} + +class Hooks { + constructor(options) { + this.options = options || defaults; + } + + static passThroughHooks = new Set([ + 'preprocess', + 'postprocess' + ]); + + /** + * Process markdown before marked + */ + preprocess(markdown) { + return markdown; + } + + /** + * Process HTML after marked is finished + */ + postprocess(html) { + return html; + } +} + +class Marked { + defaults = getDefaults(); + options = this.setOptions; + + parse = this.#parseMarkdown(Lexer.lex, Parser.parse); + parseInline = this.#parseMarkdown(Lexer.lexInline, Parser.parseInline); + + Parser = Parser; + parser = Parser.parse; + Renderer = Renderer; + TextRenderer = TextRenderer; + Lexer = Lexer; + lexer = Lexer.lex; + Tokenizer = Tokenizer; + Slugger = Slugger; + Hooks = Hooks; + + constructor(...args) { + this.use(...args); + } + + walkTokens(tokens, callback) { + let values = []; + for (const token of tokens) { + values = values.concat(callback.call(this, token)); + switch (token.type) { + case 'table': { + for (const cell of token.header) { + values = values.concat(this.walkTokens(cell.tokens, callback)); + } + for (const row of token.rows) { + for (const cell of row) { + values = values.concat(this.walkTokens(cell.tokens, callback)); + } + } + break; + } + case 'list': { + values = values.concat(this.walkTokens(token.items, callback)); + break; + } + default: { + if (this.defaults.extensions && this.defaults.extensions.childTokens && this.defaults.extensions.childTokens[token.type]) { // Walk any extensions + this.defaults.extensions.childTokens[token.type].forEach((childTokens) => { + values = values.concat(this.walkTokens(token[childTokens], callback)); + }); + } else if (token.tokens) { + values = values.concat(this.walkTokens(token.tokens, callback)); + } + } + } + } + return values; + } + + use(...args) { + const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} }; + + args.forEach((pack) => { + // copy options to new object + const opts = { ...pack }; + + // set async to true if it was set to true before + opts.async = this.defaults.async || opts.async || false; + + // ==-- Parse "addon" extensions --== // + if (pack.extensions) { + pack.extensions.forEach((ext) => { + if (!ext.name) { + throw new Error('extension name required'); + } + if (ext.renderer) { // Renderer extensions + const prevRenderer = extensions.renderers[ext.name]; + if (prevRenderer) { + // Replace extension with func to run new extension but fall back if false + extensions.renderers[ext.name] = function(...args) { + let ret = ext.renderer.apply(this, args); + if (ret === false) { + ret = prevRenderer.apply(this, args); + } + return ret; + }; + } else { + extensions.renderers[ext.name] = ext.renderer; + } + } + if (ext.tokenizer) { // Tokenizer Extensions + if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) { + throw new Error("extension level must be 'block' or 'inline'"); + } + if (extensions[ext.level]) { + extensions[ext.level].unshift(ext.tokenizer); + } else { + extensions[ext.level] = [ext.tokenizer]; + } + if (ext.start) { // Function to check for start of token + if (ext.level === 'block') { + if (extensions.startBlock) { + extensions.startBlock.push(ext.start); + } else { + extensions.startBlock = [ext.start]; + } + } else if (ext.level === 'inline') { + if (extensions.startInline) { + extensions.startInline.push(ext.start); + } else { + extensions.startInline = [ext.start]; + } + } + } + } + if (ext.childTokens) { // Child tokens to be visited by walkTokens + extensions.childTokens[ext.name] = ext.childTokens; + } + }); + opts.extensions = extensions; + } + + // ==-- Parse "overwrite" extensions --== // + if (pack.renderer) { + const renderer = this.defaults.renderer || new Renderer(this.defaults); + for (const prop in pack.renderer) { + const prevRenderer = renderer[prop]; + // Replace renderer with func to run extension, but fall back if false + renderer[prop] = (...args) => { + let ret = pack.renderer[prop].apply(renderer, args); + if (ret === false) { + ret = prevRenderer.apply(renderer, args); + } + return ret; + }; + } + opts.renderer = renderer; + } + if (pack.tokenizer) { + const tokenizer = this.defaults.tokenizer || new Tokenizer(this.defaults); + for (const prop in pack.tokenizer) { + const prevTokenizer = tokenizer[prop]; + // Replace tokenizer with func to run extension, but fall back if false + tokenizer[prop] = (...args) => { + let ret = pack.tokenizer[prop].apply(tokenizer, args); + if (ret === false) { + ret = prevTokenizer.apply(tokenizer, args); + } + return ret; + }; + } + opts.tokenizer = tokenizer; + } + + // ==-- Parse Hooks extensions --== // + if (pack.hooks) { + const hooks = this.defaults.hooks || new Hooks(); + for (const prop in pack.hooks) { + const prevHook = hooks[prop]; + if (Hooks.passThroughHooks.has(prop)) { + hooks[prop] = (arg) => { + if (this.defaults.async) { + return Promise.resolve(pack.hooks[prop].call(hooks, arg)).then(ret => { + return prevHook.call(hooks, ret); + }); + } + + const ret = pack.hooks[prop].call(hooks, arg); + return prevHook.call(hooks, ret); + }; + } else { + hooks[prop] = (...args) => { + let ret = pack.hooks[prop].apply(hooks, args); + if (ret === false) { + ret = prevHook.apply(hooks, args); + } + return ret; + }; + } + } + opts.hooks = hooks; + } + + // ==-- Parse WalkTokens extensions --== // + if (pack.walkTokens) { + const walkTokens = this.defaults.walkTokens; + opts.walkTokens = function(token) { + let values = []; + values.push(pack.walkTokens.call(this, token)); + if (walkTokens) { + values = values.concat(walkTokens.call(this, token)); + } + return values; + }; + } + + this.defaults = { ...this.defaults, ...opts }; + }); + + return this; + } + + setOptions(opt) { + this.defaults = { ...this.defaults, ...opt }; + return this; + } + + #parseMarkdown(lexer, parser) { + return (src, opt, callback) => { + if (typeof opt === 'function') { + callback = opt; + opt = null; + } + + const origOpt = { ...opt }; + opt = { ...this.defaults, ...origOpt }; + const throwError = this.#onError(opt.silent, opt.async, callback); + + // throw error in case of non string input + if (typeof src === 'undefined' || src === null) { + return throwError(new Error('marked(): input parameter is undefined or null')); + } + if (typeof src !== 'string') { + return throwError(new Error('marked(): input parameter is of type ' + + Object.prototype.toString.call(src) + ', string expected')); + } + + checkDeprecations(opt, callback); + + if (opt.hooks) { + opt.hooks.options = opt; + } + + if (callback) { + const highlight = opt.highlight; + let tokens; + + try { + if (opt.hooks) { + src = opt.hooks.preprocess(src); + } + tokens = lexer(src, opt); + } catch (e) { + return throwError(e); + } + + const done = (err) => { + let out; + + if (!err) { + try { + if (opt.walkTokens) { + this.walkTokens(tokens, opt.walkTokens); + } + out = parser(tokens, opt); + if (opt.hooks) { + out = opt.hooks.postprocess(out); + } + } catch (e) { + err = e; + } + } + + opt.highlight = highlight; + + return err + ? throwError(err) + : callback(null, out); + }; + + if (!highlight || highlight.length < 3) { + return done(); + } + + delete opt.highlight; + + if (!tokens.length) return done(); + + let pending = 0; + this.walkTokens(tokens, (token) => { + if (token.type === 'code') { + pending++; + setTimeout(() => { + highlight(token.text, token.lang, (err, code) => { + if (err) { + return done(err); + } + if (code != null && code !== token.text) { + token.text = code; + token.escaped = true; + } + + pending--; + if (pending === 0) { + done(); + } + }); + }, 0); + } + }); + + if (pending === 0) { + done(); + } + + return; + } + + if (opt.async) { + return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src) + .then(src => lexer(src, opt)) + .then(tokens => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens) + .then(tokens => parser(tokens, opt)) + .then(html => opt.hooks ? opt.hooks.postprocess(html) : html) + .catch(throwError); + } + + try { + if (opt.hooks) { + src = opt.hooks.preprocess(src); + } + const tokens = lexer(src, opt); + if (opt.walkTokens) { + this.walkTokens(tokens, opt.walkTokens); + } + let html = parser(tokens, opt); + if (opt.hooks) { + html = opt.hooks.postprocess(html); + } + return html; + } catch (e) { + return throwError(e); + } + }; + } + + #onError(silent, async, callback) { + return (e) => { + e.message += '\nPlease report this to https://github.com/markedjs/this.'; + + if (silent) { + const msg = '

An error occurred:

'
+          + escape(e.message + '', true)
+          + '