[WIP] Feature/blueprint clone command

src/cli/cmds/clone.js

@@ -0,0 +1,35 @@
+import buildBlueprintCommands from './clone/build-blueprint-commands';
+
+const usage = `Usage:
+  $0 clone <blueprint> <name>
+  $0 help clone <blueprint>`;
+
+module.exports = {
+  command: 'clone <blueprint> <name>',
+  aliases: ['g', 'gen'],
+  describe: 'Clone a blueprint with a different name',
+  builder: yargs => {
+    yargs
+      .usage(usage)
+      .option('dry-run', {
+        alias: 'd',
+        describe: "List files but don't generate them",
+        type: 'boolean'
+      })
+      .option('verbose', {
+        alias: 'v',
+        describe: 'Verbose output, including file contents',
+        type: 'boolean'
+      })
+      .group(['dry-run', 'verbose', 'help'], 'Generate Options:')
+      .updateStrings({
+        'Commands:': 'Blueprints:',
+        'Options:': 'Blueprint Options:'
+      });
+    return buildBlueprintCommands().reduce(
+      (yargs, command) => yargs.command(command),
+      yargs
+    );
+  },
+  handler: argv => console.error(`Unrecognised blueprint '${argv.blueprint}'`)
+};

src/cli/cmds/clone/build-blueprint-command.js

@@ -0,0 +1,96 @@
+/*
+  Build a yargs command module object from options defined in the blueprint
+  https://github.com/yargs/yargs/blob/master/docs/advanced.md#providing-a-command-module
+
+  Target object structure:
+  {
+    command: 'blueprint <name>',
+    aliases: [],
+    describe: 'Generates a blueprint',
+    builder: yargs => yargs,
+    handler: argv => runner.run()
+  }
+*/
+const buildBlueprintCommand = (blueprint, runner) => {
+  // extract custom command pieces
+  let {
+    aliases = [],
+    options,
+    examples,
+    epilog,
+    epilogue,
+    check,
+    sanitize
+  } = blueprint.command;
+
+  // mandate the command name to guarantee name is passed to generate task
+  let command = `${blueprint.name} <name>`;
+
+  // rc aliases override blueprint configuration
+  aliases = [].concat(blueprint.settings.aliases || aliases);
+
+  // default usage
+  let usage = `Usage:\n  $0 clone ${command}`;
+  aliases.forEach(
+    alias =>
+      (usage += `\n  $0 clones ${command.replace(blueprint.name, alias)}`)
+  );
+
+  // default options from settings
+  if (options && blueprint.settings) {
+    Object.keys(options).forEach(option => {
+      if (blueprint.settings[option]) {
+        options[option].default = blueprint.settings[option];
+      }
+    });
+  }
+
+  // alterate epilogue keys
+  epilogue = epilogue || epilog;
+
+  // builder brings together multiple customizations, whilst keeping the
+  // options easy to parse for prompting in the init command
+  const builder = yargs => {
+    yargs.usage(usage).strict(false); // allow undocumented options through
+
+    if (options) yargs.options(options);
+    if (check) yargs.check(check, false);
+    if (examples) {
+      [].concat(examples).forEach(example => yargs.example(example));
+    }
+    if (epilogue) yargs.epilogue(epilogue);
+
+    return yargs;
+  };
+
+  // handler runs the generate blueprint task
+  const handler = argv => {
+    // merge command line options into rc options
+    let options = { ...blueprint.settings, ...argv };
+
+    // tidy up options before passing them on so that all hooks have access
+    // to the clean version
+    if (sanitize) options = sanitize(options);
+
+    const cliArgs = {
+      entity: {
+        name: argv.name,
+        options,
+        rawArgs: argv
+      },
+      debug: argv.verbose || false,
+      dryRun: argv.dryRun || false
+    };
+    runner.run(blueprint.name, cliArgs);
+  };
+
+  return {
+    command,
+    aliases,
+    describe: `Clones ${blueprint.name}`,
+    builder,
+    handler
+  };
+};
+
+export default buildBlueprintCommand;

src/cli/cmds/clone/build-blueprint-commands.js

@@ -0,0 +1,26 @@
+import _merge from 'lodash/merge';
+import _cloneDeep from 'lodash/cloneDeep';
+
+import getEnvironment from '../../environment';
+import Clone from '../../../sub-commands/clone';
+import buildBlueprintCommand from './build-blueprint-command';
+
+const loadBlueprintSettings = (blueprint, bp) =>
+  (blueprint.settings = _merge(
+    _cloneDeep(bp.common),
+    _cloneDeep(bp[blueprint.name])
+  ));
+
+const buildBlueprintCommands = () => {
+  const environment = getEnvironment();
+  const subCommand = new Clone(environment);
+
+  const { blueprints, settings: { bp = {} } } = environment.settings;
+
+  return blueprints.generators().map(blueprint => {
+    loadBlueprintSettings(blueprint, bp);
+    return buildBlueprintCommand(blueprint, subCommand);
+  });
+};
+
+export default buildBlueprintCommands;

src/models/blueprint-cloner.js

@@ -0,0 +1,84 @@
+import path from 'path';
+import { copySync } from 'fs-extra';
+import walkSync from 'walk-sync';
+
+import { fileExists } from '../util/fs';
+
+const FILES_BLACKLIST = ['.ds_store', '.git', '.gitkeep'];
+
+export default class BlueprintCloner {
+  constructor(blueprint, options) {
+    this.blueprint = blueprint;
+    this.options = options || {};
+    this.ui = options.ui;
+  }
+
+  clone() {
+    const blueprint  = this.blueprint;
+    this.ui.writeInfo('cloning blueprint...');
+
+    const cloneToDirectory = this.cloneToDirectory();
+    this.ui.writeInfo('cloning into: ' + cloneToDirectory);
+
+    const blueprintFiles = this.blueprintFiles();
+    this.cloneFiles(blueprint.path, cloneToDirectory, blueprintFiles);
+  }
+
+  cloneFiles(sourceDirectory, cloneToDirectory, files) {
+    files.forEach((file) => {
+      let sourcePath = path.resolve(sourceDirectory, file);
+      let destinationPath = path.resolve(cloneToDirectory, file);
+      this.cloneFile(sourcePath, destinationPath);
+    });
+  }
+
+  cloneFile(sourcePath, destinationPath) {
+    const ui = this.ui;
+    const dryRun = this.options.dryRun;
+
+    ui.writeDebug(`Attempting to clone file: ${destinationPath}`);
+    if (fileExists(destinationPath)) {
+      ui.writeError(
+        `Not writing file.  File already exists at: ${destinationPath}`
+      );
+    } else {
+      if (!dryRun) {
+        copySync(sourcePath, destinationPath);
+        ui.writeCreate(destinationPath);
+      } else {
+        ui.writeWouldCreate(destinationPath);
+      }
+    }
+  }
+
+  cloneToDirectory() {
+    const settings = this.options.settings;
+
+    // settings.blueprints.searchPaths[0] will be settings.cloneTo
+    return path.resolve(settings.blueprints.searchPaths[0], this.newBlueprintName());
+  }
+
+  newBlueprintName() {
+    const options = this.options;
+
+    if(options.entity) {
+      return options.entity.name;
+    }
+  }
+
+  blueprintFiles() {
+    const blueprint = this.blueprint;
+    let blueprintFiles = walkSync(blueprint.path, { directories: false, ignore: FILES_BLACKLIST });
+    blueprintFiles = this.filterBlacklistedFiles(blueprintFiles);
+    return blueprintFiles;
+  }
+
+  filterBlacklistedFiles(files) {
+    return files.filter((file) => !this.isBlacklistedFile(file));
+  }
+
+  isBlacklistedFile(file) {
+    const fileName = path.basename(file).toLowerCase();
+    return FILES_BLACKLIST.includes(fileName);
+  }
+}

src/sub-commands/clone.js

@@ -0,0 +1,26 @@
+import SubCommand from '../models/sub-command';
+import Blueprint from '../models/blueprint';
+import CloneBlueprint from '../tasks/clone-blueprint';
+import chalk from 'chalk';
+
+// Primary purpose is to take cli args and pass them through
+// to the proper task that will do the generation.
+//
+// Logic for displaying all blueprints and what their options
+// are will live in here.  For now it's pretty baren.
+class Clone extends SubCommand {
+  constructor(options) {
+    super(options);
+    this.cloneTask = new CloneBlueprint(this.environment);
+  }
+
+  run(blueprintName, cliArgs) {
+    if (cliArgs.debug) {
+      this.ui.setWriteLevel('DEBUG');
+    }
+
+    this.cloneTask.run(blueprintName, cliArgs);
+  }
+}
+
+export default Clone;

src/tasks/clone-blueprint.js

@@ -0,0 +1,32 @@
+import Task from '../models/task';
+import BlueprintCloner from '../models/blueprint-cloner';
+
+export default class extends Task {
+  constructor(environment) {
+    super(environment);
+  }
+
+  run(blueprintName, cliArgs) {
+    const blueprint = this.lookupBlueprint(blueprintName);
+
+    const entity = {
+      name: cliArgs.entity.name,
+      options: cliArgs.entity.options
+    };
+
+    const blueprintOptions = {
+      originalBlueprintName: blueprintName,
+      ui: this.ui,
+      settings: this.settings,
+      dryRun: cliArgs.dryRun,
+      entity
+    };
+
+    const blueprintCloner = new BlueprintCloner(blueprint, blueprintOptions);
+    blueprintCloner.clone();
+  }
+
+  lookupBlueprint(name) {
+    return this.settings.blueprints.lookup(name);
+  }
+}