Lint

[rbdr/blog] / bin / blog.js

#!/usr/bin/env node
import Config from '../config/config.js';
import Blog from '../lib/blog.js';
import Minimist from 'minimist';

const internals = {
  blog: new Blog(Config),
  expectedKeys: [
    'add',
    'generate',
    'update',
    'publish',
    'publish-archive',
    'add-remote',
    'remove-remote',
    'sync-up',
    'sync-down',
    'version'],

  // Application entry point. Reads arguments and calls the
  // corresponding method from the blog lib

  async main() {

    try {
      const parsedArguments = this._parseArguments();

      for (const argument in parsedArguments) {
        if (parsedArguments.hasOwnProperty(argument)) {

          const value = parsedArguments[argument];

          if (argument === 'version') {
            console.log('6.0.0');
            return;
          }

          if (argument === 'add') {
            await internals.blog.add(value);
            return;
          }

          if (argument === 'update') {
            await internals.blog.update(value);
            return;
          }

          if (argument === 'generate') {
            await internals.blog.generate();
            return;
          }

          if (argument === 'publish') {
            await internals.blog.publish(value);
            return;
          }

          if (argument === 'publish-archive') {
            await internals.blog.publishArchive(value);
            return;
          }

          if (argument === 'add-remote') {
            await internals.blog.addRemote(value);
            return;
          }

          if (argument === 'remove-remote') {
            await internals.blog.removeRemote();
            return;
          }

          if (argument === 'sync-up') {
            await internals.blog.syncUp();
            return;
          }

          if (argument === 'sync-down') {
            await internals.blog.syncDown();
            return;
          }
        }
      }

      console.log('Not yet implemented');
    }
    catch (err) {
      console.error(err.message || err);
      this._printUsage();
      process.exit(1);
    }
  },

  // Parses arguments and returns them if valid. otherwise Throws

  _parseArguments() {

    const parsedArguments = Minimist(process.argv.slice(2));

    if (!this._areArgumentsValid(parsedArguments)) {
      throw new Error(internals.strings.invalidArguments);
    }

    return parsedArguments;
  },

  // Checks if the arguments are valid, returns a boolean value.

  _areArgumentsValid(parsedArguments) {

    const argumentKeys = Object.keys(parsedArguments);

    return argumentKeys.some((key) => internals.expectedKeys.indexOf(key) >= 0);
  },

  // Prints the usage to stderr

  _printUsage() {

    console.error('\nUsage:\n');
    console.error('blog --add <path_to_post>\t\t(creates new blog post)');
    console.error('blog --update <path_to_post>\t\t(updates latest blog post)');
    console.error('blog --generate \t\t\t(generates the blog assets)');
    console.error('blog --publish <bucket> \t\t(publishes the blog to an S3 bucket)');
    console.error('blog --publish-archive <destination> \t(publishes the archive to a remote host)');
    console.error('blog --add-remote <git_url> \t\t(adds or updates a git remote to sync with)');
    console.error('blog --remove-remote \t\t\t(removes the git remote)');
    console.error('blog --sync-up \t\t\t\t(pushes to the git remote if configured)');
    console.error('blog --sync-down \t\t\t(pulls from the git remote if configured)');
    console.error('blog --version \t\t\t\t(print the version)');
  }
};

// Add the strings, added after declaration so they can consume the
// internals object.

internals.strings = {
  invalidArguments: `Invalid Arguments, expecting one of: ${internals.expectedKeys.join(', ')}`
};



internals.main();