X-Git-Url: https://git.r.bdr.sh/rbdr/blog/blobdiff_plain/cf6302904d61ead65e6294e7f1be406eb68ef5f9..b0c3bb911306b2468152cf8a83c28eca843b7647:/lib/blog.js diff --git a/lib/blog.js b/lib/blog.js index 483577f..fd5adaf 100644 --- a/lib/blog.js +++ b/lib/blog.js @@ -1,39 +1,45 @@ 'use strict'; -const Fs = require('fs'); -const Markdown = require('markdown'); -const Mustache = require('mustache'); -const Ncp = require('ncp'); -const Path = require('path'); -const Rimraf = require('rimraf'); -const Util = require('util'); +const { access, cp, mkdir, readdir, readFile, writeFile } = require('fs/promises'); +const { exec } = require('child_process'); +const { basename, resolve, join } = require('path'); +const ParseGemini = require('gemini-to-html/parse'); +const RenderGemini = require('gemini-to-html/render'); +const { debuglog, promisify } = require('util'); +const { ensureDirectoryExists, rmIfExists } = require('./utils'); +const { kFileNotFoundError } = require('./constants'); + +// Generators for the Blog + +const StaticGenerator = require('./generators/static'); +const HTMLGenerator = require('./generators/html'); +const RSSGenerator = require('./generators/rss'); +const TXTGenerator = require('./generators/txt'); + +// Archiving Methods + +const GemlogArchiver = require('./archivers/gemlog'); + +// Remote Handler + +const Remote = require('./remote'); const internals = { // Promisified functions + exec: promisify(exec), - fs: { - access: Util.promisify(Fs.access), - mkdir: Util.promisify(Fs.mkdir), - readdir: Util.promisify(Fs.readdir), - readFile: Util.promisify(Fs.readFile), - writeFile: Util.promisify(Fs.writeFile) - }, - ncp: Util.promisify(Ncp.ncp), - rimraf: Util.promisify(Rimraf), - debuglog: Util.debuglog('blog'), + debuglog: debuglog('blog'), // constants - kAssetsDirectoryName: 'assets', - kIndexName: 'index.html', - kFileNotFoundError: 'ENOENT', - kMarkdownRe: /\.md$/i, + kGeminiRe: /\.gmi$/i, + kMetadataFilename: 'metadata.json', // Strings strings: { - markdownNotFound: 'Markdown file was not found in blog directory. Please update.' + geminiNotFound: 'Gemini file was not found in blog directory. Please update.' } }; @@ -42,7 +48,7 @@ const internals = { * updating posts, and handling the publishing. * * @class Blog - * @param {Potluck.tConfiguration} config the initialization options to + * @param {Blog.tConfiguration} config the initialization options to * extend the instance */ module.exports = class Blog { @@ -65,8 +71,16 @@ module.exports = class Blog { */ async add(postLocation) { + await ensureDirectoryExists(this.postsDirectory); + try { + await this.syncDown(); + } + catch {}; await this._shift(); - await this.update(postLocation); + const firstDirectory = join(this.postsDirectory, '0'); + await rmIfExists(firstDirectory); + await ensureDirectoryExists(firstDirectory); + await this._update(postLocation); } /** @@ -81,8 +95,11 @@ module.exports = class Blog { */ async update(postLocation) { - await this._copyPost(postLocation); - await this._generate(); + try { + await this.syncDown(); + } + catch {}; + const metadata = await this._update(); } /** @@ -93,70 +110,218 @@ module.exports = class Blog { * @return {Promise} empty promise, returns no value * @instance */ - async publish() { + async publish(bucket) { + + internals.debuglog(`Publishing to ${bucket}`); + try { + await internals.exec('which aws'); + } + catch (err) { + console.error('Please install and configure AWS CLI to publish.'); + } - console.error('Publishing not yet implemented'); + try { + await internals.exec(`aws s3 sync --acl public-read --delete ${this.staticDirectory} s3://${bucket}`); + await internals.exec(`aws s3 cp --content-type 'text/plain; charset=utf-8 ' --acl public-read ${this.staticDirectory}/index.txt s3://${bucket}`); + } + catch (err) { + console.error('Failed to publish'); + console.error(err.stderr); + } + + internals.debuglog('Finished publishing'); } - // Parses markdown for each page, copies assets and generates index. + /** + * Publishes the archive to a host using rsync. Currently assumes + * gemlog archive. + * + * @function publishArchive + * @memberof Blog + * @return {Promise} empty promise, returns no value + * @instance + */ + async publishArchive(host) { - async _generate() { + internals.debuglog(`Publishing archive to ${host}`); + try { + await internals.exec('which rsync'); + } + catch (err) { + console.error('Please install rsync to publish the archive.'); + } - const assetsTarget = Path.join(this.staticDirectory, internals.kAssetsDirectoryName); - const indexTarget = Path.join(this.staticDirectory, internals.kIndexName); - const indexLocation = Path.join(this.templatesDirectory, internals.kIndexName); - const posts = []; + try { + const gemlogPath = resolve(join(__dirname, '../', '.gemlog')); + internals.debuglog(`Reading archive from ${gemlogPath}`); + await internals.exec(`rsync -r ${gemlogPath}/ ${host}`); + } + catch (err) { + console.error('Failed to publish archive'); + console.error(err.stderr); + } - internals.debuglog(`Removing ${assetsTarget}`); - await internals.rimraf(assetsTarget); + internals.debuglog('Finished publishing'); + } - for (let i = 0; i < this.maxPosts; ++i) { - const sourcePath = Path.join(this.postsDirectory, `${i}`); - const assetsSource = Path.join(sourcePath, internals.kAssetsDirectoryName); - const postContentPath = await this._findBlogContent(sourcePath); + /** + * Adds a remote + * + * @function addRemote + * @memberof Blog + * @return {Promise} empty promise, returns no value + * @instance + */ + async addRemote(remote) { + await Remote.add(this.remoteConfig, remote) + } + + /** + * Removes a remote + * + * @function removeRemote + * @memberof Blog + * @return {Promise} empty promise, returns no value + * @instance + */ + async removeRemote() { + await Remote.remove(this.remoteConfig) + } - internals.debuglog(`Copying ${assetsSource} to ${assetsTarget}`); - await internals.ncp(assetsSource, assetsTarget); - internals.debuglog(`Reading ${postContentPath}`); - const postContent = await internals.fs.readFile(postContentPath, { encoding: 'utf8' }); + /** + * Pulls the posts and archive from the remote + * + * @function syncDown + * @memberof Blog + * @return {Promise} empty promise, returns no value + * @instance + */ + async syncDown() { + internals.debuglog('Pulling remote state'); + await ensureDirectoryExists(this.postsDirectory); + await Remote.syncDown(this.remoteConfig, this.blogDirectory) + internals.debuglog('Pulled remote state'); + } + + /** + * Pushes the posts and archive to the remote + * + * @function syncUp + * @memberof Blog + * @return {Promise} empty promise, returns no value + * @instance + */ + async syncUp() { + internals.debuglog('Pushing remote state'); + await ensureDirectoryExists(this.postsDirectory); + await Remote.syncUp(this.remoteConfig, this.blogDirectory) + internals.debuglog('Pushed remote state'); + } + + // Adds the passed path to slot 0, and generates files. + + async _update(postLocation) { + + const metadata = await this._getMetadata(); + await ensureDirectoryExists(this.postsDirectory); + await this._copyPost(postLocation); + await this._writeMetadata(metadata); - internals.debuglog('Parsing markdown'); - posts.push({ - html: Markdown.markdown.toHTML(postContent), - id: i + 1 - }); + await this._archive(postLocation); + + await this.generate(); + try { + await this.syncUp(); } + catch {}; + } + + + // Parses Gemini for each page, copies assets and generates index. + + async generate() { + + internals.debuglog('Generating output'); + + const posts = await this._readPosts(); - internals.debuglog(`Reading ${indexLocation}`); - const indexTemplate = await internals.fs.readFile(indexLocation, { encoding: 'utf8' }); + await StaticGenerator(this.postsDirectory, this.staticDirectory, posts); + await HTMLGenerator(this.templatesDirectory, this.staticDirectory, posts); + await RSSGenerator(this.templatesDirectory, this.staticDirectory, posts); + await TXTGenerator(this.templatesDirectory, this.staticDirectory, posts); - internals.debuglog('Generating HTML'); - const indexHtml = Mustache.render(indexTemplate, { posts }); - await internals.fs.writeFile(indexTarget, indexHtml); + await GemlogArchiver(this.archiveDirectory); + } + + // Reads the posts into an array + + async _readPosts() { + + internals.debuglog('Reading posts'); + const posts = []; + + for (let i = 0; i < this.maxPosts; ++i) { + try { + posts.push(await this._readPost(i)); + } + catch (error) { + if (error.code === kFileNotFoundError) { + internals.debuglog(`Skipping ${i}`); + continue; + } + + throw error; + } + } + + return posts; + } + + // Reads an individual post + + async _readPost(index=0) { + const postSourcePath = join(this.postsDirectory, `${index}`); + + internals.debuglog(`Reading ${postSourcePath}`); + + await access(postSourcePath); + + const metadata = await this._getMetadata(index); + + const postContentPath = await this._findBlogContent(postSourcePath); + internals.debuglog(`Reading ${postContentPath}`); + const postContent = await readFile(postContentPath, { encoding: 'utf8' }); + + internals.debuglog('Parsing Gemini'); + return { + ...metadata, + location: postSourcePath, + index, + html: RenderGemini(ParseGemini(postContent)), + raw: postContent + }; } // Shift the posts, delete any remainder. async _shift() { - await this._ensurePostsDirectoryExists(); - for (let i = this.maxPosts - 1; i > 0; --i) { - const targetPath = Path.join(this.postsDirectory, `${i}`); - const sourcePath = Path.join(this.postsDirectory, `${i - 1}`); + for (let i = this.maxPosts - 1; i >= 1; --i) { + const targetPath = join(this.postsDirectory, `${i}`); + const sourcePath = join(this.postsDirectory, `${i - 1}`); try { - await internals.fs.access(sourcePath); - - internals.debuglog(`Removing ${targetPath}`); - await internals.rimraf(targetPath); + internals.debuglog(`Archiving ${targetPath}`); + await rmIfExists(targetPath); + await access(sourcePath); // check the source path internals.debuglog(`Shifting blog post ${sourcePath} to ${targetPath}`); - await internals.ncp(sourcePath, targetPath); + await cp(sourcePath, targetPath, { recursive: true }); } catch (error) { - if (error.code === internals.kFileNotFoundError) { + if (error.code === kFileNotFoundError) { internals.debuglog(`Skipping ${sourcePath}: Does not exist.`); continue; } @@ -166,55 +331,86 @@ module.exports = class Blog { } } - // Copies a post directory to the latest slot. + // Moves older posts to the archive - async _copyPost(postLocation) { - - await this._ensurePostsDirectoryExists(); + async _archive() { + internals.debuglog('Archiving post'); + const post = await this._readPost(0); + await ensureDirectoryExists(this.archiveDirectory); - const targetPath = Path.join(this.postsDirectory, '0'); + const targetPath = join(this.archiveDirectory, post.id); internals.debuglog(`Removing ${targetPath}`); - await internals.rimraf(targetPath); - - internals.debuglog(`Adding ${postLocation} to ${targetPath}`); - await internals.ncp(postLocation, targetPath); + await rmIfExists(targetPath); + internals.debuglog(`Adding ${post.location} to ${targetPath}`); + await ensureDirectoryExists(targetPath); + await cp(post.location, targetPath, { recursive: true }); + internals.debuglog(`Added ${post.location} to ${targetPath}`); } - // Ensures the posts directory exists. + // Attempts to read existing metadata. Otherwise generates new set. - async _ensurePostsDirectoryExists() { + async _getMetadata(index = 0) { + + const metadataTarget = join(this.postsDirectory, String(index), internals.kMetadataFilename); - internals.debuglog(`Checking if ${this.postsDirectory} exists.`); try { - await internals.fs.access(this.postsDirectory); + internals.debuglog(`Looking for metadata at ${metadataTarget}`); + return JSON.parse(await readFile(metadataTarget, { encoding: 'utf8' })); } - catch (error) { - if (error.code === internals.kFileNotFoundError) { - internals.debuglog('Creating posts directory'); - await internals.fs.mkdir(this.postsDirectory); - return; - } - - throw error; + catch (e) { + internals.debuglog(`Metadata not found or unreadable. Generating new set.`); + const createdOn = Date.now(); + const metadata = { + id: String(createdOn), + createdOn + }; + + return metadata; } } - // Looks for a `.md` file in the blog directory, and returns the path + // Writes metadata. Assumes post 0 since it only gets written + // on create + + async _writeMetadata(metadata) { + + const metadataTarget = join(this.postsDirectory, '0', internals.kMetadataFilename); + internals.debuglog(`Writing ${metadataTarget}`); + await writeFile(metadataTarget, JSON.stringify(metadata, null, 2)); + } + + // Copies a post directory to the latest slot. + + async _copyPost(postLocation) { + + const targetPath = join(this.postsDirectory, '0'); + const postName = basename(postLocation); + const targetPost = join(targetPath, postName); + + internals.debuglog(`Removing ${targetPath}`); + await rmIfExists(targetPath); + await ensureDirectoryExists(targetPath); + internals.debuglog(`Adding ${postLocation} to ${targetPost}`); + await cp(postLocation, targetPost, { recursive: true }); + internals.debuglog(`Added ${postLocation} to ${targetPath}`); + } + + // Looks for a `.gmi` file in the blog directory, and returns the path async _findBlogContent(directory) { - const entries = await internals.fs.readdir(directory); + const entries = await readdir(directory); - const markdownEntries = entries - .filter((entry) => internals.kMarkdownRe.test(entry)) - .map((entry) => Path.join(directory, entry)); + const geminiEntries = entries + .filter((entry) => internals.kGeminiRe.test(entry)) + .map((entry) => join(directory, entry)); - if (markdownEntries.length > 0) { - internals.debuglog(`Found markdown file: ${markdownEntries[0]}`); - return markdownEntries[0]; + if (geminiEntries.length > 0) { + internals.debuglog(`Found gemini file: ${geminiEntries[0]}`); + return geminiEntries[0]; } - throw new Error(internals.strings.markdownNotFound); + throw new Error(internals.strings.geminiNotFound); } };