gemfedwiki

index.js (4818B)

---

 const request = require('superagent')
 const fs = require('fs')
 const {createServer} = require('@derhuerst/gemini')
 
 function slugify(text)
 {
 	return text.replace(/\s/g, '-').replace(/[^A-Za-z0-9-]/g, '').toLowerCase()
 }
 
 function consume_until(cursor, c)
 {
 	for (; cursor.pos < cursor.str.length; cursor.pos++) {
 		if (cursor.str[cursor.pos] == c[0])
 			return true
 	}
 	return false
 }
 
 function pull_char(cursor)
 {
 	if (cursor.pos >= cursor.str.length)
 		return null
 	return cursor.str[cursor.pos++]
 }
 
 function consume_char(cursor, match)
 {
 	return pull_char(cursor) === match[0]
 }
 
 function parse_slug_link(cursor, links, root, start)
 {
 	let i = cursor.pos
 	if (!consume_until(cursor, ']')) return false
 	const name = cursor.str.slice(i, cursor.pos)
 	const url = `${root}/${slugify(name)}`
 	if (!consume_char(cursor, ']')) return false
 	if (!consume_char(cursor, ']')) return false
 	const orig = cursor.str.slice(start, cursor.pos)
 	links.push({name, url, orig})
 	return true
 }
 
 function consume_whitespace(cursor)
 {
 	for (; cursor.pos < cursor.str.length; cursor.pos++) {
 		if (cursor.str[cursor.pos] !== ' ')
 			return;
 	}
 }
 
 function parse_external_link(cursor, links, start)
 {
 	consume_whitespace(cursor)
 	let i = cursor.pos
 
 	for (; cursor.pos < cursor.str.length; cursor.pos++) {
 		if (cursor.str[cursor.pos] === ']')
 			return false;
 		if (cursor.str[cursor.pos] === ' ')
 			break
 	}
 
 	url = cursor.str.slice(i, cursor.pos++)
 	i = cursor.pos
 
 	if (!consume_until(cursor, "]")) return false
 	name = cursor.str.slice(i, cursor.pos++).trim()
 
 	const orig = cursor.str.slice(start, cursor.pos)
 
 	links.push({ name, url, orig })
 	return true
 }
 
 function parse_link(cursor, links, root)
 {
 	let c, i, url, name
 
 	let start = cursor.pos
 
 	if (!consume_char(cursor, "["))
 		return false
 
 	if ((c = pull_char(cursor)) && c == '[')
 		return parse_slug_link(cursor, links, root, start)
 
 	cursor.pos--
 	return parse_external_link(cursor, links, start)
 }
 
 function parse_links(text, root)
 {
 	let cursor = {pos: 0, str: text}
 	let links = []
 
 	for (; cursor.pos < cursor.str.length;) {
 		if (!consume_until(cursor, "["))
 			return links
 
 		if (!parse_link(cursor, links, root))
 			continue
 	}
 
 	return links
 }
 
 function process_item(root, lines, item)
 {
 	let first = true;
 	let i = 0
 
 	if (item.type === 'paragraph' || item.type === 'markdown' || item.type === 'html') {
 		const text = item.text.replace(/\n/g, " ").trim()
 		const links = parse_links(text, root)
 
 		lines.push('')
 		lines.push(text)
 		i = lines.length-1
 
 		if (links.length !== 0)
 			lines.push('')
 
 		for (const {url, name, orig} of links) {
 			lines[i] = lines[i].replace(orig, name)
 			if (lines[i] === name)
 				// just remove it if it's the same as the link
 				lines.splice(i, 2)
 			lines.push(`=> ${url} ${name}`)
 		}
 
 	}
 }
 
 function get_forks(journal)
 {
 	let forks = []
 	for (const item of journal)
 	{
 		if (item.type === "fork" && item.site)
 			forks.push(item.site)
 	}
 
 	return forks
 }
 
 function fedwiki2gmi(root, article)
 {
 	let lines = []
 	lines.push(`# ${article.title}`)
 
 	//const forks = get_fork(article.journal)
 	//root = fork || root
 
 	for (const item of article.story) {
 		process_item(root, lines, item)
 	}
 
 	return lines.join("\n") + "\n"
 }
 
 function last(arr)
 {
 	if (arr.length === 0)
 		return null
 	return arr[arr.length - 1]
 }
 
 async function make_request(json_url, root="")
 {
 	const res = await request.get(json_url)
 	return fedwiki2gmi(root, res.body)
 }
 
 async function make_index_request(host, root="")
 {
 	const res = await request.get(host + '/')
 	const file = last(res.redirects)
 	const json = file.replace(/.html$/, ".json")
 	return await make_request(json, root)
 }
 
 async function handle_request(req, res)
 {
 	console.log(req.path)
 
 	if (!req.path || req.path === "" || req.path === "/") {
 		fs.readFile("index.gmi", (err, dat) => {
 			res.sendHeader(20, 'text/gemini')
 			res.end(dat)
 		})
 		return
 	}
 
 	const indreq = req.path.match(/^\/([^/]+)\/?$/)
 	if (indreq) {
 		try {
 			const gmi = await make_index_request(indreq[1], "/" + indreq[1])
 			res.sendHeader(20, 'text/gemini')
 			return res.end(gmi)
 		} catch (e) {
 			if (e.status === 404)
 				return res.notFound()
 			else
 				return crashed(res, e)
 		}
 	}
 
 	const pathreq = req.path.match(/\/([^/]+)\/(.*)$/)
 	if (!pathreq) return res.gone()
 
 	const host = pathreq[1]
 	const slug = pathreq[2]
 
 	const url = host + "/" + slug + ".json"
 	try {
 		const gmi = await make_request(url, "/" + host)
 		res.sendHeader(20, 'text/gemini')
 		return res.end(gmi)
 	} catch (e) {
 		if (e.status === 404)
 			return res.notFound()
 		else
 			return crashed(res, e)
 	}
 }
 
 function crashed(res, err)
 {
 	console.log(err)
 	res.sendHeader(40)
 	return res.end()
 }
 
 function serve(opts)
 {
 	// opts = { cert, key, passphrase }
 	return createServer(opts, handle_request)
 }
 
 module.exports = serve