traxxx/src/app.js

'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');

function initScreen() {
    const screen = blessed.screen({
        title: `traxxx ${new Date().getTime()}`,
        smartCSR: true,
        mouse: false,
    });

    screen.enableInput();

    screen.key(['escape', 'q', 'C-c'], () => {
        screen.render();
        screen.destroy();
    });

    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;

            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]), []);
}

async function init() {
    const sites = accumulateSites();
    const scenes = await fetchScenes(sites);

    if (argv.render) {
        const screen = initScreen();
        const sortedScenes = scenes.sort(({ date: dateA }, { date: dateB }) => moment(dateB).diff(dateA));

        render(sortedScenes, screen);
    }
}

init();