diff options
Diffstat (limited to 'upd8.js')
| -rw-r--r-- | upd8.js | 765 |
1 files changed, 765 insertions, 0 deletions
diff --git a/upd8.js b/upd8.js new file mode 100644 index 0000000..8e43e7e --- /dev/null +++ b/upd8.js @@ -0,0 +1,765 @@ +// HEY N8RDS! +// +// This is one of the 8ACKEND FILES. It's not used anywhere on the actual site +// you are might 8e using right now. +// +// Specifically, this one does all the actual work of the music wiki. The +// process looks something like this: +// +// 1. Crawl the music directories. Well, not so much "crawl" as "look inside +// the folders for each al8um, and read the metadata file descri8ing that +// al8um and the tracks within." +// +// 2. Read that metadata. I'm writing this 8efore actually doing any of the +// code, and I've gotta admit I have no idea what file format they're +// going to 8e in. May8e JSON, 8ut more likely some weird custom format +// which will 8e a lot easier to edit. +// +// 3. Generate the page files! They're just static index.html files, and are +// what gh-pages (or wherever this is hosted) will show to clients. +// Hopefully pretty minimalistic HTML, 8ut like, shrug. They'll reference +// CSS (and maaaaaaaay8e JS) files, hard-coded somewhere near the root. +// +// 4. Print an awesome message which says the process is done. This is the +// most important step. +// +// Oh yeah, like. Just run this through some relatively recent version of +// node.js and you'll 8e fine. ...Within the project root. O8viously. + +// HEY FUTURE ME!!!!!!!! Don't forget to implement artist pages! Those are, +// like, the coolest idea you've had yet, so DO NOT FORGET. (Remem8er, link +// from track listings, etc!) --- Thanks, past me. To futurerer me: an al8um +// listing page (a list of all the al8ums)! Make sure to sort these 8y date - +// we'll need a new field for al8ums. + +// ^^^^^^^^ DID THAT! 8ut also, artist images. Pro8a8ly stolen from the fandom +// wiki (I found half those images anywayz). + +// TRACK ART CREDITS. This is a must. + +'use strict'; + +const fs = require('fs'); +const path = require('path'); +const util = require('util'); + +// I made this dependency myself! A long, long time ago. It is pro8a8ly my +// most useful li8rary ever. I'm not sure 8esides me actually uses it, though. +const fixWS = require('fix-whitespace'); +// Wait nevermind, I forgot a8out why-do-kids-love-the-taste-of-cinnamon-toast- +// crunch. THAT is my 8est li8rary. + +// The require function just returns whatever the module exports, so there's +// no reason you can't wrap it in some decorator right out of the 8ox. Which is +// exactly what we do here. +const mkdirp = util.promisify(require('mkdirp')); + +// This is the dum8est name for a function possi8le. Like, SURE, fine, may8e +// the UNIX people had some valid reason to go with the weird truncated +// lowercased convention they did. 8ut Node didn't have to ALSO use that +// convention! Would it have 8een so hard to just name the function something +// like fs.readDirectory???????? No, it wouldn't have 8een. +const readdir = util.promisify(fs.readdir); +// 8ut okay, like, look at me. DOING THE SAME THING. See, *I* could have named +// my promisified function differently, and yet I did not. I literally cannot +// explain why. We are all used to following in the 8ad decisions of our +// ancestors, and never never never never never never never consider that hey, +// may8e we don't need to make the exact same decisions they did. Even when +// we're perfectly aware th8t's exactly what we're doing! Programmers, +// including me, are all pretty stupid. + +// 8ut I mean, come on. Look. Node decided to use readFile, instead of like, +// what, cat? Why couldn't they rename readdir too???????? As Johannes Kepler +// once so elegantly put it: "Shrug." +const readFile = util.promisify(fs.readFile); +const writeFile = util.promisify(fs.writeFile); +const access = util.promisify(fs.access); + +const { + joinNoOxford, + splitArray +} = require('./upd8-util'); + +const SITE_TITLE = 'Homestuck'; + +// The folder you stick your random downloads in is called "Downloads", yeah? +// (Unless you sort all your downloads into manual, organized locations. Good +// for you.) It might just 8e me, 8ut I've always said "the downloads folder." +// And yet here I say "the al8um directory!" It's like we've gotten "Downloads" +// as a name so ingrained into our heads that we use it like an adjective too, +// even though it doesn't make any grammatical sense to do so. Anyway, also for +// contrast, note that this folder is called "album" and not "albums". To 8e +// clear, that IS against how I normally name folders - 8ut here, I'm doing it +// to match 8andcamp's URL schema: "/album/genesis-frog" instead of "/albums +// /genesis-frog." That seems to kind of 8e a standard for a lot of sites? +// 8ut only KIND OF. Twitter has the weird schema of "/<user>/status/<id>" +// (not "statuses")... 8ut it also has "/<user>/likes", so I really have no +// idea how people decide to make their URL schemas consistent. Luckily I don't +// have to worry a8out any of that, 8ecause I'm just stealing 8andcamp. +const ALBUM_DIRECTORY = 'album'; +const TRACK_DIRECTORY = 'track'; +const ARTIST_DIRECTORY = 'artist'; +const ARTIST_AVATAR_DIRECTORY = 'artist-avatar'; +const GRID_DIRECTORY = 'grid'; + +// Might ena8le this later... we'll see! Eventually. May8e. +const ENABLE_ARTIST_AVATARS = false; + +const ALBUM_DATA_FILE = 'album.txt'; + +const CSS_FILE = 'site.css'; +const GRID_CSS_FILE = 'grid-site.css'; + +// Note there isn't a 'find track data files' function. I plan on including the +// data for all tracks within an al8um collected in the single metadata file +// for that al8um. Otherwise there'll just 8e way too many files, and I'd also +// have to worry a8out linking track files to al8um files (which would contain +// only the track listing, not track data itself), and dealing with errors of +// missing track files (or track files which are not linked to al8ums). All a +// 8unch of stuff that's a pain to deal with for no apparent 8enefit. +async function findAlbumDataFiles() { + // Promises suck. This could pro8a8ly 8e written with async/await and an + // ordinary for loop, 8ut I'm using promises 8ecause they let all the + // folders get read simultaneously. + // ...Actually screw it, let's use async/await AND promises. + /* + return readdir(ALBUM_DIRECTORY) + .then(albums => Promise.all(albums + .map(album => readdir(path.join(ALBUM_DIRECTORY, album)) + .then(files => files.includes(ALBUM_DATA_FILE) ? path.join(ALBUM_DIRECTORY, album, ALBUM_DATA_FILE) : null)))) + .then(paths => paths.filter(Boolean)); + */ + + const albums = await readdir(ALBUM_DIRECTORY); + + const paths = await Promise.all(albums.map(async album => { + // Argua8ly terri8le/am8iguous varia8le naming. Too 8ad! + const albumDirectory = path.join(ALBUM_DIRECTORY, album); + const files = await readdir(albumDirectory); + if (files.includes(ALBUM_DATA_FILE)) { + return path.join(albumDirectory, ALBUM_DATA_FILE); + } + // The old code returns null if the data file isn't present, 8ut that's + // not actually necessary. We just need some falsey value, and the + // implied undefined when you don't explicitly return anything works. + })); + + return paths.filter(Boolean); +} + +async function processAlbumDataFile(file) { + let contents; + try { + contents = await readFile(file, 'utf-8'); + } catch (error) { + // This function can return "error o8jects," which are really just + // ordinary o8jects with an error message attached. I'm not 8othering + // with error codes here or anywhere in this function; while this would + // normally 8e 8ad coding practice, it doesn't really matter here, + // 8ecause this isn't an API getting consumed by other services (e.g. + // translaction functions). If we return an error, the caller will just + // print the attached message in the output summary. + return {error: `Could not read ${file} (${error.code}).`}; + } + + // We're probably supposed to, like, search for a header somewhere in the + // album contents, to make sure it's trying to be the intended structure + // and is a valid utf-8 (or at least ASCII) file. 8ut like, whatever. + // We'll just return more specific errors if it's missing necessary data + // fields. + + // ::::) + const isSeparatorLine = line => /^-{8,}$/.test(line); + + const contentLines = contents.split('\n'); + + // In this line of code I defeat the purpose of using a generator in the + // first place. Sorry!!!!!!!! + const sections = Array.from(splitArray(contentLines, isSeparatorLine)); + + const initialLines = contentLines.slice(0, contentLines.findIndex(isSeparatorLine)); + + const getBasicField = (lines, name) => { + const line = lines.find(line => line.startsWith(name + ':')); + return line && line.slice(name.length + 1).trim(); + }; + + const getListField = (lines, name) => { + let startIndex = lines.findIndex(line => line.startsWith(name + ':')); + // If callers want to default to an empty array, they should stick + // "|| []" after the call. + if (startIndex === -1) { + return null; + } + // We increment startIndex 8ecause we don't want to include the + // "heading" line (e.g. "URLs:") in the actual data. + startIndex++; + let endIndex = lines.findIndex((line, index) => index >= startIndex && !line.startsWith('- ')); + if (endIndex === -1) { + endIndex = lines.length; + } + if (endIndex === startIndex) { + // If there is no list that comes after the heading line, treat the + // heading line itself as the comma-separ8ted array value, using + // the 8asic field function to do that. (It's l8 and my 8rain is + // sleepy. Please excuse any unhelpful comments I may write, or may + // have already written, in this st8. Thanks!) + const value = getBasicField(lines, name); + return value && value.split(',').map(val => val.trim()); + } + const listLines = lines.slice(startIndex, endIndex); + return listLines.map(line => line.slice(2)); + }; + + const albumSection = sections[0]; + const albumName = getBasicField(albumSection, 'Album'); + const albumArtists = getListField(albumSection, 'Artists') || getListField(albumSection, 'Artist'); + const albumDate = getBasicField(albumSection, 'Date'); + let albumDirectory = getBasicField(albumSection, 'Directory'); + + // I don't like these varia8le names. I'm sorry. -- I only really use the + // FG theme in the Homestuck wiki site (at least as of this writing), since + // without any styles consistent across the site, it kinda ends up losing + // any coherence of a single we8site and is a 8it distracting to navig8. + // 8ut these are implemented if you ever want to mess with them in the + // future or whatever. + const albumColorFG = getBasicField(albumSection, 'FG') || '#0088ff'; + const albumColorBG = getBasicField(albumSection, 'BG') || '#222222'; + const albumTheme = getBasicField(albumSection, 'Theme') || 0; + + if (!albumName) { + return {error: 'Expected "Album" (name) field!'}; + } + + if (!albumDate) { + return {error: 'Expected "Date" field!'}; + } + + if (isNaN(Date.parse(albumDate))) { + return {error: `Invalid Date field: "${albumDate}"`}; + } + + const dateValue = new Date(albumDate); + + if (!albumDirectory) { + albumDirectory = getKebabCase(albumName); + } + + // We need to declare this varia8le 8efore the al8um varia8le, 8ecause + // that varia8le references this one. 8ut we won't actually fill in the + // contents of the tracks varia8le until after creating the al8um one, + // 8ecause each track o8ject will (8ack-)reference the al8um o8ject. + const tracks = []; + + const albumData = { + name: albumName, + date: dateValue, + artists: albumArtists, + directory: albumDirectory, + theme: { + fg: albumColorFG, + bg: albumColorBG, + theme: albumTheme + }, + tracks + }; + + for (const section of sections.slice(1)) { + // Just skip empty sections. Sometimes I paste a bunch of dividers, + // and this lets the empty sections doing that creates (temporarily) + // exist without raising an error. + if (!section.filter(Boolean).length) { + continue; + } + + const trackName = getBasicField(section, 'Track'); + const originalDate = getBasicField(section, 'Original Date'); + let trackArtists = getListField(section, 'Artists') || getListField(section, 'Artist'); + let trackContributors = getListField(section, 'Contributors') || []; + let trackDirectory = getBasicField(section, 'Directory'); + + if (!trackName) { + return {error: 'A track section is missing the "Track" (name) field.'}; + } + + if (!trackArtists) { + // If an al8um has an artist specified (usually 8ecause it's a solo + // al8um), let tracks inherit that artist. We won't display the + // "8y <artist>" string on the al8um listing. + if (albumArtists) { + trackArtists = albumArtists; + } else { + return {error: `The track "${trackName}" is missing the "Artist" field.`}; + } + } + + if (!trackDirectory) { + trackDirectory = getKebabCase(trackName); + } + + trackContributors = trackContributors.map(contrib => { + // 8asically, the format is "Who (What)", or just "Who". 8e sure to + // keep in mind that "what" doesn't necessarily have a value! + const match = contrib.match(/^(.*?)( \((.*)\))?$/); + if (!match) { + return contrib; + } + const who = match[1]; + const what = match[3] || null; + if (!what) { + console.log(trackName, '-\t', albumName, '-\t', who); + } + return {who, what}; + }); + + const badContributor = trackContributors.find(val => typeof val === 'string'); + if (badContributor) { + return {error: `The track "${trackName}" has an incorrectly formatted contributor, "${badContributor}".`}; + } + + let date; + if (originalDate) { + if (isNaN(Date.parse(originalDate))) { + return {error: `The track "${trackName}"'s has an invalid "Original Date" field: "${originalDate}"`}; + } + date = new Date(originalDate); + } else { + date = dateValue; + } + + const trackURLs = (getListField(section, 'URLs') || []).filter(Boolean); + + if (!trackURLs.length) { + return {error: `The track "${trackName}" should have at least one URL specified.`}; + } + + tracks.push({ + name: trackName, + artists: trackArtists, + contributors: trackContributors, + date, + directory: trackDirectory, + urls: trackURLs, + // 8ack-reference the al8um o8ject! This is very useful for when + // we're outputting the track pages. + album: albumData + }); + } + + return albumData; +} + +// This gets all the track o8jects defined in every al8um, and sorts them 8y +// date released. Generally, albumData will pro8a8ly already 8e sorted 8efore +// you pass it to this function, 8ut individual tracks can have their own +// original release d8, distinct from the al8um's d8. I allowed that 8ecause +// in Homestuck, the first four Vol.'s were com8ined into one al8um really +// early in the history of the 8andcamp, and I still want to use that as the +// al8um listing (not the original four al8um listings), 8ut if I only did +// that, all the tracks would be sorted as though they were released at the +// same time as the compilation al8um - i.e, after some other al8ums (including +// Vol.'s 5 and 6!) were released. That would mess with chronological listings +// including tracks from multiple al8ums, like artist pages. So, to fix that, +// I gave tracks an Original Date field, defaulting to the release date of the +// al8um if not specified. Pretty reasona8le, I think! Oh, and this feature can +// 8e used for other projects too, like if you wanted to have an al8um listing +// compiling a 8unch of songs with radically different & interspersed release +// d8s, 8ut still keep the al8um listing in a specific order, since that isn't +// sorted 8y date. +function getAllTracks(albumData) { + return sortByDate(albumData.reduce((acc, album) => acc.concat(album.tracks), [])); +} + +// This function was originally made to sort just al8um data, 8ut its exact +// code works fine for sorting tracks too, so I made the varia8les and names +// more general. +function sortByDate(data) { + // Just to 8e clear: sort is a mutating function! I only return the array + // 8ecause then you don't have to define it as a separate varia8le 8efore + // passing it into this function. + return data.sort((a, b) => a.date - b.date); +} + +function getDateString({ date }) { + return date.toLocaleDateString(); +} + +function getArtistNames(albumData) { + return Array.from(new Set(albumData.reduce((acc, album) => acc.concat(album.tracks.reduce((acc, track) => acc.concat(track.artists), [])), []))); +} + +async function writeTopIndexPage(albumData) { + // This is hard-coded, i.e. we don't do a path.join(ROOT_DIRECTORY). + // May8e that's 8ad? Yes, definitely 8ad. 8ut I'm too lazy to fix it... + // for now. TM. + await writeFile('index.html', fixWS` + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + <title>${SITE_TITLE}</title> + <link rel="stylesheet" href="site.css"> + </head> + <body id="top-index"> + <div id="content"> + <h1>${SITE_TITLE}</h1> + <div class="grid-listing"> + ${albumData.map(album => fixWS` + <a class="grid-item" href="${ALBUM_DIRECTORY}/${album.directory}/index.html" style="${getThemeString(album.theme)}"> + <img src="${getAlbumCover(album)}"> + <span>${album.name}</span> + </a> + `).join('\n')} + </div> + </div> + </body> + </html> + `); +} + +// This function title is my gr8test work of art. +async function writeIndexAndTrackPagesForAlbum(album, albumData) { + await writeAlbumPage(album); + await Promise.all(album.tracks.map(track => writeTrackPage(track, albumData))); +} + +async function writeAlbumPage(album) { + const albumDirectory = path.join(ALBUM_DIRECTORY, album.directory); + await mkdirp(albumDirectory); + await writeFile(path.join(albumDirectory, 'index.html'), fixWS` + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + <title>${album.name}</title> + <base href="${path.relative(albumDirectory, '')}"> + <link rel="stylesheet" href="${CSS_FILE}"> + </head> + <body style="${getThemeString(album.theme)}"> + <div id="sidebar"> + ${generateSidebarForAlbum(album)} + </div> + <div id="content"> + <a id="cover-art" href="${getAlbumCover(album)}"><img src="${getAlbumCover(album)}"></a> + <h1>${album.name}</h1> + <p> + ${album.artist && `By ${getArtistString(album.artists)}.<br>`} + Released ${getDateString(album)}. + </p> + <ol> + ${album.tracks.map(track => fixWS` + <li> + <a href="${TRACK_DIRECTORY}/${track.directory}/index.html">${track.name}</a> + ${track.artists !== album.artists && fixWS` + <i>by ${getArtistString(track.artists)}</i> + `} + </li> + `).join('\n')} + </ol> + </div> + </body> + </html> + `); +} + +async function writeTrackPage(track, albumData) { + const artistNames = getArtistNames(albumData); + const allTracks = getAllTracks(albumData); + const trackDirectory = path.join(TRACK_DIRECTORY, track.directory); + await mkdirp(trackDirectory); + await writeFile(path.join(trackDirectory, 'index.html'), fixWS` + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + <title>${track.name}</title> + <base href="${path.relative(trackDirectory, '')}"> + <link rel="stylesheet" href="${CSS_FILE}"> + </head> + <body style="${getThemeString(track.album.theme)}"> + <div id="sidebar"> + ${generateSidebarForAlbum(track.album, track)} + </div> + <div id="content"> + <a href="${getTrackCover(track)}" id="cover-art"><img src="${getTrackCover(track)}"></a> + <h1>${track.name}</h1> + <p> + By ${getArtistString(track.artists)}.<br> + Released ${getDateString(track)}. + </p> + ${track.contributors.length && fixWS` + <p>Contributors:</p> + <ul> + ${track.contributors.map(({ who, what }) => fixWS` + <li>${artistNames.includes(who) + ? `<a href="${ARTIST_DIRECTORY}/${getArtistDirectory(who)}/index.html">${who}</a>` + : who + } ${what && `(${getContributionString({what}, allTracks)})`}</li> + `).join('\n')} + </ul> + `} + <p>Listen:</p> + <ul> + ${track.urls.map(url => fixWS` + <li><a href="${url}">${ + url.includes('bandcamp.com') ? 'Bandcamp' : + url.includes('youtu') ? 'YouTube' : + '(External)' + }</a></li> + `)} + </ul> + </div> + </body> + </html> + `); +} + +async function writeArtistPages(albumData) { + await Promise.all(getArtistNames(albumData).map(artistName => writeArtistPage(artistName, albumData))); +} + +async function writeArtistPage(artistName, albumData) { + const tracks = sortByDate(getAllTracks(albumData).filter(track => track.artists.includes(artistName) || track.contributors.some(({ who }) => who === artistName))); + + // Shish! + const kebab = getArtistDirectory(artistName); + + const artistDirectory = path.join(ARTIST_DIRECTORY, kebab); + await mkdirp(artistDirectory); + await writeFile(path.join(artistDirectory, 'index.html'), fixWS` + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + <title>${artistName}</title> + <base href="${path.relative(artistDirectory, '')}"> + <link rel="stylesheet" href="${CSS_FILE}"> + </head> + <body> + <div id="content"> + ${ENABLE_ARTIST_AVATARS && await access(path.join(ARTIST_AVATAR_DIRECTORY, kebab + '.jpg')).then(() => true, () => false) && fixWS` + <a id="cover-art" href="${ARTIST_AVATAR_DIRECTORY}/${getArtistDirectory(artistName)}.jpg"><img src="${ARTIST_AVATAR_DIRECTORY}/${getArtistDirectory(artistName)}.jpg"></a> + `} + <h1>${artistName}</h1> + <ol> + ${tracks.map(track => fixWS` + <li class="${!track.artists.includes(artistName) && `contributed ${track.contributors.filter(({ who }) => who === artistName).every(({ what }) => what && what.startsWith('[') && what.endsWith(']')) && 'contributed-only-original'}`}"> + <a href="${TRACK_DIRECTORY}/${track.directory}/index.html">${track.name}</a> + ${track.artists.includes(artistName) && track.artists.length > 1 && `<span="contributed">(with ${getArtistString(track.artists.filter(a => a !== artistName))})</span>`} + ${!track.artists.includes(artistName) && `<span class="contributed">(${track.contributors.filter(({ who }) => who === artistName).map(contrib => getContributionString(contrib, tracks)).join(', ') || 'contributed'})</span> `} + <i>from <a href="${ALBUM_DIRECTORY}/${track.album.directory}/index.html" style="${getThemeString(track.album.theme)}">${track.album.name}</a></i> + </li> + `).join('\n')} + </ol> + </div> + </body> + </html> + `); +} + +// This function is terri8le. Sorry! +function getContributionString({ what }, allTracks) { + return what + ? what.replace(/\[(.*?)\]/g, (match, name) => + allTracks.some(track => track.name === name) + ? `<i><a href="${TRACK_DIRECTORY}/${allTracks.find(track => track.name === name).directory}/index.html">${name}</a></i>` + : `<i>${name}</i>`) + : ''; +} + +function getArtistString(artists) { + return joinNoOxford(artists.map(artist => fixWS` + <a href="${ARTIST_DIRECTORY}/${getArtistDirectory(artist)}/index.html">${artist}</a> + `)); +} + +function getThemeString({fg, bg, theme}) { + return `--fg-color: ${fg}; --bg-color: ${bg}; --theme: ${theme + ''}`; +} + +// Terri8le hack: since artists aren't really o8jects and don't have proper +// "directories", we just reformat the artist's name. +function getArtistDirectory(artistName) { + return getKebabCase(artistName); +} + +function getKebabCase(name) { + return name.split(' ').join('-').replace(/[^a-zA-Z0-9\-]/g, '').replace(/-{2,}/g, '-').toLowerCase(); +} + +function generateSidebarForAlbum(album, currentTrack = null) { + return fixWS` + <h2><a href="index.html">(Home)</a></h2> + <hr> + <h1><a href="${ALBUM_DIRECTORY}/${album.directory}/index.html">${album.name}</a></h1> + <ol> + ${album.tracks.map(track => fixWS` + <li class="${track === currentTrack ? 'current-track' : ''}"><a href="${TRACK_DIRECTORY}/${track.directory}/index.html">${track.name}</a></li> + `).join('\n')} + </ol> + ` +} + +// These two functions are sort of hard-coded ways to quickly gra8 the path to +// cover arts, for em8edding witin the HTML. They're actually 8ig hacks, +// 8ecause they assume the track and al8um directories are adjacent to each +// other. I get to make that assumption on the responsi8ility that I la8el +// these functions "hard-coded", which 8asically just means my future self and +// anyone else trying to mess with this code can't 8lame me for my terri8le +// decisions / laziness in figuring out a 8etter solution. That said, note to +// future self: these only work from two levels above the root directory. +// "O8viously," if you look at their implementation, 8ut if you don't... yeah. +// You won't 8e a8le to call these for use in the lower level files. +// ACTUALLY this means I really should just use a <base> element, which yes, I +// have done before (on my 8log). That way all HTML files have the same root +// for referenced files, and these functions work anywhere. The catch, then, is +// that you have to have a "8ase directory" constant, and keep that accurate on +// 8oth your development machine and the server you pu8lish this too. So, it's +// a trade-off. 8ut it does mean much cleaner, more general-use functions. +// Which is kind of the goal here, I suppose. --- Actually, hold on, I took a +// look at the document8tion and apparently relative URLs are totally okay! +// Com8ine that with path.relative and I think that should work as a way to +// skip a 8ase directory constant. Neat! +/* +function getAlbumCover(album) { + return `../../${ALBUM_DIRECTORY}/${album.directory}/cover.png`; +} +function getTrackCover(track) { + return `../../${ALBUM_DIRECTORY}/${track.album.directory}/${track.directory}.png`; +} +*/ + +function getAlbumCover(album) { + return `${ALBUM_DIRECTORY}/${album.directory}/cover.jpg`; +} +function getTrackCover(track) { + // Some al8ums don't have any track art at all, and in those, every track + // just inherits the al8um's own cover art. + // TODO: Don't hard-c8de this! + if ([ + 'homestuck-vol-5', + 'squiddles', + 'medium', + 'symphony-impossible-to-play' + ].includes(track.album.directory)) { + return getAlbumCover(track.album); + } else { + return `${ALBUM_DIRECTORY}/${track.album.directory}/${track.directory}.jpg`; + } +} + +// Super fancy, more interactive 8rowsing section of the site. May8e the +// primary one in time???????? We'll see! For real. +async function writeGridSite(albumData) { + await mkdirp(GRID_DIRECTORY); + await writeFile(path.join(GRID_DIRECTORY, 'index.html'), fixWS` + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + <title>${SITE_TITLE}</title> + <base href="${path.relative(GRID_DIRECTORY, '')}"> + <link rel="stylesheet" href="${GRID_CSS_FILE}"> + </head> + <body> + <div class="grid-listing"> + ${albumData.map(album => fixWS` + <a class="grid-item" href="${GRID_DIRECTORY}/${ALBUM_DIRECTORY}/${album.directory}/index.html"> + <img src="${getAlbumCover(album)}"> + <span>${album.name}</span> + </a> + `).join('\n')} + </div> + </body> + </html> + `); + await Promise.all(albumData.map(writeGridAlbumPage)); +} + +async function writeGridAlbumPage(album) { + const albumDirectory = path.join(GRID_DIRECTORY, ALBUM_DIRECTORY, album.directory); + await mkdirp(albumDirectory); + await writeFile(path.join(albumDirectory, 'index.html'), fixWS` + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + <title>${album.name}</title> + <base href="${path.relative(albumDirectory, '')}"> + <link rel="stylesheet" href="${GRID_CSS_FILE}"> + </head> + <body> + <!-- + <a id="cover-art" href="${getAlbumCover(album)}"><img src="${getAlbumCover(album)}"></a> + <h1>${album.name}</h1> + <p> + ${album.artist && `By ${getArtistString(album.artists)}.<br>`} + Released ${getDateString(album)}. + </p> + --> + <div class="grid-listing"> + ${album.tracks.map(track => fixWS` + <a class="grid-item" href="${TRACK_DIRECTORY}/${track.directory}/index.html"> + <img src="${getTrackCover(track)}"> + <span>${track.name}<br>by ${joinNoOxford(track.artists)}</span> + </a> + `).join('\n')} + </div> + </body> + </html> + `); +} + +async function main() { + // 8ut wait, you might say, how do we know which al8um these data files + // correspond to???????? You wouldn't dare suggest we parse the actual + // paths returned 8y this function, which ought to 8e of effectively + // unknown format except for their purpose as reada8le data files!? + // To that, I would say, yeah, you're right. Thanks a 8unch, my projection + // of "you". We're going to read these files later, and contained within + // will 8e the actual directory names that the data correspond to. Yes, + // that's redundant in some ways - we COULD just return the directory name + // in addition to the data path, and duplicating that name within the file + // itself suggests we 8e careful to avoid mismatching it - 8ut doing it + // this way lets the data files themselves 8e more porta8le (meaning we + // could store them all in one folder, if we wanted, and this program would + // still output to the correct al8um directories), and also does make the + // function's signature simpler (an array of strings, rather than some kind + // of structure containing 8oth data file paths and output directories). + // This is o8jectively a good thing, 8ecause it means the function can stay + // truer to its name, and have a narrower purpose: it doesn't need to + // concern itself with where we *output* files, or whatever other reasons + // we might (hypothetically) have for knowing the containing directory. + // And, in the strange case where we DO really need to know that info, we + // callers CAN use path.dirname to find out that data. 8ut we'll 8e + // avoiding that in our code 8ecause, again, we want to avoid assuming the + // format of the returned paths here - they're only meant to 8e used for + // reading as-is. + const albumDataFiles = await findAlbumDataFiles(); + + // Technically, we could do the data file reading and output writing at the + // same time, 8ut that kinda makes the code messy, so I'm not 8othering + // with it. + const albumData = await Promise.all(albumDataFiles.map(processAlbumDataFile)); + + sortByDate(albumData); + + const errors = albumData.filter(obj => obj.error); + if (errors.length) { + for (const error of errors) { + console.log(error.error); + } + return; + } + + await writeTopIndexPage(albumData); + await Promise.all(albumData.map(album => writeIndexAndTrackPagesForAlbum(album, albumData))); + await writeArtistPages(albumData); + + // await writeGridSite(albumData); + + // The single most important step. + console.log('Written!'); +} + +main().catch(error => console.error(error)); |