[WIP] Feature/blueprint clone command

src/cli/cmds/clone.js

@@ -0,0 +1,25 @@
+import getHandler from '../handler';
+import handlers from './clone/handlers';
+
+getHandler().onRun('clone', handlers.handleRun);
+
+const usage = `Usage:
+  $0 clone <blueprint> <name>`;
+
+module.exports = {
+  command: 'clone <blueprint> <name>',
+  aliases: [],
+  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'
+      })
+      .group(['dry-run', 'help'], 'Clone Options:');
+
+    return yargs;
+  }
+};

src/cli/cmds/clone/handlers.js

@@ -0,0 +1,25 @@
+import getEnvironment from '../../environment';
+import { logYargs } from '../../yargs';
+import Clone from '../../../sub-commands/clone';
+
+const handlers = {
+  handleRun
+};
+
+export default handlers;
+
+function handleRun(argv, yargs, rawArgs = process.argv.slice(3)) {
+  const blueprintName = argv.blueprint;
+  const environment = getEnvironment();
+
+  if (blueprintExists(environment.settings.blueprints, blueprintName)) {
+    const subCommand = new Clone(environment);
+    subCommand.run(argv.blueprint, argv);
+  } else {
+    logYargs(yargs, `Unknown blueprint '${blueprintName}'`);
+  }
+}
+
+function blueprintExists(blueprints, blueprintName) {
+  return blueprints.lookup(blueprintName);
+}

src/models/blueprint-cloner.js

@@ -0,0 +1,90 @@
+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,31 @@
+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.name
+    };
+
+    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);
+  }
+}