cbd-cli/lib/generate.js

const Metalsmith = require("metalsmith");
const Handlebars = require("handlebars");
const async = require("async");
const render = require("consolidate").handlebars.render;
const path = require("path");
const multimatch = require("multimatch");
const getOptions = require("./options");
const ask = require("./ask");
const filter = require("./filter");

// register handlebars helper
Handlebars.registerHelper("if_eq", function(a, b, opts) {
  return a === b ?
    opts.fn(this) :
    opts.inverse(this);
});

Handlebars.registerHelper("unless_eq", function(a, b, opts) {
  return a === b ?
    opts.inverse(this) :
    opts.fn(this);
});

/**
 * Generate a template given a `src` and `dest`.
 *
 * @param {String} name
 * @param {String} src
 * @param {String} dest
 * @param {Function} done
 */

module.exports = function generate(name, src, dest, done) {
  const opts = getOptions(name, src);
  const metalsmith = Metalsmith(path.join(src, "template"));
  const data = Object.assign(metalsmith.metadata(), {
    destDirName: name,

    inPlace: dest === process.cwd(),
    noEscape: true,
  });
  opts.helpers && Object.keys(opts.helpers).map((key) => {
    Handlebars.registerHelper(key, opts.helpers[key]);
  });
  metalsmith
    .metadata({
      createDate: DateFormater.get("yyyy-mm-dd"),
      year: DateFormater.get("yyyy"),
      month: DateFormater.get("mm"),
    })
    .use(askQuestions(opts.prompts))
    .use(filterFiles(opts.filters))
    .use(renderTemplateFiles(opts.skipInterpolation))
    .clean(false)
    .source(".") // start from template root instead of `./src` which is Metalsmith's default for `source`
    .destination(dest)
    .build((err) => {
      done(err);
      logMessage(opts.completeMessage, data);
    });

  return data;
};

/**
 * Create a middleware for asking questions.
 *
 * @param {Object} prompts
 * @return {Function}
 */

function askQuestions(prompts) {
  return function(files, metalsmith, done) {
    ask(prompts, metalsmith.metadata(), done);
  };
}

/**
 * Create a middleware for filtering files.
 *
 * @param {Object} filters
 * @return {Function}
 */

function filterFiles(filters) {
  return function(files, metalsmith, done) {
    filter(files, filters, metalsmith.metadata(), done);
  };
}

/**
 * Template in place plugin.
 *
 * @param {Object} files
 * @param {Metalsmith} metalsmith
 * @param {Function} done
 */

function renderTemplateFiles(skipInterpolation) {
  skipInterpolation = typeof skipInterpolation === "string" ? [skipInterpolation] :
    skipInterpolation;
  return function(files, metalsmith, done) {
    const keys = Object.keys(files);
    const metalsmithMetadata = metalsmith.metadata();
    async.each(keys, (file, next) => {
      // skipping files with skipInterpolation option
      if (skipInterpolation && multimatch([file], skipInterpolation, {
        dot: true
      }).length) {
        return next();
      }
      const str = files[file].contents.toString();
      // do not attempt to render files that do not have mustaches
      if (!/{{([^{}]+)}}/g.test(str)) {
        return next();
      }
      render(str, metalsmithMetadata, (err, res) => {
        if (err) return next(err);
        files[file].contents = new Buffer(res);
        next();
      });
    }, done);
  };
}

/**
 * Display template complete message.
 *
 * @param {String} message
 * @param {Object} data
 */

function logMessage(message, data) {
  if (!message) return;
  render(message, data, (err, res) => {
    if (err) {
      console.error(`\n   Error when rendering template complete message: ${err.message.trim()}`);
    } else {
      console.log(`\n${res.split(/\r?\n/g).map(line => `   ${line}`).join("\n")}`);
    }
  });
}


var DateFormater = (function () {
  // Private methods
  const text = [];
  const repAllText = function (t) {
    const treg = t.match(/('[^']*')|("[^"]*")/ig);
    if (treg) {
      for (let i in treg) {
        t = t.replace(treg[i], `\${${i}}`);
        text.push(treg[i]);
      }
    } else {
      for (let i in text) {
        t = t.replace(`\${${i}}`, text[i].replace(/'|"/g, ""));
      }
    }
    return t;
  };
  const getDate = function (who, date) {
    let check = who.toLowerCase(),
      add = check.match(/[\+-]\d+/),
      result = "";
    if (add) add = parseInt(add, 10);
    else add = 0;
    switch (check.replace(/[\+-]\d+/, "")) {
    case "yyyy":
      date.setFullYear(date.getFullYear() + add);
      result = date.getFullYear();
      break;
    case "yy":
      result = date.getFullYear().toString().substring(2) + add;
      break;
    case "mm":
      date.setMonth(date.getMonth() + add);
      result = dn(date.getMonth() + 1);
      break;
    case "dd":
      date.setDate(date.getDate() + add);
      result = dn(date.getDate());
      break;
    case "h":
      date.setHours(date.getHours() + add);
      result = dn(date.getHours());
      break;
    case "m":
      date.setMinutes(date.getMinutes() + add);
      result = dn(date.getMinutes());
      break;
    case "s":
      result = dn(date.getSeconds());
      break;
    case "ms":
      result = tn(date.getMilliseconds());
      break;
    }
    return result;
  };
  var dn = function (n) {
    if (n < 10) return `0${n}`;
    return n;
  };
  var tn = function (n) {
    if (n < 100 && n >= 10) return `0${n}`;
    else if (n < 10) return `00${n}`;
    return n;
  };
  // Public methods
  return {
    get(f) {
      const reg = /(y{4}|y{2}|m{2}|d{2}|H|ms|M|S)([\+-]\d+)?|(?:\'[^\']*\')/g;
      let vals = f.match(reg),
        now = new Date();
      f = repAllText(f);
      if (vals) {
        for (const step1 in vals) {
          if (/[a-zA-Z][\+-]\d+/.test(vals[step1])) getDate(vals[step1], now);
        }
        f = f.replace(/(y{4}|y{2}|m{2}|d{2}|H|ms|M|S)[\+-]\d+/ig, "$1");
        vals = f.match(reg);
        for (const step2 in vals) f = f.replace(vals[step2], `${getDate(vals[step2], now)}`);
      }
      f = repAllText(f);
      return f;
    },
  };
}());