]> git.r.bdr.sh - rbdr/blog/blob - lib/blog.js
8ae3e21a28884f1b091b1f3e4d221d0543481cf8
[rbdr/blog] / lib / blog.js
1 'use strict';
2
3 const { access, mkdir, readdir, readFile, rm, writeFile } = require('fs/promises');
4 const { exec } = require('child_process');
5 const { ncp } = require('ncp');
6 const { join } = require('path');
7 const ParseGemini = require('gemini-to-html/parse');
8 const RenderGemini = require('gemini-to-html/render');
9 const { debuglog, promisify } = require('util');
10
11 // Generators for the Blog
12
13 const StaticGenerator = require('./generators/static');
14 const HTMLGenerator = require('./generators/html');
15 const RSSGenerator = require('./generators/rss');
16 const TXTGenerator = require('./generators/txt');
17
18 // Archiving Methods
19
20 const GemlogArchiver = require('./archivers/gemlog');
21
22 const 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 */
51 module.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 mkdir(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 // Parses Gemini for each page, copies assets and generates index.
130
131 async generate() {
132
133 internals.debuglog('Generating output');
134
135 const posts = await this._readPosts();
136
137 await StaticGenerator(this.postsDirectory, this.staticDirectory, posts);
138 await HTMLGenerator(this.templatesDirectory, this.staticDirectory, posts);
139 await RSSGenerator(this.templatesDirectory, this.staticDirectory, posts);
140 await TXTGenerator(this.templatesDirectory, this.staticDirectory, posts);
141
142 await GemlogArchiver(this.archiveDirectory);
143 }
144
145 // Reads the posts into an array
146
147 async _readPosts() {
148
149 internals.debuglog('Reading posts');
150 const posts = [];
151
152 for (let i = 0; i < this.maxPosts; ++i) {
153 try {
154 posts.push(await this._readPost(i));
155 }
156 catch (error) {
157 if (error.code === internals.kFileNotFoundError) {
158 internals.debuglog(`Skipping ${i}`);
159 continue;
160 }
161
162 throw error;
163 }
164 }
165
166 return posts;
167 }
168
169 // Reads an individual post
170
171 async _readPost(index=0) {
172 const postSourcePath = join(this.postsDirectory, `${index}`);
173
174 internals.debuglog(`Reading ${postSourcePath}`);
175
176 await access(postSourcePath);
177
178 const metadata = await this._getMetadata(index);
179
180 const postContentPath = await this._findBlogContent(postSourcePath);
181 internals.debuglog(`Reading ${postContentPath}`);
182 const postContent = await readFile(postContentPath, { encoding: 'utf8' });
183
184 internals.debuglog('Parsing Gemini');
185 return {
186 ...metadata,
187 location: postSourcePath,
188 index,
189 html: RenderGemini(ParseGemini(postContent)),
190 raw: postContent
191 };
192 }
193
194 // Shift the posts, delete any remainder.
195
196 async _shift() {
197
198
199 for (let i = this.maxPosts - 1; i >= 0; --i) {
200 const targetPath = join(this.postsDirectory, `${i}`);
201 const sourcePath = join(this.postsDirectory, `${i - 1}`);
202
203 try {
204 internals.debuglog(`Archiving ${targetPath}`);
205 await rm(targetPath, { recursive: true });
206
207 await access(sourcePath); // check the source path
208
209 internals.debuglog(`Shifting blog post ${sourcePath} to ${targetPath}`);
210 await internals.ncp(sourcePath, targetPath);
211 }
212 catch (error) {
213 if (error.code === internals.kFileNotFoundError) {
214 internals.debuglog(`Skipping ${sourcePath}: Does not exist.`);
215 continue;
216 }
217
218 throw error;
219 }
220 }
221 }
222
223 // Moves older posts to the archive
224
225 async _archive() {
226 internals.debuglog('Archiving post');
227 const post = await this._readPost(0);
228 await this._ensureDirectoryExists(this.archiveDirectory);
229
230 const targetPath = join(this.archiveDirectory, post.id);
231
232 try {
233 internals.debuglog(`Removing ${targetPath}`);
234 await rm(targetPath, { recursive: true });
235 }
236 finally {
237 internals.debuglog(`Adding ${post.location} to ${targetPath}`);
238 await internals.ncp(post.location, targetPath);
239 internals.debuglog(`Added ${post.location} to ${targetPath}`);
240 }
241 }
242
243 // Attempts to read existing metadata. Otherwise generates new set.
244
245 async _getMetadata(index = 0) {
246
247 const metadataTarget = join(this.postsDirectory, String(index), internals.kMetadataFilename);
248
249 try {
250 internals.debuglog(`Looking for metadata at ${metadataTarget}`);
251 return JSON.parse(await readFile(metadataTarget, { encoding: 'utf8' }));
252 }
253 catch (e) {
254 internals.debuglog(`Metadata not found or unreadable. Generating new set.`);
255 const createdOn = Date.now();
256 const metadata = {
257 id: String(createdOn),
258 createdOn
259 };
260
261 return metadata;
262 }
263 }
264
265 // Writes metadata. Assumes post 0 since it only gets written
266 // on create
267
268 async _writeMetadata(metadata) {
269
270 const metadataTarget = join(this.postsDirectory, '0', internals.kMetadataFilename);
271 internals.debuglog(`Writing ${metadataTarget}`);
272 await writeFile(metadataTarget, JSON.stringify(metadata, null, 2));
273 }
274
275 // Copies a post directory to the latest slot.
276
277 async _copyPost(postLocation) {
278
279 const targetPath = join(this.postsDirectory, '0');
280
281 internals.debuglog(`Removing ${targetPath}`);
282 await rm(targetPath, { recursive: true });
283
284 internals.debuglog(`Adding ${postLocation} to ${targetPath}`);
285 await internals.ncp(postLocation, targetPath);
286 }
287
288 // Ensures a directory exists.
289
290 async _ensureDirectoryExists(directory) {
291
292 internals.debuglog(`Checking if ${directory} exists.`);
293 try {
294 await access(directory);
295 }
296 catch (error) {
297 if (error.code === internals.kFileNotFoundError) {
298 internals.debuglog('Creating posts directory');
299 await mkdir(directory);
300 return;
301 }
302
303 throw error;
304 }
305 }
306
307 // Ensures posts directory exists
308
309 async _ensurePostsDirectoryExists() {
310
311 return this._ensureDirectoryExists(this.postsDirectory);
312 internals.debuglog(`Checking if ${this.postsDirectory} exists.`);
313 try {
314 await access(this.postsDirectory);
315 }
316 catch (error) {
317 if (error.code === internals.kFileNotFoundError) {
318 internals.debuglog('Creating posts directory');
319 await mkdir(this.postsDirectory);
320 return;
321 }
322
323 throw error;
324 }
325 }
326
327 // Looks for a `.gmi` file in the blog directory, and returns the path
328
329 async _findBlogContent(directory) {
330
331 const entries = await readdir(directory);
332
333 const geminiEntries = entries
334 .filter((entry) => internals.kGeminiRe.test(entry))
335 .map((entry) => join(directory, entry));
336
337 if (geminiEntries.length > 0) {
338 internals.debuglog(`Found gemini file: ${geminiEntries[0]}`);
339 return geminiEntries[0];
340 }
341
342 throw new Error(internals.strings.geminiNotFound);
343 }
344 };