]> git.r.bdr.sh - rbdr/blog/blame_incremental - lib/blog.js
Assorted fixes
[rbdr/blog] / lib / blog.js
... / ...
CommitLineData
1'use strict';
2
3const { access, mkdir, readdir, readFile, rm, writeFile } = require('fs/promises');
4const { exec } = require('child_process');
5const { ncp } = require('ncp');
6const { basename, resolve, join } = require('path');
7const ParseGemini = require('gemini-to-html/parse');
8const RenderGemini = require('gemini-to-html/render');
9const { debuglog, promisify } = require('util');
10
11// Generators for the Blog
12
13const StaticGenerator = require('./generators/static');
14const HTMLGenerator = require('./generators/html');
15const RSSGenerator = require('./generators/rss');
16const TXTGenerator = require('./generators/txt');
17
18// Archiving Methods
19
20const GemlogArchiver = require('./archivers/gemlog');
21
22const internals = {
23
24 // Promisified functions
25 exec: promisify(exec),
26 ncp: promisify(ncp),
27
28 debuglog: debuglog('blog'),
29
30 // constants
31
32 kFileNotFoundError: 'ENOENT',
33 kGeminiRe: /\.gmi$/i,
34 kMetadataFilename: 'metadata.json',
35
36 // Strings
37
38 strings: {
39 geminiNotFound: 'Gemini file was not found in blog directory. Please update.'
40 }
41};
42
43/**
44 * The Blog class is the blog generator, it's in charge of adding and
45 * updating posts, and handling the publishing.
46 *
47 * @class Blog
48 * @param {Blog.tConfiguration} config the initialization options to
49 * extend the instance
50 */
51module.exports = class Blog {
52
53 constructor(config) {
54
55 Object.assign(this, config);
56 }
57
58 /**
59 * Shifts the blog posts, adds the passed path to slot 0, and
60 * generates files.
61 *
62 * @function add
63 * @memberof Blog
64 * @param {string} postLocation the path to the directory containing
65 * the post structure
66 * @return {Promise<undefined>} empty promise, returns no value
67 * @instance
68 */
69 async add(postLocation) {
70
71 await this._ensurePostsDirectoryExists();
72 await this._shift();
73 await this._ensurePostsDirectoryExists(join(this.postsDirectory, '0'));
74 await this.update(postLocation);
75 }
76
77 /**
78 * Adds the passed path to slot 0, and generates files.
79 *
80 * @function update
81 * @memberof Blog
82 * @param {string} postLocation the path to the directory containing
83 * the post structure
84 * @return {Promise<undefined>} empty promise, returns no value
85 * @instance
86 */
87 async update(postLocation) {
88
89 const metadata = await this._getMetadata();
90 await this._ensurePostsDirectoryExists();
91 await this._copyPost(postLocation);
92 await this._writeMetadata(metadata);
93
94 await this._archive(postLocation);
95
96 await this.generate();
97 }
98
99 /**
100 * Publishes the files to a static host.
101 *
102 * @function publish
103 * @memberof Blog
104 * @return {Promise<undefined>} empty promise, returns no value
105 * @instance
106 */
107 async publish(bucket) {
108
109 internals.debuglog(`Publishing to ${bucket}`);
110 try {
111 await internals.exec('which aws');
112 }
113 catch (err) {
114 console.error('Please install and configure AWS CLI to publish.');
115 }
116
117 try {
118 await internals.exec(`aws s3 sync --acl public-read --delete ${this.staticDirectory} s3://${bucket}`);
119 await internals.exec(`aws s3 cp --content-type 'text/plain; charset=utf-8 ' --acl public-read ${this.staticDirectory}/index.txt s3://${bucket}`);
120 }
121 catch (err) {
122 console.error('Failed to publish');
123 console.error(err.stderr);
124 }
125
126 internals.debuglog('Finished publishing');
127 }
128
129 /**
130 * Publishes the archive to a host using rsync. Currently assumes
131 * gemlog archive.
132 *
133 * @function publishArchive
134 * @memberof Blog
135 * @return {Promise<undefined>} empty promise, returns no value
136 * @instance
137 */
138 async publishArchive(host) {
139
140 internals.debuglog(`Publishing archive to ${host}`);
141 try {
142 await internals.exec('which rsync');
143 }
144 catch (err) {
145 console.error('Please install rsync to publish the archive.');
146 }
147
148 try {
149 const gemlogPath = resolve(join(__dirname, '../', '.gemlog'));
150 internals.debuglog(`Reading archive from ${gemlogPath}`);
151 await internals.exec(`rsync -r ${gemlogPath}/ ${host}`);
152 }
153 catch (err) {
154 console.error('Failed to publish archive');
155 console.error(err.stderr);
156 }
157
158 internals.debuglog('Finished publishing');
159 }
160
161 // Parses Gemini for each page, copies assets and generates index.
162
163 async generate() {
164
165 internals.debuglog('Generating output');
166
167 const posts = await this._readPosts();
168
169 await StaticGenerator(this.postsDirectory, this.staticDirectory, posts);
170 await HTMLGenerator(this.templatesDirectory, this.staticDirectory, posts);
171 await RSSGenerator(this.templatesDirectory, this.staticDirectory, posts);
172 await TXTGenerator(this.templatesDirectory, this.staticDirectory, posts);
173
174 await GemlogArchiver(this.archiveDirectory);
175 }
176
177 // Reads the posts into an array
178
179 async _readPosts() {
180
181 internals.debuglog('Reading posts');
182 const posts = [];
183
184 for (let i = 0; i < this.maxPosts; ++i) {
185 try {
186 posts.push(await this._readPost(i));
187 }
188 catch (error) {
189 if (error.code === internals.kFileNotFoundError) {
190 internals.debuglog(`Skipping ${i}`);
191 continue;
192 }
193
194 throw error;
195 }
196 }
197
198 return posts;
199 }
200
201 // Reads an individual post
202
203 async _readPost(index=0) {
204 const postSourcePath = join(this.postsDirectory, `${index}`);
205
206 internals.debuglog(`Reading ${postSourcePath}`);
207
208 await access(postSourcePath);
209
210 const metadata = await this._getMetadata(index);
211
212 const postContentPath = await this._findBlogContent(postSourcePath);
213 internals.debuglog(`Reading ${postContentPath}`);
214 const postContent = await readFile(postContentPath, { encoding: 'utf8' });
215
216 internals.debuglog('Parsing Gemini');
217 return {
218 ...metadata,
219 location: postSourcePath,
220 index,
221 html: RenderGemini(ParseGemini(postContent)),
222 raw: postContent
223 };
224 }
225
226 // Shift the posts, delete any remainder.
227
228 async _shift() {
229
230
231 for (let i = this.maxPosts - 1; i >= 1; --i) {
232 const targetPath = join(this.postsDirectory, `${i}`);
233 const sourcePath = join(this.postsDirectory, `${i - 1}`);
234
235 try {
236 internals.debuglog(`Archiving ${targetPath}`);
237 await rm(targetPath, { recursive: true, force: true });
238 await access(sourcePath); // check the source path
239
240 internals.debuglog(`Shifting blog post ${sourcePath} to ${targetPath}`);
241 await internals.ncp(sourcePath, targetPath);
242 }
243 catch (error) {
244 if (error.code === internals.kFileNotFoundError) {
245 internals.debuglog(`Skipping ${sourcePath}: Does not exist.`);
246 continue;
247 }
248
249 throw error;
250 }
251 }
252 }
253
254 // Moves older posts to the archive
255
256 async _archive() {
257 internals.debuglog('Archiving post');
258 const post = await this._readPost(0);
259 await this._ensureDirectoryExists(this.archiveDirectory);
260
261 const targetPath = join(this.archiveDirectory, post.id);
262
263 try {
264 internals.debuglog(`Removing ${targetPath}`);
265 await rm(targetPath, { recursive: true });
266 }
267 finally {
268 internals.debuglog(`Adding ${post.location} to ${targetPath}`);
269 await this._ensureDirectoryExists(targetPath);
270 await internals.ncp(post.location, targetPath);
271 internals.debuglog(`Added ${post.location} to ${targetPath}`);
272 }
273 }
274
275 // Attempts to read existing metadata. Otherwise generates new set.
276
277 async _getMetadata(index = 0) {
278
279 const metadataTarget = join(this.postsDirectory, String(index), internals.kMetadataFilename);
280
281 try {
282 internals.debuglog(`Looking for metadata at ${metadataTarget}`);
283 return JSON.parse(await readFile(metadataTarget, { encoding: 'utf8' }));
284 }
285 catch (e) {
286 internals.debuglog(`Metadata not found or unreadable. Generating new set.`);
287 const createdOn = Date.now();
288 const metadata = {
289 id: String(createdOn),
290 createdOn
291 };
292
293 return metadata;
294 }
295 }
296
297 // Writes metadata. Assumes post 0 since it only gets written
298 // on create
299
300 async _writeMetadata(metadata) {
301
302 const metadataTarget = join(this.postsDirectory, '0', internals.kMetadataFilename);
303 internals.debuglog(`Writing ${metadataTarget}`);
304 await writeFile(metadataTarget, JSON.stringify(metadata, null, 2));
305 }
306
307 // Copies a post directory to the latest slot.
308
309 async _copyPost(postLocation) {
310
311 const targetPath = join(this.postsDirectory, '0');
312 const postName = basename(postLocation);
313 const targetPost = join(targetPath, postName);
314
315 internals.debuglog(`Removing ${targetPath}`);
316 try {
317 await rm(targetPath, { recursive: true });
318 }
319 finally {
320 await this._ensureDirectoryExists(targetPath);
321 internals.debuglog(`Adding ${postLocation} to ${targetPost}`);
322 await internals.ncp(postLocation, targetPost);
323 }
324 }
325
326 // Ensures a directory exists.
327
328 async _ensureDirectoryExists(directory) {
329
330 internals.debuglog(`Checking if ${directory} exists.`);
331 try {
332 await access(directory);
333 }
334 catch (error) {
335 if (error.code === internals.kFileNotFoundError) {
336 internals.debuglog(`Creating ${directory}`);
337 await mkdir(directory);
338 return;
339 }
340
341 throw error;
342 }
343 }
344
345 // Ensures posts directory exists
346
347 async _ensurePostsDirectoryExists() {
348
349 return this._ensureDirectoryExists(this.postsDirectory);
350 }
351
352 // Looks for a `.gmi` file in the blog directory, and returns the path
353
354 async _findBlogContent(directory) {
355
356 const entries = await readdir(directory);
357
358 const geminiEntries = entries
359 .filter((entry) => internals.kGeminiRe.test(entry))
360 .map((entry) => join(directory, entry));
361
362 if (geminiEntries.length > 0) {
363 internals.debuglog(`Found gemini file: ${geminiEntries[0]}`);
364 return geminiEntries[0];
365 }
366
367 throw new Error(internals.strings.geminiNotFound);
368 }
369};