Improved module structure. Added individual scene scrapers for Jules Jordan and XEmpire.

src/app.js

@@ -1,13 +1,12 @@
 'use strict';
 
-const config = require('config');
-const moment = require('moment');
 const blessed = require('neo-blessed');
 
 const argv = require('./argv');
-const networks = require('../networks.js');
-const scrapers = require('./scrapers');
-const render = require('./tui/render');
+const { renderReleases, renderScene } = require('./tui/render');
+
+const fetchReleases = require('./fetch-releases');
+const fetchScene = require('./fetch-scene');
 
 function initScreen() {
     const screen = blessed.screen({
@@ -26,104 +25,32 @@ function initScreen() {
     return screen;
 }
 
-function accumulateIncludedSites() {
-    return config.include.reduce((acc, network) => {
-        // network included with specific sites, only include specified sites
-        if (Array.isArray(network)) {
-            const [networkId, siteIds] = network;
+function getMethod() {
+    if (argv.scene) {
+        return {
+            fetch: () => fetchScene(argv.scene),
+            render: renderScene,
+        };
+    }
 
-            return [
-                ...acc,
-                ...siteIds.map(siteId => ({
-                    id: siteId,
-                    network: networkId,
-                    ...networks[networkId].sites[siteId],
-                })),
-            ];
-        }
-
-        // network included without further specification, include all sites
-        return [
-            ...acc,
-            ...Object.entries(networks[network].sites).map(([siteId, site]) => ({
-                id: siteId,
-                network,
-                ...site,
-            })),
-        ];
-    }, []);
-}
-
-function accumulateExcludedSites() {
-    return Object.entries(networks).reduce((acc, [networkId, network]) => {
-        const excludedNetwork = config.exclude.find((excludedNetworkX) => {
-            if (Array.isArray(excludedNetworkX)) {
-                return excludedNetworkX[0] === networkId;
-            }
-
-            return excludedNetworkX === networkId;
-        });
-
-        // network excluded with specific sites, only exclude specified sites
-        if (excludedNetwork && Array.isArray(excludedNetwork)) {
-            const [, excludedSiteIds] = excludedNetwork;
-
-            return [
-                ...acc,
-                ...Object.entries(network.sites)
-                    .filter(([siteId]) => !excludedSiteIds.includes(siteId))
-                    .map(([siteId, site]) => ({
-                        id: siteId,
-                        network: networkId,
-                        ...site,
-                    })),
-            ];
-        }
-
-        // network excluded without further specification, exclude all its sites
-        if (excludedNetwork) {
-            return acc;
-        }
-
-        // network not excluded, include all its sites
-        return [
-            ...acc,
-            ...Object.entries(network.sites).map(([siteId, site]) => ({
-                id: siteId,
-                network: networkId,
-                ...site,
-            })),
-        ];
-    }, []);
-}
-
-function accumulateSites() {
-    return config.include ? accumulateIncludedSites() : accumulateExcludedSites();
-}
-
-async function fetchScenes(sites) {
-    const scenesPerSite = await Promise.all(sites.map(async (site) => {
-        const scraper = scrapers[site.id] || scrapers[site.network];
-
-        if (scraper) {
-            return scraper(site);
-        }
-
-        return [];
-    }));
-
-    return scenesPerSite.reduce((acc, siteScenes) => ([...acc, ...siteScenes]), []);
+    return {
+        fetch: () => fetchReleases(),
+        render: renderReleases,
+    };
 }
 
 async function init() {
-    const sites = accumulateSites();
-    const scenes = await fetchScenes(sites);
+    const screen = argv.render && initScreen();
 
-    if (argv.render) {
-        const screen = initScreen();
-        const sortedScenes = scenes.sort(({ date: dateA }, { date: dateB }) => moment(dateB).diff(dateA));
+    try {
+        const method = getMethod();
+        const result = await method.fetch();
 
-        render(sortedScenes, screen);
+        if (argv.render) {
+            method.render(result, screen);
+        }
+    } catch (error) {
+        console.error(error.message);
     }
 }