feat(extensions): services are dead, long live extensions

closes #146
- add new Extensions API
- refactor setup command to be less of a piece of crap
- cleanup lots of things

Author: acburdine

lib/bootstrap.js

@@ -5,6 +5,7 @@ const path = require('path');
 const abbrev = require('abbrev');
 const createDebug = require('debug');
 const Command = require('./command');
+const findExtensions = require('./utils/find-extensions');
 
 const debug = createDebug('ghost-cli:bootstrap');
 
@@ -40,9 +41,17 @@ module.exports = {
             process.exit(1);
         }
 
+        let extensions = findExtensions();
+        debug(`Found ${ extensions.length } extensions: ${ extensions.map((ext) => ext.pkg.name).join(', ') }`);
+
         debug('loading built-in commands');
         let commands = discoverCommands({}, __dirname);
 
+        debug('loading commands from extensions');
+        extensions.forEach((extension) => {
+            commands = discoverCommands(commands, extension.dir, extension.name);
+        });
+
         debug(`discovered commands: ${ Object.keys(commands).join(', ') }`);
         let abbreviations = abbrev(Object.keys(commands));
         let firstArg = argv.shift();
@@ -64,7 +73,7 @@ module.exports = {
                 }
 
                 let aliases = Object.keys(abbreviations).filter((key) => abbreviations[key] === commandName);
-                CommandClass.configure(commandName, aliases, yargs, {});
+                CommandClass.configure(commandName, aliases, yargs, extensions);
                 argv.unshift('help');
             });
         } else if (abbreviations[firstArg]) {
@@ -78,7 +87,7 @@ module.exports = {
             }
 
             let aliases = Object.keys(abbreviations).filter((key) => abbreviations[key] === commandName);
-            CommandClass.configure(commandName, aliases, yargs);
+            CommandClass.configure(commandName, aliases, yargs, extensions);
             argv.unshift(commandName);
         } else {
             console.error(`Unrecognized command: '${ firstArg }'. Run \`ghost help\` for usage.`);

lib/command.js

@@ -13,7 +13,6 @@ const kebabCase = require('lodash/kebabCase');
 const UI = require('./ui');
 const System = require('./system');
 const Config = require('./utils/config');
-const ServiceManager = require('./services');
 
 const debug = createDebug('ghost-cli:command');
 
@@ -45,7 +44,7 @@ class Command {
      * @param {Array<String>} aliases Aliases from abbrev
      * @param {Yargs} yargs Yargs instance
      */
-    static configure(commandName, aliases, yargs) {
+    static configure(commandName, aliases, yargs, extensions) {
         if (!this.description) {
             throw new Error(`Command ${ commandName } must have a description!`);
         }
@@ -63,15 +62,15 @@ class Command {
             describe: this.description,
             builder: (commandArgs) => {
                 debug(`building options for ${ commandName }`);
-                commandArgs = this.configureOptions(commandName, commandArgs);
+                commandArgs = this.configureOptions(commandName, commandArgs, extensions);
                 if (this.configureSubcommands) {
-                    commandArgs = this.configureSubcommands(commandName, commandArgs);
+                    commandArgs = this.configureSubcommands(commandName, commandArgs, extensions);
                 }
                 return commandArgs;
             },
 
             handler: (argv) => {
-                this._run(commandName, argv);
+                this._run(commandName, argv, extensions);
             }
         });
     }
@@ -100,7 +99,7 @@ class Command {
      * @param {Object} args Parsed arguments
      * @param {Object} context Various contextual dependencies
      */
-    static _run(commandName, argv) {
+    static _run(commandName, argv, extensions) {
         if (!this.global) {
             checkValidInstall(commandName);
         }
@@ -112,15 +111,10 @@ class Command {
             verbose: verbose,
             allowPrompt: argv.prompt
         });
-        let system = new System(ui);
-        let service = ServiceManager.load(ui, system);
+        let system = new System(ui, extensions);
 
         system.setEnvironment(argv.development || process.env.NODE_ENV === 'development', true);
-
-        // TODO: This is intended to maintain maximum compatability with the pre-yargs
-        // version of Ghost-CLI - so this will look ugly until the service manager part
-        // can be refactored.
-        let commandInstance = new this(ui, service, system);
+        let commandInstance = new this(ui, system);
         debug(`running command ${ commandName }`);
 
         if (commandInstance.cleanup) {
@@ -143,9 +137,8 @@ class Command {
     /**
      * Constructs the command instance
      */
-    constructor(ui, service, system) {
+    constructor(ui, system) {
         this.ui = ui;
-        this.service = service;
         this.system = system;
     }
 
@@ -161,7 +154,7 @@ class Command {
             throw new Error('Provided command class does not extend the Command class');
         }
 
-        let cmdInstance = new CommandClass(this.ui, this.service, this.system);
+        let cmdInstance = new CommandClass(this.ui, this.system);
         return cmdInstance.run(argv || {});
     }
 }

lib/commands/config/index.js

@@ -10,12 +10,12 @@ const advancedOptions   = require('./advanced');
 const errors            = require('../../errors');
 
 class ConfigCommand extends Command {
-    constructor(ui, service, system) {
-        super(ui, service, system);
+    constructor(ui, system) {
+        super(ui, system);
 
-        this.instance = this.system.getInstance();
-        this.instance.loadConfig(true);
-        this.config = this.instance.config;
+        let instance = this.system.getInstance();
+        instance.loadConfig(true);
+        this.config = instance.config;
     }
 
     handleAdvancedOptions(argv) {
@@ -64,9 +64,6 @@ class ConfigCommand extends Command {
             }
 
             this.config.save();
-
-            let pname = argv.pname || url.parse(this.config.get('url')).hostname.replace(/\./g, '-');
-            this.instance.name = pname; // Set instance name
         });
     }
 
@@ -138,11 +135,6 @@ class ConfigCommand extends Command {
 
 ConfigCommand.description = 'Configure a Ghost instance';
 ConfigCommand.params = '[key] [value]';
-ConfigCommand.options = Object.assign({
-    pname: {
-        description: 'Ghost process name',
-        type: 'string'
-    }
-}, advancedOptions);
+ConfigCommand.options = advancedOptions;
 
 module.exports = ConfigCommand;

lib/commands/doctor/checks/setup.js

@@ -38,7 +38,7 @@ module.exports = [{
             });
         }
 
-        return promise.then(() => { return {continue: true}; }).catch((error) => {
+        return promise.then(() => { return {yes: true}; }).catch((error) => {
             // If the error caught is not a SystemError, something went wrong with execa,
             // so throw a ProcessError instead
             if (!(error instanceof errors.SystemError)) {
@@ -57,14 +57,9 @@ module.exports = [{
                 'yellow'
             );
 
-            return context.ui.prompt({
-                type: 'confirm',
-                name: 'continue',
-                message: chalk.blue('Continue anyways?'),
-                default: true
-            });
+            return context.ui.confirm(chalk.blue('Continue anyways?'), true);
         }).then(
-            (answers) => answers.continue || Promise.reject(new errors.SystemError(
+            (answer) => answer.yes || Promise.reject(new errors.SystemError(
                 `Setup was halted. Ghost is installed but not fully setup.${os.EOL}` +
                 'Fix any errors shown and re-run `ghost setup`, or run `ghost setup --no-stack`.'
             ))

lib/commands/install.js

@@ -17,9 +17,9 @@ const yarnInstall = require('../tasks/yarn-install');
 const SetupCommand = require('./setup');
 
 class InstallCommand extends Command {
-    static configureOptions(commandName, yargs) {
-        yargs = super.configureOptions(commandName, yargs);
-        return SetupCommand.configureOptions('setup', yargs);
+    static configureOptions(commandName, yargs, extensions) {
+        yargs = super.configureOptions(commandName, yargs, extensions);
+        return SetupCommand.configureOptions('setup', yargs, extensions);
     }
 
     run(argv) {

lib/commands/run.js

@@ -16,7 +16,6 @@ class RunCommand extends Command {
         instance.loadConfig(true);
 
         process.env.paths__contentPath = path.join(process.cwd(), 'content');
-        this.service.setConfig(instance.config);
 
         this.child = spawn(process.execPath, ['current/index.js'], {
             cwd: process.cwd(),
@@ -30,11 +29,11 @@ class RunCommand extends Command {
 
         this.child.on('message', (message) => {
             if (message.started) {
-                this.service.process.success();
+                instance.process.success();
                 return;
             }
 
-            this.service.process.error(message.error);
+            instance.process.error(message.error);
         });
     }
 

lib/commands/setup.js

@@ -1,15 +1,41 @@
 'use strict';
-const path  = require('path');
+const url            = require('url');
+const path           = require('path');
+const get            = require('lodash/get');
+const omit           = require('lodash/omit');
 
-const setupChecks           = require('./doctor/checks/setup');
-const StartCommand          = require('./start');
-const ConfigCommand         = require('./config');
-const Command               = require('../command');
+const errors         = require('../errors');
+const Command        = require('../command');
+const setupChecks    = require('./doctor/checks/setup');
+const StartCommand   = require('./start');
+const ConfigCommand  = require('./config');
 
 class SetupCommand extends Command {
-    static configureOptions(commandName, yargs) {
-        yargs = super.configureOptions(commandName, yargs);
-        return ConfigCommand.configureOptions('config', yargs);
+    static configureOptions(commandName, yargs, extensions) {
+        extensions.forEach((extension) => {
+            let options = get(extension, 'config.options.setup', false);
+            if (!options) {
+                return;
+            }
+
+            Object.assign(this.options, omit(options, Object.keys(this.options)));
+        });
+
+        yargs = super.configureOptions(commandName, yargs, extensions);
+        return ConfigCommand.configureOptions('config', yargs, extensions);
+    }
+
+    constructor(ui, system) {
+        super(ui, system);
+
+        this.stages = [];
+    }
+
+    addStage(name, fn) {
+        this.stages.push({
+            name: name,
+            fn: fn
+        });
     }
 
     run(argv) {
@@ -32,41 +58,78 @@ class SetupCommand extends Command {
             this.system.setEnvironment(true, true);
         }
 
-        return this.ui.listr([{
-            title: 'Configuring Ghost',
-            task: () => this.runCommand(ConfigCommand, argv)
-        }, {
+        let initialStages = [{
             title: 'Running setup checks',
             skip: () => !argv.stack,
             task: () => this.ui.listr(setupChecks, false)
         }, {
-            title: 'Finishing setup',
-            task: (ctx) => {
+            title: 'Setting up instance',
+            task: () => {
                 let instance = this.system.getInstance();
                 instance.loadConfig();
+                instance.name = argv.pname || url.parse(instance.config.get('url')).hostname.replace(/\./g, '-');
                 this.system.addInstance(instance);
-
-                this.service.setConfig(instance.config);
-                return this.service.callHook('setup', ctx);
             }
-        }], {setup: true}).then(() => {
-            let promise = argv.start ? Promise.resolve({start: true}) : this.ui.prompt({
-                type: 'confirm',
-                name: 'start',
-                message: 'Do you want to start Ghost?',
-                default: true
+        }];
+
+        if (argv.stage) {
+            return this.system.hook('setup', this, argv).then(() => {
+                let stage = this.stages.find(stage => stage.name === argv.stage);
+
+                if (!stage) {
+                    throw new errors.SystemError(`No setup stage '${argv.stage} exists`);
+                }
+
+                return this.ui.listr([{
+                    title: `Setting up ${stage.name}`,
+                    task: (ctx, task) => stage.fn(argv, Object.assign(ctx, {single: true}), task)
+                }]);
             });
+        }
+
+        return this.ui.run(() => this.runCommand(ConfigCommand, argv), 'Configuring Ghost').then(
+            () => this.system.hook('setup', this, argv)
+        ).then(() => {
+            let tasks = initialStages.concat(this.stages.map((stage) => {
+                return {
+                    title: `Setting up ${stage.name}`,
+                    task: (ctx, task) => {
+                        if (argv[`setup-${stage.name}`] === false) {
+                            return task.skip();
+                        }
 
-            return promise.then((answer) => {
-                if (answer.start) {
-                    return this.runCommand(StartCommand, argv);
+                        if (!argv.prompt) {
+                            // Prompt has been disabled and there has not been a `--no-setup-<stagename>`
+                            // flag passed, so we will automatically run things
+                            return stage.fn(argv, ctx, task);
+                        }
+
+                        return this.ui.confirm(`Do you wish to set up ${stage.name}?`, true).then((res) => {
+                            if (!res.yes) {
+                                return task.skip();
+                            }
+
+                            return stage.fn(argv, ctx, task);
+                        });
+                    }
+                };
+            }));
+
+            return this.ui.listr(tasks, {setup: true}).then(() => {
+                if (!argv.prompt || argv.start) {
+                    return Promise.resolve({yes: argv.start});
                 }
+
+                return this.ui.confirm('Do you want to start Ghost?', true);
+            }).then((res) => {
+                return res.yes && this.runCommand(StartCommand, argv);
             });
         });
     }
 }
 
 SetupCommand.description = 'Setup an installation of Ghost (after it is installed)';
+SetupCommand.params = '[stage]';
 SetupCommand.options = {
     stack: {
         description: 'Check the system stack on setup',
@@ -82,6 +145,10 @@ SetupCommand.options = {
         name: 'start',
         description: 'Automatically start Ghost without prompting',
         type: 'boolean'
+    },
+    pname: {
+        description: 'Ghost instance name',
+        type: 'string'
     }
 };