485 lines
14 KiB
JavaScript
485 lines
14 KiB
JavaScript
(function() {
|
|
/**
|
|
Implementation of the 'build' verb for HackMyResume.
|
|
@module verbs/build
|
|
@license MIT. See LICENSE.md for details.
|
|
*/
|
|
/**
|
|
Reinforce the chosen theme with "freebie" formats provided by HackMyResume.
|
|
A "freebie" format is an output format such as JSON, YML, or PNG that can be
|
|
generated directly from the resume model or from one of the theme's declared
|
|
output formats. For example, the PNG format can be generated for any theme
|
|
that declares an HTML format; the theme doesn't have to provide an explicit
|
|
PNG template.
|
|
@param theTheme A FRESHTheme or JRSTheme object.
|
|
*/
|
|
/**
|
|
Given a source resume in FRESH or JRS format, a destination resume path, and a
|
|
theme file, generate 0..N resumes in the desired formats.
|
|
@param src Path to the source JSON resume file: "rez/resume.json".
|
|
@param dst An array of paths to the target resume file(s).
|
|
@param opts Generation options.
|
|
*/
|
|
/**
|
|
Expand output files. For example, "foo.all" should be expanded to
|
|
["foo.html", "foo.doc", "foo.pdf", "etc"].
|
|
@param dst An array of output files as specified by the user.
|
|
@param theTheme A FRESHTheme or JRSTheme object.
|
|
*/
|
|
/**
|
|
Load the specified theme, which could be either a FRESH theme or a JSON Resume
|
|
theme (or both).
|
|
*/
|
|
/**
|
|
Prepare for a BUILD run.
|
|
*/
|
|
/**
|
|
Generate a single target resume such as "out/rez.html" or "out/rez.doc".
|
|
TODO: Refactor.
|
|
@param targInfo Information for the target resume.
|
|
@param theme A FRESHTheme or JRSTheme object.
|
|
*/
|
|
/** Ensure that user-specified outputs/targets are valid. */
|
|
/**
|
|
Verify the specified theme name/path.
|
|
*/
|
|
var BuildVerb, FRESHTheme, FS, HMEVENT, HMSTATUS, JRSTheme, MD, MKDIRP, PATH, RConverter, RTYPES, ResumeFactory, Verb, _, _addFreebieFormats, _build, _err, _expand, _fmts, _loadTheme, _log, _opts, _prep, _rezObj, _single, _verifyOutputs, _verifyTheme, addFreebieFormats, build, expand, extend, loadTheme, parsePath, prep, single, verifyOutputs, verifyTheme;
|
|
|
|
_ = require('underscore');
|
|
|
|
PATH = require('path');
|
|
|
|
FS = require('fs');
|
|
|
|
MD = require('marked');
|
|
|
|
MKDIRP = require('mkdirp');
|
|
|
|
extend = require('extend');
|
|
|
|
parsePath = require('parse-filepath');
|
|
|
|
RConverter = require('fresh-jrs-converter');
|
|
|
|
HMSTATUS = require('../core/status-codes');
|
|
|
|
HMEVENT = require('../core/event-codes');
|
|
|
|
RTYPES = {
|
|
FRESH: require('../core/fresh-resume'),
|
|
JRS: require('../core/jrs-resume')
|
|
};
|
|
|
|
_opts = require('../core/default-options');
|
|
|
|
FRESHTheme = require('../core/fresh-theme');
|
|
|
|
JRSTheme = require('../core/jrs-theme');
|
|
|
|
ResumeFactory = require('../core/resume-factory');
|
|
|
|
_fmts = require('../core/default-formats');
|
|
|
|
Verb = require('../verbs/verb');
|
|
|
|
_err = null;
|
|
|
|
_log = null;
|
|
|
|
_rezObj = null;
|
|
|
|
build = null;
|
|
|
|
prep = null;
|
|
|
|
single = null;
|
|
|
|
verifyOutputs = null;
|
|
|
|
addFreebieFormats = null;
|
|
|
|
expand = null;
|
|
|
|
verifyTheme = null;
|
|
|
|
loadTheme = null;
|
|
|
|
/** An invokable resume generation command. */
|
|
module.exports = BuildVerb = class BuildVerb extends Verb {
|
|
/** Create a new build verb. */
|
|
constructor() {
|
|
super('build', _build);
|
|
}
|
|
|
|
};
|
|
|
|
_build = function(src, dst, opts) {
|
|
var err, inv, isFRESH, mixed, newEx, orgFormat, problemSheets, results, rez, sheetObjects, sheets, tFolder, targets, theme, toFormat;
|
|
if (!src || !src.length) {
|
|
this.err(HMSTATUS.resumeNotFound, {
|
|
quit: true
|
|
});
|
|
return null;
|
|
}
|
|
_prep.call(this, src, dst, opts);
|
|
// Load input resumes as JSON...
|
|
sheetObjects = ResumeFactory.load(src, {
|
|
format: null,
|
|
objectify: false,
|
|
quit: true,
|
|
inner: {
|
|
sort: _opts.sort,
|
|
private: _opts.private
|
|
}
|
|
}, this);
|
|
// Explicit check for any resume loading errors...
|
|
problemSheets = _.filter(sheetObjects, function(so) {
|
|
return so.fluenterror;
|
|
});
|
|
if (problemSheets && problemSheets.length) {
|
|
problemSheets[0].quit = true; // can't go on
|
|
this.err(problemSheets[0].fluenterror, problemSheets[0]);
|
|
return null;
|
|
}
|
|
// Get the collection of raw JSON sheets
|
|
sheets = sheetObjects.map(function(r) {
|
|
return r.json;
|
|
});
|
|
// Load the theme...
|
|
theme = null;
|
|
this.stat(HMEVENT.beforeTheme, {
|
|
theme: _opts.theme
|
|
});
|
|
try {
|
|
tFolder = _verifyTheme.call(this, _opts.theme);
|
|
if (tFolder.fluenterror) {
|
|
tFolder.quit = true;
|
|
this.err(tFolder.fluenterror, tFolder);
|
|
return;
|
|
}
|
|
theme = _opts.themeObj = _loadTheme(tFolder);
|
|
_addFreebieFormats(theme);
|
|
} catch (error) {
|
|
err = error;
|
|
newEx = {
|
|
fluenterror: HMSTATUS.themeLoad,
|
|
inner: err,
|
|
attempted: _opts.theme,
|
|
quit: true
|
|
};
|
|
this.err(HMSTATUS.themeLoad, newEx);
|
|
return null;
|
|
}
|
|
this.stat(HMEVENT.afterTheme, {
|
|
theme: theme
|
|
});
|
|
// Check for invalid outputs...
|
|
inv = _verifyOutputs.call(this, dst, theme);
|
|
if (inv && inv.length) {
|
|
this.err(HMSTATUS.invalidFormat, {
|
|
data: inv,
|
|
theme: theme,
|
|
quit: true
|
|
});
|
|
return null;
|
|
}
|
|
//# Merge input resumes, yielding a single source resume...
|
|
rez = null;
|
|
if (sheets.length > 1) {
|
|
isFRESH = !sheets[0].basics;
|
|
mixed = _.any(sheets, function(s) {
|
|
if (isFRESH) {
|
|
return s.basics;
|
|
} else {
|
|
return !s.basics;
|
|
}
|
|
});
|
|
this.stat(HMEVENT.beforeMerge, {
|
|
f: _.clone(sheetObjects),
|
|
mixed: mixed
|
|
});
|
|
if (mixed) {
|
|
this.err(HMSTATUS.mixedMerge);
|
|
}
|
|
rez = _.reduceRight(sheets, function(a, b, idx) {
|
|
return extend(true, b, a);
|
|
});
|
|
this.stat(HMEVENT.afterMerge, {
|
|
r: rez
|
|
});
|
|
} else {
|
|
rez = sheets[0];
|
|
}
|
|
orgFormat = rez.basics ? 'JRS' : 'FRESH';
|
|
toFormat = theme.render ? 'JRS' : 'FRESH';
|
|
if (toFormat !== orgFormat) {
|
|
this.stat(HMEVENT.beforeInlineConvert);
|
|
rez = RConverter['to' + toFormat](rez);
|
|
this.stat(HMEVENT.afterInlineConvert, {
|
|
file: sheetObjects[0].file,
|
|
fmt: toFormat
|
|
});
|
|
}
|
|
// Announce the theme
|
|
this.stat(HMEVENT.applyTheme, {
|
|
r: rez,
|
|
theme: theme
|
|
});
|
|
// Load the resume into a FRESHResume or JRSResume object
|
|
_rezObj = new RTYPES[toFormat]().parseJSON(rez, {
|
|
private: _opts.private
|
|
});
|
|
targets = _expand(dst, theme);
|
|
// Run the transformation!
|
|
_.each(targets, function(t) {
|
|
var ref;
|
|
if (this.hasError() && opts.assert) {
|
|
return {};
|
|
}
|
|
t.final = _single.call(this, t, theme, targets);
|
|
if ((ref = t.final) != null ? ref.fluenterror : void 0) {
|
|
t.final.quit = opts.assert;
|
|
this.err(t.final.fluenterror, t.final);
|
|
}
|
|
}, this);
|
|
results = {
|
|
sheet: _rezObj,
|
|
targets: targets,
|
|
processed: targets
|
|
};
|
|
if (this.hasError() && !opts.assert) {
|
|
this.reject(results);
|
|
} else if (!this.hasError()) {
|
|
this.resolve(results);
|
|
}
|
|
return results;
|
|
};
|
|
|
|
_prep = function(src, dst, opts) {
|
|
var that;
|
|
// Cherry-pick options //_opts = extend( true, _opts, opts );
|
|
_opts.theme = (opts.theme && opts.theme.toLowerCase().trim()) || 'modern';
|
|
_opts.prettify = opts.prettify === true;
|
|
_opts.private = opts.private === true;
|
|
_opts.noescape = opts.noescape === true;
|
|
_opts.css = opts.css;
|
|
_opts.pdf = opts.pdf;
|
|
_opts.wrap = opts.wrap || 60;
|
|
_opts.stitles = opts.sectionTitles;
|
|
_opts.tips = opts.tips;
|
|
_opts.errHandler = opts.errHandler;
|
|
_opts.noTips = opts.noTips;
|
|
_opts.debug = opts.debug;
|
|
_opts.sort = opts.sort;
|
|
_opts.wkhtmltopdf = opts.wkhtmltopdf;
|
|
that = this;
|
|
// Set up callbacks for internal generators
|
|
_opts.onTransform = function(info) {
|
|
that.stat(HMEVENT.afterTransform, info);
|
|
};
|
|
_opts.beforeWrite = function(info) {
|
|
that.stat(HMEVENT.beforeWrite, info);
|
|
};
|
|
_opts.afterWrite = function(info) {
|
|
that.stat(HMEVENT.afterWrite, info);
|
|
};
|
|
// If two or more files are passed to the GENERATE command and the TO
|
|
// keyword is omitted, the last file specifies the output file.
|
|
(src.length > 1 && (!dst || !dst.length)) && dst.push(src.pop());
|
|
};
|
|
|
|
_single = function(targInfo, theme, finished) {
|
|
var e, ex, f, fName, fType, outFolder, ret, theFormat;
|
|
ret = null;
|
|
ex = null;
|
|
f = targInfo.file;
|
|
try {
|
|
if (!targInfo.fmt) {
|
|
return {};
|
|
}
|
|
fType = targInfo.fmt.outFormat;
|
|
fName = PATH.basename(f, '.' + fType);
|
|
theFormat = null;
|
|
this.stat(HMEVENT.beforeGenerate, {
|
|
fmt: targInfo.fmt.outFormat,
|
|
file: PATH.relative(process.cwd(), f)
|
|
});
|
|
_opts.targets = finished;
|
|
// If targInfo.fmt.files exists, this format is backed by a document.
|
|
// Fluent/FRESH themes are handled here.
|
|
if (targInfo.fmt.files && targInfo.fmt.files.length) {
|
|
theFormat = _fmts.filter(function(fmt) {
|
|
return fmt.name === targInfo.fmt.outFormat;
|
|
})[0];
|
|
MKDIRP.sync(PATH.dirname(f));
|
|
ret = theFormat.gen.generate(_rezObj, f, _opts);
|
|
} else {
|
|
// Otherwise this is an ad-hoc format (JSON, YML, or PNG) that every theme
|
|
// gets "for free".
|
|
theFormat = _fmts.filter(function(fmt) {
|
|
return fmt.name === targInfo.fmt.outFormat;
|
|
})[0];
|
|
outFolder = PATH.dirname(f);
|
|
MKDIRP.sync(outFolder); // Ensure dest folder exists;
|
|
ret = theFormat.gen.generate(_rezObj, f, _opts);
|
|
}
|
|
} catch (error) {
|
|
e = error;
|
|
ex = e;
|
|
}
|
|
this.stat(HMEVENT.afterGenerate, {
|
|
fmt: targInfo.fmt.outFormat,
|
|
file: PATH.relative(process.cwd(), f),
|
|
error: ex
|
|
});
|
|
if (ex) {
|
|
if (ex.fluenterror) {
|
|
ret = ex;
|
|
} else {
|
|
ret = {
|
|
fluenterror: HMSTATUS.generateError,
|
|
inner: ex
|
|
};
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
_verifyOutputs = function(targets, theme) {
|
|
this.stat(HMEVENT.verifyOutputs, {
|
|
targets: targets,
|
|
theme: theme
|
|
});
|
|
return _.reject(targets.map(function(t) {
|
|
var pathInfo;
|
|
pathInfo = parsePath(t);
|
|
return {
|
|
format: pathInfo.extname.substr(1)
|
|
};
|
|
}), function(t) {
|
|
return t.format === 'all' || theme.hasFormat(t.format);
|
|
});
|
|
};
|
|
|
|
_addFreebieFormats = function(theTheme) {
|
|
// Add freebie formats (JSON, YAML, PNG) every theme gets...
|
|
// Add HTML-driven PNG only if the theme has an HTML format.
|
|
theTheme.formats.json = theTheme.formats.json || {
|
|
freebie: true,
|
|
title: 'json',
|
|
outFormat: 'json',
|
|
pre: 'json',
|
|
ext: 'json',
|
|
path: null,
|
|
data: null
|
|
};
|
|
theTheme.formats.yml = theTheme.formats.yml || {
|
|
freebie: true,
|
|
title: 'yaml',
|
|
outFormat: 'yml',
|
|
pre: 'yml',
|
|
ext: 'yml',
|
|
path: null,
|
|
data: null
|
|
};
|
|
if (theTheme.formats.html && !theTheme.formats.png) {
|
|
theTheme.formats.png = {
|
|
freebie: true,
|
|
title: 'png',
|
|
outFormat: 'png',
|
|
ext: 'yml',
|
|
path: null,
|
|
data: null
|
|
};
|
|
}
|
|
};
|
|
|
|
_expand = function(dst, theTheme) {
|
|
var destColl, targets;
|
|
// Set up the destination collection. It's either the array of files passed
|
|
// by the user or 'out/resume.all' if no targets were specified.
|
|
destColl = (dst && dst.length && dst) || [PATH.normalize('out/resume.all')];
|
|
targets = [];
|
|
destColl.forEach(function(t) {
|
|
var fmat, pa, to;
|
|
to = PATH.resolve(t);
|
|
pa = parsePath(to);
|
|
fmat = pa.extname || '.all';
|
|
return targets.push.apply(targets, fmat === '.all' ? Object.keys(theTheme.formats).map(function(k) {
|
|
var z;
|
|
z = theTheme.formats[k];
|
|
return {
|
|
file: to.replace(/all$/g, z.outFormat),
|
|
fmt: z
|
|
};
|
|
}) : [
|
|
{
|
|
file: to,
|
|
fmt: theTheme.getFormat(fmat.slice(1))
|
|
}
|
|
]);
|
|
});
|
|
return targets;
|
|
};
|
|
|
|
_verifyTheme = function(themeNameOrPath) {
|
|
var exists, tFolder, themesObj;
|
|
// First, see if this is one of the predefined FRESH themes. There are only a
|
|
// handful of these, but they may change over time, so we need to query
|
|
// the official source of truth: the fresh-themes repository, which mounts the
|
|
// themes conveniently by name to the module object, and which is embedded
|
|
// locally inside the HackMyResume installation.
|
|
themesObj = require('fresh-themes');
|
|
if (_.has(themesObj.themes, themeNameOrPath)) {
|
|
tFolder = PATH.join(parsePath(require.resolve('fresh-themes')).dirname, '/themes/', themeNameOrPath);
|
|
} else {
|
|
// Otherwsie it's a path to an arbitrary FRESH or JRS theme sitting somewhere
|
|
// on the user's system (or, in the future, at a URI).
|
|
tFolder = PATH.resolve(themeNameOrPath);
|
|
}
|
|
// In either case, make sure the theme folder exists
|
|
exists = require('path-exists').sync;
|
|
if (exists(tFolder)) {
|
|
return tFolder;
|
|
} else {
|
|
return {
|
|
fluenterror: HMSTATUS.themeNotFound,
|
|
data: _opts.theme
|
|
};
|
|
}
|
|
};
|
|
|
|
_loadTheme = function(tFolder) {
|
|
var exists, theTheme, themeJsonPath;
|
|
themeJsonPath = PATH.join(tFolder, 'theme.json'); // [^1]
|
|
exists = require('path-exists').sync;
|
|
// Create a FRESH or JRS theme object
|
|
theTheme = exists(themeJsonPath) ? new FRESHTheme().open(tFolder) : new JRSTheme().open(tFolder);
|
|
// Cache the theme object
|
|
_opts.themeObj = theTheme;
|
|
return theTheme;
|
|
};
|
|
|
|
// FOOTNOTES
|
|
// ------------------------------------------------------------------------------
|
|
// [^1] We don't know ahead of time whether this is a FRESH or JRS theme.
|
|
// However, all FRESH themes have a theme.json file, so we'll use that as a
|
|
// canary for now, as an interim solution.
|
|
|
|
// Unfortunately, with the exception of FRESH's theme.json, both FRESH and
|
|
// JRS themes are free-form and don't have a ton of reliable distinguishing
|
|
// marks, which makes a simple task like ad hoc theme detection harder than
|
|
// it should be to do cleanly.
|
|
|
|
// Another complicating factor is that it's possible for a theme to be BOTH.
|
|
// That is, a single set of theme files can serve as a FRESH theme -and- a
|
|
// JRS theme.
|
|
|
|
// TODO: The most robust way to deal with all these issues is with a strong
|
|
// theme validator. If a theme structure validates as a particular theme
|
|
// type, then for all intents and purposes, it IS a theme of that type.
|
|
|
|
}).call(this);
|
|
|
|
//# sourceMappingURL=build.js.map
|