Update README image.

Add support for default font specs in FRESH theme.json files. The "all"
format matches any format that doesn't have a specific key in "fonts".

.gitignore

@@ -1,2 +1,40 @@
 node_modules/
 tests/sandbox/
+doc/
+docs/
+local/
+npm-debug.log
+
+# Emacs detritus
+# -*- mode: gitignore; -*-
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+
+# Org-mode
+.org-id-locations
+*_archive
+
+# flymake-mode
+*_flymake.*
+
+# eshell files
+/eshell/history
+/eshell/lastdir
+
+# elpa packages
+/elpa/
+
+# reftex files
+*.rel
+
+# AUCTeX auto folder
+/auto/
+
+# cask packages
+.cask/

.travis.yml

@@ -0,0 +1,9 @@
+language: node_js
+node_js:
+  - "0.10"
+  - "0.11"
+  - "0.12"
+  - "4.0"
+  - "4.1"
+  - "4.2"
+  - "5.0"

CHANGELOG.md

@@ -0,0 +1,306 @@
+CHANGELOG
+=========
+## v1.6.0
+
+### Major Improvements
+
+- Better consistency and coverage for all FRESH resumes and themes ([#45][i45]).
+
+- Initial support for overridable fonts in FRESH themes. Like a particular
+theme, but want to change the typography? The specific fonts used by a theme
+can now be overridden by the user. (FRESH themes only).
+
+- New resume sections! Support for `projects` and `affiliation` resume sections
+for technical and creative projects and memberships / clubs / associations,
+respectively ([#92][i92]).
+
+- New command! `PEEK` at any arbitrary field or entry on your `.json` resume.
+
+### Added
+
+- Improved handling of start and end dates on `employment`, `projects`,
+`education`, and other sections with start/end dates.
+
+- Support for an `.ignore` property on any FRESH or JSON Resume section or field.
+Ignored properties will be treated by HackMyResume as if they weren't present.
+
+- Emit extended status and error info with the `--debug` or `-d` switch.
+
+- The `-o` or `--options` switch can now handle either the path to a **JSON
+settings file** or **raw JSON/JavaScript**. Since the JSON double quote syntax
+is a bit cumbersome from the command line, HackMyResume accepts regular
+JavaScript object literal syntax:
+
+        hackmyresume build resume.json -o "{ theme: 'compact', silent: 'true' }"
+
+- Ability to disable sorting of resume sections (employments, projects, etc.)
+with the `--no-sort` option. HMR will respect the order of items as they appear
+in your resume `.json` file.
+
+- Improvements to the starter resume emitted by `hackmyresume new`.
+
+- Theme Authoring: Annotated the HTML and MS Word (XML) formats of the Modern
+theme for FRESH theme authors.
+
+- Theme Authoring: Support for templatized CSS files in FRESH themes. CSS files
+are now expanded via Handlebars or Underscore prior to copying to the
+destination.
+
+- Added CHANGELOG.md (this file).
+
+### Changed
+
+- Rewrote the HackMyResume man/help page.
+
+- Minor incremental updates to the [FRESCA][fresca] schema.
+
+- PDF generation now uses asynchronous `spawn()` which has better compatibility
+with old or boutique versions of Node.js.
+
+- Refactored colors in HackMyResume output. Errors will now display as red,
+warnings as yellow, successful operations as green, and informational messages
+as cyan.
+
+- Theme messages and usage tips will no longer display during resume generation
+by default. Use the `--tips` option to view them.
+
+- The `--no-tips` option (default: false) has been replaced with the `--tips`
+option, also defaulting to false.
+
+- Removed the `hello-world` theme from the [prebuilt themes][themes] that ship
+with HackMyResume. It can be installed separately from NPM:
+
+  ```bash
+  npm install fresh-theme-hello-world
+  hackmyresume resume.json -t node_modules/fresh-theme-hello-world
+  ```
+
+- sd
+
+### Fixed
+
+- PDF generation issues on older versions of Node.
+
+- Stack traces not being emitted correctly.
+
+- Missing `speaking` section will now appear on generated resumes ([#101][i101]).
+
+- Incomplete `education` details will now appear on generated resumes ([#65][i65]).
+
+- Missing employment end date being interpreted as "employment ends today"
+([#84][i84]).
+
+- Merging multiple source resumes during `BUILD` sometimes fails.
+
+- Document `--pdf` flag in README ([#111][i111]).
+
+### Internal
+
+- Logging messages have been moved out of core HackMyResume code ahead of
+localization support.
+
+- All HackMyResume console output is described in `msg.yml`.
+
+- Relaxed pure JavaScript requirement. CoffeeScript will now start appearing
+in HackMyResume and FluentCV sources!
+
+- Additional tests.
+
+## v1.5.2
+
+### Fixed
+
+- Tweak stack trace under `--debug`.
+
+## v1.5.1
+
+### Added
+
+- Preliminary support for `-d` or `--debug` flag. Forces HackMyResume to emit a stack trace under error conditions.
+
+## v1.5.0
+
+### Added
+
+- HackMyResume now supports **CLI-based generation of PDF formats across multiple engines (Phantom, wkhtmltopdf, etc)**. Instead of talking to these engines over a programmatic API, as in prior versions, HackMyResume 1.5+ speaks to them over the same command-line interface (CLI) you'd use if you were using these tools directly.
+
+- HackMyResume will now (attempt to) **generate a PDF output for JSON Resume themes** (in addition to HTML).
+
+- Minor README and FAQ additions.
+
+### Changed
+
+- **Cleaner, quicker installs**. Installing HackMyResume with `npm install hackmyresume -g` will no longer trigger a lengthy, potentially error-prone install for Phantom.js and/or wkhtmltopdf for PDF support. Instead, users can install these engines externally and HMR will use them when present.
+
+- Minor error handling improvements.
+
+### Fixed
+
+- Fixed an error with generating specific formats with the `BUILD` command (#97).
+
+- Fixed numerous latent/undocumented bugs and glitches.
+
+## v1.4.2
+
+### Added
+
+- Introduced [FAQ](https://github.com/hacksalot/HackMyResume/blob/master/FAQ.md).
+- Additional README notes.
+
+## v1.4.1
+
+### Added
+
+- `hackmyresume new` now generates a [valid starter resume with sample data](https://github.com/fluentdesk/fresh-resume-starter).
+
+### Fixed
+
+- Fixed warning message when `hackmyresume new` is run without a filename.
+
+## v1.4.0
+
+### Added
+
+- **"Projects" support**: FRESH resumes and themes can now store and display
+open source, commercial, private, personal, and creative projects.
+- **New command: ANALYZE**. Inspect your resume for gaps, keyword counts, and other metrics. (Experimental.)
+- **Side-by-side PDF generation** with Phantom and wkhtmltopdf. Use the `--pdf` or `-p` flag to pick between `phantom` and `wkhtmltopdf` generation.
+- **Disable PDF generation** with the `--pdf none` switch.
+- **Inherit formats between themes**. Themes can now inherit formats (Word, HTML, .txt, etc.) from other themes. (FRESH themes only.)
+- **Rename resume sections** to different languages or wordings.
+- **Specify complex options via external file**. Use with the `-o` or `--opts` option.
+- **Disable colors** with the `--no-color` flag.
+- **Theme messages and usage tips** instructions will now appear in the default HackMyResume output for the `build` command. Run `hackmyresume build resume.json -t awesome` for an example. Turn off with the `--no-tips` flag.
+- **Treat validation errors as warnings** with the `--assert` switch (VALIDATE command only).
+
+### Fixed
+
+- Fixed a minor glitch in the FRESCA schema.
+- Fixed encoding issues in the `Highlights` section of certain resumes.
+- Fix behavior of `-s` and `--silent` flags.
+
+### Changed
+
+- PDF generation now defaults to Phantom for all platforms, with `wkhtmltopdf`
+accessible with `--pdf wkhtmltopdf`.
+- Resumes are now validated, by default, prior to generation. This
+behavior can be disabled with the `--novalidate` or `--force` switch.
+- Syntax errors in source FRESH and JSON Resumes are now captured for all
+commands.
+- Minor updates to README.
+- Most themes now inherit Markdown and Plain Text formats from the **Basis**
+theme.
+
+### Internal
+
+- Switched from color to chalk.
+- Command invocations now handled through commander.js.
+- Improved FRESH theme infrastructure (more partials, more DRY).
+
+## v1.3.1
+
+### Added
+
+- Add additional Travis badges.
+
+### Fixed
+
+- Fix extraneous console log output when generating a FRESH theme to MS Word.
+- Fix Travis tests on `dev`.
+
+## v1.3.0
+
+### Added
+
+- **Local generation of JSON Resume themes**. To use a JSON Resume theme, first install it with `npm install jsonresume-theme-[blah]` (most JSON Resume themes are on NPM). Then pass it into HackMyResume via the `-t` parameter:
+
+    `hackmyresume BUILD resume.json TO out/somefile.all -t node_modules/jsonresume-theme-classy`
+- **Better Markdown support.** HackMyResume will start flowing basic Markdown styles to JSON Resume (HTML) themes. FRESH's existing Markdown support has also been improved.
+- **.PNG output formats** will start appearing in themes that declare an HTML output.
+- **Tweak CSS embedding / linking via the --css option** (`<style></style>` vs `<link>`). Only works for HTML (or HTML-driven) formats of FRESH themes. Use `--css=link` to link in CSS assets and `--css=embed` to embed the styles in the HTML document. For example `hackmyresume BUILD resume.json TO out/resume.all --css=link`.
+- **Improved Handlebars/Underscore helper support** for FRESH themes. Handlebars themes can access helpers via `{{helperName}}`. Underscore themes can access helpers via the `h` object.
+
+### Changed
+
+- **Distinguish between validation errors and syntax errors** when validating a FRESH or JRS resume with `hackmyresume validate <blah>`.
+- **Emit line and column info** for syntax errors during validation of FRESH and JRS resumes.
+- **FRESH themes now embed CSS into HTML formats by default** so that the HTML resume output doesn't have an external CSS file dependency by default. Users can specify normal linked stylesheets by setting `--css=link`.
+- **Renamed fluent-themes repo to fresh-themes** in keeping with the other parts of the project.
+
+### Fixed
+
+- Fix various encoding errors in MS Word outputs.
+- Fix assorted FRESH-to-JRS and JRS-to-FRESH conversion glitches.
+- Fix error when running HMR with no parameters.
+- Other minor fixes.
+
+## v1.3.0-beta
+
+- Numerous changes supporting v1.3.0.
+
+## v1.2.2
+
+### Fixed
+
+- Various in-passing fixes.
+
+## v1.2.1
+
+### Fixed
+
+- Fix `require('FRESCA')` error.
+- Fix `.history` and `.map` errors on loading incomplete or empty JRS resumes.
+
+### Added
+
+- Better test coverage of incomplete/empty resumes.
+
+## v1.2.0
+
+### Fixed
+
+- Fixed the `new` command: Generate a new FRESH-format resume with `hackmyresume new resume.json` or a new JSON Resume with `hackmyresume new resume.json -f jrs`.
+
+### Added
+
+- Introduced CLI tests.
+
+## v1.1.0
+
+### Fixed
+
+- MS Word formats: Fixed skill coloring/level bug.
+
+### Changed
+
+- Make the `TO` keyword optional. If no `TO` keyword is specified (for the `build` and `convert` commands), HMR will assume the last file passed in is the desired output file. So these are equivalent:
+
+    ```shell
+    hackmyresume BUILD resume.json TO out/resume.all
+    hackmyresume BUILD resume.json out/resume.all
+    ```
+
+    `TO` only needs to be included if you have multipled output files:
+
+    ```shell
+     hackmyresume BUILD resume.json TO out1.doc out2.html out3.tex
+    ```
+
+## v1.0.1
+
+### Fixed
+
+- Correctly generate MS Word hyperlinks from Markdown source data.
+
+## v1.0.0
+
+- Initial public 1.0 release.
+
+[i45]: https://github.com/hacksalot/HackMyResume/issues/45
+[i65]: https://github.com/hacksalot/HackMyResume/issues/65
+[i84]: https://github.com/hacksalot/HackMyResume/issues/84
+[i92]: https://github.com/hacksalot/HackMyResume/issues/92
+[i101]: https://github.com/hacksalot/HackMyResume/issues/101
+[i111]: https://github.com/hacksalot/HackMyResume/issues/111
+[fresca]: https://github.com/fluentdesk/FRESCA
+[themes]: https://github.com/fluentdesk/fresh-themes

CONTRIBUTING.md

@@ -0,0 +1,58 @@
+Contributing
+============
+
+*Note: HackMyResume is also available as [FluentCV][fcv]. Contributors are
+credited in both.*
+
+HackMyResume needs your help! Our contribution workflow is based on [GitHub
+Flow][flow] and we respond to all pull requests and issues, usually within 24
+hours. HackMyResume has no corporate affiliation and no commercial basis, which
+allows the project to maintain a strict user-first policy, rapid development
+velocity, and a liberal stance on contributions and exotic functionality in
+keeping with the spirit (and name) of the tool.
+
+In short, your code is welcome here.
+
+## How To Contribute
+
+1. Optional: [**open an issue**][iss] identifying the feature or bug you'd like
+to implement or fix. This step isn't required — you can start hacking away on
+HackMyResume without clearing it with us — but helps avoid duplication of work
+and ensures that your changes will be accepted once submitted.
+2. **Fork and clone** the HackMyResume project.
+3. Ideally, **create a new feature branch** (eg, `feat/new-awesome-feature` or
+similar; call it whatever you like) to perform your work in.
+4. **Install dependencies** by running `npm install` in the top-level
+HackMyResume folder.
+5. Make your **commits** as usual.
+6. **Verify** your changes locally with `npm test`.
+7. **Push** your commits.
+7. **Submit a pull request** from your feature branch to the HackMyResume `dev`
+branch.
+8. We'll typically **respond** within 24 hours.
+9. Your awesome changes will be **merged** after verification.
+
+## Project Maintainers
+
+HackMyResume is currently maintained by [hacksalot][ha] with assistance from
+[tomheon][th] and our awesome [contributors][awesome]. Please direct all official
+or internal inquiries to:
+
+```
+admin@hackmyresume.com
+```
+
+You can reach hacksalot directly at:
+
+```
+hacksalot@indevious.com
+```
+
+Thanks! See you out there in the trenches.
+
+[fcv]: https://github.com/fluentdesk/fluentcv
+[flow]: https://guides.github.com/introduction/flow/
+[iss]: https://github.com/hacksalot/HackMyResume/issues
+[ha]: https://github.com/hacksalot
+[th]: https://github.com/tomheon
+[awesome]: https://github.com/hacksalot/HackMyResume/graphs/contributors

FAQ.md

@@ -0,0 +1,228 @@
+Frequently Asked Questions (FAQ)
+================================
+
+## How do I get started with HackMyResume?
+
+1. Install with NPM: `[sudo] npm install hackmyresume -g`.
+
+2. Create a new resume with: `hackmyresume NEW <resume-name>.json`.
+
+3. Test with `hackmyresume BUILD <resume-name>.json`. Look in the `out/` folder.
+
+4. Play around with different themes with the `-t` or `--theme` parameter.
+You can use any [FRESH](https://github.com/fluentdesk/fresh-themes) or
+[JSON Resume](https://jsonresume.org/themes) theme. The latter have to be
+installed first.
+
+## What is FRESH?
+
+FRESH is the **F**luent **R**esume and **E**mployment **S**ystem for **H**umans.
+It's an open-source, user-first workflow, schema, and set of practices for
+technical candidates and recruiters.
+
+## What is FRESCA?
+
+The **F**RESH **R**esume and **E**mployment **SC**hem**A**&mdash;an open-source,
+JSON-driven schema for resumes, CVs, and other employment artifacts. FRESCA is
+the recommended schema/format for FRESH, with optional support for JSON Resume.
+
+## What is JSON Resume?
+
+An [open resume standard](http://jsonresume.org/themes/) sponsored by Hired.com.
+Like FRESCA, JSON Resume is JSON-driven and open-source. Unlike FRESCA, JSON
+Resume targets a worldwide audience where FRESCA is optimized for technical
+candidates.
+
+## Should I use the FRESH or JSON Resume format/schema for my resume?
+
+Both! The workflow we like to use:
+
+1. Create a resume in FRESH format for tooling and analysis.
+2. Convert it to JSON Resume format for additional themes/tools.
+3. Maintain both versions.
+
+Both formats are open-source and both formats are JSON-driven. FRESH was
+designed as a universal container format and superset of existing formats, where
+the JSON Resume format is intended for a generic audience.
+
+## How do I use a FRESH theme?
+
+Several FRESH themes come preinstalled with HackMyResume; others can be
+installed from NPM and GitHub.
+
+### To use a preinstalled FRESH theme:
+
+1. Pass the theme name into HackMyResume via the `--theme` or `-t` parameter:
+
+    ```bash
+    hackmyresume build resume.json --theme compact
+    ```
+
+### To use an external FRESH theme:
+
+1. Install the theme locally. The easiest way to do that is with NPM.
+
+    ```bash
+    npm install fresh-theme-underscore
+    ```
+
+2. Pass the theme folder into HackMyResume:
+
+    ```bash
+    hackmyresume BUILD resume.json --theme node_modules/fresh-theme-underscore
+    ```
+
+3. Check your output folder. It's best to view HTML formats over a local web
+server connection.
+
+## How do I use a JSON Resume theme?
+
+JSON Resume (JRS) themes can be installed from NPM and GitHub and passed into
+HackMyResume via the `--theme` or `-t` parameter.
+
+1. Install the theme locally. The easiest way to do that is with NPM.
+
+    ```bash
+    npm install jsonresume-theme-classy
+    ```
+
+2. Pass the theme folder path into HackMyResume:
+
+    ```bash
+    hackmyresume BUILD resume.json --theme node_modules/jsonresume-theme-classy
+    ```
+
+3. Check your output folder. It's best to view HTML formats over a local web
+server connection.
+
+## Should I keep my resume in version control?
+
+Absolutely! As text-based, JSON-driven documents, both FRESH and JSON Resume are
+ideal candidates for version control. Future versions of HackMyResume will have
+this functionality built in.
+
+## Can I change the default section titles ("Employment", "Skills", etc.)?
+
+If you're using a FRESH theme, yes. First, create a HackMyResume options file
+mapping resume sections to your preferred section title:
+
+```javascript
+// myoptions.json
+{
+  "sectionTitles": {
+    "employment": "empleo",
+    "skills": "habilidades",
+    "education": "educación"
+  }
+}
+```
+
+Then, pass the options file into the `-o` or `--opts` parameter:
+
+```bash
+hackmyresume BUILD resume.json -o myoptions.json
+```
+
+This ability is currently only supported for FRESH resume themes.
+
+## How does resume merging work?
+
+Resume merging is a way of storing your resume in separate files that
+HackMyResume will merge into a single "master" resume file prior to generating
+specific output formats like HTML or PDF. It's a way of producing flexible,
+configurable, targeted resumes with minimal duplication.
+
+For example, a software developer who moonlights as a game programmer might
+create three FRESH or JRS resumes at different levels of specificity:
+
+- **generic.json**: A generic technical resume, suitable for all audiences.
+- **game-developer.json**: Overrides and amendments for game developer
+positions.
+- **blizzard.json**: Overrides and amendments specific to a hypothetical
+position at Blizzard.
+
+If you run `hackmyresume BUILD generic.json TO out/resume.all`, HMR will
+generate all available output formats for the `generic.json` as usual. But if
+you instead run...
+
+```bash
+hackmyresume BUILD generic.json game-developer.json TO out/resume.all
+```
+
+...HackMyResume will notice that multiple source resumes were specified and
+merge `game-developer.json` onto `generic.json` before generating, yielding a
+resume that's more suitable for game-developer-related positions.
+
+You can take this a step further. Let's say you want to do a targeted resume
+submission to a game developer position at Blizzard, and `blizzard.json`
+contains the edits and revisions you'd like to show up in the targeted resume.
+In that case, merge again! Feed all three resumes to HackMyResume, in order
+from most generic to most specific, and HMR will merge them all prior to
+generating the final output format(s) for your resume.
+
+```bash
+# Merge blizzard.json onto game-developer.json onto generic.json, then build
+hackmyresume BUILD generic.json game-developer.json blizzard.json TO out/resume.all
+```
+
+There's no limit to the number of resumes you can merge this way.
+
+You can also divide your resume into files containing different sections:
+
+- **resume-a.json**: Contains `info`, `employment`, and `summary` sections.
+- **resume-b.json**: Contains all other sections except `references`.
+- **references.json**: Contains the private `references` section.
+
+Under that scenario, `hackmyresume BUILD resume-a.json resume-b.json` would
+
+
+## The HackMyResume terminal color scheme is giving me a headache. Can I disable it?
+
+Yes. Use the `--no-color` option to disable terminal colors:
+
+`hackmyresume <somecommand> <someoptions> --no-color`
+
+## What's the difference between a FRESH theme and a JSON Resume theme?
+
+FRESH themes are multiformat (HTML, Word, PDF, etc.) and required to support
+Markdown formatting, configurable section titles, and various other features.
+
+JSON Resume themes are typically HTML-driven, but capable of expansion to other
+formats through tools. JSON Resume themes don't support Markdown natively, but
+HMR does its best to apply your Markdown, when present, to any JSON Resume
+themes it encounters.
+
+## Do I have to have a FRESH resume to use a FRESH theme or a JSON Resume to use a JSON Resume theme?
+
+No. You can mix and match FRESH and JRS-format themes freely. HackMyResume will
+perform the necessary conversions on the fly.
+
+## Can I build my own custom FRESH theme?
+
+Yes. The easiest way is to copy an existing FRESH theme, like `modern` or
+`compact`, and make your changes there. You can test your theme with:
+
+```bash
+hackmyresume build resume.json --theme path/to/my/theme/folder
+```
+
+## Can I build my own custom JSON Resume theme?
+
+Yes. The easiest way is to copy an existing JSON Rsume theme and make your
+changes there. You can test your theme with:
+
+```bash
+hackmyresume build resume.json --theme path/to/my/theme/folder
+```
+
+## Can I build my own tools / services / apps / websites around FRESH / FRESCA?
+
+Yes! FRESH/FRESCA formats are 100% open source, permissively licensed under MIT,
+and 100% free from company-specific, tool-specific, or commercially oriented
+lock-in or cruft. These are clean formats designed for users and builders.
+
+## Can I build my own tools / services / apps / websites around JSON Resume?
+
+Yes! HackMyResume is not affiliated with JSON Resume, but like FRESH/FRESCA,
+JSON Resume is open-source, permissively licensed, and free of proprietary
+lock-in. See the JSON Resume website for details.

Gruntfile.js

@@ -1,7 +1,7 @@
-'use strict';
-
 module.exports = function (grunt) {
 
+  'use strict';
+
   var opts = {
 
     pkg: grunt.file.readJSON('package.json'),
@@ -14,16 +14,57 @@ module.exports = function (grunt) {
         ui: 'bdd',
         reporter: 'spec'
       },
-      all: { src: ['tests/*.js'] }
+      all: { src: ['test/*.js'] }
+    },
+
+    jsdoc : {
+      dist : {
+        src: ['src/**/*.js'],
+        options: {
+          private: true,
+          destination: 'doc'
+        }
+      }
+    },
+
+    clean: ['test/sandbox'],
+
+    yuidoc: {
+      compile: {
+        name: '<%= pkg.name %>',
+        description: '<%= pkg.description %>',
+        version: '<%= pkg.version %>',
+        url: '<%= pkg.homepage %>',
+        options: {
+          paths: 'src/',
+          //themedir: 'path/to/custom/theme/',
+          outdir: 'docs/'
+        }
+      }
+    },
+
+    jshint: {
+      options: {
+        laxcomma: true,
+        expr: true
+      },
+      all: ['Gruntfile.js', 'src/**/*.js', 'test/*.js']
     }
 
   };
 
   grunt.initConfig( opts );
+
   grunt.loadNpmTasks('grunt-simple-mocha');
-  grunt.registerTask('test', 'Test the FluentLib library.', function( config ) {
-    grunt.task.run( ['simplemocha:all'] );
-  });
-  grunt.registerTask('default', [ 'test' ]);
+  grunt.loadNpmTasks('grunt-contrib-yuidoc');
+  grunt.loadNpmTasks('grunt-jsdoc');
+  grunt.loadNpmTasks('grunt-contrib-jshint');
+  grunt.loadNpmTasks('grunt-contrib-clean');
+
+  grunt.registerTask('test', 'Test the HackMyResume library.',
+    function( config ) { grunt.task.run(['clean','jshint','simplemocha:all']); });
+  grunt.registerTask('document', 'Generate HackMyResume library documentation.',
+    function( config ) { grunt.task.run( ['jsdoc'] ); });
+  grunt.registerTask('default', [ 'test', 'jsdoc' ]);
 
 };

LICENSE.md

@@ -1,7 +1,7 @@
 The MIT License
 ===============
 
-Copyright (c) 2015 James M. Devlin (https://github.com/devlinjd)
+Copyright (c) 2016 hacksalot (https://github.com/hacksalot)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,64 +1,216 @@
-fluentCV
-========
-*Generate beautiful, targeted resumes from your command line or shell.*
+HackMyResume
+============
 
-FluentCV is a **hackable, data-driven, dev-friendly resume authoring tool** with support for HTML, Markdown, Word, PDF, plain text, smoke signal, carrier pigeon, and other arbitrary-format resumes and CVs.
+[![Latest release][img-release]][latest-release]
+[![Build status (MASTER)][img-master]][travis-url-master]
+[![Build status (DEV)][img-dev]][travis-url-dev]
 
-![](assets/fluentcv_cli_ubuntu.png)
+*Create polished résumés and CVs in multiple formats from your command line or
+shell. Author in clean Markdown and JSON, export to Word, HTML, PDF, LaTeX,
+plain text, and other arbitrary formats. Fight the power, save trees. Compatible
+with [FRESH][fresca] and [JRS][6] resumes.*
 
-Looking for a desktop GUI version with pretty timelines and graphs? Check out [FluentCV Desktop][7].
+![](assets/hackmyresume.cli.1.6.0.png)
+
+HackMyResume is a dev-friendly, local-only Swiss Army knife for resumes and CVs.
+Use it to:
+
+1. **Generate** HTML, Markdown, LaTeX, MS Word, PDF, plain text, JSON, XML,
+YAML, print, smoke signal, carrier pigeon, and other arbitrary-format resumes
+and CVs, from a single source of truth—without violating DRY.
+2. **Analyze** your resume for keyword density, gaps/overlaps, and other
+metrics.
+3. **Convert** resumes between [FRESH][fresca] and [JSON Resume][6] formats.
+4. **Validate** resumes against either format.
+
+HackMyResume is built with Node.js and runs on recent versions of OS X, Linux,
+or Windows. View the [FAQ](FAQ.md).
 
 ## Features
 
-- Runs on OS X, Linux, and Windows.
-- Store your resume data as a durable, versionable JSON, YML, or XML document.
-- Generate multiple targeted resumes in multiple formats, based on your needs.
-- Output to HTML, PDF, Markdown, Word, JSON, YAML, XML, or a custom format.
-- Never update one piece of information in four different resumes again.
-- Compatible with the [JSON Resume standard][6] and [authoring tools][7].
+- OS X, Linux, and Windows.
+- Choose from dozens of FRESH or JSON Resume themes.
+- Private, local-only resume authoring and analysis.
+- Analyze your resume for keywords, gaps, and other metrics.
+- Store your resume data as a durable, versionable JSON or YAML document.
+- Generate polished resumes in multiple formats without violating [DRY][dry].
+- Output to HTML, Markdown, LaTeX, PDF, MS Word, JSON, YAML, plain text, or XML.
+- Validate resumes against the FRESH or JSON Resume schema.
+- Support for multiple input and output resumes.
+- Convert between FRESH and JSON Resume resumes.
+- Use from your command line or [desktop][7].
 - Free and open-source through the MIT license.
-- Forthcoming: StackOverflow and LinkedIn support.
-- Forthcoming: More themes!
+- Updated daily / weekly. Contributions are [welcome](CONTRIBUTING.md).
 
 ## Install
 
-FluentCV requires a recent version of [Node.js][4] and [NPM][5]. Then:
+Install the latest stable version of HackMyResume with NPM:
 
-1. (Optional, for PDF support) Install the latest official [wkhtmltopdf][3] binary for your platform.
-2. Install **fluentCV** by running `npm install fluentcv -g`.
-3. You're ready to go.
+```bash
+[sudo] npm install hackmyresume -g
+```
+
+Alternately, install the latest bleeding-edge version (updated daily):
+
+```bash
+[sudo] npm install hacksalot/hackmyresume#dev -g
+```
+
+## Installing PDF Support (optional)
+
+HackMyResume tries not to impose a specific PDF engine requirement on
+the user, but will instead work with whatever PDF engines you have installed.
+
+Currently, HackMyResume's PDF generation requires either [Phantom.js][2] or
+[wkhtmltopdf][3] to be installed on your system and the `phantomjs` and/or
+`wkhtmltopdf` binaries to be accessible on your PATH. This is an optional
+requirement for users who care about PDF formats. If you don't care about PDF
+formats, skip this step.
+
+## Installing Themes
+
+HackMyResume supports both [FRESH][fresh-themes] and [JSON Resume][jrst]-style
+résumé themes.
+
+- FRESH themes currently come preinstalled with HackMyResume.
+- JSON Resume themes can be installed from NPM, GitHub, or manually.
+
+To install a JSON Resume theme, just `cd` to the folder where you want to store
+your themes and run one of:
+
+```bash
+# Install with NPM
+npm install jsonresume-theme-[theme-name]
+
+# Install with GitHub
+git clone https://github.com/[user-or-org]/[repo-name]
+```
+
+Then when you're ready to generate your resume, just reference the location of
+the theme folder as you installed it:
+
+```bash
+hackmyresume BUILD resume.json TO out/resume.all -t node_modules/jsonresume-theme-classy
+```
+
+Note: You can use install themes anywhere on your file system. You don't need a
+package.json or other NPM/Node infrastructure.
+
+## Getting Started
+
+To use HackMyResume you'll need to create a valid resume in either
+[FRESH][fresca] or [JSON Resume][6] format. Then you can start using the command
+line tool. There are five basic commands you should be aware of:
+
+- **build** generates resumes in HTML, Word, Markdown, PDF, and other formats.
+Use it when you need to submit, upload, print, or email resumes in specific
+formats.
+
+    ```bash
+    # hackmyresume BUILD <INPUTS...> TO <OUTPUTS...> [-t THEME]
+    hackmyresume BUILD resume.json TO out/resume.all
+    hackmyresume BUILD r1.json r2.json TO out/rez.html out/rez.md foo/rez.all
+    ```
+
+- **new** creates a new resume in FRESH or JSON Resume format.
+
+    ```bash
+    # hackmyresume NEW <OUTPUTS...> [-f <FORMAT>]
+    hackmyresume NEW resume.json
+    hackmyresume NEW resume.json -f fresh
+    hackmyresume NEW r1.json r2.json -f jrs
+    ```
+
+- **analyze** inspects your resume for keywords, duration, and other metrics.
+
+    ```bash
+    # hackmyresume ANALYZE <INPUTS...>
+    hackmyresume ANALYZE resume.json
+    hackmyresume ANALYZE r1.json r2.json
+    ```
+
+- **convert** converts your source resume between FRESH and JSON Resume
+formats. Use it to convert between the two formats to take advantage of tools
+and services.
+
+    ```bash
+    # hackmyresume CONVERT <INPUTS...> TO <OUTPUTS...>
+    hackmyresume CONVERT resume.json TO resume-jrs.json
+    hackmyresume CONVERT 1.json 2.json 3.json TO out/1.json out/2.json out/3.json
+    ```
+
+- **validate** validates the specified resume against either the FRESH or JSON
+Resume schema. Use it to make sure your resume data is sufficient and complete.
+
+    ```bash
+    # hackmyresume VALIDATE <INPUTS...>
+    hackmyresume VALIDATE resume.json
+    hackmyresume VALIDATE r1.json r2.json r3.json
+    ```
+
+- **peek** echoes your resume or any field, property, or object path on your
+resume to standard output.
+
+    ```bash
+    # hackmyresume PEEK <INPUTS...> [OBJECT-PATH]
+    hackmyresume PEEK rez.json # Echo the whole resume
+    hackmyresume PEEK rez.json info.brief # Echo the "info.brief" field
+    hackmyresume PEEK rez.json employment.history[1] # Echo the 1st job
+    hackmyresume PEEK rez.json rez2.json info.brief # Compare value
+    ```    
+
+## Supported Output Formats
+
+HackMyResume supports these output formats:
+
+Output Format | Ext | Notes
+------------- | --- | -----
+HTML | .html | A standard HTML 5 + CSS resume format that can be viewed in a browser, deployed to a website, etc.
+Markdown | .md | A structured Markdown document that can be used as-is or used to generate HTML.
+LaTeX | .tex | A structured LaTeX document (or collection of documents) that can be processed with pdflatex, xelatex, and similar tools.
+MS Word | .doc | A Microsoft Word office document (XML-driven; WordProcessingML).
+Adobe Acrobat (PDF) | .pdf | A binary PDF document driven by an HTML theme (through wkhtmltopdf).
+plain text | .txt | A formatted plain text document appropriate for emails or copy-paste.
+JSON | .json | A JSON representation of the resume.
+YAML | .yml | A YAML representation of the resume.
+RTF | .rtf | Forthcoming.
+Textile | .textile | Forthcoming.
+image | .png, .bmp | Forthcoming.
 
 ## Use
 
-Assuming you've got a JSON-formatted resume handy, generating resumes in different formats and combinations easy. Just run:
+Assuming you've got a JSON-formatted resume handy, generating resumes in
+different formats and combinations is easy. Just run:
 
 ```bash
-fluentcv [inputs] [outputs] [-t theme].
+hackmyresume BUILD <INPUTS> <OUTPUTS> [-t theme].
 ```
 
-Where `[inputs]` is one or more .json resume files, separated by spaces; `[outputs]` is one or more destination resumes, each prefaced with the `-o` option; and `[theme]` is the desired theme. For example:
+Where `<INPUTS>` is one or more .json resume files, separated by spaces;
+`<OUTPUTS>` is one or more destination resumes, and `<THEME>` is the desired
+theme (default to Modern). For example:
 
 ```bash
 # Generate all resume formats (HTML, PDF, DOC, TXT, YML, etc.)
-fluentcv resume.json -o out/resume.all -t modern
+hackmyresume BUILD resume.json TO out/resume.all -t modern
 
 # Generate a specific resume format
-fluentcv resume.json -o out/resume.html
-fluentcv resume.json -o out/resume.pdf
-fluentcv resume.json -o out/resume.md
-fluentcv resume.json -o out/resume.doc
-fluentcv resume.json -o out/resume.json
-fluentcv resume.json -o out/resume.txt
-fluentcv resume.json -o out/resume.yml
+hackmyresume BUILD resume.json TO out/resume.html
+hackmyresume BUILD resume.json TO out/resume.pdf
+hackmyresume BUILD resume.json TO out/resume.md
+hackmyresume BUILD resume.json TO out/resume.doc
+hackmyresume BUILD resume.json TO out/resume.json
+hackmyresume BUILD resume.json TO out/resume.txt
+hackmyresume BUILD resume.json TO out/resume.yml
 
 # Specify 2 inputs and 3 outputs
-fluentcv in1.json in2.json -o out.html -o out.doc -o out.pdf
+hackmyresume BUILD in1.json in2.json TO out.html out.doc out.pdf
 ```
 
 You should see something to the effect of:
 
 ```
-*** FluentCV v0.7.0 ***
+*** HackMyResume v1.4.0 ***
 Reading JSON resume: foo/resume.json
 Applying MODERN Theme (7 formats)
 Generating HTML resume: out/resume.html
@@ -74,28 +226,56 @@ Generating YAML resume: out/resume.yml
 
 ### Applying a theme
 
-You can specify a predefined or custom theme via the optional `-t` parameter. For a predefined theme, include the theme name. For a custom theme, include the path to the custom theme's folder.
+HackMyResume can work with any FRESH or JSON Resume theme (the latter must be
+installed first). To specify a theme when generating your resume, use the `-t`
+or `--theme` parameter:
 
 ```bash
-fluentcv resume.json -t modern
-fluentcv resume.json -t ~/foo/bar/my-custom-theme/
+hackmyresume BUILD resume.json TO out/rez.all -t [theme]
 ```
 
-As of v0.7.0, available predefined themes are `modern`, `minimist`, and `hello-world`.
+The `[theme]` parameter can be the name of a predefined theme OR the path to any
+FRESH or JSON Resume theme folder:
+
+```bash
+hackmyresume BUILD resume.json TO out/rez.all -t modern
+hackmyresume BUILD resume.json TO OUT.rez.all -t ../some-folder/my-custom-theme/
+hackmyresume BUILD resume.json TO OUT.rez.all -t node_modules/jsonresume-theme-classy
+```
+
+FRESH themes are currently pre-installed with HackMyResume. JSON Resume themes
+can be installed prior to use:
+
+```bash
+# Install a JSON Resume theme into a local node_modules subfolder:
+npm install jsonresume-theme-[name]
+# Use it with HackMyResume
+hackmyresume build resume.json -t node_modules/jsonresume-theme-[name]
+```
+
+As of v1.6.0, available predefined FRESH themes are `positive`, `modern`,
+`compact`, `minimist`, and `hello-world`. For a list of JSON Resume themes,
+check the [NPM Registry](https://www.npmjs.com/search?q=jsonresume-theme).
 
 ### Merging resumes
 
-You can **merge multiple resumes together** by specifying them in order from most generic to most specific:
+You can **merge multiple resumes together** by specifying them in order from
+most generic to most specific:
 
 ```bash
 # Merge specific.json onto base.json and generate all formats
-fluentcv base.json specific.json -o resume.all
+hackmyresume BUILD base.json specific.json TO resume.all
 ```
 
-This can be useful for overriding a base (generic) resume with information from a specific (targeted) resume. For example, you might override your generic catch-all "software developer" resume with specific details from your targeted "game developer" resume, or combine two partial resumes into a "complete" resume. Merging follows conventional [extend()][9]-style behavior and there's no arbitrary limit to how many resumes you can merge:
+This can be useful for overriding a base (generic) resume with information from
+a specific (targeted) resume. For example, you might override your generic
+catch-all "software developer" resume with specific details from your targeted
+"game developer" resume, or combine two partial resumes into a "complete"
+resume. Merging follows conventional [extend()][9]-style behavior and there's
+no arbitrary limit to how many resumes you can merge:
 
 ```bash
-fluentcv in1.json in2.json in3.json in4.json -o out.html -o out.doc
+hackmyresume BUILD in1.json in2.json in3.json in4.json TO out.html out.doc
 Reading JSON resume: in1.json
 Reading JSON resume: in2.json
 Reading JSON resume: in3.json
@@ -107,37 +287,231 @@ Generating WORD resume: out.doc
 
 ### Multiple targets
 
-You can specify **multiple output targets** and FluentCV will build them:
+You can specify **multiple output targets** and HackMyResume will build them:
 
 ```bash
 # Generate out1.doc, out1.pdf, and foo.txt from me.json.
-fluentcv me.json -o out1.doc -o out1.pdf -o foo.txt
-```
-
-You can also omit the output file(s) and/or theme completely:
-
-```bash
-# Equivalent to "fluentcv resume.json resume.all -t modern"
-fluentcv resume.json
+hackmyresume BUILD me.json TO out1.doc out1.pdf foo.txt
 ```
 
 ### Using .all
 
-The special `.all` extension tells FluentCV to generate all supported output formats for the given resume. For example, this...
+The special `.all` extension tells HackMyResume to generate all supported output
+formats for the given resume. For example, this...
 
 ```bash
 # Generate all resume formats (HTML, PDF, DOC, TXT, etc.)
-fluentcv me.json -o out/resume.all
+hackmyresume BUILD me.json TO out/resume.all
 ```
 
-..tells FluentCV to read `me.json` and generate `out/resume.md`, `out/resume.doc`, `out/resume.html`, `out/resume.txt`, `out/resume.pdf`, and `out/resume.json`.
+..tells HackMyResume to read `me.json` and generate `out/resume.md`,
+`out/resume.doc`, `out/resume.html`, `out/resume.txt`, `out/resume.pdf`, and
+`out/resume.json`.
+
+### Building PDFs
+
+*Users who don't care about PDFs can turn off PDF generation across all themes
+and formats with the `--pdf none` switch.*
+
+HackMyResume takes a unique approach to PDF generation. Instead of enforcing
+a specific PDF engine on users, HackMyResume will attempt to work with whatever
+PDF engine you have installed through the engine's command-line interface (CLI).
+Currently that means one or both of...
+
+- [wkhtmltopdf][3]
+- [Phantom.js][3]
+
+..with support for other engines planned in the future. But for now, **one or
+both of these engines must be installed and accessible on your PATH in order to
+generate PDF resumes with HackMyResume**. That means you should be able to
+invoke either of these tools directly from your shell or terminal without error:
+
+```bash
+wkhtmltopdf input.html output.pdf
+phantomjs script.js input.html output.pdf
+```
+
+Assuming you've installed one or both of these engines on your system, you can
+tell HackMyResume which flavor of PDF generation to use via the `--pdf` option
+(`-p` for short):
+
+```bash
+hackmyresume BUILD resume.json TO out.all --pdf phantom
+hackmyresume BUILD resume.json TO out.all --pdf wkhtmltopdf
+hackmyresume BUILD resume.json TO out.all --pdf none
+```
+
+### Analyzing
+
+HackMyResume can analyze your resume for keywords, employment gaps, and other
+metrics. Run:
+
+```bash
+hackmyresume ANALYZE <my-resume>.json
+```
+
+Depending on the HackMyResume version, you should see output similar to:
+
+
+```
+*** HackMyResume v1.6.0 ***
+Reading resume: resume.json
+Analyzing FRESH resume: resume.json
+
+SECTIONS (10):
+
+        employment:    12
+         education:     2
+           service:     1
+            skills:     8
+           writing:     1
+       recognition:     0
+            social:     4
+         interests:     2
+        references:     1
+         languages:     2
+
+COVERAGE (61.1%):
+
+        Total Days:  6034
+          Employed:  3688
+              Gaps:     8  [31, 1065, 273, 153, 671, 61, 61, 31]
+          Overlaps:     1  [243]
+
+KEYWORDS (61):
+
+           Node.js:     6 mentions
+        JavaScript:     9 mentions
+        SQL Server:     3 mentions
+     Visual Studio:     6 mentions
+           Web API:     1 mentions
+   N-tier / 3-tier:     1 mentions
+            HTML 5:     1 mentions
+        JavaScript:     6 mentions
+               CSS:     2 mentions
+Sass / LESS / SCSS:     1 mentions
+              LAMP:     3 mentions
+              WISC:     1 mentions
+              HTTP:    21 mentions
+              JSON:     1 mentions
+               XML:     2 mentions
+              REST:     1 mentions
+        WebSockets:     2 mentions
+       Backbone.js:     3 mentions
+        Angular.js:     1 mentions
+           Node.js:     4 mentions
+               NPM:     1 mentions
+             Bower:     1 mentions
+             Grunt:     2 mentions
+              Gulp:     1 mentions
+            jQuery:     2 mentions
+         Bootstrap:     3 mentions
+     Underscore.js:     1 mentions
+         PhantomJS:     1 mentions
+      CoffeeScript:     1 mentions
+            Python:    11 mentions
+              Perl:     4 mentions
+               PHP:     7 mentions
+             MySQL:    12 mentions
+        PostgreSQL:     4 mentions
+             NoSQL:     2 mentions
+            Apache:     2 mentions
+               AWS:     2 mentions
+               EC2:     2 mentions
+               RDS:     3 mentions
+                S3:     1 mentions
+             Azure:     1 mentions
+         Rackspace:     1 mentions
+               C++:    23 mentions
+            C++ 11:     1 mentions
+             Boost:     1 mentions
+             Xcode:     2 mentions
+               gcc:     1 mentions
+             OO&AD:     1 mentions
+              .NET:    20 mentions
+           Unity 5:     2 mentions
+              Mono:     3 mentions
+       MonoDevelop:     1 mentions
+           Xamarin:     1 mentions
+             TOTAL:   180 mentions
+```
+
+### Validating
+
+HackMyResume can also validate your resumes against either the [FRESH /
+FRESCA][fresca] or [JSON Resume][6] formats. To validate one or more existing
+resumes, use the `validate` command:
+
+```bash
+# Validate myresume.json against either the FRESH or JSON Resume schema.
+hackmyresume VALIDATE resumeA.json resumeB.json
+```
+
+HackMyResume will validate each specified resume in turn:
+
+```bash
+*** HackMyResume v1.6.0 ***
+Validating JSON resume: resumeA.json (INVALID)
+Validating JSON resume: resumeB.json (VALID)
+```
+
+### Converting
+
+HackMyResume can convert between the [FRESH][fresca] and [JSON Resume][6]
+formats. Just run:
+
+```bash
+hackmyresume CONVERT <INPUTS> <OUTPUTS>
+```
+
+where <INPUTS> is one or more resumes in FRESH or JSON Resume format, and
+<OUTPUTS> is a corresponding list of output file names. HackMyResume will
+autodetect the format (FRESH or JRS) of each input resume and convert it to the
+other format (JRS or FRESH).
+
+### File-based Options
+
+You can pass options into HackMyResume via an external options or ".hackmyrc"
+file with the `--options` or `-o` switch:
+
+```bash
+hackmyresume BUILD resume.json -o path/to/options.json
+```
+
+The options file can contain any documented HackMyResume option, including
+`theme`, `silent`, `debug`, `pdf`, `css`, and other settings.
+
+```javascript
+{
+  // Set the default theme to "compact"
+  "theme": "compact",
+  // Change the "employment" section title text to "Work"
+  "sectionTitles": {
+    "employment": "Work"
+  }
+}
+```
+
+If a particular option is specified both on the command line and in an external
+options file, the explicit command-line option takes precedence.
+
+```bash
+# path/to/options.json specifes the POSITIVE theme
+# -t parameter specifies the COMPACT theme
+# The -t parameter wins.
+hackmyresume BUILD resume.json -o path/to/options.json -t compact
+> Reading resume: resume.json
+> Applying COMPACT theme (7 formats)
+```
 
 ### Prettifying
 
-FluentCV applies [js-beautify][10]-style HTML prettification by default to HTML-formatted resumes. To disable prettification, the `--nopretty` or `-n` flag can be used:
+HackMyResume applies [js-beautify][10]-style HTML prettification by default to
+HTML-formatted resumes. To disable prettification, the `--no-prettify` or `-n`
+flag can be used:
 
 ```bash
-fluentcv resume.json out.all --nopretty
+hackmyresume BUILD resume.json out.all --no-prettify
 ```
 
 ### Silent Mode
@@ -145,10 +519,26 @@ fluentcv resume.json out.all --nopretty
 Use `-s` or `--silent` to run in silent mode:
 
 ```bash
-fluentcv resume.json -o someFile.all -s
-fluentcv resume.json -o someFile.all --silent
+hackmyresume BUILD resume.json -o someFile.all -s
+hackmyresume BUILD resume.json -o someFile.all --silent
 ```
 
+### Debug Mode
+
+Use `-d` or `--debug` to force HMR to emit a call stack when errors occur. In
+the future, this option will emit detailed error logging.
+
+```bash
+hackmyresume BUILD resume.json -d
+hackmyresume ANALYZE resume.json --debug
+```
+
+## Contributing
+
+HackMyResume is a community-driven free and open source project under the MIT
+License. Contributions are encouraged and we respond to all PRs and issues,
+usually within 24 hours. See [CONTRIBUTING.md][contribute] for details.
+
 ## License
 
 MIT. Go crazy. See [LICENSE.md][1] for details.
@@ -163,3 +553,15 @@ MIT. Go crazy. See [LICENSE.md][1] for details.
 [8]: https://youtu.be/N9wsjroVlu8
 [9]: https://api.jquery.com/jquery.extend/
 [10]: https://github.com/beautify-web/js-beautify
+[fresh]: https://github.com/fluentdesk/FRESH
+[fresca]: https://github.com/fluentdesk/FRESCA
+[dry]: https://en.wikipedia.org/wiki/Don%27t_repeat_yourself
+[img-release]: https://img.shields.io/github/release/hacksalot/HackMyResume.svg?label=version
+[img-master]: https://img.shields.io/travis/hacksalot/HackMyResume/master.svg
+[img-dev]: https://img.shields.io/travis/hacksalot/HackMyResume/dev.svg?label=dev
+[travis-url-master]: https://travis-ci.org/hacksalot/HackMyResume?branch=master
+[travis-url-dev]: https://travis-ci.org/hacksalot/HackMyResume?branch=dev
+[latest-release]: https://github.com/hacksalot/HackMyResume/releases/latest
+[contribute]: CONTRIBUTING.md
+[fresh-themes]: https://github.com/fluentdesk/fresh-themes
+[jrst]: https://www.npmjs.com/search?q=jsonresume-theme

package.json

@@ -1,48 +1,101 @@
 {
-  "name": "fluentcv",
-  "version": "0.7.0",
-  "description": "Generate beautiful, targeted resumes from your command line, shell, or in Javascript with Node.js.",
+  "name": "hackmyresume",
+  "version": "1.6.0",
+  "description": "Generate polished résumés and CVs in HTML, Markdown, LaTeX, MS Word, PDF, plain text, JSON, XML, YAML, smoke signal, and carrier pigeon.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/fluentdesk/fluentcv.git"
+    "url": "https://github.com/hacksalot/HackMyResume.git"
+  },
+  "scripts": {
+    "test": "grunt clean && mocha",
+    "grunt": "grunt"
   },
   "keywords": [
     "resume",
     "CV",
     "portfolio",
-    "Markdown"
+    "employment",
+    "career",
+    "Markdown",
+    "JSON",
+    "Word",
+    "PDF",
+    "YAML",
+    "HTML",
+    "LaTeX",
+    "CLI",
+    "Handlebars",
+    "Underscore",
+    "template"
+  ],
+  "author": "hacksalot <hacksalot@indevious.com> (https://github.com/hacksalot)",
+  "contributors": [
+    "aruberto (https://github.com/aruberto)",
+    "jjanusch (https://github.com/driftdev)",
+    "robertmain (https://github.com/robertmain)",
+    "tomheon (https://github.com/tomheon)",
+    "zhuangya (https://github.com/zhuangya)",
+    "hacksalot <hacksalot@indevious.com> (https://github.com/hacksalot)"
   ],
-  "author": "James M. Devlin",
   "license": "MIT",
   "preferGlobal": "true",
   "bugs": {
-    "url": "https://github.com/fluentdesk/fluentcv/issues"
+    "url": "https://github.com/hacksalot/HackMyResume/issues"
   },
-  "main": "src/fluentcmd.js",
+  "main": "src/hackmyapi.js",
   "bin": {
-    "fluentcv": "src/index.js"
+    "hackmyresume": "src/index.js"
   },
-  "homepage": "https://github.com/fluentdesk/fluentcv",
+  "homepage": "https://github.com/hacksalot/HackMyResume",
   "dependencies": {
-    "fluent-themes": "0.1.0-beta",
+    "chalk": "^1.1.1",
+    "commander": "^2.9.0",
+    "copy": "^0.1.3",
+    "extend": "^3.0.0",
+    "fresca": "~0.6.0",
+    "fresh-jrs-converter": "^0.2.0",
+    "fresh-resume-starter": "^0.2.2",
+    "fresh-themes": "~0.13.0-beta",
     "fs-extra": "^0.24.0",
+    "handlebars": "^4.0.5",
     "html": "0.0.10",
     "is-my-json-valid": "^2.12.2",
+    "json-lint": "^0.1.0",
     "jst": "0.0.13",
+    "lodash": "^3.10.1",
     "marked": "^0.3.5",
-    "minimist": "^1.2.0",
     "mkdirp": "^0.5.1",
     "moment": "^2.10.6",
+    "parse-filepath": "^0.6.3",
+    "path-exists": "^2.1.0",
+    "printf": "^0.2.3",
+    "recursive-readdir-sync": "^1.0.6",
+    "simple-html-tokenizer": "^0.2.0",
+    "slash": "^1.0.0",
+    "string-padding": "^1.0.2",
+    "string.prototype.endswith": "^0.2.0",
+    "string.prototype.startswith": "^0.2.0",
+    "traverse": "^0.6.6",
     "underscore": "^1.8.3",
-    "wkhtmltopdf": "^0.1.5",
+    "webshot": "^0.16.0",
+    "word-wrap": "^1.1.0",
     "xml-escape": "^1.0.0",
     "yamljs": "^0.2.4"
   },
   "devDependencies": {
     "chai": "*",
+    "fresh-test-resumes": "^0.6.0",
     "grunt": "*",
+    "grunt-cli": "^0.1.13",
+    "grunt-contrib-clean": "^0.7.0",
+    "grunt-contrib-jshint": "^0.11.3",
+    "grunt-contrib-yuidoc": "^0.10.0",
+    "grunt-jsdoc": "^1.1.0",
     "grunt-simple-mocha": "*",
-    "is-my-json-valid": "^2.12.2",
+    "jsonresume-theme-boilerplate": "^0.1.2",
+    "jsonresume-theme-classy": "^1.0.9",
+    "jsonresume-theme-modern": "0.0.18",
+    "jsonresume-theme-sceptile": "^1.0.5",
     "mocha": "*",
     "resample": "fluentdesk/resample"
   }

src/cli/analyze.hbs

@@ -0,0 +1,30 @@
+
+{{style "SECTIONS (" "bold"}}{{style totals.numSections "white" }}{{style ")" "bold"}}
+
+        employment:     {{v totals.totals.employment "-" 2 "bold" }}
+          projects:     {{v totals.totals.projects "-" 2 "bold" }}
+         education:     {{v totals.totals.education "-" 2 "bold" }}
+           service:     {{v totals.totals.service "-" 2 "bold" }}
+            skills:     {{v totals.totals.skills "-" 2 "bold" }}
+           writing:     {{v totals.totals.writing "-" 2 "bold" }}
+          speaking:     {{v totals.totals.speaking "-" 2 "bold" }}
+           reading:     {{v totals.totals.reading "-" 2 "bold" }}
+            social:     {{v totals.totals.social "-" 2 "bold" }}
+        references:     {{v totals.totals.references "-" 2 "bold" }}
+      testimonials:     {{v totals.totals.testimonials "-" 2 "bold" }}
+         languages:     {{v totals.totals.languages "-" 2 "bold" }}
+         interests:     {{v totals.totals.interests "-" 2 "bold" }}
+
+{{style "COVERAGE (" "bold"}}{{style coverage.pct "white"}}{{style ")" "bold"}}
+
+        Total Days:  {{v coverage.duration.total "-" 5 "bold" }}
+          Employed:  {{v coverage.duration.work "-" 5 "bold" }}
+              Gaps:  {{v coverage.gaps.length "-" 5 "bold" }}  [{{#if coverage.gaps.length }}{{#each coverage.gaps }}{{#unless @first}} {{/unless}}{{gapLength duration }}{{/each}}{{/if}}]
+          Overlaps:  {{v coverage.overlaps.length "-" 5 "bold" }}  [{{#if coverage.overlaps.length }}{{#each coverage.overlaps }}{{#unless @first}} {{/unless}}{{gapLength duration }}{{/each}}{{/if}}]
+
+{{style "KEYWORDS (" "bold"}}{{style keywords.length "white" }}{{style ")" "bold"}}
+
+{{#each keywords }}{{{pad name 18}}}:  {{v count "-" 5 "bold"}} mention{{#isPlural count}}s{{/isPlural}}
+{{/each}}
+    -------------------------------
+{{v keywords.length "0" 9 "bold"}} {{style "KEYWORDS" "bold"}}   {{v keywords.totalKeywords "0" 5 "bold"}} {{style "mentions" "bold"}}

src/cli/error.js

@@ -0,0 +1,280 @@
+/**
+Error-handling routines for HackMyResume.
+@module cli/error
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function() {
+
+
+
+  var HMSTATUS = require('../core/status-codes')
+    , PKG = require('../../package.json')
+    , FS = require('fs')
+    , FCMD = require('../hackmyapi')
+    , PATH = require('path')
+    , WRAP = require('word-wrap')
+    , M2C = require('../utils/md2chalk.js')
+    , chalk = require('chalk')
+    , extend = require('extend')
+    , YAML = require('yamljs')
+    , printf = require('printf')
+    , SyntaxErrorEx = require('../utils/syntax-error-ex');
+    require('string.prototype.startswith');
+
+
+
+  /**
+  Error handler for HackMyResume. All errors are handled here.
+  @class ErrorHandler
+  */
+  var ErrorHandler = module.exports = {
+
+
+
+    init: function( debug, assert, silent ) {
+      this.debug = debug;
+      this.assert = assert;
+      this.silent = silent;
+      this.msgs = require('./msg.js').errors;
+      return this;
+    },
+
+
+
+    err: function( ex, shouldExit ) {
+
+      // Short-circuit logging output if --silent is on
+      var o = this.silent ? function() { } : _defaultLog;
+
+      // Special case; can probably be removed.
+      if( ex.pass ) throw ex;
+
+      // Load error messages
+      this.msgs = this.msgs || require('./msg.js').errors;
+
+      // Handle packaged HMR exceptions
+      if( ex.fluenterror ) {
+
+        // Output the error message
+        var objError = assembleError.call( this, ex );
+        o( this[ 'format_' + objError.etype ]( objError.msg ));
+
+        // Output the stack (sometimes)
+        if( objError.withStack ) {
+          var stack = ex.stack || (ex.inner && ex.inner.stack);
+          stack && o( chalk.gray( stack ) );
+        }
+
+        // Quit if necessary
+        if( ex.quit || objError.quit ) {
+          this.debug && o(
+            chalk.cyan('Exiting with error code ' + ex.fluenterror.toString()));
+          if( this.assert ) { ex.pass = true; throw ex; }
+          process.exit( ex.fluenterror );
+        }
+
+      }
+
+      // Handle raw exceptions
+      else {
+        o( ex );
+        var stackTrace = ex.stack || (ex.inner && ex.inner.stack);
+        if( stackTrace && this.debug )
+          o( M2C(ex.stack || ex.inner.stack, 'gray') );
+      }
+
+    },
+
+
+
+    format_error: function( msg ) {
+      msg = msg || '';
+      return chalk.red.bold(
+        msg.toUpperCase().startsWith('ERROR:') ? msg : 'Error: ' + msg );
+    },
+
+
+
+    format_warning: function( brief, msg ) {
+      return chalk.yellow(brief) + chalk.yellow(msg || '');
+    },
+
+
+    format_custom: function( msg ) {
+      return msg;
+    }
+
+
+
+  };
+
+
+
+  function _defaultLog() {
+    console.log.apply( console.log, arguments );
+  }
+
+
+
+  function assembleError( ex ) {
+
+    var msg = '', withStack = false, quit = false, etype = 'warning';
+    if( this.debug ) withStack = true;
+
+    switch( ex.fluenterror ) {
+
+      case HMSTATUS.themeNotFound:
+        msg = printf( M2C( this.msgs.themeNotFound.msg, 'yellow' ), ex.data);
+        break;
+
+      case HMSTATUS.copyCSS:
+        msg = M2C( this.msgs.copyCSS.msg, 'red' );
+        quit = false;
+        break;
+
+      case HMSTATUS.resumeNotFound:
+        msg = M2C( this.msgs.resumeNotFound.msg, 'yellow' );
+        break;
+
+      case HMSTATUS.missingCommand:
+        msg = M2C( this.msgs.missingCommand.msg + " (", 'yellow');
+        msg += Object.keys( FCMD.verbs ).map( function(v, idx, ar) {
+          return (idx === ar.length - 1 ? chalk.yellow('or ') : '') +
+            chalk.yellow.bold(v.toUpperCase());
+        }).join( chalk.yellow(', ')) + chalk.yellow(").\n\n");
+
+        msg += chalk.gray(FS.readFileSync(
+          PATH.resolve(__dirname, '../cli/use.txt'), 'utf8' ));
+        break;
+
+      case HMSTATUS.invalidCommand:
+        msg = printf( M2C( this.msgs.invalidCommand.msg, 'yellow'), ex.attempted );
+        break;
+
+      case HMSTATUS.resumeNotFoundAlt:
+        msg = M2C( this.msgs.resumeNotFoundAlt.msg, 'yellow' );
+        break;
+
+      case HMSTATUS.inputOutputParity:
+        msg = M2C( this.msgs.inputOutputParity.msg );
+        break;
+
+      case HMSTATUS.createNameMissing:
+        msg = M2C( this.msgs.createNameMissing.msg );
+        break;
+
+      case HMSTATUS.pdfGeneration:
+        msg = M2C( this.msgs.pdfGeneration.msg, 'bold' );
+        if( ex.inner ) msg += chalk.red('\n' + ex.inner);
+        withStack = true; quit = false; etype = 'error';
+        break;
+
+      case HMSTATUS.invalid:
+        msg = M2C( this.msgs.invalid.msg, 'red' );
+        etype = 'error';
+        break;
+
+      case HMSTATUS.generateError:
+        msg = (ex.inner && ex.inner.toString()) || ex;
+        quit = false;
+        etype = 'error';
+        break;
+
+      case HMSTATUS.fileSaveError:
+        msg = printf( M2C( this.msgs.fileSaveError.msg ), (ex.inner || ex).toString() );
+        etype = 'error';
+        quit = false;
+        break;
+
+      case HMSTATUS.invalidFormat:
+        ex.data.forEach(function(d){
+          msg += printf( M2C( this.msgs.invalidFormat.msg, 'bold' ),
+            ex.theme.name.toUpperCase(), d.format.toUpperCase());
+        }, this);
+        break;
+
+      case HMSTATUS.missingParam:
+        msg = printf( M2C( this.msgs.missingParam.msg ), ex.expected, ex.helper );
+        break;
+
+      case HMSTATUS.invalidHelperUse:
+        msg = printf( M2C( this.msgs.invalidHelperUse.msg ), ex.helper );
+        if( ex.error ) {
+          msg += '\n--> ' + assembleError.call( this, extend( true, {}, ex, {fluenterror: ex.error} )).msg;
+          //msg += printf( '\n--> ' + M2C( this.msgs.invalidParamCount.msg ), ex.expected );
+        }
+        quit = false;
+        etype = 'warning';
+        break;
+
+      case HMSTATUS.notOnPath:
+        msg = printf( M2C(this.msgs.notOnPath.msg, 'bold'), ex.engine);
+        quit = false;
+        etype = 'error';
+        break;
+
+      case HMSTATUS.readError:
+        if( !ex.quiet )
+          console.error(printf( M2C(this.msgs.readError.msg, 'red'), ex.file));
+        msg = ex.inner.toString();
+        etype = 'error';
+        break;
+
+      case HMSTATUS.mixedMerge:
+        msg = M2C( this.msgs.mixedMerge.msg );
+        quit = false;
+        break;
+
+      case HMSTATUS.invokeTemplate:
+        msg = M2C( this.msgs.invokeTemplate.msg, 'red' );
+        msg += M2C( '\n' + WRAP(ex.inner.toString(), { width: 60, indent: '   ' }), 'gray' );
+        etype = 'custom';
+        break;
+
+      case HMSTATUS.compileTemplate:
+        etype = 'error';
+        break;
+
+      case HMSTATUS.themeLoad:
+        msg = M2C( printf( this.msgs.themeLoad.msg, ex.attempted.toUpperCase() ), 'red');
+        if( ex.inner && ex.inner.fluenterror ) {
+          msg += M2C('\nError: ', 'red') + assembleError.call( this, ex.inner ).msg;
+        }
+        quit = true;
+        etype = 'custom';
+        break;
+
+      case HMSTATUS.parseError:
+        if( SyntaxErrorEx.is( ex.inner )) {
+          console.error( printf( M2C(this.msgs.readError.msg, 'red'), ex.file ) );
+          var se = new SyntaxErrorEx( ex, ex.raw );
+          msg = printf( M2C( this.msgs.parseError.msg, 'red' ),
+            se.line, se.col);
+        }
+        else if( ex.inner && ex.inner.line !== undefined && ex.inner.col !== undefined ) {
+          msg = printf( M2C( this.msgs.parseError.msg, 'red' ),
+            ex.inner.line, ex.inner.col);
+        }
+        else {
+          msg = ex;
+        }
+        etype = 'error';
+        break;
+
+    }
+
+    return {
+      msg: msg,              // The error message to display
+      withStack: withStack,  // Whether to include the stack
+      quit: quit,
+      etype: etype
+    };
+  }
+
+
+
+
+}());

src/cli/main.js

@@ -0,0 +1,331 @@
+/**
+Definition of the `main` function.
+@module cli/main
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function(){
+
+
+
+  var HMR  = require( '../hackmyapi')
+    , PKG = require('../../package.json')
+    , FS = require('fs')
+    , EXTEND = require('extend')
+    , chalk = require('chalk')
+    , PATH = require('path')
+    , HMSTATUS = require('../core/status-codes')
+    , HME = require('../core/event-codes')
+    , safeLoadJSON = require('../utils/safe-json-loader')
+    , StringUtils = require('../utils/string.js')
+    , _ = require('underscore')
+    , OUTPUT = require('./out')
+    , PAD = require('string-padding')
+    , Command = require('commander').Command;
+
+  var _opts = { };
+  var _title = chalk.white.bold('\n*** HackMyResume v' +PKG.version+ ' ***');
+  var _out = new OUTPUT( _opts );
+
+
+
+  /**
+  A callable implementation of the HackMyResume CLI. Encapsulates the command
+  line interface as a single method accepting a parameter array.
+  @alias module:cli/main.main
+  @param rawArgs {Array} An array of command-line parameters. Will either be
+  process.argv (in production) or custom parameters (in test).
+  */
+  var main = module.exports = function( rawArgs ) {
+
+    var initInfo = initialize( rawArgs );
+    var args = initInfo.args;
+
+    // Create the top-level (application) command...
+    var program = new Command('hackmyresume')
+      .version(PKG.version)
+      .description(chalk.yellow.bold('*** HackMyResume ***'))
+      .option('-s --silent', 'Run in silent mode')
+      .option('--no-color', 'Disable colors')
+      .option('--color', 'Enable colors')
+      .option('-d --debug', 'Enable diagnostics', false)
+      .option('-a --assert', 'Treat warnings as errors', false)
+      .option('-v --version', 'Show the version')
+      .allowUnknownOption();
+      program.jsonArgs = initInfo.options;
+
+    // Create the NEW command
+    program
+      .command('new')
+      .arguments('<sources...>')
+      .option('-f --format <fmt>', 'FRESH or JRS format', 'FRESH')
+      .alias('create')
+      .description('Create resume(s) in FRESH or JSON RESUME format.')
+      .action(function( sources ) {
+        execute.call( this, sources, [], this.opts(), logMsg);
+      });
+
+    // Create the VALIDATE command
+    program
+      .command('validate')
+      .arguments('<sources...>')
+      .description('Validate a resume in FRESH or JSON RESUME format.')
+      .action(function(sources) {
+        execute.call( this, sources, [], this.opts(), logMsg);
+      });
+
+    // Create the CONVERT command
+    program
+      .command('convert')
+      .description('Convert a resume to/from FRESH or JSON RESUME format.')
+      .action(function() {
+        var x = splitSrcDest.call( this );
+        execute.call( this, x.src, x.dst, this.opts(), logMsg);
+      });
+
+    // Create the ANALYZE command
+    program
+      .command('analyze')
+      .arguments('<sources...>')
+      .description('Analyze one or more resumes.')
+      .action(function( sources ) {
+        execute.call( this, sources, [], this.opts(), logMsg);
+      });
+
+    // Create the PEEK command
+    program
+      .command('peek')
+      .arguments('<sources...>')
+      .description('Peek at a resume field or section')
+      .action(function( sources, sectionOrField ) {
+        var dst = (sources && sources.length > 1) ? [sources.pop()] : [];
+        execute.call( this, sources, dst, this.opts(), logMsg);
+      });
+
+    // Create the BUILD command
+    program
+      .command('build')
+      .alias('generate')
+      .option('-t --theme <theme>', 'Theme name or path')
+      .option('-n --no-prettify', 'Disable HTML prettification', true)
+      .option('-c --css <option>', 'CSS linking / embedding')
+      .option('-p --pdf <engine>', 'PDF generation engine')
+      .option('--no-sort', 'Sort resume sections by date', false)
+      .option('--tips', 'Display theme tips and warnings.', false)
+      .description('Generate resume to multiple formats')
+      .action(function( sources, targets, options ) {
+        var x = splitSrcDest.call( this );
+        execute.call( this, x.src, x.dst, this.opts(), logMsg);
+      });
+
+    program.parse( args );
+
+    if (!program.args.length) { throw { fluenterror: 4 }; }
+
+  };
+
+
+
+  /** Massage command-line args and setup Commander.js. */
+  function initialize( ar ) {
+
+    var o = initOptions( ar );
+
+    o.silent || logMsg( _title );
+
+    // Emit debug prelude if --debug was specified
+    if( o.debug ) {
+      _out.log(chalk.cyan('The -d or --debug switch was specified. DEBUG mode engaged.'));
+      _out.log('');
+      _out.log(chalk.cyan(PAD('  Platform:',25, null, PAD.RIGHT)) + chalk.cyan.bold( process.platform === 'win32' ? 'windows' : process.platform ));
+      _out.log(chalk.cyan(PAD('  Node.js:',25, null, PAD.RIGHT)) + chalk.cyan.bold( process.version ));
+      _out.log(chalk.cyan(PAD('  HackMyResume:',25, null, PAD.RIGHT)) + chalk.cyan.bold('v' + PKG.version ));
+      _out.log(chalk.cyan(PAD('  FRESCA:',25, null, PAD.RIGHT)) + chalk.cyan.bold( PKG.dependencies.fresca ));
+      _out.log(chalk.cyan(PAD('  fresh-themes:',25, null, PAD.RIGHT)) + chalk.cyan.bold( PKG.dependencies['fresh-themes'] ));
+      _out.log(chalk.cyan(PAD('  fresh-jrs-converter:',25, null, PAD.RIGHT)) + chalk.cyan.bold( PKG.dependencies['fresh-jrs-converter'] ));
+      _out.log('');
+    }
+
+    // Handle invalid verbs here (a bit easier here than in commander.js)...
+    if( o.verb && !HMR.verbs[ o.verb ] && !HMR.alias[ o.verb ] ) {
+      throw { fluenterror: HMSTATUS.invalidCommand, quit: true,
+              attempted: o.orgVerb };
+    }
+
+    // Override the .missingArgument behavior
+    Command.prototype.missingArgument = function(name) {
+      if( this.name() !== 'new' ) {
+        throw { fluenterror: HMSTATUS.resumeNotFound, quit: true };
+      }
+    };
+
+    // Override the .helpInformation behavior
+    Command.prototype.helpInformation = function() {
+      var manPage = FS.readFileSync(
+        PATH.join(__dirname, 'use.txt'), 'utf8' );
+      return chalk.green.bold(manPage);
+    };
+
+    return {
+      args: o.args,
+      options: o.json
+    };
+  }
+
+
+
+  /** Init options prior to setting up command infrastructure. */
+  function initOptions( ar ) {
+    var oVerb, verb = '', args = ar.slice(), cleanArgs = args.slice(2), oJSON;
+    if( cleanArgs.length ) {
+
+      // Support case-insensitive sub-commands (build, generate, validate, etc)
+      var vidx = _.findIndex( cleanArgs, function(v){ return v[0] !== '-'; });
+      if( vidx !== -1 ) {
+        oVerb = cleanArgs[ vidx ];
+        verb = args[ vidx + 2 ] = oVerb.trim().toLowerCase();
+      }
+
+      // Remove --options --opts -o and process separately
+      var optsIdx = _.findIndex( cleanArgs, function(v){
+        return v === '-o' || v === '--options' || v === '--opts';
+      });
+      if(optsIdx !== -1) {
+        var optStr = cleanArgs[ optsIdx + 1];
+        args.splice( optsIdx + 2, 2 );
+        if( optStr && (optStr = optStr.trim()) ) {
+          //var myJSON = JSON.parse(optStr);
+          if( optStr[0] === '{')
+            oJSON = eval('(' + optStr + ')'); // jshint ignore:line
+          else {
+            var inf = safeLoadJSON( optStr );
+            if( !inf.ex )
+              oJSON = inf.json;
+            // TODO: Error handling
+          }
+        }
+      }
+    }
+
+    // Grab the --debug flag
+    var isDebug = _.some( args, function(v) {
+      return v === '-d' || v === '--debug';
+    });
+
+    // Grab the --silent flag
+    var isSilent = _.some( args, function(v) {
+      return v === '-s' || v === '--silent';
+    });
+
+    return {
+      debug: isDebug,
+      silent: isSilent,
+      orgVerb: oVerb,
+      verb: verb,
+      json: oJSON,
+      args: args
+    };
+  }
+
+
+
+  /** Invoke a HackMyResume verb. */
+  function execute( src, dst, opts, log ) {
+
+    loadOptions.call( this, opts, this.parent.jsonArgs );
+    var hand = require( './error' );
+    hand.init( _opts.debug, _opts.assert, _opts.silent );
+    var v = new HMR.verbs[ this.name() ]();
+    _opts.errHandler = v;
+    _out.init( _opts );
+    v.on( 'hmr:status', function() { _out.do.apply( _out, arguments ); });
+    v.on( 'hmr:error', function() {
+      hand.err.apply( hand, arguments );
+    });
+    v.invoke.call( v, src, dst, _opts, log );
+    if( v.errorCode )
+      process.exit(v.errorCode);
+  }
+
+
+
+  /**
+  Initialize HackMyResume options.
+  TODO: Options loading is a little hacky, for two reasons:
+    - Commander.js idiosyncracies
+    - Need to accept JSON inputs from the command line.
+  */
+  function loadOptions( o, cmdO ) {
+
+    // o and this.opts() seem to be the same (command-specific options)
+
+    // Load the specified options file (if any) and apply options
+    if( cmdO )
+      o = EXTEND(true, o, cmdO);
+
+    // Merge in command-line options
+    o = EXTEND( true, o, this.opts() );
+
+    // Kludge parent-level options until piping issue is resolved
+    if( this.parent.silent !== undefined && this.parent.silent !== null)
+      o.silent = this.parent.silent;
+    if( this.parent.debug !== undefined && this.parent.debug !== null)
+      o.debug = this.parent.debug;
+    if( this.parent.assert !== undefined && this.parent.assert !== null)
+      o.assert = this.parent.assert;
+
+    if( o.debug ) {
+      logMsg(chalk.cyan('OPTIONS:') + '\n');
+      _.each(o, function(val, key) {
+        logMsg(chalk.cyan('  %s') + chalk.cyan.bold(' %s'),
+          PAD(key,22,null,PAD.RIGHT), val);
+      });
+      logMsg('');
+    }
+
+    // Cache
+    EXTEND(true, _opts, o);
+  }
+
+
+
+  /** Split multiple command-line filenames by the 'TO' keyword */
+  function splitSrcDest() {
+
+    var params = this.parent.args.filter(function(j) { return String.is(j); });
+    if( params.length === 0 )
+      throw { fluenterror: HMSTATUS.resumeNotFound, quit: true };
+
+    // Find the TO keyword, if any
+    var splitAt = _.findIndex( params, function(p) {
+      return p.toLowerCase() === 'to';
+    });
+
+    // TO can't be the last keyword
+    if( splitAt === params.length - 1 && splitAt !== -1 ) {
+      logMsg(chalk.yellow('Please ') +
+        chalk.yellow.bold('specify an output file') +
+        chalk.yellow(' for this operation or ') +
+        chalk.yellow.bold('omit the TO keyword') +
+        chalk.yellow('.') );
+      return;
+    }
+
+    return {
+      src: params.slice(0, splitAt === -1 ? undefined : splitAt ),
+      dst: splitAt === -1 ? [] : params.slice( splitAt + 1 )
+    };
+  }
+
+
+
+  /** Simple logging placeholder. */
+  function logMsg() {
+    _opts.silent || console.log.apply( console.log, arguments );
+  }
+
+
+
+}());

src/cli/msg.js

@@ -0,0 +1,18 @@
+/**
+Message-handling routines for HackMyResume.
+@module msg.js
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function() {
+
+  var PATH = require('path');
+  var YAML = require('yamljs');
+
+  var cache = module.exports = function() {
+    return cache ? cache : YAML.load( PATH.join(__dirname, 'msg.yml') );
+  }();
+
+}());

src/cli/msg.yml

@@ -0,0 +1,98 @@
+events:
+  begin:
+    msg: Invoking **%s** command.
+  beforeCreate:
+    msg: Creating new **%s** resume: **%s**
+  afterRead:
+    msg: Reading **%s** resume: **%s**
+  beforeTheme:
+    msg: Verifying **%s** theme.
+  afterTheme:
+    msg: Verifying outputs:  ???
+  beforeMerge:
+    msg:
+      - "Merging **%s**"
+      - " onto **%s**"
+  applyTheme:
+    msg: Applying **%s** theme (**%s** format%s)
+  afterBuild:
+    msg:
+      - "The **%s** theme says:"
+      - |
+          "For best results view JSON Resume themes over a
+          local or remote HTTP connection. For example:
+
+            npm install http-server -g
+            http-server <resume-folder>
+
+          For more information, see the README."
+  afterGenerate:
+    msg:
+      - " (with %s)"
+      - "Skipping %s resume: %s"
+      - "Generating **%s** resume: **%s**"
+  beforeAnalyze:
+    msg: "Analyzing **%s** resume: **%s**"
+  beforeConvert:
+    msg: "Converting **%s** (**%s**) to **%s** (**%s**)"
+  afterValidate:
+    msg:
+      - "Validating **%s** against the **%s** schema: "
+      - "VALID!"
+      - "INVALID"
+      - "BROKEN"
+  beforePeek:
+    msg:
+      - Peeking at **%s** in **%s**
+      - Peeking at **%s**
+  afterPeek:
+    msg: "The specified key **%s** was not found in **%s**."
+  afterInlineConvert:
+    msg: Converting **%s** to **%s** format.
+errors:
+  themeNotFound:
+    msg: >
+      **Couldn't find the '%s' theme.** Please specify the name of a preinstalled
+      FRESH theme or the path to a locally installed FRESH or JSON Resume theme.
+  copyCSS:
+    msg: Couldn't copy CSS file to destination folder.
+  resumeNotFound:
+    msg: Please **feed me a resume** in FRESH or JSON Resume format.
+  missingCommand:
+    msg: Please **give me a command**
+  invalidCommand:
+    msg: Invalid command: '%s'
+  resumeNotFoundAlt:
+    msg: Please **feed me a resume** in either FRESH or JSON Resume format.
+  inputOutputParity:
+    msg: Please **specify an output file name** for every input file you wish to convert.
+  createNameMissing:
+    msg: Please **specify the filename** of the resume to create.
+  pdfGeneration:
+    msg: PDF generation failed. Make sure wkhtmltopdf is installed and accessible from your path.
+  invalid:
+    msg: Validation failed and the --assert option was specified.
+  invalidFormat:
+    msg: The **%s** theme doesn't support the **%s** format.
+  notOnPath:
+    msg: %s wasn't found on your system path or is inaccessible. PDF not generated.
+  readError:
+    msg: Reading **???** resume: **%s**
+  parseError:
+    msg: Invalid or corrupt JSON on line %s column %s.
+  invalidHelperUse:
+    msg: "**Warning**: Incorrect use of the **%s** theme helper."
+  fileSaveError:
+    msg: An error occurred while writing %s to disk: %s.
+  mixedMerge:
+    msg: "**Warning:** merging mixed resume types. Errors may occur."
+  invokeTemplate:
+    msg: "An error occurred during template invocation."
+  compileTemplate:
+    msg: "An error occurred during template compilation."
+  themeLoad:
+    msg: "Applying **%s** theme (? formats)"
+  invalidParamCount:
+    msg: "Invalid number of parameters. Expected: **%s**."
+  missingParam:
+    msg: The '**%s**' parameter was needed but not supplied.

src/cli/out.js

@@ -0,0 +1,229 @@
+/**
+Output routines for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module out.js
+*/
+
+
+
+(function() {
+
+
+
+  var chalk = require('chalk')
+    , HME = require('../core/event-codes')
+    , _ = require('underscore')
+    , Class = require('../utils/class.js')
+    , M2C = require('../utils/md2chalk.js')
+    , PATH = require('path')
+    , LO = require('lodash')
+    , FS = require('fs')
+    , EXTEND = require('extend')
+    , HANDLEBARS = require('handlebars')
+    , YAML = require('yamljs')
+    , printf = require('printf')
+    , pad = require('string-padding')
+    , dbgStyle = 'cyan';
+
+
+
+  /**
+  A stateful output module. All HMR console output handled here.
+  */
+  var OutputHandler = module.exports = Class.extend({
+
+
+
+    init: function( opts ) {
+      this.opts = EXTEND( true, this.opts || { }, opts );
+      this.msgs = YAML.load(PATH.join( __dirname, 'msg.yml' )).events;
+    },
+
+
+
+    log: function( msg ) {
+      msg = msg || '';
+      var printf = require('printf');
+      var finished = printf.apply( printf, arguments );
+      this.opts.silent || console.log( finished );
+    },
+
+
+
+    do: function( evt ) {
+
+      var that = this;
+      function L() {
+        that.log.apply( that, arguments );
+      }
+
+      switch( evt.sub ) {
+
+        case HME.begin:
+          this.opts.debug &&
+          L( M2C( this.msgs.begin.msg, dbgStyle), evt.cmd.toUpperCase() );
+          break;
+
+        case HME.error:
+          break;
+
+        case HME.beforeCreate:
+          L( M2C( this.msgs.beforeCreate.msg, 'green' ), evt.fmt, evt.file );
+          break;
+
+        case HME.beforeRead:
+          break;
+
+        case HME.afterRead:
+          break;
+
+        case HME.beforeTheme:
+          this.opts.debug &&
+            L( M2C( this.msgs.beforeTheme.msg, dbgStyle), evt.theme.toUpperCase() );
+          break;
+
+        case HME.afterParse:
+          L(
+            M2C( this.msgs.afterRead.msg, 'gray', 'white.dim'), evt.fmt.toUpperCase(), evt.file
+          );
+
+          break;
+
+        case HME.afterTheme:
+          break;
+
+        case HME.beforeMerge:
+          var msg = '';
+          evt.f.reverse().forEach( function( a, idx ) {
+            msg += printf(
+              ((idx === 0) ?
+                this.msgs.beforeMerge.msg[0] :
+                this.msgs.beforeMerge.msg[1] ), a.file
+            );
+          }, this);
+          L( M2C(msg, evt.mixed ? 'yellow' : 'gray', 'white.dim') );
+          break;
+
+        case HME.afterMerge:
+          break;
+
+        case HME.applyTheme:
+          this.theme = evt.theme;
+          var numFormats = Object.keys( evt.theme.formats ).length;
+          L( M2C(this.msgs.applyTheme.msg, evt.status === 'error' ? 'red' : 'gray', evt.status === 'error' ? 'bold' : 'white.dim'),
+            evt.theme.name.toUpperCase(),
+            numFormats, ( numFormats === 1 ? '' : 's') );
+          break;
+
+        case HME.end:
+          if( evt.cmd === 'build' ) {
+            var themeName = this.theme.name.toUpperCase();
+            if( this.opts.tips && (this.theme.message || this.theme.render) ) {
+              var WRAP = require('word-wrap');
+              if( this.theme.message ) {
+                L( M2C( this.msgs.afterBuild.msg[0], 'cyan' ), themeName );
+                L( M2C( this.theme.message, 'white' ));
+              }
+              else if ( this.theme.render ) {
+                L( M2C( this.msgs.afterBuild.msg[0], 'cyan'), themeName);
+                L( M2C( this.msgs.afterBuild.msg[1], 'white'));
+              }
+            }
+          }
+          break;
+
+        case HME.afterGenerate:
+          var suffix = '';
+          if( evt.fmt === 'pdf' ) {
+            if( this.opts.pdf ) {
+              if( this.opts.pdf !== 'none' ) {
+                suffix = printf( M2C( this.msgs.afterGenerate.msg[0], evt.error ? 'red' : 'green' ), this.opts.pdf );
+              }
+              else {
+                L( M2C( this.msgs.afterGenerate.msg[1], 'gray' ),
+                  evt.fmt.toUpperCase(), evt.file );
+                return;
+              }
+            }
+          }
+
+          L( M2C( this.msgs.afterGenerate.msg[2] + suffix, evt.error ? 'red' : 'green' ),
+              pad(evt.fmt.toUpperCase(),4,null,pad.RIGHT),
+              PATH.relative(process.cwd(), evt.file ));
+          break;
+
+        case HME.beforeAnalyze:
+          L( M2C( this.msgs.beforeAnalyze.msg, 'green' ), evt.fmt, evt.file);
+          break;
+
+        case HME.afterAnalyze:
+          var info = evt.info;
+          var rawTpl = FS.readFileSync( PATH.join( __dirname, 'analyze.hbs' ), 'utf8');
+          HANDLEBARS.registerHelper( require('../helpers/console-helpers') );
+          var template = HANDLEBARS.compile(rawTpl, { strict: false, assumeObjects: false });
+          var tot = 0;
+          info.keywords.forEach(function(g) { tot += g.count; });
+          info.keywords.totalKeywords = tot;
+          var output = template( info );
+          this.log( chalk.cyan(output) );
+          break;
+
+        case HME.beforeConvert:
+          L( M2C( this.msgs.beforeConvert.msg, 'green' ),
+            evt.srcFile, evt.srcFmt, evt.dstFile, evt.dstFmt
+          );
+          break;
+
+        case HME.afterInlineConvert:
+          L( M2C( this.msgs.afterInlineConvert.msg, 'gray', 'white.dim' ),
+            evt.file, evt.fmt );
+          break;
+
+        case HME.afterValidate:
+          var style = evt.isValid ? 'green' : 'yellow';
+          L(
+            M2C( this.msgs.afterValidate.msg[0], 'white' ) +
+            chalk[style].bold( evt.isValid ?
+                               this.msgs.afterValidate.msg[1] :
+                               this.msgs.afterValidate.msg[2] ),
+            evt.file, evt.fmt
+          );
+
+          if( evt.errors ) {
+            _.each(evt.errors, function(err,idx) {
+              L( chalk.yellow.bold('--> ') +
+                chalk.yellow(err.field.replace('data.','resume.').toUpperCase() + ' ' +
+                err.message) );
+            }, this);
+          }
+          break;
+
+        case HME.beforePeek:
+          // if( evt.target )
+          //   L(M2C(this.msgs.beforePeek.msg[0], evt.isError ? 'red' : 'green'), evt.target, evt.file);
+          // else
+          //   L(M2C(this.msgs.beforePeek.msg[1], evt.isError ? 'red' : 'green'), evt.file);
+          break;
+
+        case HME.afterPeek:
+          var sty = evt.error ? 'red' : ( evt.target !== undefined ? 'green' : 'yellow' );
+          if( evt.requested )
+            L(M2C(this.msgs.beforePeek.msg[0], sty), evt.requested, evt.file);
+          else
+            L(M2C(this.msgs.beforePeek.msg[1], sty), evt.file);
+
+          if( evt.target !== undefined )
+            console.dir( evt.target, { depth: null, colors: true } );
+          else if( !evt.error )
+            L(M2C( this.msgs.afterPeek.msg, 'yellow'), evt.requested, evt.file);
+          break;
+
+      }
+    }
+
+
+
+  });
+
+
+}());

src/cli/use.txt

@@ -0,0 +1,51 @@
+Usage:
+
+  hackmyresume <command> <sources> [TO <targets>] [<options>]
+
+Available commands:
+
+  BUILD         Build your resume to the destination format(s).
+  ANALYZE       Analyze your resume for keywords, gaps, and metrics.
+  VALIDATE      Validate your resume for errors and typos.
+  CONVERT       Convert your resume between FRESH and JSON Resume.
+  NEW           Create a new resume in FRESH or JSON Resume format.
+  PEEK          View a specific field or element on your resume.
+
+Available options:
+
+  --theme -t    Path to a FRESH or JSON Resume theme.
+  --pdf -p      Specify the PDF engine to use (wkhtmltopdf or phantom).
+  --options -o  Load options from an external JSON file.
+  --format -f   The format (FRESH or JSON Resume) to use.
+  --debug -d    Emit extended debugging info.
+  --assert -a   Treat resume validation warnings as errors.
+  --no-colors   Disable terminal colors.
+  --tips        Display theme messages and tips.
+  --help -h     Display help documentation.
+  --version -v  Display the current version.
+
+Not all options are supported for all commands. For example, the
+--theme option is only supported for the BUILD command.
+
+Examples:
+
+  hackmyresume  BUILD resume.json TO out/resume.all --theme modern
+  hackmyresume  ANALYZE resume.json
+  hackmyresume  NEW my-new-resume.json --format JRS
+  hackmyresume  CONVERT resume-fresh.json TO resume-jrs.json
+  hackmyresume  VALIDATE resume.json
+  hackmyresume  PEEK resume.json employment[2].summary
+
+Tips:
+
+  - You can specify multiple sources and/or targets for all commands.
+  - You can use any FRESH or JSON Resume theme with HackMyResume.
+  - Specify a file extension of .all to generate your resume to all
+    available formats supported by the theme. (BUILD command.)
+  - The --theme parameter can specify either the name of a preinstalled
+    theme, or the path to a local FRESH or JSON Resume theme.
+  - Visit https://www.npmjs.com/search?q=jsonresume-theme for a full
+    listing of all available JSON Resume themes.
+  - Visit https://github.com/fluentdesk/fresh-themes for a complete
+    listing of all available FRESH themes.
+  - Report bugs to https://githut.com/hacksalot/HackMyResume/issues.

src/core/default-formats.js

@@ -0,0 +1,21 @@
+(function(){
+
+  /**
+  Supported resume formats.
+  */
+
+  module.exports = [
+
+    { name: 'html', ext: 'html', gen: new (require('../generators/html-generator'))() },
+    { name: 'txt',  ext: 'txt', gen: new (require('../generators/text-generator'))()  },
+    { name: 'doc',  ext: 'doc',  fmt: 'xml', gen: new (require('../generators/word-generator'))() },
+    { name: 'pdf',  ext: 'pdf', fmt: 'html', is: false, gen: new (require('../generators/html-pdf-cli-generator'))() },
+    { name: 'png',  ext: 'png', fmt: 'html', is: false, gen: new (require('../generators/html-png-generator'))() },
+    { name: 'md', ext: 'md', fmt: 'txt', gen: new (require('../generators/markdown-generator'))() },
+    { name: 'json', ext: 'json', gen: new (require('../generators/json-generator'))() },
+    { name: 'yml', ext: 'yml', fmt: 'yml', gen: new (require('../generators/json-yaml-generator'))() },
+    { name: 'latex', ext: 'tex', fmt: 'latex', gen: new (require('../generators/latex-generator'))() }
+
+  ];
+
+}());

src/core/default-options.js

@@ -0,0 +1,13 @@
+(function(){
+
+  module.exports = {
+    theme: 'modern',
+    prettify: { // ← See https://github.com/beautify-web/js-beautify#options
+      indent_size: 2,
+      unformatted: ['em','strong'],
+      max_char: 80, // ← See lib/html.js in above-linked repo
+      //wrap_line_length: 120, ← Don't use this
+    }
+  };
+
+}());

src/core/event-codes.js

@@ -0,0 +1,46 @@
+/**
+Event code definitions.
+@module event-codes.js
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function(){
+
+  var val = 0;
+
+  module.exports = {
+
+    error:            -1,
+    success:          0,
+    begin:            1,
+    end:              2,
+    beforeRead:       3,
+    afterRead:        4,
+    beforeCreate:     5,
+    afterCreate:      6,
+    beforeTheme:      7,
+    afterTheme:       8,
+    beforeMerge:      9,
+    afterMerge:       10,
+    beforeGenerate:   11,
+    afterGenerate:    12,
+    beforeAnalyze:    13,
+    afterAnalyze:     14,
+    beforeConvert:    15,
+    afterConvert:     16,
+    verifyOutputs:    17,
+    beforeParse:      18,
+    afterParse:       19,
+    beforePeek:       20,
+    afterPeek:        21,
+    beforeInlineConvert: 22,
+    afterInlineConvert: 23,
+    beforeValidate:   24,
+    afterValidate:    25
+  };
+
+
+
+}());

src/core/fluent-date.js

@@ -1,80 +1,95 @@
 /**
-The FluentCV date representation.
-@license Copyright (c) 2015 by James M. Devlin. All rights reserved.
+The HackMyResume date representation.
+@license MIT. See LICENSE.md for details.
+@module core/fluent-date
 */
 
-var moment = require('moment');
+(function(){
 
-/**
-Create a FluentDate from a string or Moment date object. There are a few date
-formats to be aware of here.
-1. The words "Present" and "Now", referring to the current date
-2. The default "YYYY-MM-DD" format used in JSON Resume ("2015-02-10")
-3. Year-and-month only ("2015-04")
-4. Year-only "YYYY" ("2015")
-5. The friendly FluentCV "mmm YYYY" format ("Mar 2015" or "Dec 2008")
-6. Empty dates ("", " ")
-7. Any other date format that Moment.js can parse from
-Note: Moment can transparently parse all or most of these, without requiring us
-to specify a date format...but for maximum parsing safety and to avoid Moment
-deprecation warnings, it's recommended to either a) explicitly specify the date
-format or b) use an ISO format. For clarity, we handle these cases explicitly.
-@class FluentDate
-*/
-function FluentDate( dt ) {
-  this.rep = this.fmt( dt );
-}
+  var moment = require('moment');
 
-FluentDate/*.prototype*/.fmt = function( dt ) {
-  if( (typeof dt === 'string' || dt instanceof String) ) {
-    dt = dt.toLowerCase().trim();
-    if( /^(present|now)$/.test(dt) ) { // "Present", "Now"
-      return moment();
-    }
-    else if( /^\D+\s+\d{4}$/.test(dt) ) { // "Mar 2015"
-      var parts = dt.split(' ');
-      var month = (months[parts[0]] || abbr[parts[0]]);
-      var dt = parts[1] + '-' + (month < 10 ? '0' + month : month.toString());
-      return moment( dt, 'YYYY-MM' );
-    }
-    else if( /^\d{4}-\d{1,2}$/.test(dt) ) { // "2015-03", "1998-4"
-      return moment( dt, 'YYYY-MM' );
-    }
-    else if( /^\s\d{4}$/.test(dt) ) { // "2015"
-      return moment( dt, 'YYYY' );
-    }
-    else if( /^\s*$/.test(dt) ) { // "", " "
-      var defTime = {
-        isNull: true,
-        isBefore: function( other ) {
-          return( other && !other.isNull ) ? true : false;
-        },
-        isAfter: function( other ) {
-          return( other && !other.isNull ) ? false : false;
-        },
-        unix: function() { return 0; },
-        format: function() { return ''; },
-        diff: function() { return 0; }
-      };
-      return defTime;
+  /**
+  Create a FluentDate from a string or Moment date object. There are a few date
+  formats to be aware of here.
+  1. The words "Present" and "Now", referring to the current date
+  2. The default "YYYY-MM-DD" format used in JSON Resume ("2015-02-10")
+  3. Year-and-month only ("2015-04")
+  4. Year-only "YYYY" ("2015")
+  5. The friendly HackMyResume "mmm YYYY" format ("Mar 2015" or "Dec 2008")
+  6. Empty dates ("", " ")
+  7. Any other date format that Moment.js can parse from
+  Note: Moment can transparently parse all or most of these, without requiring us
+  to specify a date format...but for maximum parsing safety and to avoid Moment
+  deprecation warnings, it's recommended to either a) explicitly specify the date
+  format or b) use an ISO format. For clarity, we handle these cases explicitly.
+  @class FluentDate
+  */
+  function FluentDate( dt ) {
+    this.rep = this.fmt( dt );
+  }
+
+  FluentDate/*.prototype*/.fmt = function( dt, throws ) {
+
+    throws = (throws === undefined || throws === null) || throws;
+
+    if( (typeof dt === 'string' || dt instanceof String) ) {
+      dt = dt.toLowerCase().trim();
+      if( /^(present|now|current)$/.test(dt) ) { // "Present", "Now"
+        return moment();
+      }
+      else if( /^\D+\s+\d{4}$/.test(dt) ) { // "Mar 2015"
+        var parts = dt.split(' ');
+        var month = (months[parts[0]] || abbr[parts[0]]);
+        var temp = parts[1] + '-' + (month < 10 ? '0' + month : month.toString());
+        return moment( temp, 'YYYY-MM' );
+      }
+      else if( /^\d{4}-\d{1,2}$/.test(dt) ) { // "2015-03", "1998-4"
+        return moment( dt, 'YYYY-MM' );
+      }
+      else if( /^\s*\d{4}\s*$/.test(dt) ) { // "2015"
+        return moment( dt, 'YYYY' );
+      }
+      else if( /^\s*$/.test(dt) ) { // "", " "
+        var defTime = {
+          isNull: true,
+          isBefore: function( other ) {
+            return( other && !other.isNull ) ? true : false;
+          },
+          isAfter: function( other ) {
+            return( other && !other.isNull ) ? false : false;
+          },
+          unix: function() { return 0; },
+          format: function() { return ''; },
+          diff: function() { return 0; }
+        };
+        return defTime;
+      }
+      else {
+        var mt = moment( dt );
+        if(mt.isValid())
+          return mt;
+        if( throws )
+          throw 'Invalid date format encountered.';
+        return null;
+      }
     }
     else {
-      var mt = moment( dt );
-      if(mt.isValid())
-        return mt;
-      throw 'Invalid date format encountered.';
+      if( !dt ) {
+        return moment();
+      }
+      else if( dt.isValid && dt.isValid() )
+        return dt;
+      if( throws )
+        throw 'Unknown date object encountered.';
+      return null;
     }
-  }
-  else {
-    if( dt.isValid && dt.isValid() )
-      return dt;
-    throw 'Unknown date object encountered.';
-  }
-};
+  };
 
-var months = {}, abbr = {};
-moment.months().forEach(function(m,idx){months[m.toLowerCase()]=idx+1;});
-moment.monthsShort().forEach(function(m,idx){abbr[m.toLowerCase()]=idx+1;});
-abbr.sept = 9;
+  var months = {}, abbr = {};
+  moment.months().forEach(function(m,idx){months[m.toLowerCase()]=idx+1;});
+  moment.monthsShort().forEach(function(m,idx){abbr[m.toLowerCase()]=idx+1;});
+  abbr.sept = 9;
 
-module.exports = FluentDate;
+  module.exports = FluentDate;
+
+}());

src/core/fresh-resume.js

@@ -0,0 +1,526 @@
+/**
+Definition of the FRESHResume class.
+@license MIT. See LICENSE.md for details.
+@module core/fresh-resume
+*/
+
+
+
+(function() {
+
+
+
+  var FS = require('fs')
+    , extend = require('extend')
+    , validator = require('is-my-json-valid')
+    , _ = require('underscore')
+    , __ = require('lodash')
+    , PATH = require('path')
+    , moment = require('moment')
+    , XML = require('xml-escape')
+    , MD = require('marked')
+    , CONVERTER = require('fresh-jrs-converter')
+    , JRSResume = require('./jrs-resume');
+
+
+
+  /**
+  A FRESH resume or CV. FRESH resumes are backed by JSON, and each FreshResume
+  object is an instantiation of that JSON decorated with utility methods.
+  @constructor
+  */
+  function FreshResume() {
+
+  }
+
+
+
+  /**
+  Initialize the FreshResume from file.
+  */
+  FreshResume.prototype.open = function( file, opts ) {
+    var raw = FS.readFileSync( file, 'utf8' );
+    var ret = this.parse( raw, opts );
+    this.imp.file = file;
+    return ret;
+  };
+
+
+
+  /**
+  Initialize the the FreshResume from JSON string data.
+  */
+  FreshResume.prototype.parse = function( stringData, opts ) {
+    return this.parseJSON( JSON.parse( stringData ), opts );
+  };
+
+
+
+  /**
+  Initialize the FreshResume from JSON.
+  Open and parse the specified FRESH resume. Merge the JSON object model onto
+  this Sheet instance with extend() and convert sheet dates to a safe &
+  consistent format. Then sort each section by startDate descending.
+  @param rep {Object} The raw JSON representation.
+  @param opts {Object} Resume loading and parsing options.
+  {
+    date: Perform safe date conversion.
+    sort: Sort resume items by date.
+    compute: Prepare computed resume totals.
+  }
+  */
+  FreshResume.prototype.parseJSON = function( rep, opts ) {
+
+    // Ignore any element with the 'ignore: true' designator.
+    var that = this, traverse = require('traverse'), ignoreList = [];
+    var scrubbed = traverse( rep ).map( function( x ) {
+      if( !this.isLeaf && this.node.ignore ) {
+        if ( this.node.ignore === true || this.node.ignore === 'true' ) {
+          ignoreList.push( this.node );
+          this.remove();
+        }
+      }
+    });
+
+    // Now apply the resume representation onto this object
+    extend( true, this, scrubbed );
+
+    // If the resume already has a .imp object, then we are being called from
+    // the .dupe method, and there's no need to do any post processing
+    if( !this.imp ) {
+      // Set up metadata TODO: Clean up metadata on the object model.
+      opts = opts || { };
+      if( opts.imp === undefined || opts.imp ) {
+        this.imp = this.imp || { };
+        this.imp.title = (opts.title || this.imp.title) || this.name;
+      }
+      // Parse dates, sort dates, and calculate computed values
+      (opts.date === undefined || opts.date) && _parseDates.call( this );
+      (opts.sort === undefined || opts.sort) && this.sort();
+      (opts.compute === undefined || opts.compute) && (this.computed = {
+         numYears: this.duration(),
+         keywords: this.keywords()
+      });
+    }
+    return this;
+  };
+
+
+
+  /**
+  Save the sheet to disk (for environments that have disk access).
+  */
+  FreshResume.prototype.save = function( filename ) {
+    this.imp.file = filename || this.imp.file;
+    FS.writeFileSync( this.imp.file, this.stringify(), 'utf8' );
+    return this;
+  };
+
+
+
+  /**
+  Save the sheet to disk in a specific format, either FRESH or JSON Resume.
+  */
+  FreshResume.prototype.saveAs = function( filename, format ) {
+
+    if( format !== 'JRS' ) {
+      this.imp.file = filename || this.imp.file;
+      FS.writeFileSync( this.imp.file, this.stringify(), 'utf8' );
+    }
+    else {
+      var newRep = CONVERTER.toJRS( this );
+      FS.writeFileSync( filename, JRSResume.stringify( newRep ), 'utf8' );
+    }
+    return this;
+  };
+
+
+
+  /**
+  Duplicate this FreshResume instance.
+  This method first extend()s this object onto an empty, creating a deep copy,
+  and then passes the result into a new FreshResume instance via .parseJSON.
+  We do it this way to create a true clone of the object without re-running any
+  of the associated processing.
+  */
+  FreshResume.prototype.dupe = function() {
+    var jso = extend( true, { }, this );
+    var rnew = new FreshResume();
+    rnew.parseJSON( jso, { } );
+    return rnew;
+  };
+
+
+
+  /**
+  Convert the supplied FreshResume to a JSON string, sanitizing meta-properties
+  along the way.
+  */
+  FreshResume.stringify = function( obj ) {
+    function replacer( key,value ) { // Exclude these keys from stringification
+      return _.some(['imp', 'warnings', 'computed', 'filt', 'ctrl', 'index',
+        'safe', 'result', 'isModified', 'htmlPreview', 'display_progress_bar'],
+        function( val ) { return key.trim() === val; }
+      ) ? undefined : value;
+    }
+    return JSON.stringify( obj, replacer, 2 );
+  };
+
+
+
+  /**
+  Convert this object to a JSON string, sanitizing meta-properties along the
+  way.
+  */
+  FreshResume.prototype.stringify = function() {
+    return FreshResume.stringify( this );
+  };
+
+
+
+  /**
+  Create a copy of this resume in which all string fields have been run through
+  a transformation function (such as a Markdown filter or XML encoder).
+  TODO: Move this out of FRESHResume.
+  */
+  FreshResume.prototype.transformStrings = function( filt, transformer ) {
+    var ret = this.dupe();
+    var trx = require('../utils/string-transformer');
+    return trx( ret, filt, transformer );
+  };
+
+
+
+  /**
+  Create a copy of this resume in which all fields have been interpreted as
+  Markdown.
+  */
+  FreshResume.prototype.markdownify = function() {
+
+    function MDIN( txt ){
+      return MD(txt || '' ).replace(/^\s*<p>|<\/p>\s*$/gi, '');
+    }
+
+    function trx(key, val) {
+      if( key === 'summary' ) {
+        return MD(val);
+      }
+      return MDIN(val);
+    }
+
+    return this.transformStrings( ['skills','url','start','end','date'], trx );
+  };
+
+
+
+  /**
+  Create a copy of this resume in which all fields have been interpreted as
+  Markdown.
+  */
+  FreshResume.prototype.xmlify = function() {
+    function trx(key, val) {
+      return XML(val);
+    }
+    return this.transformStrings( [], trx );
+  };
+
+
+
+  /**
+  Return the resume format.
+  */
+  FreshResume.prototype.format = function() {
+    return 'FRESH';
+  };
+
+
+
+  /**
+  Return internal metadata. Create if it doesn't exist.
+  */
+  FreshResume.prototype.i = function() {
+    this.imp = (this.imp || { });
+    return this.imp;
+  };
+
+
+
+  /**
+  Return a unique list of all keywords across all skills.
+  */
+  FreshResume.prototype.keywords = function() {
+    var flatSkills = [];
+    if( this.skills ) {
+      if( this.skills.sets ) {
+        flatSkills = this.skills.sets.map(function(sk) { return sk.skills;  })
+          .reduce(function(a,b) { return a.concat(b); });
+      }
+      else if( this.skills.list ) {
+        flatSkills = flatSkills.concat( this.skills.list.map(function(sk) {
+          return sk.name;
+        }));
+      }
+      flatSkills = _.uniq( flatSkills );
+    }
+    return flatSkills;
+  },
+
+
+
+  /**
+  Reset the sheet to an empty state. TODO: refactor/review
+  */
+  FreshResume.prototype.clear = function( clearMeta ) {
+    clearMeta = ((clearMeta === undefined) && true) || clearMeta;
+    clearMeta && (delete this.imp);
+    delete this.computed; // Don't use Object.keys() here
+    delete this.employment;
+    delete this.service;
+    delete this.education;
+    delete this.recognition;
+    delete this.reading;
+    delete this.writing;
+    delete this.interests;
+    delete this.skills;
+    delete this.social;
+  };
+
+
+
+  /**
+  Get a safe count of the number of things in a section.
+  */
+  FreshResume.prototype.count = function( obj ) {
+    if( !obj ) return 0;
+    if( obj.history ) return obj.history.length;
+    if( obj.sets ) return obj.sets.length;
+    return obj.length || 0;
+  };
+
+
+
+  /**
+  Get the default (starter) sheet.
+  */
+  FreshResume.default = function() {
+    return new FreshResume().parseJSON( require('fresh-resume-starter')  );
+  };
+
+
+
+  /**
+  Add work experience to the sheet.
+  */
+  FreshResume.prototype.add = function( moniker ) {
+    var defSheet = FreshResume.default();
+    var newObject = defSheet[moniker].history ?
+      $.extend( true, {}, defSheet[ moniker ].history[0] ) :
+      (moniker === 'skills' ?
+        $.extend( true, {}, defSheet.skills.sets[0] ) :
+        $.extend( true, {}, defSheet[ moniker ][0] ));
+    this[ moniker ] = this[ moniker ] || [];
+    if( this[ moniker ].history )
+      this[ moniker ].history.push( newObject );
+    else if( moniker === 'skills' )
+      this.skills.sets.push( newObject );
+    else
+      this[ moniker ].push( newObject );
+    return newObject;
+  };
+
+
+
+  /**
+  Determine if the sheet includes a specific social profile (eg, GitHub).
+  */
+  FreshResume.prototype.hasProfile = function( socialNetwork ) {
+    socialNetwork = socialNetwork.trim().toLowerCase();
+    return this.social && _.some( this.social, function(p) {
+      return p.network.trim().toLowerCase() === socialNetwork;
+    });
+  };
+
+
+
+  /**
+  Return the specified network profile.
+  */
+  FreshResume.prototype.getProfile = function( socialNetwork ) {
+    socialNetwork = socialNetwork.trim().toLowerCase();
+    return this.social && _.find( this.social, function(sn) {
+      return sn.network.trim().toLowerCase() === socialNetwork;
+    });
+  };
+
+
+
+  /**
+  Return an array of profiles for the specified network, for when the user
+  has multiple eg. GitHub accounts.
+  */
+  FreshResume.prototype.getProfiles = function( socialNetwork ) {
+    socialNetwork = socialNetwork.trim().toLowerCase();
+    return this.social && _.filter( this.social, function(sn){
+      return sn.network.trim().toLowerCase() === socialNetwork;
+    });
+  };
+
+
+
+  /**
+  Determine if the sheet includes a specific skill.
+  */
+  FreshResume.prototype.hasSkill = function( skill ) {
+    skill = skill.trim().toLowerCase();
+    return this.skills && _.some( this.skills, function(sk) {
+      return sk.keywords && _.some( sk.keywords, function(kw) {
+        return kw.trim().toLowerCase() === skill;
+      });
+    });
+  };
+
+
+
+  /**
+  Validate the sheet against the FRESH Resume schema.
+  */
+  FreshResume.prototype.isValid = function( info ) {
+    var schemaObj = require('fresca');
+    var validator = require('is-my-json-valid');
+    var validate = validator( schemaObj, { // See Note [1].
+      formats: { date: /^\d{4}(?:-(?:0[0-9]{1}|1[0-2]{1})(?:-[0-9]{2})?)?$/ }
+    });
+    var ret = validate( this );
+    if( !ret ) {
+      this.imp = this.imp || { };
+      this.imp.validationErrors = validate.errors;
+    }
+    return ret;
+  };
+
+
+
+  /**
+  Calculate the total duration of the sheet. Assumes this.work has been sorted
+  by start date descending, perhaps via a call to Sheet.sort().
+  @returns The total duration of the sheet's work history, that is, the number
+  of years between the start date of the earliest job on the resume and the
+  *latest end date of all jobs in the work history*. This last condition is for
+  sheets that have overlapping jobs.
+  */
+  FreshResume.prototype.duration = function(unit) {
+    unit = unit || 'years';
+    var empHist = __.get(this, 'employment.history');
+    if( empHist && empHist.length ) {
+      var firstJob = _.last( empHist );
+      var careerStart = firstJob.start ? firstJob.safe.start : '';
+      if ((typeof careerStart === 'string' || careerStart instanceof String) &&
+          !careerStart.trim())
+        return 0;
+      var careerLast = _.max( empHist, function( w ) {
+        return( w.safe && w.safe.end ) ? w.safe.end.unix() : moment().unix();
+      });
+      return careerLast.safe.end.diff( careerStart, unit );
+    }
+    return 0;
+  };
+
+
+
+  /**
+  Sort dated things on the sheet by start date descending. Assumes that dates
+  on the sheet have been processed with _parseDates().
+  */
+  FreshResume.prototype.sort = function( ) {
+
+    function byDateDesc(a,b) {
+      return( a.safe.start.isBefore(b.safe.start) ) ? 1
+        : ( a.safe.start.isAfter(b.safe.start) && -1 ) || 0;
+    }
+
+    function sortSection( key ) {
+      var ar = __.get(this, key);
+      if( ar && ar.length ) {
+        var datedThings = obj.filter( function(o) { return o.start; } );
+        datedThings.sort( byDateDesc );
+      }
+    }
+
+    sortSection( 'employment.history' );
+    sortSection( 'education.history' );
+    sortSection( 'service.history' );
+    sortSection( 'projects' );
+
+    // this.awards && this.awards.sort( function(a, b) {
+    //   return( a.safeDate.isBefore(b.safeDate) ) ? 1
+    //     : ( a.safeDate.isAfter(b.safeDate) && -1 ) || 0;
+    // });
+    this.writing && this.writing.sort( function(a, b) {
+      return( a.safe.date.isBefore(b.safe.date) ) ? 1
+        : ( a.safe.date.isAfter(b.safe.date) && -1 ) || 0;
+    });
+  };
+
+
+
+  /**
+  Convert human-friendly dates into formal Moment.js dates for all collections.
+  We don't want to lose the raw textual date as entered by the user, so we store
+  the Moment-ified date as a separate property with a prefix of .safe. For ex:
+  job.startDate is the date as entered by the user. job.safeStartDate is the
+  parsed Moment.js date that we actually use in processing.
+  */
+  function _parseDates() {
+
+    var _fmt = require('./fluent-date').fmt;
+    var that = this;
+
+    // TODO: refactor recursion
+    function replaceDatesInObject( obj ) {
+
+      if( !obj ) return;
+      if( Object.prototype.toString.call( obj ) === '[object Array]' ) {
+        obj.forEach(function(elem){
+          replaceDatesInObject( elem );
+        });
+      }
+      else if (typeof obj === 'object') {
+        if( obj._isAMomentObject || obj.safe )
+         return;
+        Object.keys( obj ).forEach(function(key) {
+          replaceDatesInObject( obj[key] );
+        });
+        ['start','end','date'].forEach( function(val) {
+          if( (obj[val] !== undefined) && (!obj.safe || !obj.safe[val] )) {
+            obj.safe = obj.safe || { };
+            obj.safe[ val ] = _fmt( obj[val] );
+            if( obj[val] && (val === 'start') && !obj.end ) {
+              obj.safe.end = _fmt('current');
+            }
+          }
+        });
+      }
+    }
+
+    Object.keys( this ).forEach(function(member){
+      replaceDatesInObject( that[ member ] );
+    });
+
+  }
+
+
+
+  /**
+  Export the Sheet function/ctor.
+  */
+  module.exports = FreshResume;
+
+
+
+}());
+
+// Note 1: Adjust default date validation to allow YYYY and YYYY-MM formats
+// in addition to YYYY-MM-DD. The original regex:
+//
+//     /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}$/
+//

src/core/fresh-theme.js

@@ -0,0 +1,338 @@
+/**
+Definition of the FRESHTheme class.
+@module fresh-theme.js
+@license MIT. See LICENSE.md for details.
+*/
+
+(function() {
+
+
+
+  var FS = require('fs')
+    , validator = require('is-my-json-valid')
+    , _ = require('underscore')
+    , PATH = require('path')
+    , parsePath = require('parse-filepath')
+    , pathExists = require('path-exists').sync
+    , EXTEND = require('extend')
+    , HMSTATUS = require('./status-codes')
+    , moment = require('moment')
+    , loadSafeJson = require('../utils/safe-json-loader')
+    , READFILES = require('recursive-readdir-sync');
+
+
+
+  /**
+  The FRESHTheme class is a representation of a FRESH theme
+  asset. See also: JRSTheme.
+  @class FRESHTheme
+  */
+  function FRESHTheme() {
+
+  }
+
+
+
+  /**
+  Open and parse the specified theme.
+  */
+  FRESHTheme.prototype.open = function( themeFolder ) {
+
+    this.folder = themeFolder;
+
+    // Open the [theme-name].json file; should have the same name as folder
+    var pathInfo = parsePath( themeFolder );
+
+    // Set up a formats hash for the theme
+    var formatsHash = { };
+
+    // Load the theme
+    var themeFile = PATH.join( themeFolder, 'theme.json' );
+    var themeInfo = loadSafeJson( themeFile );
+    if( themeInfo.ex ) throw {
+      fluenterror: themeInfo.ex.operation === 'parse' ?
+        HMSTATUS.parseError : HMSTATUS.readError,
+      inner: themeInfo.ex.inner
+    };
+
+    var that = this;
+
+    // Move properties from the theme JSON file to the theme object
+    EXTEND( true, this, themeInfo.json );
+
+    // Check for an "inherits" entry in the theme JSON.
+    if( this.inherits ) {
+      var cached = { };
+      _.each( this.inherits, function(th, key) {
+        var themesFolder = require.resolve('fresh-themes');
+        var d = parsePath( themeFolder ).dirname;
+        var themePath = PATH.join(d, th);
+        cached[ th ] = cached[th] || new FRESHTheme().open( themePath );
+        formatsHash[ key ] = cached[ th ].getFormat( key );
+      });
+    }
+
+    // Check for an explicit "formats" entry in the theme JSON. If it has one,
+    // then this theme declares its files explicitly.
+    if( !!this.formats ) {
+      formatsHash = loadExplicit.call( this, formatsHash );
+      this.explicit = true;
+    }
+    else {
+      formatsHash = loadImplicit.call( this, formatsHash );
+    }
+
+    // Cache
+    this.formats = formatsHash;
+
+    // Set the official theme name
+    this.name = parsePath( this.folder ).name;
+
+    return this;
+  };
+
+
+
+  /**
+  Determine if the theme supports the specified output format.
+  */
+  FRESHTheme.prototype.hasFormat = function( fmt ) {
+    return _.has( this.formats, fmt );
+  };
+
+
+
+  /**
+  Determine if the theme supports the specified output format.
+  */
+  FRESHTheme.prototype.getFormat = function( fmt ) {
+    return this.formats[ fmt ];
+  };
+
+
+  /**
+  Load the theme implicitly, by scanning the theme folder for
+  files. TODO: Refactor duplicated code with loadExplicit.
+  */
+  function loadImplicit(formatsHash) {
+
+    // Set up a hash of formats supported by this theme.
+    var that = this;
+    var major = false;
+
+    // Establish the base theme folder
+    var tplFolder = PATH.join( this.folder, 'src' );
+
+    // Iterate over all files in the theme folder, producing an array, fmts,
+    // containing info for each file. While we're doing that, also build up
+    // the formatsHash object.
+    var fmts = READFILES(tplFolder).map( function(absPath) {
+
+      // If this file lives in a specific format folder within the theme,
+      // such as "/latex" or "/html", then that format is the output format
+      // for all files within the folder.
+      var pathInfo = parsePath(absPath);
+      var outFmt = '', isMajor = false;
+      var portion = pathInfo.dirname.replace(tplFolder,'');
+      if( portion && portion.trim() ) {
+        if( portion[1] === '_' ) return;
+        var reg = /^(?:\/|\\)(html|latex|doc|pdf|png|partials)(?:\/|\\)?/ig;
+        var res = reg.exec( portion );
+        if( res ) {
+          if( res[1] !== 'partials' ) {
+            outFmt = res[1];
+          }
+          else {
+            that.partials = that.partials || [];
+            that.partials.push( { name: pathInfo.name, path: absPath } );
+            return null;
+          }
+        }
+      }
+
+      // Otherwise, the output format is inferred from the filename, as in
+      // compact-[outputformat].[extension], for ex, compact-pdf.html.
+      if( !outFmt ) {
+        var idx = pathInfo.name.lastIndexOf('-');
+        outFmt = (idx === -1) ? pathInfo.name : pathInfo.name.substr(idx + 1);
+        isMajor = true;
+      }
+
+      // We should have a valid output format now.
+      formatsHash[ outFmt ] = formatsHash[outFmt] || {
+        outFormat: outFmt,
+        files: []
+      };
+
+      // Create the file representation object.
+      var obj = {
+        action: 'transform',
+        path: absPath,
+        major: isMajor,
+        orgPath: PATH.relative(tplFolder, absPath),
+        ext: pathInfo.extname.slice(1),
+        title: friendlyName( outFmt ),
+        pre: outFmt,
+        // outFormat: outFmt || pathInfo.name,
+        data: FS.readFileSync( absPath, 'utf8' ),
+        css: null
+      };
+
+      // Add this file to the list of files for this format type.
+      formatsHash[ outFmt ].files.push( obj );
+      return obj;
+    });
+
+    // Now, get all the CSS files...
+    (this.cssFiles = fmts.filter(function( fmt ){
+      return fmt && (fmt.ext === 'css');
+    }))
+
+    // For each CSS file, get its corresponding HTML file. It's possible that
+    // a theme can have a CSS file but *no* HTML file, as when a theme author
+    // creates a pure CSS override of an existing theme.
+    .forEach(function( cssf ) {
+
+      var idx = _.findIndex(fmts, function( fmt ) {
+        return fmt && fmt.pre === cssf.pre && fmt.ext === 'html';
+      });
+      cssf.major = false;
+      if( idx > -1) {
+        fmts[ idx ].css = cssf.data;
+        fmts[ idx ].cssPath = cssf.path;
+      }
+      else {
+        if( that.inherits ) {
+          // Found a CSS file without an HTML file in a theme that inherits
+          // from another theme. This is the override CSS file.
+          that.overrides = { file: cssf.path, data: cssf.data };
+        }
+      }
+    });
+
+    return formatsHash;
+  }
+
+
+
+  /**
+  Load the theme explicitly, by following the 'formats' hash
+  in the theme's JSON settings file.
+  */
+  function loadExplicit(formatsHash) {
+
+    // Housekeeping
+    var tplFolder = PATH.join( this.folder, 'src' );
+    var act = null;
+    var that = this;
+
+    // Iterate over all files in the theme folder, producing an array, fmts,
+    // containing info for each file. While we're doing that, also build up
+    // the formatsHash object.
+    var fmts = READFILES( tplFolder ).map( function( absPath ) {
+
+      act = null;
+      // If this file is mentioned in the theme's JSON file under "transforms"
+      var pathInfo = parsePath(absPath);
+      var absPathSafe = absPath.trim().toLowerCase();
+      var outFmt = _.find(
+        Object.keys( that.formats ),
+        function( fmtKey ) {
+          var fmtVal = that.formats[ fmtKey ];
+          return _.some( fmtVal.transform, function(fpath) {
+            var absPathB = PATH.join( that.folder, fpath )
+              .trim().toLowerCase();
+            return absPathB === absPathSafe;
+          });
+        });
+      if( outFmt ) {
+        act = 'transform';
+      }
+
+      // If this file lives in a specific format folder within the theme,
+      // such as "/latex" or "/html", then that format is the output format
+      // for all files within the folder.
+      if( !outFmt ) {
+        var portion = pathInfo.dirname.replace(tplFolder,'');
+        if( portion && portion.trim() ) {
+          var reg = /^(?:\/|\\)(html|latex|doc|pdf)(?:\/|\\)?/ig;
+          var res = reg.exec( portion );
+          res && (outFmt = res[1]);
+        }
+      }
+
+      // Otherwise, the output format is inferred from the filename, as in
+      // compact-[outputformat].[extension], for ex, compact-pdf.html.
+      if( !outFmt ) {
+        var idx = pathInfo.name.lastIndexOf('-');
+        outFmt = (idx === -1) ? pathInfo.name : pathInfo.name.substr(idx + 1);
+      }
+
+      // We should have a valid output format now.
+      formatsHash[ outFmt ] =
+        formatsHash[ outFmt ] || {
+          outFormat: outFmt,
+          files: [],
+          symLinks: that.formats[ outFmt ].symLinks
+        };
+
+      // Create the file representation object.
+      var obj = {
+        action: act,
+        orgPath: PATH.relative(that.folder, absPath),
+        path: absPath,
+        ext: pathInfo.extname.slice(1),
+        title: friendlyName( outFmt ),
+        pre: outFmt,
+        // outFormat: outFmt || pathInfo.name,
+        data: FS.readFileSync( absPath, 'utf8' ),
+        css: null
+      };
+
+      // Add this file to the list of files for this format type.
+      formatsHash[ outFmt ].files.push( obj );
+      return obj;
+    });
+
+    // Now, get all the CSS files...
+    (this.cssFiles = fmts.filter(function( fmt ){
+      return fmt.ext === 'css';
+    }))
+
+    // For each CSS file, get its corresponding HTML file
+    .forEach(function( cssf ) {
+        // For each CSS file, get its corresponding HTML file
+        var idx = _.findIndex(fmts, function( fmt ) {
+          return fmt.pre === cssf.pre && fmt.ext === 'html';
+      });
+      fmts[ idx ].css = cssf.data;
+      fmts[ idx ].cssPath = cssf.path;
+    });
+
+    // Remove CSS files from the formats array
+    fmts = fmts.filter( function( fmt) {
+      return fmt.ext !== 'css';
+    });
+
+    return formatsHash;
+  }
+
+
+
+  /**
+  Return a more friendly name for certain formats.
+  TODO: Refactor
+  */
+  function friendlyName( val ) {
+    val = val.trim().toLowerCase();
+    var friendly = { yml: 'yaml', md: 'markdown', txt: 'text' };
+    return friendly[val] || val;
+  }
+
+
+
+  module.exports = FRESHTheme;
+
+
+
+}());

src/core/jrs-resume.js

@@ -0,0 +1,454 @@
+/**
+Definition of the JRSResume class.
+@license MIT. See LICENSE.md for details.
+@module core/jrs-resume
+*/
+
+
+
+(function() {
+
+
+
+  var FS = require('fs')
+    , extend = require('extend')
+    , validator = require('is-my-json-valid')
+    , _ = require('underscore')
+    , PATH = require('path')
+    , MD = require('marked')
+    , CONVERTER = require('fresh-jrs-converter')
+    , moment = require('moment');
+
+
+
+  /**
+  A JRS resume or CV. JRS resumes are backed by JSON, and each JRSResume object
+  is an instantiation of that JSON decorated with utility methods.
+  @class JRSResume
+  */
+  function JRSResume() {
+
+  }
+
+
+
+  /**
+  Initialize the JSResume from file.
+  */
+  JRSResume.prototype.open = function( file, title ) {
+    //this.imp = { fileName: file }; <-- schema violation, tuck it into .basics
+    this.basics = {
+      imp: {
+        file: file,
+        raw: FS.readFileSync( file, 'utf8' )
+      }
+    };
+    return this.parse( this.basics.imp.raw, title );
+  };
+
+
+
+  /**
+  Initialize the the JSResume from string.
+  */
+  JRSResume.prototype.parse = function( stringData, opts ) {
+    opts = opts || { };
+    var rep = JSON.parse( stringData );
+    return this.parseJSON( rep, opts );
+  };
+
+
+
+  /**
+  Initialize the JRSResume object from JSON.
+  Open and parse the specified JRS resume. Merge the JSON object model onto
+  this Sheet instance with extend() and convert sheet dates to a safe &
+  consistent format. Then sort each section by startDate descending.
+  @param rep {Object} The raw JSON representation.
+  @param opts {Object} Resume loading and parsing options.
+  {
+    date: Perform safe date conversion.
+    sort: Sort resume items by date.
+    compute: Prepare computed resume totals.
+  }
+  */
+  JRSResume.prototype.parseJSON = function( rep, opts ) {
+    opts = opts || { };
+
+    // Ignore any element with the 'ignore: true' designator.
+    var that = this, traverse = require('traverse'), ignoreList = [];
+    var scrubbed = traverse( rep ).map( function( x ) {
+      if( !this.isLeaf && this.node.ignore ) {
+        if ( this.node.ignore === true || this.node.ignore === 'true' ) {
+          ignoreList.push( this.node );
+          this.remove();
+        }
+      }
+    });
+
+    // Extend resume properties onto ourself.
+    extend( true, this, scrubbed );
+
+    // Set up metadata
+    if( opts.imp === undefined || opts.imp ) {
+      this.basics.imp = this.basics.imp || { };
+      this.basics.imp.title =
+        (opts.title || this.basics.imp.title) || this.basics.name;
+      this.basics.imp.orgFormat = 'JRS';
+    }
+    // Parse dates, sort dates, and calculate computed values
+    (opts.date === undefined || opts.date) && _parseDates.call( this );
+    (opts.sort === undefined || opts.sort) && this.sort();
+    (opts.compute === undefined || opts.compute) && (this.basics.computed = {
+      numYears: this.duration(),
+      keywords: this.keywords()
+    });
+    return this;
+  };
+
+
+
+  /**
+  Save the sheet to disk (for environments that have disk access).
+  */
+  JRSResume.prototype.save = function( filename ) {
+    this.basics.imp.file = filename || this.basics.imp.file;
+    FS.writeFileSync(this.basics.imp.file, this.stringify( this ), 'utf8');
+    return this;
+  };
+
+
+
+  /**
+  Save the sheet to disk in a specific format, either FRESH or JRS.
+  */
+  JRSResume.prototype.saveAs = function( filename, format ) {
+
+    if( format === 'JRS' ) {
+      this.basics.imp.file = filename || this.basics.imp.file;
+      FS.writeFileSync( this.basics.imp.file, this.stringify(), 'utf8' );
+    }
+    else {
+      var newRep = CONVERTER.toFRESH( this );
+      var stringRep = CONVERTER.toSTRING( newRep );
+      FS.writeFileSync( filename, stringRep, 'utf8' );
+    }
+    return this;
+
+  };
+
+
+
+  /**
+  Return the resume format.
+  */
+  JRSResume.prototype.format = function() {
+    return 'JRS';
+  };
+
+
+
+  /**
+  Convert this object to a JSON string, sanitizing meta-properties along the
+  way. Don't override .toString().
+  */
+  JRSResume.stringify = function( obj ) {
+    function replacer( key,value ) { // Exclude these keys from stringification
+      return _.some(['imp', 'warnings', 'computed', 'filt', 'ctrl', 'index',
+        'safeStartDate', 'safeEndDate', 'safeDate', 'safeReleaseDate', 'result',
+        'isModified', 'htmlPreview', 'display_progress_bar'],
+        function( val ) { return key.trim() === val; }
+      ) ? undefined : value;
+    }
+    return JSON.stringify( obj, replacer, 2 );
+  };
+
+
+
+  JRSResume.prototype.stringify = function() {
+    return JRSResume.stringify( this );
+  };
+
+
+
+  /**
+  Return a unique list of all keywords across all skills.
+  */
+  JRSResume.prototype.keywords = function() {
+    var flatSkills = [];
+    if( this.skills && this.skills.length ) {
+      this.skills.forEach( function( s ) {
+        flatSkills = _.union( flatSkills, s.keywords );
+      });
+    }
+    return flatSkills;
+  };
+
+
+
+  /**
+  Return internal metadata. Create if it doesn't exist.
+  JSON Resume v0.0.0 doesn't allow additional properties at the root level,
+  so tuck this into the .basic sub-object.
+  */
+  JRSResume.prototype.i = function() {
+    this.basics = this.basics || { };
+    this.basics.imp = this.basics.imp || { };
+    return this.basics.imp;
+  };
+
+
+
+  /**
+  Reset the sheet to an empty state.
+  */
+  JRSResume.prototype.clear = function( clearMeta ) {
+    clearMeta = ((clearMeta === undefined) && true) || clearMeta;
+    clearMeta && (delete this.imp);
+    delete this.basics.computed; // Don't use Object.keys() here
+    delete this.work;
+    delete this.volunteer;
+    delete this.education;
+    delete this.awards;
+    delete this.publications;
+    delete this.interests;
+    delete this.skills;
+    delete this.basics.profiles;
+  };
+
+
+
+  /**
+  Get the default (empty) sheet.
+  */
+  JRSResume.default = function() {
+    return new JRSResume().open(
+      PATH.join( __dirname, 'empty-jrs.json'), 'Empty'
+    );
+  };
+
+
+
+  /**
+  Add work experience to the sheet.
+  */
+  JRSResume.prototype.add = function( moniker ) {
+    var defSheet = JRSResume.default();
+    var newObject = $.extend( true, {}, defSheet[ moniker ][0] );
+    this[ moniker ] = this[ moniker ] || [];
+    this[ moniker ].push( newObject );
+    return newObject;
+  };
+
+
+
+  /**
+  Determine if the sheet includes a specific social profile (eg, GitHub).
+  */
+  JRSResume.prototype.hasProfile = function( socialNetwork ) {
+    socialNetwork = socialNetwork.trim().toLowerCase();
+    return this.basics.profiles && _.some( this.basics.profiles, function(p) {
+      return p.network.trim().toLowerCase() === socialNetwork;
+    });
+  };
+
+
+
+  /**
+  Determine if the sheet includes a specific skill.
+  */
+  JRSResume.prototype.hasSkill = function( skill ) {
+    skill = skill.trim().toLowerCase();
+    return this.skills && _.some( this.skills, function(sk) {
+      return sk.keywords && _.some( sk.keywords, function(kw) {
+        return kw.trim().toLowerCase() === skill;
+      });
+    });
+  };
+
+
+
+  /**
+  Validate the sheet against the JSON Resume schema.
+  */
+  JRSResume.prototype.isValid = function( ) { // TODO: ↓ fix this path ↓
+    var schema = FS.readFileSync( PATH.join( __dirname, 'resume.json' ),'utf8');
+    var schemaObj = JSON.parse( schema );
+    var validator = require('is-my-json-valid');
+    var validate = validator( schemaObj, { // Note [1]
+      formats: { date: /^\d{4}(?:-(?:0[0-9]{1}|1[0-2]{1})(?:-[0-9]{2})?)?$/ }
+    });
+    var ret = validate( this );
+    if( !ret ) {
+      this.basics.imp = this.basics.imp || { };
+      this.basics.imp.validationErrors = validate.errors;
+    }
+    return ret;
+  };
+
+
+
+  /**
+  Calculate the total duration of the sheet. Assumes this.work has been sorted
+  by start date descending, perhaps via a call to Sheet.sort().
+  @returns The total duration of the sheet's work history, that is, the number
+  of years between the start date of the earliest job on the resume and the
+  *latest end date of all jobs in the work history*. This last condition is for
+  sheets that have overlapping jobs.
+  */
+  JRSResume.prototype.duration = function( unit ) {
+    unit = unit || 'years';
+    if( this.work && this.work.length ) {
+      var careerStart = this.work[ this.work.length - 1].safeStartDate;
+      if ((typeof careerStart === 'string' || careerStart instanceof String) &&
+          !careerStart.trim())
+        return 0;
+      var careerLast = _.max( this.work, function( w ) {
+        return w.safeEndDate.unix();
+      }).safeEndDate;
+      return careerLast.diff( careerStart, unit );
+    }
+    return 0;
+  };
+
+
+
+  /**
+  Sort dated things on the sheet by start date descending. Assumes that dates
+  on the sheet have been processed with _parseDates().
+  */
+  JRSResume.prototype.sort = function( ) {
+
+    this.work && this.work.sort( byDateDesc );
+    this.education && this.education.sort( byDateDesc );
+    this.volunteer && this.volunteer.sort( byDateDesc );
+
+    this.awards && this.awards.sort( function(a, b) {
+      return( a.safeDate.isBefore(b.safeDate) ) ? 1
+        : ( a.safeDate.isAfter(b.safeDate) && -1 ) || 0;
+    });
+    this.publications && this.publications.sort( function(a, b) {
+      return( a.safeReleaseDate.isBefore(b.safeReleaseDate) ) ? 1
+        : ( a.safeReleaseDate.isAfter(b.safeReleaseDate) && -1 ) || 0;
+    });
+
+    function byDateDesc(a,b) {
+      return( a.safeStartDate.isBefore(b.safeStartDate) ) ? 1
+        : ( a.safeStartDate.isAfter(b.safeStartDate) && -1 ) || 0;
+    }
+
+  };
+
+
+
+  JRSResume.prototype.dupe = function() {
+    var rnew = new JRSResume();
+    rnew.parse( this.stringify(), { } );
+    return rnew;
+  };
+
+
+
+  /**
+  Create a copy of this resume in which all fields have been interpreted as
+  Markdown.
+  */
+  JRSResume.prototype.harden = function() {
+
+    var that = this;
+    var ret = this.dupe();
+
+    function HD(txt) {
+      return '@@@@~' + txt + '~@@@@';
+    }
+
+    function HDIN(txt){
+      //return MD(txt || '' ).replace(/^\s*<p>|<\/p>\s*$/gi, '');
+      return HD(txt);
+    }
+
+    // TODO: refactor recursion
+    function hardenStringsInObject( obj, inline ) {
+
+      if( !obj ) return;
+      inline = inline === undefined || inline;
+
+
+      if( Object.prototype.toString.call( obj ) === '[object Array]' ) {
+        obj.forEach(function(elem, idx, ar){
+          if( typeof elem === 'string' || elem instanceof String )
+            ar[idx] = inline ? HDIN(elem) : HD( elem );
+          else
+            hardenStringsInObject( elem );
+        });
+      }
+      else if (typeof obj === 'object') {
+        Object.keys( obj ).forEach(function(key) {
+          var sub = obj[key];
+          if( typeof sub === 'string' || sub instanceof String ) {
+            if( _.contains(['skills','url','website','startDate','endDate',
+              'releaseDate','date','phone','email','address','postalCode',
+              'city','country','region'], key) )
+              return;
+            if( key === 'summary' )
+              obj[key] = HD( obj[key] );
+            else
+              obj[key] = inline ? HDIN( obj[key] ) : HD( obj[key] );
+          }
+          else
+            hardenStringsInObject( sub );
+        });
+      }
+
+    }
+
+    Object.keys( ret ).forEach(function(member){
+      hardenStringsInObject( ret[ member ] );
+    });
+
+    return ret;
+  };
+
+
+
+  /**
+  Convert human-friendly dates into formal Moment.js dates for all collections.
+  We don't want to lose the raw textual date as entered by the user, so we store
+  the Moment-ified date as a separate property with a prefix of .safe. For ex:
+  job.startDate is the date as entered by the user. job.safeStartDate is the
+  parsed Moment.js date that we actually use in processing.
+  */
+  function _parseDates() {
+
+    var _fmt = require('./fluent-date').fmt;
+
+    this.work && this.work.forEach( function(job) {
+      job.safeStartDate = _fmt( job.startDate );
+      job.safeEndDate = _fmt( job.endDate );
+    });
+    this.education && this.education.forEach( function(edu) {
+      edu.safeStartDate = _fmt( edu.startDate );
+      edu.safeEndDate = _fmt( edu.endDate );
+    });
+    this.volunteer && this.volunteer.forEach( function(vol) {
+      vol.safeStartDate = _fmt( vol.startDate );
+      vol.safeEndDate = _fmt( vol.endDate );
+    });
+    this.awards && this.awards.forEach( function(awd) {
+      awd.safeDate = _fmt( awd.date );
+    });
+    this.publications && this.publications.forEach( function(pub) {
+      pub.safeReleaseDate = _fmt( pub.releaseDate );
+    });
+  }
+
+
+
+  /**
+  Export the JRSResume function/ctor.
+  */
+  module.exports = JRSResume;
+
+
+
+}());

src/core/jrs-theme.js

@@ -0,0 +1,108 @@
+/**
+Definition of the JRSTheme class.
+@module jrs-theme.js
+@license MIT. See LICENSE.MD for details.
+*/
+
+(function() {
+
+
+
+  var _ = require('underscore')
+    , PATH = require('path')
+    , parsePath = require('parse-filepath')
+    , pathExists = require('path-exists').sync;
+
+
+
+  /**
+  The JRSTheme class is a representation of a JSON Resume theme asset.
+  @class JRSTheme
+  */
+  function JRSTheme() {
+
+  }
+
+
+
+  /**
+  Open and parse the specified theme.
+  @method open
+  */
+  JRSTheme.prototype.open = function( thFolder ) {
+
+    this.folder = thFolder;
+
+    // Open the [theme-name].json file; should have the same
+    // name as folder
+    var pathInfo = parsePath( thFolder );
+
+    // Open and parse the theme's package.json file.
+    var pkgJsonPath = PATH.join( thFolder, 'package.json' );
+    if( pathExists( pkgJsonPath )) {
+
+      var thApi = require( thFolder )
+        , thPkg = require( pkgJsonPath );
+
+      this.name = thPkg.name;
+      this.render = (thApi && thApi.render) || undefined;
+      this.engine = 'jrs';
+
+      // Create theme formats (HTML and PDF). Just add the bare minimum mix of
+      // properties necessary to allow JSON Resume themes to share a rendering
+      // path with FRESH themes.
+      this.formats = {
+        html: { outFormat: 'html', files: [
+          {
+            action: 'transform',
+            render: this.render,
+            major: true,
+            ext: 'html',
+            css: null
+          }
+        ]},
+        pdf: { outFormat: 'pdf', files: [
+          {
+            action: 'transform',
+            render: this.render,
+            major: true,
+            ext: 'pdf',
+            css: null
+          }
+        ]}
+      };
+    }
+    else {
+      throw { fluenterror: HACKMYSTATUS.missingPackageJSON };
+    }
+
+    return this;
+  };
+
+
+
+  /**
+  Determine if the theme supports the output format.
+  @method hasFormat
+  */
+  JRSTheme.prototype.hasFormat = function( fmt ) {
+    return _.has( this.formats, fmt );
+  };
+
+
+
+  /**
+  Return the requested output format.
+  @method getFormat
+  */
+  JRSTheme.prototype.getFormat = function( fmt ) {
+    return this.formats[ fmt ];
+  };
+
+
+
+  module.exports = JRSTheme;
+
+
+
+}());

src/core/resume-factory.js

@@ -0,0 +1,138 @@
+/**
+Definition of the ResumeFactory class.
+@license MIT. See LICENSE.md for details.
+@module resume-factory.js
+*/
+
+
+
+(function(){
+
+
+
+  var FS          = require('fs'),
+  HACKMYSTATUS    = require('./status-codes'),
+  HME             = require('./event-codes'),
+  ResumeConverter = require('fresh-jrs-converter'),
+  chalk           = require('chalk'),
+  SyntaxErrorEx   = require('../utils/syntax-error-ex'),
+  _               = require('underscore');
+                    require('string.prototype.startswith');
+
+
+
+  /**
+  A simple factory class for FRESH and JSON Resumes.
+  @class ResumeFactory
+  */
+  var ResumeFactory = module.exports = {
+
+
+
+    /**
+    Load one or more resumes from disk.
+
+    @param {Object} opts An options object with settings for the factory as well
+    as passthrough settings for FRESHResume or JRSResume. Structure:
+
+        {
+          format: 'FRESH',    // Format to open as. ('FRESH', 'JRS', null)
+          objectify: true,    // FRESH/JRSResume or raw JSON?
+          inner: {            // Passthru options for FRESH/JRSResume
+            sort: false
+          }
+        }
+
+    */
+    load: function ( sources, opts, emitter ) {
+
+      return sources.map( function( src ) {
+        return this.loadOne( src, opts, emitter );
+      }, this);
+
+    },
+
+
+
+    /**
+    Load a single resume from disk.
+    */
+    loadOne: function( src, opts, emitter ) {
+
+      var toFormat = opts.format;     // Can be null
+      var objectify = opts.objectify;
+
+      // Get the destination format. Can be 'fresh', 'jrs', or null/undefined.
+      toFormat && (toFormat = toFormat.toLowerCase().trim());
+
+      // Load and parse the resume JSON
+      var info = _parse( src, opts, emitter );
+      if( info.fluenterror ) return info;
+
+      // Determine the resume format: FRESH or JRS
+      var json = info.json;
+      var orgFormat = ( json.meta && json.meta.format &&
+                        json.meta.format.startsWith('FRESH@') ) ?
+                        'fresh' : 'jrs';
+
+      // Convert between formats if necessary
+      if( toFormat && (orgFormat !== toFormat) ) {
+        json = ResumeConverter[ 'to' + toFormat.toUpperCase() ]( json );
+      }
+
+      // Objectify the resume, that is, convert it from JSON to a FRESHResume
+      // or JRSResume object.
+      var rez;
+      if( objectify ) {
+        var ResumeClass = require('../core/' + (toFormat || orgFormat) + '-resume');
+        rez = new ResumeClass().parseJSON( json, opts.inner );
+        rez.i().file = src;
+      }
+
+      return {
+        file: src,
+        json: info.json,
+        rez: rez
+      };
+    }
+  };
+
+
+
+  function _parse( fileName, opts, eve ) {
+
+    var rawData;
+    try {
+
+      // Read the file
+      eve && eve.stat( HME.beforeRead, { file: fileName });
+      rawData = FS.readFileSync( fileName, 'utf8' );
+      eve && eve.stat( HME.afterRead, { file: fileName, data: rawData });
+
+      // Parse the file
+      eve && eve.stat( HME.beforeParse, { data: rawData });
+      var ret = { json: JSON.parse( rawData ) };
+      var orgFormat = ( ret.json.meta && ret.json.meta.format &&
+                        ret.json.meta.format.startsWith('FRESH@') ) ?
+                        'fresh' : 'jrs';
+      eve && eve.stat( HME.afterParse, { file: fileName, data: ret.json, fmt: orgFormat } );
+
+      return ret;
+    }
+    catch( e ) {
+      // Can be ENOENT, EACCES, SyntaxError, etc.
+      var ex = {
+        fluenterror: rawData ? HACKMYSTATUS.parseError : HACKMYSTATUS.readError,
+        inner: e, raw: rawData, file: fileName, shouldExit: false
+      };
+      opts.quit && (ex.quit = true);
+      eve && eve.err( ex.fluenterror, ex );
+      if( opts.throw ) throw ex;
+      return ex;
+    }
+
+  }
+
+
+
+}());

src/core/sheet.js

@@ -1,259 +0,0 @@
-/**
-Abstract character/resume sheet representation.
-@license Copyright (c) 2015 by James M. Devlin. All rights reserved.
-*/
-
-(function() {
-
-  var FS = require('fs')
-    , extend = require('../utils/extend')
-    , validator = require('is-my-json-valid')
-    , _ = require('underscore')
-    , PATH = require('path')
-    , moment = require('moment');
-
-  /**
-  The Sheet class represent a specific JSON character sheet. When Sheet.open
-  is called, we merge the loaded JSON sheet properties onto the Sheet instance
-  via extend(), so a full-grown sheet object will have all of the methods here,
-  plus a complement of JSON properties from the backing JSON file. That allows
-  us to treat Sheet objects interchangeably with the loaded JSON model.
-  @class Sheet
-  */
-  function Sheet() {
-
-  }
-
-  /**
-  Open and parse the specified JSON resume sheet. Merge the JSON object model
-  onto this Sheet instance with extend() and convert sheet dates to a safe &
-  consistent format. Then sort each section by startDate descending.
-  */
-  Sheet.prototype.open = function( file, title ) {
-    this.meta = { fileName: file };
-    this.meta.raw = FS.readFileSync( file, 'utf8' );
-    return this.parse( this.meta.raw, title );
-  };
-
-  /**
-  Save the sheet to disk (for environments that have disk access).
-  */
-  Sheet.prototype.save = function( filename ) {
-    filename = filename || this.meta.fileName;
-    FS.writeFileSync( filename, this.stringify(), 'utf8' );
-    return this;
-  };
-
-  /**
-  Convert this object to a JSON string, sanitizing meta-properties along the
-  way. Don't override .toString().
-  */
-  Sheet.prototype.stringify = function() {
-    function replacer( key,value ) { // Exclude these keys from stringification
-      return _.some(['meta', 'warnings', 'computed', 'filt', 'ctrl', 'index',
-        'safeStartDate', 'safeEndDate', 'safeDate', 'safeReleaseDate', 'result',
-      'isModified', 'htmlPreview'],
-        function( val ) { return key.trim() === val; }
-      ) ? undefined : value;
-    }
-    return JSON.stringify( this, replacer, 2 );
-  };
-
-  /**
-  Open and parse the specified JSON resume sheet. Merge the JSON object model
-  onto this Sheet instance with extend() and convert sheet dates to a safe &
-  consistent format. Then sort each section by startDate descending.
-  */
-  Sheet.prototype.parse = function( stringData, opts ) {
-    opts = opts || { };
-    var rep = JSON.parse( stringData );
-    extend( true, this, rep );
-    // Set up metadata
-    if( opts.meta === undefined || opts.meta ) {
-      this.meta = this.meta || { };
-      this.meta.title = (opts.title || this.meta.title) || this.basics.name;
-    }
-    // Parse dates, sort dates, and calculate computed values
-    (opts.date === undefined || opts.date) && _parseDates.call( this );
-    (opts.sort === undefined || opts.sort) && this.sort();
-    (opts.compute === undefined || opts.compute) && (this.computed = {
-      numYears: this.duration(),
-      keywords: this.keywords()
-    });
-    return this;
-  };
-
-  /**
-  Return a unique list of all keywords across all skills.
-  */
-  Sheet.prototype.keywords = function() {
-    var flatSkills = [];
-    if( this.skills && this.skills.length ) {
-      this.skills.forEach( function( s ) {
-        flatSkills = _.union( flatSkills, s.keywords );
-      });
-    }
-    return flatSkills;
-  },
-
-  /**
-  Update the sheet's raw data. TODO: remove/refactor
-  */
-  Sheet.prototype.updateData = function( str ) {
-    this.clear( false );
-    this.parse( str )
-    return this;
-  };
-
-  /**
-  Reset the sheet to an empty state.
-  */
-  Sheet.prototype.clear = function( clearMeta ) {
-    clearMeta = ((clearMeta === undefined) && true) || clearMeta;
-    clearMeta && (delete this.meta);
-    delete this.computed; // Don't use Object.keys() here
-    delete this.work;
-    delete this.volunteer;
-    delete this.education;
-    delete this.awards;
-    delete this.publications;
-    delete this.interests;
-    delete this.skills;
-  };
-
-  /**
-  Get the default (empty) sheet.
-  */
-  Sheet.default = function() {
-    return new Sheet().open( PATH.join( __dirname, 'empty.json'), 'Empty' );
-  }
-
-  /**
-  Add work experience to the sheet.
-  */
-  Sheet.prototype.add = function( moniker ) {
-    var defSheet = Sheet.default();
-    var newObject = $.extend( true, {}, defSheet[ moniker ][0] );
-    this[ moniker ] = this[ moniker ] || [];
-    this[ moniker ].push( newObject );
-    return newObject;
-  };
-
-  /**
-  Determine if the sheet includes a specific social profile (eg, GitHub).
-  */
-  Sheet.prototype.hasProfile = function( socialNetwork ) {
-    socialNetwork = socialNetwork.trim().toLowerCase();
-    return this.basics.profiles && _.some( this.basics.profiles, function(p) {
-      return p.network.trim().toLowerCase() === socialNetwork;
-    });
-  };
-
-  /**
-  Determine if the sheet includes a specific skill.
-  */
-  Sheet.prototype.hasSkill = function( skill ) {
-    skill = skill.trim().toLowerCase();
-    return this.skills && _.some( this.skills, function(sk) {
-      return sk.keywords && _.some( sk.keywords, function(kw) {
-        return kw.trim().toLowerCase() === skill;
-      });
-    });
-  };
-
-  /**
-  Validate the sheet against the JSON Resume schema.
-  */
-  Sheet.prototype.isValid = function( ) { // TODO: ↓ fix this path ↓
-    var schema = FS.readFileSync( PATH.join( __dirname, 'resume.json' ), 'utf8' );
-    var schemaObj = JSON.parse( schema );
-    var validator = require('is-my-json-valid')
-    var validate = validator( schemaObj );
-    return validate( this );
-  };
-
-  /**
-  Calculate the total duration of the sheet. Assumes this.work has been sorted
-  by start date descending, perhaps via a call to Sheet.sort().
-  @returns The total duration of the sheet's work history, that is, the number
-  of years between the start date of the earliest job on the resume and the
-  *latest end date of all jobs in the work history*. This last condition is for
-  sheets that have overlapping jobs.
-  */
-  Sheet.prototype.duration = function() {
-    if( this.work && this.work.length ) {
-      var careerStart = this.work[ this.work.length - 1].safeStartDate;
-      if ((typeof careerStart === 'string' || careerStart instanceof String) &&
-          !careerStart.trim())
-        return 0;
-      var careerLast = _.max( this.work, function( w ) {
-        return w.safeEndDate.unix();
-      }).safeEndDate;
-      return careerLast.diff( careerStart, 'years' );
-    }
-    return 0;
-  };
-
-  /**
-  Sort dated things on the sheet by start date descending. Assumes that dates
-  on the sheet have been processed with _parseDates().
-  */
-  Sheet.prototype.sort = function( ) {
-
-    this.work && this.work.sort( byDateDesc );
-    this.education && this.education.sort( byDateDesc );
-    this.volunteer && this.volunteer.sort( byDateDesc );
-
-    this.awards && this.awards.sort( function(a, b) {
-      return( a.safeDate.isBefore(b.safeDate) ) ? 1
-        : ( a.safeDate.isAfter(b.safeDate) && -1 ) || 0;
-    });
-    this.publications && this.publications.sort( function(a, b) {
-      return( a.safeReleaseDate.isBefore(b.safeReleaseDate) ) ? 1
-        : ( a.safeReleaseDate.isAfter(b.safeReleaseDate) && -1 ) || 0;
-    });
-
-    function byDateDesc(a,b) {
-      return( a.safeStartDate.isBefore(b.safeStartDate) ) ? 1
-        : ( a.safeStartDate.isAfter(b.safeStartDate) && -1 ) || 0;
-    }
-
-  };
-
-  /**
-  Convert human-friendly dates into formal Moment.js dates for all collections.
-  We don't want to lose the raw textual date as entered by the user, so we store
-  the Moment-ified date as a separate property with a prefix of .safe. For ex:
-  job.startDate is the date as entered by the user. job.safeStartDate is the
-  parsed Moment.js date that we actually use in processing.
-  */
-  function _parseDates() {
-
-    var _fmt = require('./fluent-date').fmt;
-
-    this.work && this.work.forEach( function(job) {
-      job.safeStartDate = _fmt( job.startDate );
-      job.safeEndDate = _fmt( job.endDate );
-    });
-    this.education && this.education.forEach( function(edu) {
-      edu.safeStartDate = _fmt( edu.startDate );
-      edu.safeEndDate = _fmt( edu.endDate );
-    });
-    this.volunteer && this.volunteer.forEach( function(vol) {
-      vol.safeStartDate = _fmt( vol.startDate );
-      vol.safeEndDate = _fmt( vol.endDate );
-    });
-    this.awards && this.awards.forEach( function(awd) {
-      awd.safeDate = _fmt( awd.date );
-    });
-    this.publications && this.publications.forEach( function(pub) {
-      pub.safeReleaseDate = _fmt( pub.releaseDate );
-    });
-  }
-
-  /**
-  Export the Sheet function/ctor.
-  */
-  module.exports = Sheet;
-
-}());

src/core/status-codes.js

@@ -0,0 +1,37 @@
+/**
+Status codes for HackMyResume.
+@module status-codes.js
+@license MIT. See LICENSE.MD for details.
+*/
+
+(function(){
+
+  module.exports = {
+    success: 0,
+    themeNotFound: 1,
+    copyCss: 2,
+    resumeNotFound: 3,
+    missingCommand: 4,
+    invalidCommand: 5,
+    resumeNotFoundAlt: 6,
+    inputOutputParity: 7,
+    createNameMissing: 8,
+    pdfgeneration: 9,
+    missingPackageJSON: 10,
+    invalid: 11,
+    invalidFormat: 12,
+    notOnPath: 13,
+    readError: 14,
+    parseError: 15,
+    fileSaveError: 16,
+    generateError: 17,
+    invalidHelperUse: 18,
+    mixedMerge: 19,
+    invokeTemplate: 20,
+    compileTemplate: 21,
+    themeLoad: 22,
+    invalidParamCount: 23,
+    missingParam: 24
+  };
+
+}());

src/core/theme.js

@@ -1,90 +0,0 @@
-/**
-Abstract theme representation.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-*/
-
-(function() {
-
-  var FS = require('fs')
-    , extend = require('../utils/extend')
-    , validator = require('is-my-json-valid')
-    , _ = require('underscore')
-    , PATH = require('path')
-    , moment = require('moment');
-
-  /**
-  The Theme class represents a specific presentation of a resume.
-  @class Theme
-  */
-  function Theme() {
-
-  }
-
-  /**
-  Open and parse the specified theme.
-  */
-  Theme.prototype.open = function( themeFolder ) {
-
-    function friendlyName( val ) {
-      val = val.trim().toLowerCase();
-      var friendly = { yml: 'yaml', md: 'markdown', txt: 'text' };
-      return friendly[val] || val;
-    }
-
-    var tplFolder = PATH.join( themeFolder, 'templates' );
-    var fmts = FS.readdirSync( tplFolder ).map( function( file ) {
-      var absPath = PATH.join( tplFolder, file );
-      var pathInfo = PATH.parse(absPath);
-      var temp = [ pathInfo.name, {
-        title: friendlyName(pathInfo.name),
-        pre: pathInfo.name,
-        ext: pathInfo.ext.slice(1),
-        path: absPath,
-        data: FS.readFileSync( absPath, 'utf8' ),
-        css: null
-      }];
-      return temp;
-    });
-
-    // Freebie formats every theme gets
-    fmts.push( [ 'json', { title: 'json', pre: 'json', ext: 'json', path: null, data: null } ] );
-    fmts.push( [ 'yml', { title: 'yaml', pre: 'yml', ext: 'yml', path: null, data: null } ] );
-
-    // Handle CSS files
-    var cssFiles = fmts.filter(function( fmt ){
-      return fmt[1].ext === 'css';
-    });
-    cssFiles.forEach(function( cssf ) {
-      // For each CSS file, get its corresponding HTML file
-      var idx = _.findIndex(fmts, function( fmt ) { return fmt[1].pre === cssf[1].pre && fmt[1].ext === 'html' });
-      fmts[ idx ][1].css = cssf[1].data;
-      fmts[ idx ][1].cssPath = cssf[1].path;
-    });
-    fmts = fmts.filter( function( fmt) {
-      return fmt[1].ext !== 'css';
-    });
-
-    // Create a hash out of the formats for this theme
-    this.formats = _.object( fmts );
-
-    this.name = PATH.parse( themeFolder ).name;
-    return this;
-  };
-
-  /**
-  Determine if the theme supports the specified output format.
-  */
-  Theme.prototype.hasFormat = function( fmt ) {
-    return _.has( this.formats, fmt );
-  };
-
-  /**
-  Determine if the theme supports the specified output format.
-  */
-  Theme.prototype.getFormat = function( fmt ) {
-    return this.formats[ fmt ];
-  };
-
-  module.exports = Theme;
-
-}());

src/fluentcmd.js

@@ -1,148 +0,0 @@
-/**
-Internal resume generation logic for FluentCV.
-@license Copyright (c) 2015 | James M. Devlin
-*/
-
-module.exports = function () {
-
-  // We don't mind pseudo-globals here
-  var path = require( 'path' )
-    , extend = require( './utils/extend' )
-    , unused = require('./utils/string')
-    , fs = require('fs')
-    , _ = require('underscore')
-    , FLUENT = require('./fluentlib')
-    , PATH = require('path')
-    , MKDIRP = require('mkdirp')
-    , rez, _log, _err;
-
-  /**
-  Given a source JSON resume, 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 theme Friendly name of the resume theme. Defaults to "modern".
-  @param logger Optional logging override.
-  */
-  function gen( src, dst, opts, logger, errHandler ) {
-
-    _log = logger || console.log;
-    _err = errHandler || error;
-
-    //_opts = extend( true, _opts, opts );
-    _opts.theme = (opts.theme && opts.theme.toLowerCase().trim()) || 'modern';
-    _opts.prettify = opts.prettify === true ? _opts.prettify : false;
-
-    // Load input resumes...
-    if(!src || !src.length) { throw { fluenterror: 3 }; }
-    var sheets = src.map( function( res ) {
-      _log( 'Reading JSON resume: ' + res );
-      return (new FLUENT.Sheet()).open( res );
-    });
-
-    // Merge input resumes...
-    var msg = '';
-    rez = _.reduceRight( sheets, function( a, b, idx ) {
-      msg += ((idx == sheets.length - 2) ? 'Merging ' + a.meta.fileName : '')
-        + ' onto ' + b.meta.fileName;
-      return extend( true, b, a );
-    });
-    msg && _log(msg);
-
-    // Load the active theme
-    // Verify the specified theme name/path
-    var tFolder = PATH.resolve( __dirname, '../node_modules/fluent-themes/themes', _opts.theme );
-    var exists = require('./utils/file-exists');
-    if (!exists( tFolder )) {
-      tFolder = PATH.resolve( _opts.theme );
-      if (!exists( tFolder )) {
-        throw { fluenterror: 1, data: _opts.theme };
-      }
-    }
-    var theTheme = new FLUENT.Theme().open( tFolder );
-    _opts.themeObj = theTheme;
-    _log( 'Applying ' + theTheme.name.toUpperCase() + ' theme (' + Object.keys(theTheme.formats).length + ' formats)' );
-
-    // Expand output resumes... (can't use map() here)
-    var targets = [];
-    var that = this;
-    ( (dst && dst.length && dst) || ['resume.all'] ).forEach( function(t) {
-      var to = path.resolve(t), pa = path.parse(to), fmat = pa.ext || '.all';
-      targets.push.apply(targets, fmat === '.all' ?
-        Object.keys( theTheme.formats ).map(function(k){ var z = theTheme.formats[k]; return { file: to.replace(/all$/g,z.pre), fmt: z } })
-        : [{ file: to, fmt: theTheme.getFormat( fmat.slice(1) ) }]);
-    });
-
-    // Run the transformation!
-    var finished = targets.map( function(t) { return single(t, theTheme); } );
-
-    // Don't send the client back empty-handed
-    return { sheet: rez, targets: targets, processed: finished };
-  }
-
-  /**
-  Generate a single resume of a specific format.
-  @param f Full path to the destination resume to generate, for example,
-  "/foo/bar/resume.pdf" or "c:\foo\bar\resume.txt".
-  */
-  function single( fi, theme ) {
-    try {
-      var f = fi.file, fType = fi.fmt.ext, fName = path.basename( f, '.' + fType );
-      var fObj = _.property( fi.fmt.pre )( theme.formats );
-      var fOut = path.join( f.substring( 0, f.lastIndexOf('.') + 1 ) + fObj.pre );
-      _log( 'Generating ' + fi.fmt.title.toUpperCase() + ' resume: ' + path.relative(process.cwd(), f ) );
-      var theFormat = _fmts.filter( function( fmt ) {
-        return fmt.name === fi.fmt.pre;
-      })[0];
-      MKDIRP( path.dirname(fOut) ); // Ensure dest folder exists; don't bug user
-      theFormat.gen.generate( rez, fOut, _opts );
-    }
-    catch( ex ) {
-      _err( ex );
-    }
-  }
-
-  /**
-  Handle an exception.
-  */
-  function error( ex ) {
-    throw ex;
-  }
-
-  /**
-  Supported resume formats.
-  */
-  var _fmts = [
-    { name: 'html', ext: 'html', gen: new FLUENT.HtmlGenerator() },
-    { name: 'txt',  ext: 'txt', gen: new FLUENT.TextGenerator()  },
-    { name: 'doc',  ext: 'doc',  fmt: 'xml', gen: new FLUENT.WordGenerator() },
-    { name: 'pdf',  ext: 'pdf', fmt: 'html', is: false, gen: new FLUENT.HtmlPdfGenerator() },
-    { name: 'md', ext: 'md', fmt: 'txt', gen: new FLUENT.MarkdownGenerator() },
-    { name: 'json', ext: 'json', gen: new FLUENT.JsonGenerator() },
-    { name: 'yml', ext: 'yml', fmt: 'yml', gen: new FLUENT.JsonYamlGenerator() }
-  ];
-
-  /**
-  Default FluentCMD options.
-  */
-  var _opts = {
-    theme: 'modern',
-    prettify: { // ← See https://github.com/beautify-web/js-beautify#options
-      indent_size: 2,
-      unformatted: ['em','strong'],
-      max_char: 80, // ← See lib/html.js in above-linked repo
-      //wrap_line_length: 120, ← Don't use this
-    }
-  };
-
-  /**
-  Internal module interface. Used by FCV Desktop and HMR.
-  */
-  return {
-    generate: gen,
-    lib: require('./fluentlib'),
-    options: _opts,
-    formats: _fmts
-  };
-
-}();

src/fluentlib.js

@@ -1,17 +0,0 @@
-/**
-Core resume generation module for FluentCV.
-@license Copyright (c) 2015 by James M. Devlin. All rights reserved.
-*/
-
-module.exports = {
-  Sheet: require('./core/sheet'),
-  Theme: require('./core/theme'),
-  HtmlGenerator: require('./gen/html-generator'),
-  TextGenerator: require('./gen/text-generator'),
-  HtmlPdfGenerator: require('./gen/html-pdf-generator'),
-  WordGenerator: require('./gen/word-generator'),
-  MarkdownGenerator: require('./gen/markdown-generator'),
-  JsonGenerator: require('./gen/json-generator'),
-  YamlGenerator: require('./gen/yaml-generator'),
-  JsonYamlGenerator: require('./gen/json-yaml-generator')
-};

src/gen/html-generator.js

@@ -1,32 +0,0 @@
-/**
-HTML resume generator for FluentCV.
-@license Copyright (c) 2015 by James M. Devlin. All rights reserved.
-*/
-
-var TemplateGenerator = require('./template-generator');
-var FS = require('fs-extra');
-var HTML = require( 'html' );
-
-var HtmlGenerator = module.exports = TemplateGenerator.extend({
-
-  init: function() {
-    this._super( 'html' );
-  },
-
-  /**
-  Generate an HTML resume with optional pretty printing.
-  */
-  onBeforeSave: function( mk, theme, outputFile ) {
-    var themeFile = theme.getFormat('html').path;
-    var cssSrc = themeFile.replace( /.html$/g, '.css' );
-    var cssDst = outputFile.replace( /.html$/g, '.css' );
-    var that = this;
-    FS.copySync( cssSrc, cssDst, { clobber: true }, function( e ) {
-      throw { fluenterror: that.codes.copyCss, data: [cssSrc,cssDst] };
-    });
-
-    return this.opts.prettify ?
-      HTML.prettyPrint( mk, this.opts.prettify ) : mk;
-  }
-
-});

src/gen/html-pdf-generator.js

@@ -1,74 +0,0 @@
-/**
-HTML-based PDF resume generator for FluentCV.
-@license Copyright (c) 2015 by James M. Devlin. All rights reserved.
-*/
-
-var TemplateGenerator = require('./template-generator');
-var FS = require('fs-extra');
-var HTML = require( 'html' );
-
-var HtmlPdfGenerator = module.exports = TemplateGenerator.extend({
-
-  init: function() {
-    this._super( 'pdf', 'html' );
-  },
-
-  /**
-  Generate an HTML resume with optional pretty printing.
-  TODO: Avoid copying the CSS file to dest if we don't need to.
-  */
-  onBeforeSave: function( mk, themeFile, outputFile ) {
-    // var cssSrc = themeFile.replace( /pdf\.html$/gi, 'html.css' );
-    // var cssDst = outputFile.replace( /\.pdf$/gi, '.css' );
-    // var that = this;
-    // FS.copySync( cssSrc, cssDst, { clobber: true }, function( e ) {
-    //   if( e ) that.err( "Couldn't copy CSS file to destination: " + e);
-    // });
-    // return true ?
-    //   HTML.prettyPrint( mk, { indent_size: 2 } ) : mk;
-
-    pdf(mk, outputFile);
-    return mk;
-  }
-
-});
-
-/**
-Generate a PDF from HTML.
-*/
-function pdf( markup, fOut ) {
-
-  var pdfCount = 0;
-  if( false ) { //( _opts.pdf === 'phantom' || _opts.pdf == 'all' ) {
-    pdfCount++;
-    require('phantom').create( function( ph ) {
-      ph.createPage( function( page ) {
-        page.setContent( markup );
-        page.set('paperSize', {
-          format: 'A4',
-          orientation: 'portrait',
-          margin: '1cm'
-        });
-        page.set("viewportSize", {
-          width: 1024, // TODO: option-ify
-          height: 768 // TODO: Use "A" sizes
-        });
-        page.set('onLoadFinished', function(success) {
-          page.render( fOut );
-          pdfCount++;
-          ph.exit();
-        });
-      },
-      { dnodeOpts: {  weak: false   } } );
-    });
-  }
-  if( true ) { // _opts.pdf === 'wkhtmltopdf' || _opts.pdf == 'all' ) {
-    var fOut2 = fOut;
-    if( pdfCount == 1 ) {
-      fOut2 = fOut2.replace(/\.pdf$/g, '.b.pdf');
-    }
-    require('wkhtmltopdf')( markup, { pageSize: 'letter' } )
-      .pipe( FS.createWriteStream( fOut2 ) );
-      pdfCount++;
-  }
-}

src/gen/template-generator.js

@@ -1,173 +0,0 @@
-/**
-Template-based resume generator base for FluentCV.
-@license Copyright (c) 2015 | James M. Devlin
-*/
-
-var FS = require( 'fs' )
-  , _ = require( 'underscore' )
-  , MD = require( 'marked' )
-  , XML = require( 'xml-escape' )
-  , PATH = require('path')
-  , BaseGenerator = require( './base-generator' )
-  , EXTEND = require('../utils/extend')
-  , Theme = require('../core/theme');
-
-// Default options.
-var _defaultOpts = {
-  themeRelative: '../../node_modules/fluent-themes/themes',
-  keepBreaks: true,
-  freezeBreaks: true,
-  nSym: '&newl;', // newline entity
-  rSym: '&retn;', // return entity
-  template: {
-    interpolate: /\{\{(.+?)\}\}/g,
-    escape: /\{\{\=(.+?)\}\}/g,
-    evaluate: /\{\%(.+?)\%\}/g,
-    comment: /\{\#(.+?)\#\}/g
-  },
-  filters: {
-    out: function( txt ) { return txt; },
-    raw: function( txt ) { return txt; },
-    xml: function( txt ) { return XML(txt); },
-    md: function( txt ) { return MD(txt); },
-    mdin: function( txt ) { return MD(txt).replace(/^\s*\<p\>|\<\/p\>\s*$/gi, ''); },
-    lower: function( txt ) { return txt.toLowerCase(); }
-  },
-  prettify: { // ← See https://github.com/beautify-web/js-beautify#options
-    indent_size: 2,
-    unformatted: ['em','strong'],
-    max_char: 80, // ← See lib/html.js in above-linked repo
-    //wrap_line_length: 120, <-- Don't use this
-  }
-};
-
-/**
-TemplateGenerator performs resume generation via Underscore-style template
-expansion and is appropriate for text-based formats like HTML, plain text,
-and XML versions of Microsoft Word, Excel, and OpenOffice.
-*/
-var TemplateGenerator = module.exports = BaseGenerator.extend({
-
-  /** outputFormat: html, txt, pdf, doc
-      templateFormat: html or txt
-  **/
-  init: function( outputFormat, templateFormat, cssFile ){
-    this._super( outputFormat );
-    this.tplFormat = templateFormat || outputFormat;
-  },
-
-  /** Default generation method for template-based generators. */
-  invoke: function( rez, themeMarkup, cssInfo, opts ) {
-
-    // Compile and invoke the template!
-    this.opts = EXTEND( true, {}, _defaultOpts, opts );
-    mk = this.single( rez, themeMarkup, this.format, cssInfo, { } );
-    this.onBeforeSave && (mk = this.onBeforeSave( mk, themeFile, f ));
-    return mk;
-
-  },
-
-  /** Default generation method for template-based generators. */
-  generate: function( rez, f, opts ) {
-
-    // Carry over options
-    this.opts = EXTEND( true, { }, _defaultOpts, opts );
-
-    // Verify the specified theme name/path
-    var tFolder = PATH.resolve( __dirname, this.opts.themeRelative, this.opts.theme );
-    var exists = require('../utils/file-exists');
-    if (!exists( tFolder )) {
-      tFolder = PATH.resolve( this.opts.theme );
-      if (!exists( tFolder )) {
-        throw { fluenterror: this.codes.themeNotFound, data: this.opts.theme };
-      }
-    }
-
-    // Load the theme
-    var theme = opts.themeObj || new Theme().open( tFolder );
-
-    // Load theme and CSS data
-    var tplFolder = PATH.join( tFolder, 'templates' );
-    var curFmt = theme.getFormat( this.format );
-    var ctx = { file: curFmt.css ? curFmt.cssPath : null, data: curFmt.css || null };
-
-    // Compile and invoke the template!
-    var mk = this.single( rez, curFmt.data, this.format, ctx, opts );
-    this.onBeforeSave && (mk = this.onBeforeSave( mk, theme, f ));
-    FS.writeFileSync( f, mk, { encoding: 'utf8', flags: 'w' } );
-
-  },
-
-  /**
-  Perform a single resume JSON-to-DEST resume transformation. Exists as a
-  separate function in order to expose string-based transformations to clients
-  who don't have access to filesystem resources (in-browser, etc.).
-  */
-  single: function( json, jst, format, cssInfo, opts ) {
-
-    // Freeze whitespace in the template.
-    this.opts.freezeBreaks && ( jst = freeze(jst) );
-
-    // Tweak underscore's default template delimeters
-    _.templateSettings = this.opts.template;
-
-    // Convert {{ someVar }} to {% print(filt.out(someVar) %}
-    // Convert {{ someVar|someFilter }} to {% print(filt.someFilter(someVar) %}
-    jst = jst.replace( _.templateSettings.interpolate, function replace(m, p1) {
-      if( p1.indexOf('|') > -1 ) {
-        var terms = p1.split('|');
-        return '{% print( filt.' + terms[1] + '( ' + terms[0] + ' )) %}';
-      }
-      else {
-        return '{% print( filt.out(' + p1 + ') ) %}';
-      }
-    });
-
-    // Strip {# comments #}
-    jst = jst.replace( _.templateSettings.comment, '');
-    json.display_progress_bar = true;
-
-    // Compile and run the template. TODO: avoid unnecessary recompiles.
-    jst = _.template(jst)({ r: json, filt: this.opts.filters, cssInfo: cssInfo, headFragment: this.opts.headFragment || '' });
-
-    // Unfreeze whitespace
-    this.opts.freezeBreaks && ( jst = unfreeze(jst) );
-
-    return jst;
-  }
-
-
-});
-
-/**
-Export the TemplateGenerator function/ctor.
-*/
-module.exports = TemplateGenerator;
-
-/**
-Freeze newlines for protection against errant JST parsers.
-*/
-function freeze( markup ) {
-  return markup
-    .replace( _reg.regN, _defaultOpts.nSym )
-    .replace( _reg.regR, _defaultOpts.rSym );
-}
-
-/**
-Unfreeze newlines when the coast is clear.
-*/
-function unfreeze( markup ) {
-  return markup
-    .replace( _reg.regSymR, '\r' )
-    .replace( _reg.regSymN, '\n' );
-}
-
-/**
-Regexes for linebreak preservation.
-*/
-var _reg = {
-  regN: new RegExp( '\n', 'g' ),
-  regR: new RegExp( '\r', 'g' ),
-  regSymN: new RegExp( _defaultOpts.nSym, 'g' ),
-  regSymR: new RegExp( _defaultOpts.rSym, 'g' )
-};

src/gen/word-generator.js

@@ -1,13 +0,0 @@
-/**
-MS Word resume generator for FluentCV.
-@license Copyright (c) 2015 by James M. Devlin. All rights reserved.
-*/
-
-var TemplateGenerator = require('./template-generator');
-var WordGenerator = module.exports = TemplateGenerator.extend({
-
-  init: function(){
-    this._super( 'doc', 'xml' );
-  },
-
-});

src/generators/base-generator.js

@@ -1,6 +1,7 @@
 /**
-Base resume generator for FluentCV.
-@license Copyright (c) 2015 | James M. Devlin
+Definition of the BaseGenerator class.
+@module base-generator.js
+@license MIT. See LICENSE.md for details.
 */
 
 (function() {
@@ -25,12 +26,7 @@ Base resume generator for FluentCV.
     /**
     Status codes.
     */
-    codes: {
-      success: 0,
-      themeNotFound: 1,
-      copyCss: 2,
-      resumeNotFound: 3
-    },
+    codes: require('../core/status-codes'),
 
     /**
     Generator options.

src/generators/html-generator.js

@@ -0,0 +1,34 @@
+/**
+Definition of the HTMLGenerator class.
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
+@module html-generator.js
+*/
+
+(function() {
+
+  var TemplateGenerator = require('./template-generator')
+    , FS = require('fs-extra')
+    , HTML = require( 'html' )
+    , PATH = require('path');
+    require('string.prototype.endswith');
+
+  var HtmlGenerator = module.exports = TemplateGenerator.extend({
+
+    init: function() {
+      this._super( 'html' );
+    },
+
+    /**
+    Copy satellite CSS files to the destination and optionally pretty-print
+    the HTML resume prior to saving.
+    */
+    onBeforeSave: function( info ) {
+      if( info.outputFile.endsWith('.css') )
+        return info.mk;
+      return this.opts.prettify ?
+        HTML.prettyPrint( info.mk, this.opts.prettify ) : info.mk;
+    }
+
+  });
+
+}());

src/generators/html-pdf-cli-generator.js

@@ -0,0 +1,113 @@
+/**
+Definition of the HtmlPdfCLIGenerator class.
+@module html-pdf-generator.js
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function() {
+
+
+
+  var TemplateGenerator = require('./template-generator')
+    , FS = require('fs-extra')
+    , HTML = require( 'html' )
+    , PATH = require('path')
+    , SPAWN = require('../utils/safe-spawn')
+    , SLASH = require('slash');
+
+
+
+  /**
+  An HTML-driven PDF resume generator for HackMyResume. Talks to Phantom,
+  wkhtmltopdf, and other PDF engines over a CLI (command-line interface).
+  If an engine isn't installed for a particular platform, error out gracefully.
+  */
+  var HtmlPdfCLIGenerator = module.exports = TemplateGenerator.extend({
+
+
+
+    init: function() {
+      this._super( 'pdf', 'html' );
+    },
+
+
+
+    /**
+    Generate the binary PDF.
+    */
+    onBeforeSave: function( info ) {
+
+      try {
+        var safe_eng = info.opts.pdf || 'wkhtmltopdf';
+        if( safe_eng !== 'none' )
+          engines[ safe_eng ].call( this, info.mk, info.outputFile );
+        return null; // halt further processing
+      }
+      catch(ex) {
+        // { [Error: write EPIPE] code: 'EPIPE', errno: 'EPIPE', ... }
+        // { [Error: ENOENT] }
+        throw ( ex.inner && ex.inner.code === 'ENOENT' ) ?
+          { fluenterror: this.codes.notOnPath, inner: ex.inner, engine: ex.cmd,
+            stack: ex.inner && ex.inner.stack } :
+          { fluenterror: this.codes.pdfGeneration, inner: ex, stack: ex.stack };
+      }
+    }
+
+
+
+  });
+
+
+
+  // TODO: Move each engine to a separate module
+  var engines = {
+
+
+
+    /**
+    Generate a PDF from HTML using wkhtmltopdf's CLI interface.
+    Spawns a child process with `wkhtmltopdf <source> <target>`. wkhtmltopdf
+    must be installed and path-accessible.
+    TODO: If HTML generation has run, reuse that output
+    TODO: Local web server to ease wkhtmltopdf rendering
+    */
+    wkhtmltopdf: function(markup, fOut) {
+
+      // Save the markup to a temporary file
+      var tempFile = fOut.replace(/\.pdf$/i, '.pdf.html');
+      FS.writeFileSync( tempFile, markup, 'utf8' );
+      var info = SPAWN( 'wkhtmltopdf', [ tempFile, fOut ] );
+
+    },
+
+
+
+    /**
+    Generate a PDF from HTML using Phantom's CLI interface.
+    Spawns a child process with `phantomjs <script> <source> <target>`. Phantom
+    must be installed and path-accessible.
+    TODO: If HTML generation has run, reuse that output
+    TODO: Local web server to ease Phantom rendering
+    */
+    phantom: function( markup, fOut ) {
+
+      // Save the markup to a temporary file
+      var tempFile = fOut.replace(/\.pdf$/i, '.pdf.html');
+      FS.writeFileSync( tempFile, markup, 'utf8' );
+      var scriptPath = SLASH( PATH.relative( process.cwd(),
+        PATH.resolve( __dirname, '../utils/rasterize.js' ) ) );
+      var sourcePath = SLASH( PATH.relative( process.cwd(), tempFile) );
+      var destPath = SLASH( PATH.relative( process.cwd(), fOut) );
+      var info = SPAWN('phantomjs', [ scriptPath, sourcePath, destPath ]);
+
+    }
+
+
+
+  };
+
+
+
+}());

src/generators/html-png-generator.js

@@ -0,0 +1,66 @@
+/**
+Definition of the HtmlPngGenerator class.
+@license MIT. See LICENSE.MD for details.
+@module html-png-generator.js
+*/
+
+
+
+(function() {
+
+
+
+  var TemplateGenerator = require('./template-generator')
+    , FS = require('fs-extra')
+    , HTML = require( 'html' );
+
+
+
+  /**
+  An HTML-based PNG resume generator for HackMyResume.
+  */
+  var HtmlPngGenerator = module.exports = TemplateGenerator.extend({
+
+
+
+    init: function() {
+      this._super( 'png', 'html' );
+    },
+
+
+
+    invoke: function( rez, themeMarkup, cssInfo, opts ) {
+      // TODO: Not currently called or callable.
+    },
+
+
+
+    generate: function( rez, f, opts ) {
+      var htmlResults = opts.targets.filter(function(t){
+        return t.fmt.outFormat === 'html';
+      });
+      var htmlFile = htmlResults[0].final.files.filter(function(fl){
+        return fl.info.ext === 'html';
+      });
+      png( htmlFile[0].data, f );
+    }
+
+
+
+  });
+
+
+
+  /**
+  Generate a PNG from HTML.
+  */
+  function png( markup, fOut ) {
+    // TODO: Which Webshot syntax?
+    // require('webshot')( markup , { encoding: 'binary', siteType: 'html' } )
+    //   .pipe( FS.createWriteStream( fOut ) );
+    require('webshot')( markup , fOut, { siteType: 'html' }, function(err) { } );
+  }
+
+
+
+}());

src/generators/json-generator.js

@@ -1,6 +1,7 @@
 /**
 Definition of the JsonGenerator class.
-@license Copyright (c) 2015 | James M. Devlin
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
+@module json-generator.js
 */
 
 var BaseGenerator = require('./base-generator');
@@ -19,9 +20,9 @@ var JsonGenerator = module.exports = BaseGenerator.extend({
   invoke: function( rez ) {
     // TODO: merge with FCVD
     function replacer( key,value ) { // Exclude these keys from stringification
-      return _.some(['meta', 'warnings', 'computed', 'filt', 'ctrl', 'index',
+      return _.some(['imp', 'warnings', 'computed', 'filt', 'ctrl', 'index',
         'safeStartDate', 'safeEndDate', 'safeDate', 'safeReleaseDate', 'result',
-      'isModified', 'htmlPreview'],
+      'isModified', 'htmlPreview', 'safe' ],
         function( val ) { return key.trim() === val; }
       ) ? undefined : value;
     }

src/generators/json-yaml-generator.js

@@ -1,7 +1,7 @@
 /**
-A JSON-driven YAML resume generator for FluentLib.
+Definition of the JsonYamlGenerator class.
 @module json-yaml-generator.js
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
 */
 
 (function() {

src/generators/latex-generator.js

@@ -0,0 +1,18 @@
+/**
+Definition of the LaTeXGenerator class.
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
+@module latex-generator.js
+*/
+
+var TemplateGenerator = require('./template-generator');
+
+/**
+LaTeXGenerator generates a LaTeX resume via TemplateGenerator.
+*/
+var LaTeXGenerator = module.exports = TemplateGenerator.extend({
+
+  init: function(){
+    this._super( 'latex', 'tex' );
+  }
+
+});

src/generators/markdown-generator.js

@@ -1,6 +1,7 @@
 /**
-Markdown resume generator for FluentCV.
-@license Copyright (c) 2015 by James M. Devlin. All rights reserved.
+Definition of the MarkdownGenerator class.
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
+@module markdown-generator.js
 */
 
 var TemplateGenerator = require('./template-generator');

src/generators/template-generator.js

@@ -0,0 +1,244 @@
+/**
+Definition of the TemplateGenerator class. TODO: Refactor
+@license MIT. See LICENSE.md for details.
+@module template-generator.js
+*/
+
+
+
+(function() {
+
+
+
+  var FS = require( 'fs-extra' )
+    , _ = require( 'underscore' )
+    , MD = require( 'marked' )
+    , XML = require( 'xml-escape' )
+    , PATH = require('path')
+    , parsePath = require('parse-filepath')
+    , MKDIRP = require('mkdirp')
+    , BaseGenerator = require( './base-generator' )
+    , EXTEND = require('extend')
+    , FRESHTheme = require('../core/fresh-theme')
+    , JRSTheme = require('../core/jrs-theme');
+
+
+
+  /**
+  TemplateGenerator performs resume generation via local Handlebar or Underscore
+  style template expansion and is appropriate for text-based formats like HTML,
+  plain text, and XML versions of Microsoft Word, Excel, and OpenOffice.
+  @class TemplateGenerator
+  */
+  var TemplateGenerator = module.exports = BaseGenerator.extend({
+
+
+
+    /** Constructor. Set the output format and template format for this
+    generator. Will usually be called by a derived generator such as
+    HTMLGenerator or MarkdownGenerator. */
+
+    init: function( outputFormat, templateFormat, cssFile ){
+      this._super( outputFormat );
+      this.tplFormat = templateFormat || outputFormat;
+    },
+
+
+
+    /** Generate a resume using string-based inputs and outputs without touching
+    the filesystem.
+    @method invoke
+    @param rez A FreshResume object.
+    @param opts Generator options.
+    @returns {Array} An array of objects representing the generated output
+    files. */
+
+    invoke: function( rez, opts ) {
+
+      opts = opts ?
+        (this.opts = EXTEND( true, { }, _defaultOpts, opts )) :
+        this.opts;
+
+      // Sort such that CSS files are processed before others
+      var curFmt = opts.themeObj.getFormat( this.format );
+      curFmt.files = _.sortBy( curFmt.files, function(fi) {
+        return fi.ext !== 'css';
+      });
+
+      // Run the transformation!
+      var results = curFmt.files.map( function( tplInfo, idx ) {
+        var trx = this.single( rez, tplInfo.data, this.format, opts, opts.themeObj, curFmt );
+        if( tplInfo.ext === 'css' ) { curFmt.files[idx].data = trx; }
+        else if( tplInfo.ext === 'html' ) {
+          //tplInfo.css contains the CSS data loaded by theme
+          //tplInfo.cssPath contains the absolute path to the source CSS File
+        }
+        return { info: tplInfo, data: trx };
+      }, this);
+
+      return {
+        files: results
+      };
+
+    },
+
+
+
+    /** Generate a resume using file-based inputs and outputs. Requires access
+    to the local filesystem.
+    @method generate
+    @param rez A FreshResume object.
+    @param f Full path to the output resume file to generate.
+    @param opts Generator options. */
+
+    generate: function( rez, f, opts ) {
+
+      // Prepare
+      this.opts = EXTEND( true, { }, _defaultOpts, opts );
+
+      // Call the string-based generation method to perform the generation.
+      var genInfo = this.invoke( rez, null );
+
+      var outFolder = parsePath( f ).dirname;
+      var curFmt = opts.themeObj.getFormat( this.format );
+
+      // Process individual files within this format. For example, the HTML
+      // output format for a theme may have multiple HTML files, CSS files,
+      // etc. Process them here.
+      genInfo.files.forEach(function( file ){
+
+        // Pre-processing
+        file.info.orgPath = file.info.orgPath || ''; // <-- For JRS themes
+        var thisFilePath = PATH.join( outFolder, file.info.orgPath );
+        if( this.onBeforeSave ) {
+          file.data = this.onBeforeSave({
+            theme: opts.themeObj,
+            outputFile: (file.info.major ? f : thisFilePath),
+            mk: file.data,
+            opts: this.opts
+          });
+          if( !file.data ) return; // PDF etc
+        }
+
+        // Write the file
+        var fileName = file.info.major ? f : thisFilePath;
+        MKDIRP.sync( PATH.dirname( fileName ) );
+        FS.writeFileSync( fileName, file.data,
+          { encoding: 'utf8', flags: 'w' } );
+
+        // Post-processing
+        this.onAfterSave && this.onAfterSave(
+          { outputFile: fileName, mk: file.data, opts: this.opts } );
+
+      }, this);
+
+      // Some themes require a symlink structure. If so, create it.
+      if( curFmt.symLinks ) {
+        Object.keys( curFmt.symLinks ).forEach( function(loc) {
+          var absLoc = PATH.join(outFolder, loc);
+          var absTarg = PATH.join(PATH.dirname(absLoc), curFmt.symLinks[loc]);
+           // 'file', 'dir', or 'junction' (Windows only)
+          var type = parsePath( absLoc ).extname ? 'file' : 'junction';
+          FS.symlinkSync( absTarg, absLoc, type);
+        });
+      }
+
+      return genInfo;
+
+    },
+
+
+
+    /** Perform a single resume resume transformation using string-based inputs
+    and outputs without touching the local file system.
+    @param json A FRESH or JRS resume object.
+    @param jst The stringified template data
+    @param format The format name, such as "html" or "latex"
+    @param cssInfo Needs to be refactored.
+    @param opts Options and passthrough data. */
+
+    single: function( json, jst, format, opts, theme, curFmt ) {
+      this.opts.freezeBreaks && ( jst = freeze(jst) );
+
+      var eng = require( '../renderers/' + theme.engine  + '-generator' );
+      var result = eng.generate( json, jst, format, curFmt, opts, theme );
+
+      this.opts.freezeBreaks && ( result = unfreeze(result) );
+      return result;
+    }
+
+
+  });
+
+
+
+  /** Export the TemplateGenerator function/ctor. */
+  module.exports = TemplateGenerator;
+
+
+
+
+  /** Freeze newlines for protection against errant JST parsers. */
+  function freeze( markup ) {
+    return markup
+      .replace( _reg.regN, _defaultOpts.nSym )
+      .replace( _reg.regR, _defaultOpts.rSym );
+  }
+
+
+
+  /** Unfreeze newlines when the coast is clear. */
+  function unfreeze( markup ) {
+    return markup
+      .replace( _reg.regSymR, '\r' )
+      .replace( _reg.regSymN, '\n' );
+  }
+
+
+
+  /** Default template generator options. */
+  var _defaultOpts = {
+    engine: 'underscore',
+    keepBreaks: true,
+    freezeBreaks: false,
+    nSym: '&newl;', // newline entity
+    rSym: '&retn;', // return entity
+    template: {
+      interpolate: /\{\{(.+?)\}\}/g,
+      escape: /\{\{\=(.+?)\}\}/g,
+      evaluate: /\{\%(.+?)\%\}/g,
+      comment: /\{\#(.+?)\#\}/g
+    },
+    filters: {
+      out: function( txt ) { return txt; },
+      raw: function( txt ) { return txt; },
+      xml: function( txt ) { return XML(txt); },
+      md: function( txt ) { return MD( txt || '' ); },
+      mdin: function( txt ) {
+        return MD(txt || '' ).replace(/^\s*<p>|<\/p>\s*$/gi, '');
+      },
+      lower: function( txt ) { return txt.toLowerCase(); },
+      link: function( name, url ) { return url ?
+        '<a href="' + url + '">' + name + '</a>' : name; }
+    },
+    prettify: { // ← See https://github.com/beautify-web/js-beautify#options
+      indent_size: 2,
+      unformatted: ['em','strong','a'],
+      max_char: 80, // ← See lib/html.js in above-linked repo
+      //wrap_line_length: 120, <-- Don't use this
+    }
+  };
+
+
+
+  /** Regexes for linebreak preservation. */
+  var _reg = {
+    regN: new RegExp( '\n', 'g' ),
+    regR: new RegExp( '\r', 'g' ),
+    regSymN: new RegExp( _defaultOpts.nSym, 'g' ),
+    regSymR: new RegExp( _defaultOpts.rSym, 'g' )
+  };
+
+
+
+}());

src/generators/text-generator.js

@@ -1,6 +1,7 @@
 /**
-Plain text resume generator for FluentCV.
-@license Copyright (c) 2015 by James M. Devlin. All rights reserved.
+Definition of the TextGenerator class.
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
+@module text-generator.js
 */
 
 var TemplateGenerator = require('./template-generator');

src/generators/word-generator.js

@@ -0,0 +1,19 @@
+/**
+Definition of the WordGenerator class.
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
+@module word-generator.js
+*/
+
+(function() {
+
+  var TemplateGenerator = require('./template-generator');
+  var WordGenerator = module.exports = TemplateGenerator.extend({
+
+    init: function(){
+      this._super( 'doc', 'xml' );
+    }
+
+  });
+
+
+}());

src/generators/xml-generator.js

@@ -1,6 +1,7 @@
 /**
-XML resume generator for FluentCV.
-@license Copyright (c) 2015 | James M. Devlin
+Definition of the XMLGenerator class.
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
+@module xml-generator.js
 */
 
 var BaseGenerator = require('./base-generator');
@@ -8,7 +9,7 @@ var BaseGenerator = require('./base-generator');
 /**
 The XmlGenerator generates an XML resume via the TemplateGenerator.
 */
-var XmlGenerator = module.exports = BaseGenerator.extend({
+var XMLGenerator = module.exports = BaseGenerator.extend({
 
   init: function(){
     this._super( 'xml' );

src/generators/yaml-generator.js

@@ -1,7 +1,7 @@
 /**
-A YAML resume generator for FluentLib.
+Definition of the YAMLGenerator class.
 @module yaml-generator.js
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
 */
 
 
@@ -13,7 +13,7 @@ A YAML resume generator for FluentLib.
   YamlGenerator generates a YAML-formatted resume via TemplateGenerator.
   */
 
-  var YamlGenerator = module.exports = TemplateGenerator.extend({
+  var YAMLGenerator = module.exports = TemplateGenerator.extend({
 
     init: function(){
       this._super( 'yml', 'yml' );

src/hackmyapi.js

@@ -0,0 +1,51 @@
+/**
+External API surface for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module hackmyapi.js
+*/
+
+
+
+(function() {
+
+
+
+  /**
+  The formal HackMyResume API.
+  */
+  var HackMyAPI = module.exports = {
+    verbs: {
+      build: require('./verbs/build'),
+      analyze: require('./verbs/analyze'),
+      validate: require('./verbs/validate'),
+      convert: require('./verbs/convert'),
+      new: require('./verbs/create'),
+      peek: require('./verbs/peek')
+    },
+    alias: {
+      generate: require('./verbs/build'),
+      create: require('./verbs/create')
+    },
+    options: require('./core/default-options'),
+    formats: require('./core/default-formats'),
+    Sheet: require('./core/fresh-resume'),
+    FRESHResume: require('./core/fresh-resume'),
+    JRSResume: require('./core/jrs-resume'),
+    FRESHTheme: require('./core/fresh-theme'),
+    JRSTheme: require('./core/jrs-theme'),
+    FluentDate: require('./core/fluent-date'),
+    HtmlGenerator: require('./generators/html-generator'),
+    TextGenerator: require('./generators/text-generator'),
+    HtmlPdfCliGenerator: require('./generators/html-pdf-cli-generator'),
+    WordGenerator: require('./generators/word-generator'),
+    MarkdownGenerator: require('./generators/markdown-generator'),
+    JsonGenerator: require('./generators/json-generator'),
+    YamlGenerator: require('./generators/yaml-generator'),
+    JsonYamlGenerator: require('./generators/json-yaml-generator'),
+    LaTeXGenerator: require('./generators/latex-generator'),
+    HtmlPngGenerator: require('./generators/html-png-generator')
+  };
+
+
+
+}());

src/helpers/console-helpers.js

@@ -0,0 +1,67 @@
+/**
+Generic template helper definitions for command-line output.
+@module console-helpers.js
+@license MIT. See LICENSE.md for details.
+*/
+
+(function() {
+
+
+
+  var PAD   = require('string-padding')
+    , LO    = require('lodash')
+    , CHALK = require('chalk')
+    , _     = require('underscore');
+              require('../utils/string');
+
+
+
+  var consoleFormatHelpers = module.exports = {
+
+    v: function( val, defaultVal, padding, style ) {
+      retVal = ( val === null || val === undefined ) ? defaultVal : val;
+      var spaces = 0;
+      if( String.is(padding) ) {
+        spaces = parseInt( padding, 10 );
+        if( isNaN(spaces) ) spaces = 0;
+      }
+      else if( _.isNumber(padding) ) {
+        spaces = padding;
+      }
+
+      if( spaces !== 0 )
+        retVal = PAD( retVal, Math.abs(spaces), null, spaces > 0 ? PAD.LEFT : PAD.RIGHT );
+
+      if( style && String.is( style )) {
+        retVal = LO.get( CHALK, style )( retVal );
+      }
+
+      return retVal;
+    },
+
+    gapLength: function(val) {
+      if( val < 35 )
+        return CHALK.green.bold(val);
+      else if( val < 95 )
+        return CHALK.yellow.bold(val);
+      else
+        return CHALK.red.bold(val);
+    },
+
+    style: function( val, style ) {
+      return LO.get( CHALK, style )( val );
+    },
+
+    isPlural: function( val, options ) {
+      if( val > 1 )
+        return options.fn(this);
+    },
+
+    pad: function( val, spaces ) {
+      return PAD(val, Math.abs(spaces), null, spaces > 0 ? PAD.LEFT : PAD.RIGHT );
+    }
+  };
+
+
+
+}());

src/helpers/generic-helpers.js

@@ -0,0 +1,609 @@
+/**
+Generic template helper definitions for HackMyResume / FluentCV.
+@license MIT. See LICENSE.md for details.
+@module helpers/generic-helpers
+*/
+
+
+(function() {
+
+  var MD = require('marked')
+    , H2W = require('../utils/html-to-wpml')
+    , XML = require('xml-escape')
+    , FluentDate = require('../core/fluent-date')
+    , HMSTATUS = require('../core/status-codes')
+    , moment = require('moment')
+    , FS = require('fs')
+    , LO = require('lodash')
+    , PATH = require('path')
+    , printf = require('printf')
+    , _ = require('underscore')
+    , unused = require('../utils/string');
+
+  /** Generic template helper function definitions. */
+  var GenericHelpers = module.exports = {
+
+    /**
+    Convert the input date to a specified format through Moment.js.
+    If date is invalid, will return the time provided by the user,
+    or default to the fallback param or 'Present' if that is set to true
+    @method formatDate
+    */
+    formatDate: function(datetime, format, fallback) {
+      if (moment) {
+        var momentDate = moment( datetime );
+        if (momentDate.isValid()) return momentDate.format(format);
+      }
+
+      return datetime || (typeof fallback == 'string' ? fallback : (fallback === true ? 'Present' : null));
+    },
+
+    /**
+    Given a resume sub-object with a start/end date, format a representation of
+    the date range.
+    @method dateRange
+    */
+    dateRange: function( obj, fmt, sep, fallback, options ) {
+      if( !obj ) return '';
+      return _fromTo( obj.start, obj.end, fmt, sep, fallback, options );
+    },
+
+    /**
+    Format a from/to date range for display.
+    @method toFrom
+    */
+    fromTo: function() {
+      return _fromTo.apply( this, arguments );
+    },
+
+    /**
+    Return a named color value as an RRGGBB string.
+    @method toFrom
+    */
+    color: function( colorName, colorDefault ) {
+      // Key must be specified
+      if( !( colorName && colorName.trim()) ) {
+        _reportError( HMSTATUS.invalidHelperUse, {
+          helper: 'fontList', error: HMSTATUS.missingParam, expected: 'name'
+        });
+      }
+      else {
+        if( !GenericHelpers.theme.colors ) return colorDefault;
+        var ret = GenericHelpers.theme.colors[ colorName ];
+        if( !(ret && ret.trim()) )
+          return colorDefault;
+        return ret;
+      }
+    },
+
+    /**
+    Return true if the section is present on the resume and has at least one
+    element.
+    @method section
+    */
+    section: function( title, options ) {
+      title = title.trim().toLowerCase();
+      var obj = LO.get( this.r, title );
+      if( _.isArray( obj ) ) {
+        return obj.length ? options.fn(this) : undefined;
+      }
+      else if( _.isObject( obj )) {
+        return ( (obj.history && obj.history.length) ||
+            ( obj.sets && obj.sets.length ) ) ?
+            options.fn(this) : undefined;
+      }
+    },
+
+    /**
+    Emit the size of the specified named font.
+    @param key {String} A named style from the "fonts" section of the theme's
+    theme.json file. For example: 'default' or 'heading1'.
+    */
+    fontSize: function( key, defSize, units ){
+
+      var ret = ''
+        , hasDef = defSize && ( String.is( defSize ) || _.isNumber( defSize ));
+
+      // Key must be specified
+      if( !( key && key.trim()) ) {
+        _reportError( HMSTATUS.invalidHelperUse, {
+          helper: 'fontSize', error: HMSTATUS.missingParam, expected: 'key'
+        });
+        return ret;
+      }
+
+      else if ( GenericHelpers.theme.fonts ) {
+        var fontSpec = LO.get( GenericHelpers.theme.fonts, this.format + '.' + key );
+        if( !fontSpec ) {
+          // Check for an "all" format
+          if( GenericHelpers.theme.fonts.all )
+            fontSpec = GenericHelpers.theme.fonts.all[ key ];
+        }
+        if( fontSpec ) {
+          // fontSpec can be a string, an array, or an object
+          if( String.is( fontSpec )) {
+            // No font size was specified, only a font family.
+          }
+          else if( _.isArray( fontSpec )) {
+            // An array of fonts were specified. Each one could be a string
+            // or an object
+            if( !String.is( fontSpec[0] )) {
+              ret = fontSpec[0].size;
+            }
+          }
+          else {
+            // A font description object.
+            ret = fontSpec.size;
+          }
+        }
+      }
+
+      // We weren't able to lookup the specified key. Default to defFont.
+      if( !ret ) {
+        if( hasDef )
+          ret = defSize;
+        else {
+          _reportError( HMSTATUS.invalidHelperUse, {
+            helper: 'fontSize', error: HMSTATUS.missingParam,
+            expected: 'defSize'});
+          ret = '';
+        }
+      }
+
+      return ret;
+
+    },
+
+    /**
+    Emit the font face (such as 'Helvetica' or 'Calibri') associated with the
+    provided key.
+    @param key {String} A named style from the "fonts" section of the theme's
+    theme.json file. For example: 'default' or 'heading1'.
+    @param defFont {String} The font to use if the specified key isn't present.
+    Can be any valid font-face name such as 'Helvetica Neue' or 'Calibri'.
+    */
+    fontFace: function( key, defFont ) {
+
+      var ret = ''
+        , hasDef = defFont && String.is( defFont );
+
+      // Key must be specified
+      if( !( key && key.trim()) ) {
+        _reportError( HMSTATUS.invalidHelperUse, {
+          helper: 'fontFace', error: HMSTATUS.missingParam, expected: 'key'
+        });
+        return ret;
+      }
+
+      // If the theme has a "fonts" section, lookup the font face.
+      else if( GenericHelpers.theme.fonts ) {
+        var fontSpec = LO.get( GenericHelpers.theme.fonts, this.format + '.' + key );
+        if( !fontSpec ) {
+          // Check for an "all" format
+          if( GenericHelpers.theme.fonts.all )
+            fontSpec = GenericHelpers.theme.fonts.all[ key ];
+        }
+        if( fontSpec ) {
+          // fontSpec can be a string, an array, or an object
+          if( String.is( fontSpec )) {
+            ret = fontSpec;
+          }
+          else if( _.isArray( fontSpec )) {
+            // An array of fonts were specified. Each one could be a string
+            // or an object
+            ret = String.is( fontSpec[0] ) ? fontSpec[0] : fontSpec[0].name;
+          }
+          else {
+            // A font description object.
+            ret = fontSpec.name;
+          }
+        }
+      }
+
+      // We weren't able to lookup the specified key. Default to defFont.
+      if( !(ret && ret.trim()) ) {
+        ret = defFont;
+        if( !hasDef ) {
+          _reportError( HMSTATUS.invalidHelperUse, {
+            helper: 'fontFace', error: HMSTATUS.missingParam,
+            expected: 'defFont'});
+          ret = '';
+        }
+      }
+
+      return ret;
+    },
+
+    /**
+    Emit a comma-delimited list of font names suitable associated with the
+    provided key.
+    @param key {String} A named style from the "fonts" section of the theme's
+    theme.json file. For example: 'default' or 'heading1'.
+    @param defFontList {Array} The font list to use if the specified key isn't
+    present. Can be an array of valid font-face name such as 'Helvetica Neue'
+    or 'Calibri'.
+    @param sep {String} The default separator to use in the rendered output.
+    Defaults to ", " (comma with a space).
+    */
+    fontList: function( key, defFontList, sep ) {
+
+      var ret = ''
+        , hasDef = defFontList && String.is( defFontList );
+
+      // Key must be specified
+      if( !( key && key.trim()) ) {
+        _reportError( HMSTATUS.invalidHelperUse, {
+          helper: 'fontList', error: HMSTATUS.missingParam, expected: 'key'
+        });
+      }
+
+      // If the theme has a "fonts" section, lookup the font list.
+      else if( GenericHelpers.theme.fonts ) {
+        var fontSpec = LO.get( GenericHelpers.theme.fonts, this.format + '.' + key );
+        if( !fontSpec ) {
+          if( GenericHelpers.theme.fonts.all )
+            fontSpec = GenericHelpers.theme.fonts.all[ key ];
+        }
+
+        if( fontSpec ) {
+          // fontSpec can be a string, an array, or an object
+          if( String.is( fontSpec )) {
+            ret = fontSpec;
+          }
+          else if( _.isArray( fontSpec )) {
+            // An array of fonts were specified. Each one could be a string
+            // or an object
+            fontSpec = fontSpec.map( function( ff ) {
+              return "'" + (String.is( ff ) ? ff : ff.name) + "'";
+            });
+            ret = fontSpec.join( sep === undefined ? ', ' : (sep || '') );
+          }
+          else {
+            // A font description object.
+            ret = fontSpec.name;
+          }
+
+        }
+      }
+
+      // The key wasn't found in the "fonts" section. Default to defFont.
+      if( !(ret && ret.trim()) ) {
+        if( !hasDef ) {
+          _reportError( HMSTATUS.invalidHelperUse, {
+            helper: 'fontList', error: HMSTATUS.missingParam,
+            expected: 'defFontList'});
+          ret = '';
+        }
+        else {
+          ret = defFontList;
+        }
+      }
+
+      return ret;
+    },
+
+    /**
+    Capitalize the first letter of the word.
+    @method section
+    */
+    camelCase: function(val) {
+      val = (val && val.trim()) || '';
+      return val ? (val.charAt(0).toUpperCase() + val.slice(1)) : val;
+    },
+
+    /**
+    Return true if the context has the property or subpropery.
+    @method has
+    */
+    has: function( title, options ) {
+      title = title && title.trim().toLowerCase();
+      if( LO.get( this.r, title ) ) {
+        return options.fn(this);
+      }
+    },
+
+    /**
+    Generic template helper function to display a user-overridable section
+    title for a FRESH resume theme. Use this in lieue of hard-coding section
+    titles.
+
+    Usage:
+
+        {{sectionTitle "sectionName"}}
+        {{sectionTitle "sectionName" "sectionTitle"}}
+
+    Example:
+
+        {{sectionTitle "Education"}}
+        {{sectionTitle "Employment" "Project History"}}
+
+    @param sect_name The name of the section being title. Must be one of the
+    top-level FRESH resume sections ("info", "education", "employment", etc.).
+    @param sect_title The theme-specified section title. May be replaced by the
+    user.
+    @method sectionTitle
+    */
+    sectionTitle: function( sname, stitle ) {
+
+      // If not provided by the user, stitle should default to sname. ps.
+      // Handlebars silently passes in the options object to the last param,
+      // where in Underscore stitle will be null/undefined, so we check both.
+      stitle = (stitle && String.is(stitle) && stitle) || sname;
+
+      // If there's a section title override, use it.
+      return ( this.opts.stitles &&
+               this.opts.stitles[ sname.toLowerCase().trim() ] ) ||
+               stitle;
+    },
+
+    /**
+    Convert inline Markdown to inline WordProcessingML.
+    @method wpml
+    */
+    wpml: function( txt, inline ) {
+      if(!txt) return '';
+      inline = (inline && !inline.hash) || false;
+      txt = XML(txt.trim());
+      txt = inline ?
+        MD(txt).replace(/^\s*<p>|<\/p>\s*$/gi, '') :
+        MD(txt);
+      txt = H2W( txt );
+      return txt;
+    },
+
+    /**
+    Emit a conditional link.
+    @method link
+    */
+    link: function( text, url ) {
+      return url && url.trim() ?
+        ('<a href="' + url + '">' + text + '</a>') : text;
+    },
+
+    /**
+    Return the last word of the specified text.
+    @method lastWord
+    */
+    lastWord: function( txt ) {
+      return txt && txt.trim() ? _.last( txt.split(' ') ) : '';
+    },
+
+    /**
+    Convert a skill level to an RGB color triplet. TODO: refactor
+    @method skillColor
+    @param lvl Input skill level. Skill level can be expressed as a string
+    ("beginner", "intermediate", etc.), as an integer (1,5,etc), as a string
+    integer ("1", "5", etc.), or as an RRGGBB color triplet ('#C00000',
+    '#FFFFAA').
+    */
+    skillColor: function( lvl ) {
+      var idx = skillLevelToIndex( lvl );
+      var skillColors = (this.theme && this.theme.palette &&
+        this.theme.palette.skillLevels) ||
+        [ '#FFFFFF', '#5CB85C', '#F1C40F', '#428BCA', '#C00000' ];
+      return skillColors[idx];
+    },
+
+    /**
+    Return an appropriate height. TODO: refactor
+    @method lastWord
+    */
+    skillHeight: function( lvl ) {
+      var idx = skillLevelToIndex( lvl );
+      return ['38.25', '30', '16', '8', '0'][idx];
+    },
+
+    /**
+    Return all but the last word of the input text.
+    @method initialWords
+    */
+    initialWords: function( txt ) {
+      return txt && txt.trim() ? _.initial( txt.split(' ') ).join(' ') : '';
+    },
+
+    /**
+    Trim the protocol (http or https) from a URL/
+    @method trimURL
+    */
+    trimURL: function( url ) {
+      return url && url.trim() ? url.trim().replace(/^https?:\/\//i, '') : '';
+    },
+
+    /**
+    Convert text to lowercase.
+    @method toLower
+    */
+    toLower: function( txt ) {
+      return txt && txt.trim() ? txt.toLowerCase() : '';
+    },
+
+    /**
+    Convert text to lowercase.
+    @method toLower
+    */
+    toUpper: function( txt ) {
+      return txt && txt.trim() ? txt.toUpperCase() : '';
+    },
+
+    /**
+    Return true if either value is truthy.
+    @method either
+    */
+    either: function( lhs, rhs, options ) {
+      if (lhs || rhs) return options.fn(this);
+    },
+
+    /**
+    Conditional stylesheet link. Creates a link to the specified stylesheet with
+    <link> or embeds the styles inline with <style></style>, depending on the
+    theme author's and user's preferences.
+    @param url {String} The path to the CSS file.
+    @param linkage {String} The default link method. Can be either `embed` or
+    `link`. If omitted, defaults to `embed`. Can be overridden by the `--css`
+    command-line switch.
+    */
+
+    styleSheet: function( url, linkage ) {
+
+      // Establish the linkage style
+      linkage = this.opts.css || linkage || 'embed';
+
+      // Create the <link> or <style> tag
+      var ret = '';
+      if( linkage === 'link' ) {
+        ret = printf('<link href="%s" rel="stylesheet" type="text/css">', url);
+      }
+      else {
+        var rawCss = FS.readFileSync(
+          PATH.join( this.opts.themeObj.folder, '/src/', url ), 'utf8' );
+        var renderedCss = this.engine.generateSimple( this, rawCss );
+        ret = printf('<style>%s</style>', renderedCss );
+      }
+
+      // If the currently-executing template is inherited, append styles
+      if( this.opts.themeObj.inherits &&
+          this.opts.themeObj.inherits.html &&
+          this.format === 'html' ) {
+        ret += (linkage === 'link') ?
+          '<link href="' + this.opts.themeObj.overrides.path +
+          '" rel="stylesheet" type="text/css">' :
+          '<style>' + this.opts.themeObj.overrides.data + '</style>';
+      }
+
+      // TODO: It would be nice to use Handlebar.SafeString here, but these
+      // are supposed to be generic helpers. Provide an equivalent, or expose
+      // it when Handlebars is the chosen engine, which is most of the time.
+      return ret;
+    },
+
+    /**
+    Perform a generic comparison.
+    See: http://doginthehat.com.au/2012/02/comparison-block-helper-for-handlebars-templates
+    @method compare
+    */
+    compare: function(lvalue, rvalue, options) {
+      if (arguments.length < 3)
+        throw new Error("Handlerbars Helper 'compare' needs 2 parameters");
+      var operator = options.hash.operator || "==";
+      var operators = {
+          '==':       function(l,r) { return l == r; },
+          '===':      function(l,r) { return l === r; },
+          '!=':       function(l,r) { return l != r; },
+          '<':        function(l,r) { return l < r; },
+          '>':        function(l,r) { return l > r; },
+          '<=':       function(l,r) { return l <= r; },
+          '>=':       function(l,r) { return l >= r; },
+          'typeof':   function(l,r) { return typeof l == r; }
+      };
+      if (!operators[operator])
+        throw new Error("Handlerbars Helper 'compare' doesn't know the operator "+operator);
+      var result = operators[operator](lvalue,rvalue);
+      return result ? options.fn(this) : options.inverse(this);
+    }
+
+  };
+
+
+  /**
+  Report an error to the outside world without throwing an exception. Currently
+  relies on kludging the running verb into. opts.
+  */
+  function _reportError( code, params ) {
+    GenericHelpers.opts.errHandler.err( code, params );
+  }
+
+  /**
+  Format a from/to date range for display.
+  */
+  function _fromTo( dateA, dateB, fmt, sep, fallback ) {
+
+    // Prevent accidental use of safe.start, safe.end, safe.date
+    // The dateRange helper is for raw dates only
+    if( moment.isMoment( dateA ) || moment.isMoment( dateB ) ) {
+      _reportError( HMSTATUS.invalidHelperUse, { helper: 'dateRange' } );
+      return '';
+    }
+
+    var dateFrom, dateTo, dateTemp;
+
+    // Check for 'current', 'present', 'now', '', null, and undefined
+    dateA = dateA || '';
+    dateB = dateB || '';
+    var dateATrim = dateA.trim().toLowerCase();
+    var dateBTrim = dateB.trim().toLowerCase();
+    var reserved = ['current','present','now', ''];
+
+    fmt = (fmt && String.is(fmt) && fmt) || 'YYYY-MM';
+    sep = (sep && String.is(sep) && sep) || ' — ';
+
+    if( _.contains( reserved, dateATrim )) {
+      dateFrom = fallback || '???';
+    }
+    else {
+      dateTemp = FluentDate.fmt( dateA );
+      dateFrom = dateTemp.format( fmt );
+    }
+
+    if( _.contains( reserved, dateBTrim )) {
+      dateTo = fallback || 'Current';
+    }
+    else {
+      dateTemp = FluentDate.fmt( dateB );
+      dateTo = dateTemp.format( fmt );
+    }
+
+    if( dateFrom && dateTo ) {
+      return dateFrom + sep + dateTo;
+    }
+    else if( dateFrom || dateTo ) {
+      return dateFrom || dateTo;
+    }
+
+    return '';
+  }
+
+  function skillLevelToIndex( lvl ) {
+    var idx = 0;
+    if( String.is( lvl ) ) {
+      lvl = lvl.trim().toLowerCase();
+      var intVal = parseInt( lvl );
+      if( isNaN( intVal ) ) {
+        switch( lvl ) {
+          case 'beginner': idx = 1; break;
+          case 'intermediate': idx = 2; break;
+          case 'advanced': idx = 3; break;
+          case 'master': idx = 4; break;
+        }
+      }
+      else {
+        idx = Math.min( intVal / 2, 4 );
+        idx = Math.max( 0, idx );
+      }
+    }
+    else {
+      idx = Math.min( lvl / 2, 4 );
+      idx = Math.max( 0, idx );
+    }
+    return idx;
+  }
+
+}());
+
+// Note [1] --------------------------------------------------------------------
+// Make sure it's precisely a string or array since some template engines jam
+// their options/context object into the last parameter and we are allowing the
+// defFont parameter to be omitted in certain cases. This is a little kludgy,
+// but works fine for this case. If we start doing this regularly, we should
+// rebind these parameters.
+
+// Note [2]: -------------------------------------------------------------------
+// If execution reaches here, some sort of cosmic ray or sunspot has landed on
+// HackMyResume, or a theme author is deliberately messing with us by doing
+// something like:
+//
+// "fonts": {
+//   "default": "",
+//   "heading1": null
+// }
+//
+// Rather than sort it out, we'll just fall back to defFont.

src/helpers/handlebars-helpers.js

@@ -0,0 +1,26 @@
+/**
+Template helper definitions for Handlebars.
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
+@module handlebars-helpers.js
+*/
+
+
+(function() {
+
+  var HANDLEBARS = require('handlebars')
+  , _ = require('underscore')
+  , helpers = require('./generic-helpers');
+
+  /**
+  Register useful Handlebars helpers.
+  @method registerHelpers
+  */
+  module.exports = function( theme, opts ) {
+
+    helpers.theme = theme;
+    helpers.opts = opts;
+    HANDLEBARS.registerHelper( helpers );
+
+  };
+
+}());

src/helpers/underscore-helpers.js

@@ -0,0 +1,34 @@
+/**
+Template helper definitions for Underscore.
+@license MIT. Copyright (c) 2016 hacksalot (https://github.com/hacksalot)
+@module handlebars-helpers.js
+*/
+
+
+(function() {
+
+  var HANDLEBARS = require('handlebars')
+  , _ = require('underscore')
+  , helpers = require('./generic-helpers');
+
+  /**
+  Register useful Underscore helpers.
+  @method registerHelpers
+  */
+  module.exports = function( theme, opts, cssInfo, ctx, eng ) {
+
+    helpers.theme = theme;
+    helpers.opts = opts;
+    helpers.cssInfo = cssInfo;
+    helpers.engine = eng;
+    ctx.h = helpers;
+
+    _.each( helpers, function( hVal, hKey ) {
+      if( _.isFunction( hVal )) {
+        _.bind( hVal, ctx );
+      }
+    }, this);
+
+  };
+
+}());

src/index.js

@@ -1,78 +1,22 @@
 #! /usr/bin/env node
 
-/**
-Command-line interface (CLI) for FluentCV via Node.js.
-@license Copyright (c) 2015 | James M. Devlin
-*/
 
-var ARGS = require( 'minimist' )
-  , FCMD  = require( './fluentcmd')
-  , PKG = require('../package.json')
-  , opts = { };
+
+/**
+Command-line interface (CLI) for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module index.js
+*/
 
 
 
 try {
-  main();
+
+  require('./cli/main')( process.argv );
+
 }
 catch( ex ) {
-  handleError( ex );
-}
 
-
-
-function main() {
-
-  // Setup.
-  var title = '*** FluentCV v' + PKG.version + ' ***';
-  if( process.argv.length <= 2 ) { logMsg(title); throw { fluenterror: 3 }; }
-  var args = ARGS( process.argv.slice(2) );
-  opts = getOpts( args );
-  logMsg( title );
-
-  // Convert arguments to source files, target files, options
-  var src = args._ || [];
-  var dst = (args.o && ((typeof args.o === 'string' && [ args.o ]) || args.o)) || [];
-  dst = (dst === true) ? [] : dst; // Handle -o with missing output file
-
-  // Generate!
-  FCMD.generate( src, dst, opts, logMsg );
-
-  process.exit(0);
-}
-
-function logMsg( msg ) {
-  opts.silent || console.log( msg );
-}
-
-function getOpts( args ) {
-  var noPretty = args['nopretty'] || args.n;
-  noPretty = noPretty && (noPretty === true || noPretty === 'true');
-  return {
-    theme: args.t || 'modern',
-    prettify: !noPretty,
-    silent: args.s || args.silent
-  };
-}
-
-function handleError( ex ) {
-  var msg = '', exitCode;
-  if( ex.fluenterror ){
-    switch( ex.fluenterror ) { // TODO: Remove magic numbers
-      case 1: msg = "The specified theme couldn't be found: " + ex.data; break;
-      case 2: msg = "Couldn't copy CSS file to destination folder"; break;
-      case 3: msg = "Please specify a valid JSON resume file."; break;
-    };
-    exitCode = ex.fluenterror;
-  }
-  else {
-    msg = ex.toString();
-    exitCode = 4;
-  }
-
-  var idx = msg.indexOf('Error: ');
-  var trimmed = idx === -1 ? msg : msg.substring( idx + 7 );
-  console.log( 'ERROR: ' + trimmed.toString() );
-  process.exit( exitCode );
+  require('./cli/error').err( ex, true );
 
 }

src/inspectors/gap-inspector.js

@@ -0,0 +1,166 @@
+/**
+Employment gap analysis for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module inspectors/gap-inspector
+*/
+
+
+
+(function() {
+
+
+
+  var _ = require('underscore');
+  var FluentDate = require('../core/fluent-date');
+  var moment = require('moment');
+  var LO = require('lodash');
+
+
+
+  /**
+  Identify gaps in the candidate's employment history.
+  */
+  var gapInspector = module.exports = {
+
+
+
+    moniker: 'gap-inspector',
+
+
+
+    /**
+    Run the Gap Analyzer on a resume.
+    @method run
+    @return {Array} An array of object representing gaps in the candidate's
+    employment history. Each object provides the start, end, and duration of the
+    gap:
+        { <-- gap
+          start: // A Moment.js date
+          end: // A Moment.js date
+          duration: // Gap length
+        }
+    */
+    run: function( rez ) {
+
+      // This is what we'll return
+      var coverage = {
+        gaps: [],
+        overlaps: [],
+        duration: {
+          total: 0,
+          work: 0,
+          gaps: 0
+        },
+        pct: '0%'
+      };
+
+      // Missing employment section? Bye bye.
+      var hist = LO.get( rez, 'employment.history' );
+      if( !hist || !hist.length ) { return coverage; }
+
+      // Convert the candidate's employment history to an array of dates,
+      // where each element in the array is a start date or an end date of a
+      // job -- it doesn't matter which.
+      var new_e = hist.map( function( job ){
+        var obj = _.pick( job, ['start', 'end'] );
+        if( obj && (obj.start || obj.end)) {
+          obj = _.pairs( obj );
+          obj[0][1] = FluentDate.fmt( obj[0][1] );
+          if( obj.length > 1 )
+            obj[1][1] = FluentDate.fmt( obj[1][1] );
+        }
+        return obj;
+      });
+
+
+      // Flatten the array, remove empties, and sort
+      new_e = _.filter( _.flatten( new_e, true ), function(v) {
+        return ( v && v.length && v[0] && v[0].length );
+      });
+      if( !new_e || !new_e.length ) return coverage;
+      new_e = _.sortBy( new_e, function( elem ) { return elem[1].unix(); });
+
+      // Iterate over elements in the array. Each time a start date is found,
+      // increment a reference count. Each time an end date is found, decrement
+      // the reference count. When the reference count reaches 0, we have a gap.
+      // When the reference count is > 0, the candidate is employed. When the
+      // reference count reaches 2, the candidate is overlapped.
+
+      var num_gaps = 0, ref_count = 0, total_gap_days = 0, gap_start;
+
+      new_e.forEach( function(point) {
+
+        var inc = point[0] === 'start' ? 1 : -1;
+        ref_count += inc;
+
+        // If the ref count just reached 0, start a new GAP
+        if( ref_count === 0 ) {
+          coverage.gaps.push( { start: point[1], end: null });
+        }
+
+        // If the ref count reached 1 by rising, end the last GAP
+        else if( ref_count === 1 && inc === 1 ) {
+          var lastGap = _.last( coverage.gaps );
+          if( lastGap ) {
+            lastGap.end = point[1];
+            lastGap.duration = lastGap.end.diff( lastGap.start, 'days' );
+            total_gap_days += lastGap.duration;
+          }
+        }
+
+        // If the ref count reaches 2 by rising, start a new OVERLAP
+        else if( ref_count === 2 && inc === 1 ) {
+          coverage.overlaps.push( { start: point[1], end: null });
+        }
+
+        // If the ref count reaches 1 by falling, end the last OVERLAP
+        else if( ref_count === 1 && inc === -1 ) {
+          var lastOver = _.last( coverage.overlaps );
+          if( lastOver ) {
+            lastOver.end = point[1];
+            lastOver.duration = lastOver.end.diff( lastOver.start, 'days' );
+            if( lastOver.duration === 0 ) {
+              coverage.overlaps.pop();
+            }
+          }
+        }
+      });
+
+      // It's possible that the last gap/overlap didn't have an explicit .end
+      // date.If so, set the end date to the present date and compute the
+      // duration normally.
+      if( coverage.overlaps.length ) {
+        var o = _.last( coverage.overlaps );
+        if( o && !o.end ) {
+          o.end = moment();
+          o.duration = o.end.diff( o.start, 'days' );
+        }
+      }
+      if( coverage.gaps.length ) {
+        var g = _.last( coverage.gaps );
+        if( g && !g.end ) {
+          g.end = moment();
+          g.duration = g.end.diff( g.start, 'days' );
+        }
+      }
+
+      // Package data for return to the client
+      var tdur = rez.duration('days');
+      var dur = {
+        total: tdur,
+        work: tdur - total_gap_days,
+        gaps: total_gap_days
+      };
+      coverage.pct = ( dur.total > 0 && dur.work > 0 ) ?
+        ((((dur.total - dur.gaps) / dur.total) * 100)).toFixed(1) + '%' :
+        '???';
+      coverage.duration = dur;
+      return coverage;
+    }
+
+
+  };
+
+
+
+}());

src/inspectors/keyword-inspector.js

@@ -0,0 +1,98 @@
+/**
+Keyword analysis for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module keyword-inspector.js
+*/
+
+
+
+(function() {
+
+
+
+  var _ = require('underscore');
+  var FluentDate = require('../core/fluent-date');
+
+
+
+  /**
+  Analyze the resume's use of keywords.
+  TODO: BUG: Keyword search regex is inaccurate, especially for one or two
+  letter keywords like "C" or "CLI".
+  @class keywordInspector
+  */
+  var keywordInspector = module.exports = {
+
+
+
+    /**
+    A unique name for this inspector.
+    */
+    moniker: 'keyword-inspector',
+
+
+
+    /**
+    Run the Keyword Inspector on a resume.
+    @method run
+    @return An collection of statistical keyword data.
+    */
+    run: function( rez ) {
+
+      // "Quote" or safely escape a keyword so it can be used as a regex. For
+      // example, if the keyword is "C++", yield "C\+\+".
+      // http://stackoverflow.com/a/2593661/4942583
+      function regex_quote(str) {
+        return (str + '').replace(/[.?*+^$[\]\\(){}|-]/ig, "\\$&");
+      }
+
+      // Create a searchable plain-text digest of the resume
+      // TODO: BUG: Don't search within keywords for other keywords. Job A
+      // declares the "foo" keyword. Job B declares the "foo & bar" keyword. Job
+      // B's mention of "foobar" should not count as a mention of "foo".
+      // To achieve this, remove keywords from the search digest and treat them
+      // separately.
+      var searchable = '';
+      rez.transformStrings( ['imp', 'computed', 'safe'], function trxString( key, val ) {
+        searchable += ' ' + val;
+      });
+
+      // Assemble a regex skeleton we can use to test for keywords with a bit
+      // more 
+      var prefix = '(?:' + ['^', '\\s+', '[\\.,]+'].join('|') + ')';
+      var suffix = '(?:' + ['$', '\\s+', '[\\.,]+'].join('|') + ')';
+
+      return rez.keywords().map(function(kw) {
+
+        // 1. Using word boundary or other regex class is inaccurate
+        //
+        //    var regex = new RegExp( '\\b' + regex_quote( kw )/* + '\\b'*/, 'ig');
+        //
+        // 2. Searching for the raw keyword is inaccurate ("C" will match any
+        // word containing a 'c'!).
+        //
+        //    var regex = new RegExp( regex_quote( kw ), 'ig');
+        //
+        // 3. Instead, use a custom regex with special delimeters.
+
+        var regex_str = prefix + regex_quote( kw ) + suffix;
+        var regex = new RegExp( regex_str, 'ig');
+        var myArray, count = 0;
+        while ((myArray = regex.exec( searchable )) !== null) {
+          count++;
+        }
+        return {
+          name: kw,
+          count: count
+        };
+
+      });
+    }
+
+
+
+  };
+
+
+
+}());

src/inspectors/totals-inspector.js

@@ -0,0 +1,63 @@
+/**
+Section analysis for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module totals-inspector.js
+*/
+
+
+
+(function() {
+
+
+
+  var _ = require('underscore');
+  var FluentDate = require('../core/fluent-date');
+
+
+
+  /**
+  Retrieve sectional overview and summary information.
+  @class totalsInspector
+  */
+  var totalsInspector = module.exports = {
+
+
+
+    moniker: 'totals-inspector',
+
+
+
+    /**
+    Run the Totals Inspector on a resume.
+    @method run
+    @return An object containing summary information for each section on the
+    resume.
+    */
+    run: function( rez ) {
+
+      var sectionTotals = { };
+      _.each( rez, function(val, key){
+        if( _.isArray( val ) && !_.isString(val) ) {
+          sectionTotals[ key ] = val.length;
+        }
+        else if( val.history && _.isArray( val.history ) ) {
+          sectionTotals[ key ] = val.history.length;
+        }
+        else if( val.sets && _.isArray( val.sets ) ) {
+          sectionTotals[ key ] = val.sets.length;
+        }
+      });
+
+      return {
+        totals: sectionTotals,
+        numSections: Object.keys( sectionTotals ).length
+      };
+
+    }
+
+
+  };
+
+
+
+}());

src/renderers/handlebars-generator.js

@@ -0,0 +1,119 @@
+/**
+Definition of the HandlebarsGenerator class.
+@license MIT. See LICENSE.md for details.
+@module renderers/handlebars-generator
+*/
+
+
+
+(function() {
+
+
+
+  var _ = require('underscore')
+    , HANDLEBARS = require('handlebars')
+    , FS = require('fs')
+    , registerHelpers = require('../helpers/handlebars-helpers')
+    , PATH = require('path')
+    , parsePath = require('parse-filepath')
+    , READFILES = require('recursive-readdir-sync')
+    , HMSTATUS = require('../core/status-codes')
+    , SLASH = require('slash');
+
+
+
+  /**
+  Perform template-based resume generation using Handlebars.js.
+  @class HandlebarsGenerator
+  */
+  var HandlebarsGenerator = module.exports = {
+
+
+
+    generateSimple: function( data, tpl ) {
+
+      try {
+        // Compile and run the Handlebars template.
+        var template = HANDLEBARS.compile( tpl, { strict: false, assumeObjects: false } );
+        return template( data );
+      }
+      catch( ex ) {
+        throw {
+          fluenterror: template ?
+            HMSTATUS.invokeTemplate : HMSTATUS.compileTemplate,
+          inner: ex
+        };
+      }
+
+    },
+
+
+
+    generate: function( json, jst, format, curFmt, opts, theme ) {
+
+      // Set up partials and helpers
+      registerPartials( format, theme );
+      registerHelpers( theme, opts );
+
+      // Preprocess text
+      var encData = json;
+      ( format === 'html' || format === 'pdf' ) && (encData = json.markdownify());
+      ( format === 'doc' ) && (encData = json.xmlify());
+
+      // Set up the context
+      var ctx = {
+        r: encData,
+        RAW: json,
+        filt: opts.filters,
+        format: format,
+        opts: opts,
+        engine: this,
+        results: curFmt.files,
+        headFragment: opts.headFragment || ''
+      };
+
+      // Render the template
+      return this.generateSimple( ctx, jst );
+    }
+
+
+
+  };
+
+
+
+  function registerPartials(format, theme) {
+    if( _.contains( ['html','doc','md','txt'], format )) {
+
+      // Locate the global partials folder
+      var partialsFolder = PATH.join(
+        parsePath( require.resolve('fresh-themes') ).dirname,
+        '/partials/',
+        format
+      );
+
+      // Register global partials in the /partials/[format] folder
+      // TODO: Only do this once per HMR invocation.
+      _.each( READFILES( partialsFolder, function(error){ }), function( el ) {
+        var pathInfo = parsePath( el );
+        var name = SLASH( PATH.relative( partialsFolder, el )
+          .replace(/\.(?:html|xml|hbs|md|txt)$/i, '') );
+        var tplData = FS.readFileSync( el, 'utf8' );
+        var compiledTemplate = HANDLEBARS.compile( tplData );
+        HANDLEBARS.registerPartial( name, compiledTemplate );
+        theme.partialsInitialized = true;
+      });
+
+    }
+
+    // Register theme-specific partials
+    _.each( theme.partials, function( el ) {
+      var tplData = FS.readFileSync( el.path, 'utf8' );
+      var compiledTemplate = HANDLEBARS.compile( tplData );
+      HANDLEBARS.registerPartial( el.name, compiledTemplate );
+    });
+  }
+
+
+
+}());

src/renderers/jrs-generator.js

@@ -0,0 +1,65 @@
+/**
+Definition of the JRSGenerator class.
+@license MIT. See LICENSE.md for details.
+@module jrs-generator.js
+*/
+
+
+
+(function() {
+
+
+
+  var _ = require('underscore')
+    , HANDLEBARS = require('handlebars')
+    , FS = require('fs')
+    , registerHelpers = require('../helpers/handlebars-helpers')
+    , PATH = require('path')
+    , parsePath = require('parse-filepath')
+    , READFILES = require('recursive-readdir-sync')
+    , SLASH = require('slash')
+    , MD = require('marked');
+
+
+
+  /**
+  Perform template-based resume generation for JSON Resume themes.
+  @class JRSGenerator
+  */
+  var JRSGenerator = module.exports = {
+
+
+
+
+    generate: function( json, jst, format, cssInfo, opts, theme ) {
+
+      // Disable JRS theme chatter (console.log, console.error, etc.)
+      var off = ['log', 'error', 'dir'], org = off.map(function(c){
+        var ret = console[c]; console[c] = function(){}; return ret;
+      });
+
+      // Freeze and render
+      var rezHtml = theme.render( json.harden() );
+
+      // Turn logging back on
+      off.forEach(function(c, idx){ console[c] = org[idx]; });
+
+      // Unfreeze and apply Markdown
+      rezHtml = rezHtml.replace( /@@@@~.*?~@@@@/gm, function(val){
+        return MDIN( val.replace( /~@@@@/gm,'' ).replace( /@@@@~/gm,'' ) );
+      });
+
+      return rezHtml;
+    }
+
+
+  };
+
+
+
+  function MDIN(txt) { // TODO: Move this
+    return MD(txt || '' ).replace(/^\s*<p>|<\/p>\s*$/gi, '');
+  }
+
+
+}());

src/renderers/underscore-generator.js

@@ -0,0 +1,73 @@
+/**
+Definition of the UnderscoreGenerator class.
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
+@module underscore-generator.js
+*/
+
+(function() {
+
+
+
+  var _ = require('underscore')
+    , registerHelpers = require('../helpers/underscore-helpers')
+    , HMSTATUS = require('../core/status-codes');
+
+
+  /**
+  Perform template-based resume generation using Underscore.js.
+  @class UnderscoreGenerator
+  */
+  var UnderscoreGenerator = module.exports = {
+
+    generateSimple: function( data, tpl ) {
+
+      try {
+        // Compile and run the Handlebars template.
+        var template = _.template( tpl );
+        return template( data );
+      }
+      catch( ex ) {
+        throw {
+          fluenterror: template ?
+            HMSTATUS.invokeTemplate : HMSTATUS.compileTemplate,
+          inner: ex
+        };
+      }
+
+    },
+
+    generate: function( json, jst, format, cssInfo, opts, theme ) {
+
+      // Tweak underscore's default template delimeters
+      var delims = (opts.themeObj && opts.themeObj.delimeters) || opts.template;
+      if( opts.themeObj && opts.themeObj.delimeters ) {
+        delims = _.mapObject( delims, function(val,key) {
+          return new RegExp( val, "ig");
+        });
+      }
+      _.templateSettings = delims;
+
+      // Strip {# comments #}
+      jst = jst.replace( delims.comment, '');
+
+      var ctx = {
+        r: format === 'html' || format === 'pdf' || format === 'png' ? json.markdownify() : json,
+        filt: opts.filters,
+        XML: require('xml-escape'),
+        RAW: json,
+        cssInfo: cssInfo,
+        //engine: this,
+        headFragment: opts.headFragment || '',
+        opts: opts
+      };
+
+      registerHelpers( theme, opts, cssInfo, ctx, this );
+
+      return this.generateSimple( ctx, jst );
+    }
+
+  };
+
+
+
+}());

src/utils/class.js

@@ -1,3 +1,8 @@
+/**
+Definition of John Resig's `Class` class.
+@module class.js
+*/
+
 /* Simple JavaScript Inheritance
  * By John Resig http://ejohn.org/
  * MIT Licensed.
@@ -41,7 +46,7 @@
 
             return ret;
           };
-        })(name, prop[name]) :
+        })(name, prop[name]) : // jshint ignore:line
         prop[name];
     }
 

src/utils/extend.js

@@ -1,78 +0,0 @@
-/**
-Plain JavaScript replacement of jQuery .extend based on jQuery sources.
-@license Copyright (c) 2015 by James M. Devlin. All rights reserved.
-*/
-
-function _extend() {
-
-  function isPlainObject( obj ) {
-    if ((typeof obj !== "object") || obj.nodeType ||
-      (obj !== null && obj === obj.window)) {
-      return false;
-    }
-    if (obj.constructor &&
-      !hasOwnProperty.call( obj.constructor.prototype, "isPrototypeOf" )) {
-      return false;
-    }
-    return true;
-  }
-
-  var options
-    , name
-    , src
-    , copy
-    , copyIsArray
-    , clone
-    , target = arguments[0] || {}
-    , i = 1
-    , length = arguments.length
-    , deep = false;
-
-  // Handle a deep copy situation
-  if (typeof target === "boolean") {
-    deep = target;
-    // Skip the boolean and the target
-    target = arguments[i] || {};
-    i++;
-  }
-
-  // Handle case when target is a string or something (possible in deep copy)
-  //if (typeof target !== "object" && !jQuery.isFunction(target))
-  if (typeof target !== "object" && typeof target !== "function")
-    target = {};
-
-  for (; i < length; i++) {
-    // Only deal with non-null/undefined values
-    if ((options = arguments[i]) !== null) {
-      // Extend the base object
-      for (name in options) {
-        src = target[name];
-        copy = options[name];
-
-        // Prevent never-ending loop
-        if (target === copy) continue;
-
-        // Recurse if we're merging plain objects or arrays
-        if (deep && copy && (isPlainObject(copy) ||
-          (copyIsArray = (copy.constructor === Array)))) {
-          if (copyIsArray) {
-            copyIsArray = false;
-            clone = src && (src.constructor === Array) ? src : [];
-          } else {
-            clone = src && isPlainObject(src) ? src : {};
-          }
-          // Never move original objects, clone them
-          target[name] = _extend(deep, clone, copy);
-          // Don't bring in undefined values
-        } else if (copy !== undefined) {
-          target[name] = copy;
-        }
-      }
-    }
-  }
-
-  // Return the modified object
-  return target;
-}
-
-module.exports = _extend;

src/utils/file-contains.js

@@ -0,0 +1,12 @@
+/**
+Definition of the SyntaxErrorEx class.
+@module file-contains.js
+*/
+
+(function(){
+
+  module.exports = function( file, needle ) {
+    return require('fs').readFileSync(file,'utf-8').indexOf( needle ) > -1;
+  };
+
+}());

src/utils/file-exists.js

@@ -1,18 +0,0 @@
-/**
-File-exists checker for Node.js.
-@license Copyright (c) 2015 | James M. Devlin
-*/
-
-var FS = require('fs');
-
-// Yup, this is now the recommended way to check for file existence on Node.
-// fs.exists is deprecated and the recommended fs.statSync/lstatSync throws
-// exceptions on non-existent paths :)
-module.exports = function (path) {
-  try {
-    FS.statSync( path );
-    return true;
-  } catch( err ) {
-    return !(err && err.code === 'ENOENT');
-  }
-};

src/utils/html-to-wpml.js

@@ -0,0 +1,66 @@
+/**
+Definition of the Markdown to WordProcessingML conversion routine.
+@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
+@module html-to-wpml.js
+*/
+
+(function(){
+
+  var _ = require('underscore');
+  var HTML5Tokenizer = require('simple-html-tokenizer');
+
+  module.exports = function( html ) {
+
+    // Tokenize the HTML stream.
+    var tokens = HTML5Tokenizer.tokenize( html );
+
+    var final = '', is_bold, is_italic, is_link, link_url;
+
+    // Process <em>, <strong>, and <a> elements in the HTML stream, producing
+    // equivalent WordProcessingML that can be dumped into a <w:p> or other
+    // text container element.
+    _.each( tokens, function( tok ) {
+
+      switch( tok.type ) {
+
+        case 'StartTag':
+          switch( tok.tagName ) {
+            case 'p': final += '<w:p>'; break;
+            case 'strong': is_bold = true; break;
+            case 'em': is_italic = true; break;
+            case 'a':
+              is_link = true;
+              link_url = tok.attributes.filter(function(attr){
+                return attr[0] === 'href'; }
+              )[0][1];
+              break;
+          }
+          break;
+
+        case 'EndTag':
+          switch( tok.tagName ) {
+            case 'p': final += '</w:p>'; break;
+            case 'strong': is_bold = false; break;
+            case 'em': is_italic = false; break;
+            case 'a': is_link = false; break;
+          }
+          break;
+
+        case 'Chars':
+          if( tok.chars.trim().length ) {
+          var style = is_bold ? '<w:b/>' : '';
+          style += is_italic ? '<w:i/>': '';
+          style += is_link ? '<w:rStyle w:val="Hyperlink"/>' : '';
+          final +=
+            (is_link ? ('<w:hlink w:dest="' + link_url + '">') : '') +
+            '<w:r><w:rPr>' + style + '</w:rPr><w:t>' + tok.chars +
+            '</w:t></w:r>' + (is_link ? '</w:hlink>' : '');
+          }
+          break;
+      }
+    });
+    return final;
+
+  };
+
+}());

src/utils/md2chalk.js

@@ -0,0 +1,19 @@
+/**
+Inline Markdown-to-Chalk conversion routines.
+@license MIT. See LICENSE.md for details.
+@module md2chalk.js
+*/
+
+(function(){
+
+  var MD = require('marked');
+  var CHALK = require('chalk');
+  var LO = require('lodash');
+
+  module.exports = function( v, style, boldStyle ) {
+    boldStyle = boldStyle || 'bold';
+    var temp = v.replace(/\*\*(.*?)\*\*/g, LO.get( CHALK, boldStyle )('$1'));
+    return style ? LO.get( CHALK, style )(temp) : temp;
+  };
+
+}());

src/utils/rasterize.js

@@ -0,0 +1,56 @@
+// Exemplar script for generating documents with Phantom.js.
+// https://raw.githubusercontent.com/ariya/phantomjs/master/examples/rasterize.js
+
+(function() {
+
+  "use strict";
+  var page = require('webpage').create(),
+    system = require('system'),
+    address, output, size;
+
+  if (system.args.length < 3 || system.args.length > 5) {
+    console.log('Usage: rasterize.js URL filename [paperwidth*paperheight|paperformat] [zoom]');
+    console.log('  paper (pdf output) examples: "5in*7.5in", "10cm*20cm", "A4", "Letter"');
+    console.log('  image (png/jpg output) examples: "1920px" entire page, window width 1920px');
+    console.log('                                   "800px*600px" window, clipped to 800x600');
+    phantom.exit(1);
+  } else {
+    address = system.args[1];
+    output = system.args[2];
+    page.viewportSize = { width: 600, height: 600 };
+    if (system.args.length > 3 && system.args[2].substr(-4) === ".pdf") {
+      size = system.args[3].split('*');
+      page.paperSize = size.length === 2 ? { width: size[0], height: size[1], margin: '0px' }
+                                           : { format: system.args[3], orientation: 'portrait', margin: '1cm' };
+    } else if (system.args.length > 3 && system.args[3].substr(-2) === "px") {
+      size = system.args[3].split('*');
+      if (size.length === 2) {
+        pageWidth = parseInt(size[0], 10);
+        pageHeight = parseInt(size[1], 10);
+        page.viewportSize = { width: pageWidth, height: pageHeight };
+        page.clipRect = { top: 0, left: 0, width: pageWidth, height: pageHeight };
+      } else {
+        console.log("size:", system.args[3]);
+        pageWidth = parseInt(system.args[3], 10);
+        pageHeight = parseInt(pageWidth * 3/4, 10); // it's as good an assumption as any
+        console.log ("pageHeight:",pageHeight);
+        page.viewportSize = { width: pageWidth, height: pageHeight };
+      }
+    }
+    if (system.args.length > 4) {
+      page.zoomFactor = system.args[4];
+    }
+    page.open(address, function (status) {
+      if (status !== 'success') {
+        console.log('Unable to load the address!');
+        phantom.exit(1);
+      } else {
+        window.setTimeout(function () {
+          page.render(output);
+          phantom.exit();
+        }, 200);
+      }
+    });
+  }
+
+}());

src/utils/safe-json-loader.js

@@ -0,0 +1,46 @@
+/**
+Definition of the SafeJsonLoader class.
+@module syntax-error-ex.js
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function() {
+
+
+
+  var FS = require('fs')
+    , SyntaxErrorEx = require('./syntax-error-ex');
+
+
+
+  module.exports = function loadSafeJson( file ) {
+
+    var ret = { };
+    try {
+
+      ret.raw = FS.readFileSync( file, 'utf8' );
+      ret.json = JSON.parse( ret.raw );
+
+    }
+    catch( ex ) {
+
+      // If we get here, either FS.readFileSync or JSON.parse failed.
+      // We'll return HMSTATUS.readError or HMSTATUS.parseError.
+      var retRaw = ret.raw && ret.raw.trim();
+
+      ret.ex = {
+        operation: retRaw ? 'parse' : 'read',
+        inner: SyntaxErrorEx.is( ex ) ? (new SyntaxErrorEx( ex, retRaw )) : ex,
+        file: file
+      };
+
+    }
+
+    return ret;
+
+  };
+
+
+}());

src/utils/safe-spawn.js

@@ -0,0 +1,45 @@
+/**
+Safe spawn utility for HackMyResume / FluentCV.
+@module safe-spawn.js
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function() {
+
+
+
+  module.exports = function( cmd, args, isSync ) {
+
+    try {
+
+      var spawn = require('child_process')[ isSync? 'spawnSync' : 'spawn'];
+      var info = spawn( cmd, args );
+
+      if( !isSync ) {
+        info.on('error', function(err) {
+          throw {
+            cmd: 'wkhtmltopdf',
+            inner: err
+          };
+        });
+      }
+      else {
+        if( info.error ) {
+          throw {
+            cmd: 'wkhtmltopdf',
+            inner: info.error
+          };
+        }
+      }
+      
+    }
+    catch( ex ) {
+
+    }
+  };
+
+
+
+}());

src/utils/string-transformer.js

@@ -0,0 +1,65 @@
+/**
+Object string transformation.
+@module string-transformer.js
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function() {
+
+
+
+  var _ = require('underscore');
+  var moment = require('moment');
+
+
+
+  /**
+  Create a copy of this object in which all string fields have been run through
+  a transformation function (such as a Markdown filter or XML encoder).
+  */
+  module.exports = function( ret, filt, transformer ) {
+
+    var that = this;
+
+    // TODO: refactor recursion
+    function transformStringsInObject( obj, filters ) {
+
+      if( !obj ) return;
+      if( moment.isMoment( obj ) ) return;
+
+      if( _.isArray( obj ) ) {
+        obj.forEach( function(elem, idx, ar) {
+          if( typeof elem === 'string' || elem instanceof String )
+            ar[idx] = transformer( null, elem );
+          else if (_.isObject(elem))
+            transformStringsInObject( elem, filters );
+        });
+      }
+      else if (_.isObject( obj )) {
+        Object.keys( obj ).forEach(function(k) {
+          if( filters.length && _.contains(filters, k) )
+            return;
+          var sub = obj[k];
+          if( typeof sub === 'string' || sub instanceof String ) {
+            obj[k] = transformer( k, sub );
+          }
+          else if (_.isObject( sub ))
+            transformStringsInObject( sub, filters );
+        });
+      }
+
+    }
+
+    Object.keys( ret ).forEach(function(member){
+      if( !filt || !filt.length || !_.contains(filt, member) )
+        transformStringsInObject( ret[ member ], filt || [] );
+    });
+
+    return ret;
+  };
+
+
+
+}());

src/utils/string.js

@@ -1,6 +1,6 @@
 /**
-String utility functions.
-@license Copyright (c) 2015 | James M. Devlin
+Definitions of string utility functions.
+@module string.js
 */
 
 /**
@@ -9,10 +9,18 @@ See: http://stackoverflow.com/a/32800728/4942583
 @method isNullOrWhitespace
 */
 
-String.isNullOrWhitespace = function( input ) {
-  return !input || !input.trim();
-};
+(function() {
 
-String.prototype.endsWith = function(suffix) {
-  return this.indexOf(suffix, this.length - suffix.length) !== -1;
-};
+  String.isNullOrWhitespace = function( input ) {
+    return !input || !input.trim();
+  };
+
+  String.prototype.endsWith = function(suffix) {
+    return this.indexOf(suffix, this.length - suffix.length) !== -1;
+  };
+
+  String.is = function( val ) {
+    return typeof val === 'string' || val instanceof String;
+  };
+
+}());

src/utils/syntax-error-ex.js

@@ -0,0 +1,35 @@
+/**
+Definition of the SyntaxErrorEx class.
+@module syntax-error-ex.js
+@license MIT. See LICENSE.md for details.
+*/
+
+(function() {
+
+
+  /**
+  Represents a SyntaxError exception with line and column info.
+  Collect syntax error information from the provided exception object. The
+  JavaScript `SyntaxError` exception isn't interpreted uniformly across environ-
+  ments, so we reparse on error to grab the line and column.
+  See: http://stackoverflow.com/q/13323356
+  @class SyntaxErrorEx
+  */
+
+  function SyntaxErrorEx( ex, rawData ) {
+
+    var lineNum = null, colNum = null;
+    var JSONLint = require('json-lint');
+    var lint = JSONLint( rawData, { comments: false } );
+    this.line = (lint.error ? lint.line : '???');
+    this.col =  (lint.error ? lint.character : '???');
+
+  }
+
+  SyntaxErrorEx.is = function( ex ) {
+    return ex instanceof SyntaxError;
+  };
+
+  module.exports = SyntaxErrorEx;
+
+}());

src/verbs/analyze.js

@@ -0,0 +1,94 @@
+/**
+Implementation of the 'analyze' verb for HackMyResume.
+@module verbs/analyze
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function(){
+
+
+
+  var MKDIRP = require('mkdirp')
+    , PATH = require('path')
+    , HMEVENT = require('../core/event-codes')
+    , HMSTATUS = require('../core/status-codes')
+    , _ = require('underscore')
+    , ResumeFactory = require('../core/resume-factory')
+    , Verb = require('../verbs/verb')
+    , chalk = require('chalk');
+
+
+
+  var AnalyzeVerb = module.exports = Verb.extend({
+
+    init: function() {
+      this._super('analyze');
+    },
+
+    invoke: function() {
+      this.stat( HMEVENT.begin, { cmd: 'analyze' });
+      analyze.apply( this, arguments );
+      this.stat( HMEVENT.end );
+    }
+
+  });
+
+
+
+  /**
+  Run the 'analyze' command.
+  */
+  function analyze( sources, dst, opts ) {
+    if( !sources || !sources.length )
+      throw { fluenterror: HMSTATUS.resumeNotFound, quit: true };
+
+    var nlzrs = _loadInspectors();
+
+    _.each(sources, function(src) {
+      var result = ResumeFactory.loadOne( src, {
+        format: 'FRESH', objectify: true
+      }, this);
+      if( result.fluenterror )
+        this.setError( result.fluenterror, result );
+      else
+        _analyze.call(this, result, nlzrs, opts );
+    }, this);
+
+  }
+
+
+
+  /**
+  Analyze a single resume.
+  */
+  function _analyze( resumeObject, nlzrs, opts ) {
+    var rez = resumeObject.rez;
+    var safeFormat =
+      (rez.meta && rez.meta.format && rez.meta.format.startsWith('FRESH')) ?
+      'FRESH' : 'JRS';
+
+    this.stat( HMEVENT.beforeAnalyze, { fmt: safeFormat, file: resumeObject.file });
+    var info = _.mapObject( nlzrs, function(val, key) {
+      return val.run( resumeObject.rez );
+    });
+    this.stat( HMEVENT.afterAnalyze, { info: info } );
+  }
+
+
+
+  /**
+  Load inspectors.
+  */
+  function _loadInspectors() {
+    return {
+      totals: require('../inspectors/totals-inspector'),
+      coverage: require('../inspectors/gap-inspector'),
+      keywords: require('../inspectors/keyword-inspector')
+    };
+  }
+
+
+
+}());

src/verbs/build.js

@@ -0,0 +1,385 @@
+/**
+Implementation of the 'build' verb for HackMyResume.
+@module verbs/build
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function() {
+
+
+
+  var _              = 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');
+
+  var _err, _log, _rezObj;
+
+
+
+  /** An invokable resume generation command. */
+  var BuildVerb = module.exports = Verb.extend({
+
+    /** Create a new build verb. */
+    init: function() {
+      this._super('build');
+    },
+
+    /** Invoke the Build command. */
+    invoke: function() {
+      this.stat( HMEVENT.begin, { cmd: 'build' } );
+      var ret = build.apply( this, arguments );
+      this.stat( HMEVENT.end );
+      return ret;
+    }
+
+  });
+
+
+
+  /**
+  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 theme Friendly name of the resume theme. Defaults to "modern".
+  @param logger Optional logging override.
+  */
+  function build( src, dst, opts ) {
+
+    if( !src || !src.length ) {
+      this.err( HMSTATUS.resumeNotFound, { quit: true } );
+    }
+
+    prep( src, dst, opts );
+
+    // Load input resumes as JSON...
+    var sheetObjects = ResumeFactory.load(src, {
+      format: null, objectify: false, quit: true, inner: { sort: _opts.sort }
+    }, this);
+
+    // Explicit check for any resume loading errors...
+    if( !sheetObjects ||
+        _.some( sheetObjects, function(so) { return so.fluenterror; } ) ) {
+      return null;
+    }
+
+    var sheets = sheetObjects.map(function(r) { return r.json; });
+
+    // Load the theme...
+    var theme;
+    this.stat( HMEVENT.beforeTheme, { theme: _opts.theme });
+    try {
+      var tFolder = verifyTheme.call( this, _opts.theme );
+      theme = _opts.themeObj = loadTheme( tFolder );
+    }
+    catch( ex ) {
+      var newEx = {
+        fluenterror: HMSTATUS.themeLoad,
+        inner: ex,
+        attempted: _opts.theme
+      };
+      this.err( HMSTATUS.themeLoad, newEx );
+      return null;
+    }
+    this.stat( HMEVENT.afterTheme, { theme: theme });
+
+    // Check for invalid outputs...
+    var inv = verifyOutputs.call( this, dst, theme );
+    if( inv && inv.length ) {
+      this.err( HMSTATUS.invalidFormat, { data: inv, theme: theme } );
+    }
+
+    // Merge input resumes, yielding a single source resume.
+    var rez;
+    if( sheets.length > 1 ) {
+      var isFRESH = !sheets[0].basics;
+      var mixed = _.any( sheets, function(s) { return isFRESH ? s.basics : !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];
+    }
+
+    // Convert the merged source resume to the theme's format, if necessary
+    var orgFormat = rez.basics ? 'JRS' : 'FRESH';
+    var 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 });
+    }
+
+    // Add freebie formats to the theme
+    addFreebieFormats( theme  );
+    this.stat( HMEVENT.applyTheme, { r: rez, theme: theme });
+
+    // Load the resume into a FRESHResume or JRSResume object
+    _rezObj = new (RTYPES[ toFormat ])().parseJSON( rez );
+
+    // Expand output resumes...
+    var targets = expand( dst, theme );
+
+    // Run the transformation!
+    _.each(targets, function(t) {
+      t.final = single.call( this, t, theme, targets );
+    }, this);
+
+    // Don't send the client back empty-handed
+    return { sheet: _rezObj, targets: targets, processed: targets };
+  }
+
+
+
+  /**
+  Prepare for a BUILD run.
+  */
+  function prep( src, dst, opts ) {
+
+    // Cherry-pick options //_opts = extend( true, _opts, opts );
+    _opts.theme = (opts.theme && opts.theme.toLowerCase().trim()) || 'modern';
+    _opts.prettify = opts.prettify === 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;
+
+    // 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() );
+
+  }
+
+
+
+  /**
+  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.
+  */
+  function single( targInfo, theme, finished ) {
+
+    var ret, ex, f = targInfo.file;
+
+    try {
+
+      if( !targInfo.fmt ) {  return; }
+      var fType = targInfo.fmt.outFormat
+        , fName = PATH.basename(f, '.' + fType)
+        , theFormat;
+
+      this.stat( HMEVENT.beforeGenerate, {
+        fmt: targInfo.fmt.outFormat,
+        file: PATH.relative(process.cwd(), f)
+      });
+
+      // 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 ) ); // Ensure dest folder exists;
+        _opts.targets = finished;
+        ret = theFormat.gen.generate( _rezObj, f, _opts );
+      }
+      //Otherwise this is an ad-hoc format (JSON, YML, or PNG) that every theme
+      // gets "for free".
+      else {
+        theFormat = _fmts.filter( function(fmt) {
+          return fmt.name === targInfo.fmt.outFormat;
+        })[0];
+        var outFolder = PATH.dirname( f );
+        MKDIRP.sync( outFolder ); // Ensure dest folder exists;
+        ret = theFormat.gen.generate( _rezObj, f, _opts );
+      }
+    }
+    catch( e ) {
+      // Catch any errors caused by generating this file and don't let them
+      // propagate -- typically we want to continue processing other formats
+      // even if this format failed.
+      ex = e;
+    }
+
+    this.stat( HMEVENT.afterGenerate, {
+      fmt: targInfo.fmt.outFormat,
+      file: PATH.relative( process.cwd(), f ),
+      error: ex
+    });
+
+    if( ex ) {
+      if( ex.fluenterror )
+        this.err( ex.fluenterror, ex );
+      else
+        this.err( HMSTATUS.generateError, { inner: ex } );
+    }
+
+    return ret;
+  }
+
+
+
+  /**
+  Ensure that user-specified outputs/targets are valid.
+  */
+  function verifyOutputs( targets, theme ) {
+
+    this.stat(HMEVENT.verifyOutputs, { targets: targets, theme: theme });
+
+    return _.reject(
+      targets.map( function( t ) {
+        var pathInfo = parsePath( t );
+        return {
+          format: pathInfo.extname.substr(1)
+        };
+      }),
+      function(t) {
+        return t.format === 'all' || theme.hasFormat( t.format );
+      }
+    );
+
+  }
+
+
+
+  /**
+  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.
+  */
+  function addFreebieFormats( 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 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.
+  */
+  function expand( dst, theTheme ) {
+
+    // 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.
+    var destColl = (dst && dst.length && dst) ||
+                   [PATH.normalize('out/resume.all')];
+
+    // Assemble an array of expanded target files... (can't use map() here)
+    var targets = [];
+    destColl.forEach( function(t) {
+
+      var to = PATH.resolve(t), pa = parsePath(to),fmat = pa.extname || '.all';
+
+
+      targets.push.apply(
+        targets, fmat === '.all' ?
+        Object.keys( theTheme.formats ).map( function( k ) {
+          var z = theTheme.formats[k];
+          return { file: to.replace( /all$/g, z.outFormat ), fmt: z };
+        }) :
+        [{ file: to, fmt: theTheme.getFormat( fmat.slice(1) ) }]);
+
+      // targets.push.apply(
+      //   targets, fmat === '.all' ?
+      //   Object.keys( explicitFormats ).map( function( k ) {
+      //     var z = theTheme.formats[k];
+      //     return { file: to.replace( /all$/g, z.outFormat ), fmt: z };
+      //   }) :
+      //   [{ file: to, fmt: theTheme.getFormat( fmat.slice(1) ) }]);
+
+    });
+
+    return targets;
+  }
+
+
+
+  /**
+  Verify the specified theme name/path.
+  */
+  function verifyTheme( themeNameOrPath ) {
+    var tFolder = PATH.join(
+      parsePath ( require.resolve('fresh-themes') ).dirname,
+      '/themes/',
+      themeNameOrPath
+    );
+    var exists = require('path-exists').sync;
+    if( !exists( tFolder ) ) {
+      tFolder = PATH.resolve( themeNameOrPath );
+      if( !exists( tFolder ) ) {
+        this.err( HMSTATUS.themeNotFound, { data: _opts.theme } );
+      }
+    }
+    return tFolder;
+  }
+
+
+
+  /**
+  Load the specified theme, which could be either a FRESH theme or a JSON Resume
+  theme.
+  */
+  function loadTheme( tFolder ) {
+
+    // Create a FRESH or JRS theme object
+    var theTheme = _opts.theme.indexOf('jsonresume-theme-') > -1 ?
+      new JRSTheme().open(tFolder) : new FRESHTheme().open( tFolder );
+
+    // Cache the theme object
+    _opts.themeObj = theTheme;
+
+    return theTheme;
+  }
+
+
+
+}());

src/verbs/convert.js

@@ -0,0 +1,89 @@
+/**
+Implementation of the 'convert' verb for HackMyResume.
+@module verbs/convert
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function(){
+
+
+
+  var ResumeFactory = require('../core/resume-factory')
+    , chalk = require('chalk')
+    , Verb = require('../verbs/verb')
+    , HMSTATUS = require('../core/status-codes')
+    , _ = require('underscore')
+    , HMEVENT = require('../core/event-codes');
+
+
+  var ConvertVerb = module.exports = Verb.extend({
+
+    init: function() {
+      this._super('convert');
+    },
+
+    invoke: function() {
+      this.stat( HMEVENT.begin, { cmd: 'convert' });
+      convert.apply( this, arguments );
+      this.stat( HMEVENT.end );
+    }
+
+  });
+
+
+
+  /**
+  Convert between FRESH and JRS formats.
+  */
+  function convert( srcs, dst, opts ) {
+
+    // Housekeeping
+    if( !srcs || !srcs.length ) { throw { fluenterror: 6, quit: true }; }
+    if( !dst || !dst.length ) {
+      if( srcs.length === 1 ) {
+        throw { fluenterror: HMSTATUS.inputOutputParity, quit: true };
+      }
+      else if( srcs.length === 2 ) {
+        dst = dst || []; dst.push( srcs.pop() );
+      }
+      else {
+        throw { fluenterror: HMSTATUS.inputOutputParity, quit: true };
+      }
+    }
+    if(srcs && dst && srcs.length && dst.length && srcs.length !== dst.length){
+      throw { fluenterror: HMSTATUS.inputOutputParity, quit: true };
+    }
+
+    // Load source resumes
+    _.each(srcs, function( src, idx ) {
+
+      // Load the resume
+      var rinfo = ResumeFactory.loadOne( src, {
+        format: null, objectify: true, throw: false
+      });
+
+      // If a load error occurs, report it and move on to the next file (if any)
+      if( rinfo.fluenterror ) {
+        this.err( rinfo.fluenterror, rinfo );
+        return;
+      }
+
+      var s = rinfo.rez
+        , srcFmt = ((s.basics && s.basics.imp) || s.imp).orgFormat === 'JRS' ?
+          'JRS' : 'FRESH'
+        , targetFormat = srcFmt === 'JRS' ? 'FRESH' : 'JRS';
+
+      this.stat(HMEVENT.beforeConvert, { srcFile: rinfo.file, srcFmt: srcFmt, dstFile: dst[idx], dstFmt: targetFormat });
+
+      // Save it to the destination format
+      s.saveAs( dst[idx], targetFormat );
+
+    }, this);
+
+  }
+
+
+
+}());

src/verbs/create.js

@@ -0,0 +1,60 @@
+/**
+Implementation of the 'create' verb for HackMyResume.
+@module verbs/create
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function(){
+
+
+
+  var MKDIRP = require('mkdirp')
+    , PATH = require('path')
+    , chalk = require('chalk')
+    , Verb = require('../verbs/verb')
+    , _ = require('underscore')
+    , HMSTATUS = require('../core/status-codes')
+    , HMEVENT = require('../core/event-codes');
+
+
+
+  var CreateVerb = module.exports = Verb.extend({
+
+    init: function() {
+      this._super('new');
+    },
+
+    invoke: function() {
+      this.stat( HMEVENT.begin, { cmd: 'create' });
+      create.apply( this, arguments );
+      this.stat( HMEVENT.begin, { cmd: 'convert' });
+    }
+
+  });
+
+
+
+  /**
+  Create a new empty resume in either FRESH or JRS format.
+  */
+  function create( src, dst, opts ) {
+
+    if( !src || !src.length )
+      throw { fluenterror: HMSTATUS.createNameMissing, quit: true };
+
+    _.each( src, function( t ) {
+      var safeFmt = opts.format.toUpperCase();
+      this.stat( HMEVENT.beforeCreate, { fmt: safeFmt, file: t } );
+      MKDIRP.sync( PATH.dirname( t ) ); // Ensure dest folder exists;
+      var RezClass = require('../core/' + safeFmt.toLowerCase() + '-resume' );
+      RezClass.default().save(t);
+      this.stat( HMEVENT.afterCreate, { fmt: safeFmt, file: t } );
+    }, this);
+
+  }
+
+
+
+}());

src/verbs/peek.js

@@ -0,0 +1,83 @@
+/**
+Implementation of the 'peek' verb for HackMyResume.
+@module verbs/peek
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function(){
+
+
+
+  var Verb = require('../verbs/verb')
+    , _ = require('underscore')
+    , __ = require('lodash')
+    , safeLoadJSON = require('../utils/safe-json-loader')
+    , HMSTATUS = require('../core/status-codes')
+    , HMEVENT = require('../core/event-codes');
+
+
+
+  var PeekVerb = module.exports = Verb.extend({
+
+    init: function() {
+      this._super('peek');
+    },
+
+    invoke: function() {
+      this.stat( HMEVENT.begin, { cmd: 'peek' } );
+      peek.apply( this, arguments );
+      this.stat( HMEVENT.end );
+    }
+
+  });
+
+
+
+  /**
+  Peek at a resume, resume section, or resume field.
+  */
+  function peek( src, dst, opts ) {
+
+    if(!src || !src.length) throw {fluenterror: HMSTATUS.resumeNotFound};
+
+    var objPath = (dst && dst[0]) || '';
+
+    _.each( src, function( t ) {
+
+      // Fire the 'beforePeek' event 2nd, so we have error/warning/success
+      this.stat( HMEVENT.beforePeek, { file: t, target: objPath } );
+
+      // Load the input file JSON 1st
+      var obj = safeLoadJSON( t );
+
+      // Fetch the requested object path (or the entire file)
+      var tgt;
+      if( !obj.ex )
+        tgt = objPath ? __.get( obj.json, objPath ) : obj.json;
+
+      // Fire the 'afterPeek' event with collected info
+      this.stat( HMEVENT.afterPeek, {
+        file: t,
+        requested: objPath,
+        target: tgt,
+        error: obj.ex
+      });
+
+      // safeLoadJSON can only return a READ error or a PARSE error
+      if( obj.ex ) {
+        var errCode = obj.ex.operation === 'parse' ? HMSTATUS.parseError : HMSTATUS.readError;
+        if( errCode === HMSTATUS.readError )
+          obj.ex.quiet = true;
+        this.setError( errCode, obj.ex );
+        this.err( errCode, obj.ex );
+      }
+
+    }, this);
+
+  }
+
+
+
+}());

src/verbs/validate.js

@@ -0,0 +1,103 @@
+/**
+Implementation of the 'validate' verb for HackMyResume.
+@module verbs/validate
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function() {
+
+
+
+  var FS = require('fs');
+  var ResumeFactory = require('../core/resume-factory');
+  var SyntaxErrorEx = require('../utils/syntax-error-ex');
+  var chalk = require('chalk');
+  var Verb = require('../verbs/verb');
+  var HMSTATUS = require('../core/status-codes');
+  var HMEVENT = require('../core/event-codes');
+  var _ = require('underscore');
+
+
+
+  /** An invokable resume validation command. */
+  var ValidateVerb = module.exports = Verb.extend({
+
+    init: function() {
+      this._super('validate');
+    },
+
+    invoke: function() {
+      this.stat( HMEVENT.begin, { cmd: 'validate' } );
+      validate.apply( this, arguments );
+      this.stat( HMEVENT.end );
+    }
+
+  });
+
+
+
+  /** Validate 1 to N resumes in FRESH or JSON Resume format. */
+  function validate( sources, unused, opts ) {
+
+    if( !sources || !sources.length )
+      throw { fluenterror: HMSTATUS.resumeNotFoundAlt, quit: true };
+
+    var validator = require('is-my-json-valid');
+    var schemas = {
+      fresh: require('fresca'),
+      jars: require('../core/resume.json')
+    };
+
+    var resumes = ResumeFactory.load( sources, {
+      format: null,
+      objectify: false
+    }, this );
+
+    // Validate input resumes. Return a { file: <f>, isValid: <v>} object for
+    // each resume (valid, invalid, or broken).
+    return resumes.map( function( src ) {
+
+      var ret =  { file: src, isValid: false };
+
+      // If there was an error reading the resume
+      if( src.fluenterror ) {
+        if( opts.assert ) throw src;
+        this.setError( src.fluenterror, src );
+        return ret;
+      }
+
+      // Successfully read the resume. Now parse it as JSON.
+      var json = src.json, fmt = json.basics ? 'jrs' : 'fresh', errors = [];
+      try {
+        var validate = validator( schemas[ fmt ], { // Note [1]
+          formats: {
+             date: /^\d{4}(?:-(?:0[0-9]{1}|1[0-2]{1})(?:-[0-9]{2})?)?$/
+          }
+        });
+
+        ret.isValid = validate( json );
+        if( !ret.isValid ) {
+          errors = validate.errors;
+        }
+
+      }
+      catch( exc ) {
+        return ret;
+      }
+
+      this.stat( HMEVENT.afterValidate, { file: src.file, isValid: ret.isValid,
+        fmt: fmt.replace( 'jars', 'JSON Resume' ), errors: errors });
+
+      if( opts.assert && !ret.isValid ) {
+        throw { fluenterror: HMSTATUS.invalid, shouldExit: true };
+      }
+
+      return ret;
+
+    }, this);
+
+  }
+
+}());

src/verbs/verb.js

@@ -0,0 +1,96 @@
+/**
+Definition of the Verb class.
+@module verbs/verb
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+(function(){
+
+
+
+  // Use J. Resig's nifty class implementation
+  var Class = require( '../utils/class' )
+    , EVENTS = require('events');
+
+
+
+
+  /**
+  An instantiation of a HackMyResume command.
+  @class Verb
+  */
+  var Verb = module.exports = Class.extend({
+
+
+
+    /**
+    Constructor. Automatically called at creation.
+    */
+    init: function( moniker ) {
+      this.moniker = moniker;
+      this.emitter = new EVENTS.EventEmitter();
+    },
+
+
+
+    /**
+    Forward subscriptions to the event emitter.
+    */
+    on: function() {
+      this.emitter.on.apply( this.emitter, arguments );
+    },
+
+
+
+    /**
+    Fire an arbitrary event, scoped to "hmr:".
+    */
+    fire: function(evtName, payload) {
+      payload = payload || { };
+      payload.cmd = this.moniker;
+      this.emitter.emit( 'hmr:' + evtName, payload );
+      return true;
+    },
+
+
+
+    /**
+    Handle an error condition.
+    */
+    err: function( errorCode, payload, hot ) {
+      payload = payload || { };
+      payload.sub = payload.fluenterror = errorCode;
+      payload.throw = hot;
+      this.fire( 'error', payload );
+      if( hot ) throw payload;
+      return true;
+    },
+
+
+
+    /**
+    Fire the 'hmr:status' error event.
+    */
+    stat: function( subEvent, payload ) {
+      payload = payload || { };
+      payload.sub = subEvent;
+      this.fire('status', payload);
+      return true;
+    },
+
+
+    /**
+    Associate error info with the invocation.
+    */
+    setError: function( code, obj ) {
+      this.errorCode = code;
+      this.errorObj = obj;
+    }
+
+
+
+  });
+
+}());

test/.gitignore

@@ -0,0 +1 @@
+sandbox/

test/hmr-options.json

@@ -0,0 +1,4 @@
+{
+  "theme": "positive",
+  "debug": true
+}

test/resumes/jrs-0.0.0/empty.json

@@ -0,0 +1,91 @@
+{
+  "basics": {
+    "name": "",
+    "label": "",
+    "picture": "",
+    "email": "",
+    "phone": "",
+    "degree": "",
+    "website": "",
+    "summary": "",
+    "location": {
+      "address": "",
+      "postalCode": "",
+      "city": "",
+      "countryCode": "",
+      "region": ""
+    },
+    "profiles": [
+      {
+        "network": "",
+        "username": "",
+        "url": ""
+      }
+    ]
+  },
+  "work": [
+    {
+      "company": "",
+      "position": "",
+      "website": "",
+      "startDate": "",
+      "endDate": "",
+      "summary": "",
+      "highlights": [
+        ""
+      ]
+    }
+  ],
+  "awards": [
+    {
+      "title": "",
+      "date": "",
+      "awarder": "",
+      "summary": ""
+    }
+  ],
+  "education": [
+    {
+      "institution": "",
+      "area": "",
+      "studyType": "",
+      "startDate": "",
+      "endDate": "",
+      "gpa": "",
+      "courses": [
+        ""
+      ]
+    }
+  ],
+  "publications": [
+    {
+      "name": "",
+      "publisher": "",
+      "releaseDate": "",
+      "website": "",
+      "summary": ""
+    }
+  ],
+  "volunteer": [
+    {
+      "organization": "",
+      "position": "",
+      "website": "",
+      "startDate": "",
+      "endDate": "",
+      "summary": "",
+      "highlights": [
+        ""
+      ]
+    }
+  ],
+  "skills": [
+    {
+      "name": "",
+      "level": "",
+      "keywords": [
+        ""
+      ]
+    }
+  ]
+}

test/resumes/jrs-0.0.0/jane-incomplete.json

@@ -0,0 +1,104 @@
+{
+  "basics": {
+    "name": "Jane Q. Fullstacker"
+  },
+  "education": [
+    {
+      "gpa": "3.5",
+      "courses": [
+        "Course 1",
+        "Course 2",
+        "Course 2"
+      ],
+      "startDate": "2005-09",
+      "endDate": "2008-05"
+    },
+    {
+      "institution": "Medfield College",
+      "gpa": "3.2",
+      "courses": [
+        "Course 1",
+        "Course 2",
+        "Course 2"
+      ],
+      "startDate": "2003-09",
+      "endDate": "2005-06"
+    }
+  ],
+  "skills": [
+    {
+      "name": "Web Dev",
+      "keywords": [
+        "JavaScript",
+        "HTML 5",
+        "CSS",
+        "LAMP",
+        "MVC",
+        "REST"
+      ]
+    },
+    {
+      "name": "JavaScript"
+    }
+  ],
+  "volunteer": [],
+  "publications": [
+    {
+      "name": "Building User Interfaces with Electron and Atom",
+      "releaseDate": "2011",
+      "website": "http://codeproject.com/build-ui-electron-atom.aspx"
+    },
+    {
+      "name": "Jane Fullstacker's Blog",
+      "publisher": "self",
+      "releaseDate": "2011",
+      "website": "http://janef.me"
+    },
+    {
+      "name": "Teach Yourself GORFF in 21 Days",
+      "publisher": "Amazon"
+    }
+  ],
+  "interests": [
+    {
+      "name": "reading",
+      "summary": "Jane is a fan of mystery novels and courtroom dramas including Agatha Christie and John Grisham.",
+      "keywords": [
+        "mystery",
+        "Agatha Christie",
+        "John Grisham"
+      ]
+    },
+    {
+      "name": "hiking",
+      "summary": "Jane enjoys hiking, light mountain climbing, and has four summits under her belt!"
+    },
+    {
+      "name": "yoga"
+    }
+  ],
+  "references": [
+    {
+      "name": "John Davidson",
+      "reference": "Jane is awesome! I'd hire her again in a heartbeat."
+    },
+    {
+      "name": "Elias Fullstacker",
+      "reference": "I worked with Jane on Jabberwocky and can vouch for her awesome technical capabilities and attention to detail. Insta-hire."
+    },
+    {
+      "name": "Dana Nevins",
+      "reference": "I've known Jane personally and professionally for almost ten years. She is one in a million."
+    }
+  ],
+  "languages": [
+    {
+      "language": "English",
+      "level": "Native"
+    },
+    {
+      "language": "Spanish",
+      "level": "Moderate"
+    }
+  ]
+}

test/resumes/jrs-0.0.0/jane-q-fullstacker.json

@@ -0,0 +1,263 @@
+{
+  "basics": {
+    "name": "Jane Q. Fullstacker",
+    "label": "Senior Developer",
+    "summary": "**Full-stack software developer with 6+ years industry experience** specializing in scalable cloud architectures for this, that, and the other. A native of southern CA, Jane enjoys hiking, mystery novels, and the company of Rufus, her two-year-old beagle.",
+    "website": "http://janef.me/blog",
+    "phone": "1-650-999-7777",
+    "email": "jdoe@onecoolstartup.io",
+    "picture": "jane_doe.png",
+    "location": {
+      "address": "Jane Fullstacker\n123 Somewhere Rd.\nMountain View, CA 94035",
+      "postalCode": "94035",
+      "city": "Mountain View",
+      "countryCode": "US",
+      "region": "CA"
+    },
+    "profiles": [
+      {
+        "network": "GitHub",
+        "username": "janef-was-here",
+        "url": "https://github.com/janef-was-here"
+      },
+      {
+        "network": "Twitter",
+        "username": "janef-was-here",
+        "url": "https://twitter.com/janef-was-here"
+      }
+    ]
+  },
+  "work": [
+    {
+      "company": "One Cool Startup",
+      "website": "https://onecool.io/does-not-exist",
+      "position": "Head Code Ninja",
+      "startDate": "2013-09",
+      "summary": "Development team manager for OneCoolApp and OneCoolWebsite, a free social network tiddlywink generator and lifestyle portal with over 200,000 users.",
+      "highlights": [
+        "Managed a 5-person development team",
+        "Accomplishment 2",
+        "Etc."
+      ]
+    },
+    {
+      "company": "Veridian Dynamics",
+      "website": "https://en.wikipedia.org/wiki/Better_Off_Ted#Plot",
+      "position": "Principal Developer",
+      "startDate": "2011-07",
+      "endDate": "2013-08",
+      "summary": "Developer on numerous projects culminating in technical lead role for the [Jabberwocky project](http://betteroffted.wikia.com/wiki/Jabberwocky) and promotion to principal developer.",
+      "highlights": [
+        "Managed a 5-person development team",
+        "Accomplishment 2",
+        "Etc."
+      ]
+    },
+    {
+      "company": "Stark Industries",
+      "position": "IT Administrator",
+      "startDate": "2008-10",
+      "endDate": "2011-06",
+      "summary": "Junior programmer with heavy code responsibilities. Promoted to intermediate role after 6 months.",
+      "highlights": [
+        "Promoted to intermediate developer after 6 months",
+        "Accomplishment 2",
+        "Etc."
+      ]
+    },
+    {
+      "company": "Dunder Mifflin",
+      "position": "Intern",
+      "startDate": "2008-06",
+      "endDate": "2008-09",
+      "summary": "Performed IT administration and deployments for Dunder Mifflin.",
+      "highlights": [
+        "Supervised roll-out of Dunder Mifflin Infinity website.",
+        "Performed mission-critical system backups and ",
+        "Etc."
+      ]
+    }
+  ],
+  "education": [
+    {
+      "institution": "Cornell University",
+      "gpa": "3.5",
+      "courses": [
+        "Course 1",
+        "Course 2",
+        "Course 2"
+      ],
+      "startDate": "2005-09",
+      "endDate": "2008-05"
+    },
+    {
+      "institution": "Medfield College",
+      "gpa": "3.2",
+      "courses": [
+        "Course 1",
+        "Course 2",
+        "Course 2"
+      ],
+      "startDate": "2003-09",
+      "endDate": "2005-06"
+    }
+  ],
+  "skills": [
+    {
+      "name": "Web Dev",
+      "keywords": [
+        "JavaScript",
+        "HTML 5",
+        "CSS",
+        "LAMP",
+        "MVC",
+        "REST"
+      ]
+    },
+    {
+      "name": "JavaScript",
+      "keywords": [
+        "Node.js",
+        "Angular.js",
+        "jQuery",
+        "Bootstrap",
+        "React.js",
+        "Backbone.js"
+      ]
+    },
+    {
+      "name": "Database",
+      "keywords": [
+        "MySQL",
+        "PostgreSQL",
+        "NoSQL",
+        "ORM",
+        "Hibernate"
+      ]
+    },
+    {
+      "name": "Cloud",
+      "keywords": [
+        "AWS",
+        "EC2",
+        "RDS",
+        "S3",
+        "Azure",
+        "Dropbox"
+      ]
+    },
+    {
+      "name": "Project",
+      "keywords": [
+        "Agile",
+        "TFS",
+        "Unified Process",
+        "MS Project"
+      ]
+    }
+  ],
+  "volunteer": [
+    {
+      "organization": "Technology for Tots",
+      "position": "Technical Consultant",
+      "startDate": "2003-11",
+      "endDate": "2005-06",
+      "website": "http://technology-for-tots.org",
+      "summary": "Summary of this volunteer stint.",
+      "highlights": [
+        "Accomplishment 1",
+        "Accomplishment 2",
+        "etc"
+      ]
+    },
+    {
+      "organization": "US Army Reserves",
+      "position": "NCO",
+      "startDate": "1999-11",
+      "endDate": "2003-06",
+      "website": "http://www.usar.army.mil/",
+      "summary": "Summary of this military stint.",
+      "highlights": [
+        "Accomplishment 1",
+        "Accomplishment 2",
+        "etc"
+      ]
+    }
+  ],
+  "awards": [
+    {
+      "title": "Honorable Mention",
+      "date": "2012",
+      "awarder": "Google"
+    },
+    {
+      "title": "Summa cum laude",
+      "date": "2012",
+      "awarder": "Cornell University"
+    }
+  ],
+  "publications": [
+    {
+      "name": "Building User Interfaces with Electron and Atom",
+      "publisher": "Code Project",
+      "releaseDate": "2011",
+      "website": "http://codeproject.com/build-ui-electron-atom.aspx"
+    },
+    {
+      "name": "Jane Fullstacker's Blog",
+      "publisher": "self",
+      "releaseDate": "2011",
+      "website": "http://janef.me"
+    },
+    {
+      "name": "Teach Yourself GORFF in 21 Days",
+      "publisher": "Amazon",
+      "releaseDate": "2008",
+      "website": "http://url.to.publication.com/blah",
+      "summary": "A primer on the programming language of GORFF, whose for loops are coterminous with all of time and space."
+    }
+  ],
+  "interests": [
+    {
+      "name": "reading",
+      "summary": "Jane is a fan of mystery novels and courtroom dramas including Agatha Christie and John Grisham.",
+      "keywords": [
+        "mystery",
+        "Agatha Christie",
+        "John Grisham"
+      ]
+    },
+    {
+      "name": "hiking",
+      "summary": "Jane enjoys hiking, light mountain climbing, and has four summits under her belt!"
+    },
+    {
+      "name": "yoga"
+    }
+  ],
+  "references": [
+    {
+      "name": "John Davidson",
+      "reference": "Jane is awesome! I'd hire her again in a heartbeat."
+    },
+    {
+      "name": "Elias Fullstacker",
+      "reference": "I worked with Jane on Jabberwocky and can vouch for her awesome technical capabilities and attention to detail. Insta-hire."
+    },
+    {
+      "name": "Dana Nevins",
+      "reference": "I've known Jane personally and professionally for almost ten years. She is one in a million."
+    }
+  ],
+  "languages": [
+    {
+      "language": "English",
+      "level": "Native"
+    },
+    {
+      "language": "Spanish",
+      "level": "Moderate",
+      "years": 10
+    }
+  ]
+}

test/resumes/jrs-0.0.0/richard-hendriks.json

@@ -0,0 +1,130 @@
+{
+  "basics": {
+    "name": "Richard Hendriks",
+    "label": "Programmer",
+    "picture": "",
+    "email": "richard.hendriks@gmail.com",
+    "phone": "(912) 555-4321",
+    "website": "http://richardhendricks.com",
+    "summary": "Richard hails from Tulsa. He has earned degrees from the University of Oklahoma and Stanford. (Go Sooners and Cardinals!) Before starting Pied Piper, he worked for Hooli as a part time software developer. While his work focuses on applied information theory, mostly optimizing lossless compression schema of both the length-limited and adaptive variants, his non-work interests range widely, everything from quantum computing to chaos theory. He could tell you about it, but THAT would NOT be a “length-limited” conversation!",
+    "location": {
+      "address": "2712 Broadway St",
+      "postalCode": "CA 94115",
+      "city": "San Francisco",
+      "countryCode": "US",
+      "region": "California"
+    },
+    "profiles": [
+      {
+        "network": "Twitter",
+        "username": "neutralthoughts",
+        "url": ""
+      },
+      {
+        "network": "SoundCloud",
+        "username": "dandymusicnl",
+        "url": "https://soundcloud.com/dandymusicnl"
+      }
+    ]
+  },
+  "work": [
+    {
+      "company": "Pied Piper",
+      "position": "CEO/President",
+      "website": "http://piedpiper.com",
+      "startDate": "2013-12-01",
+      "endDate": "2014-12-01",
+      "summary": "Pied Piper is a multi-platform technology based on a proprietary universal compression algorithm that has consistently fielded high Weisman Scores™ that are not merely competitive, but approach the theoretical limit of lossless compression.",
+      "highlights": [
+        "Build an algorithm for artist to detect if their music was violating copy right infringement laws",
+        "Successfully won Techcrunch Disrupt",
+        "Optimized an algorithm that holds the current world record for Weisman Scores"
+      ]
+    }
+  ],
+  "volunteer": [
+    {
+      "organization": "CoderDojo",
+      "position": "Teacher",
+      "website": "http://coderdojo.com/",
+      "startDate": "2012-01-01",
+      "endDate": "2013-01-01",
+      "summary": "Global movement of free coding clubs for young people.",
+      "highlights": [
+        "Awarded 'Teacher of the Month'"
+      ]
+    }
+  ],
+  "education": [
+    {
+      "institution": "University of Oklahoma",
+      "area": "Information Technology",
+      "studyType": "Bachelor",
+      "startDate": "2011-06-01",
+      "endDate": "2014-01-01",
+      "gpa": "4.0",
+      "courses": [
+        "DB1101 - Basic SQL",
+        "CS2011 - Java Introduction"
+      ]
+    }
+  ],
+  "awards": [
+    {
+      "title": "Digital Compression Pioneer Award",
+      "date": "2014-11-01",
+      "awarder": "Techcrunch",
+      "summary": "There is no spoon."
+    }
+  ],
+  "publications": [
+    {
+      "name": "Video compression for 3d media",
+      "publisher": "Hooli",
+      "releaseDate": "2014-10-01",
+      "website": "http://en.wikipedia.org/wiki/Silicon_Valley_(TV_series)",
+      "summary": "Innovative middle-out compression algorithm that changes the way we store data."
+    }
+  ],
+  "skills": [
+    {
+      "name": "Web Development",
+      "level": "Master",
+      "keywords": [
+        "HTML",
+        "CSS",
+        "Javascript"
+      ]
+    },
+    {
+      "name": "Compression",
+      "level": "Master",
+      "keywords": [
+        "Mpeg",
+        "MP4",
+        "GIF"
+      ]
+    }
+  ],
+  "languages": [
+    {
+      "language": "English",
+      "fluency": "Native speaker"
+    }
+  ],
+  "interests": [
+    {
+      "name": "Wildlife",
+      "keywords": [
+        "Ferrets",
+        "Unicorns"
+      ]
+    }
+  ],
+  "references": [
+    {
+      "name": "Erlich Bachman",
+      "reference": "It is my pleasure to recommend Richard, his performance working as a consultant for Main St. Company proved that he will be a valuable addition to any company."
+    }
+  ]
+}

test/test-api.js

@@ -0,0 +1,207 @@
+/**
+@module test-api.js
+*/
+
+var chai = require('chai')
+  , expect = chai.expect
+  , should = chai.should()
+  , path = require('path')
+  , _ = require('underscore')
+	, FRESHResume = require('../src/core/fresh-resume')
+  , FCMD = require( '../src/hackmyapi')
+  , validator = require('is-my-json-valid')
+  , HMRMAIN = require('../src/cli/main')
+  , EXTEND = require('extend');
+
+chai.config.includeStack = false;
+
+var _sheet;
+
+var opts = {
+  format: 'FRESH',
+  prettify: true,
+  silent: false,
+  assert: true  // Causes validation errors to throw exceptions
+};
+
+var opts2 = {
+  format: 'JRS',
+  prettify: true,
+  silent: true
+};
+
+var sb = 'test/sandbox/';
+var ft = 'node_modules/fresh-test-resumes/src/fresh/';
+
+var tests = [
+
+  [ 'new',
+    [sb + 'new-fresh-resume.json'],
+    [],
+    opts,
+    ' (FRESH format)'
+  ],
+
+  [ 'new',
+    [sb + 'new-jrs-resume.json'],
+    [],
+    opts2,
+    ' (JRS format)'
+  ],
+
+  [
+    'new',
+    [sb + 'new-1.json', sb + 'new-2.json', sb + 'new-3.json'],
+    [],
+    opts,
+    ' (multiple FRESH resumes)'
+  ],
+
+  [ 'new',
+    [sb + 'new-jrs-1.json', sb + 'new-jrs-2.json', sb + 'new-jrs-3.json'],
+    [],
+    opts,
+    ' (multiple JRS resumes)'
+  ],
+
+  [ '!new',
+    [],
+    [],
+    opts,
+    " (when a filename isn't specified)"
+  ],
+
+  [ 'validate',
+    [ft + 'jane-fullstacker.json'],
+    [],
+    opts,
+    ' (jane-q-fullstacker|FRESH)'
+  ],
+
+  [ 'validate',
+    [ft + 'johnny-trouble.json'],
+    [],
+    opts,
+    ' (johnny-trouble|FRESH)'
+  ],
+
+  [ 'validate',
+    [sb + 'new-fresh-resume.json'],
+    [],
+    opts,
+    ' (new-fresh-resume|FRESH)'
+  ],
+
+  [ 'validate',
+    ['test/resumes/jrs-0.0.0/richard-hendriks.json'],
+    [],
+    opts2,
+    ' (richard-hendriks.json|JRS)'
+  ],
+
+  [ 'validate',
+    ['test/resumes/jrs-0.0.0/jane-incomplete.json'],
+    [],
+    opts2,
+    ' (jane-incomplete.json|JRS)'
+  ],
+
+  [ 'validate',
+    [sb + 'new-1.json', sb + 'new-jrs-resume.json', sb + 'new-1.json',
+      sb + 'new-2.json', sb + 'new-3.json'],
+    [],
+    opts,
+    ' (5|BOTH)'
+  ],
+
+  [ 'analyze',
+    [ft + 'jane-fullstacker.json'],
+    [],
+    opts,
+    ' (jane-q-fullstacker|FRESH)'
+  ],
+
+  [ 'analyze',
+    ['test/resumes/jrs-0.0.0/richard-hendriks.json'],
+    [],
+    opts2,
+    ' (richard-hendriks|JRS)'
+  ],
+
+  [ 'build',
+    [ ft + 'jane-fullstacker.json', ft + 'override/jane-fullstacker-override.fresh.json' ],
+    [ sb + 'merged/jane-fullstacker-gamedev.fresh.all'],
+    opts,
+    ' (jane-q-fullstacker w/ override|FRESH)'
+  ],
+
+  [ 'build',
+    [ ft + 'override/jane-partial-a.json', ft + 'override/jane-partial-b.json',
+      ft + 'override/jane-partial-c.json' ],
+    [ sb + 'merged/jane-abc.fresh.all'],
+    opts,
+    ' (jane merge A + B + C|FRESH)',
+    function( r ) {
+      var expected = [
+        'name','meta','info', 'contact', 'location', 'projects', 'social',
+        'employment', 'education', 'affiliation', 'service', 'skills',
+        'samples', 'writing', 'reading', 'speaking', 'recognition',
+        'references', 'testimonials', 'languages', 'interests',
+        'extracurricular', 'governance'
+      ];
+      return Object.keys( _.pick( r, expected ) ).length === expected.length;
+    }
+  ],
+
+  [ '!build',
+    [ ft + 'jane-fullstacker.json'],
+    [ sb + 'shouldnt-exist.pdf' ],
+    EXTEND(true, {}, opts, { theme: 'awesome' }),
+    ' (jane-q-fullstacker + Awesome + PDF|FRESH)'
+  ]
+
+];
+
+describe('Testing API interface', function () {
+
+    function run( verb, src, dst, opts, msg, fnTest ) {
+
+      msg = msg || '.';
+      var shouldSucceed = true;
+      if( verb[0] === '!' ) {
+        verb = verb.substr(1);
+        shouldSucceed = false;
+      }
+
+      it( 'The ' + verb.toUpperCase() + ' command should ' + (shouldSucceed ? ' SUCCEED' : ' FAIL') + msg, function () {
+
+        function runIt() {
+          try {
+            var v = new FCMD.verbs[verb]();
+            v.on('hmr:error', function(ex) { throw ex; });
+            var r = v.invoke( src, dst, opts );
+            if( fnTest )
+              if( !fnTest( r.sheet ) )
+                throw "Test: Unexpected API result.";
+          }
+          catch(ex) {
+            console.error(ex);
+            if( ex.stack || (ex.inner && ex.inner.stack))
+              console.error( ex.stack || ex.inner.stack );
+            throw ex;
+          }
+        }
+
+        if( shouldSucceed )
+          runIt.should.not.Throw();
+        else
+          runIt.should.Throw();
+      });
+
+    }
+
+    tests.forEach( function(a) {
+      run.apply( /* The players of */ null, a );
+    });
+
+});

test/test-cli.js

@@ -0,0 +1,76 @@
+/**
+CLI test routines for HackMyResume.
+@module test-cli.js
+*/
+
+
+
+var chai = require('chai')
+  , should = chai.should()
+  , HMRMAIN = require('../src/cli/main')
+  , CHALK = require('chalk')
+  , FS = require('fs')
+  , PATH = require('path')
+  , PKG = require('../package.json')
+  , _ = require('underscore');
+
+
+
+var gather = '';
+var ConsoleLogOrg = console.log;
+var ProcessExitOrg = process.exit;
+var commandRetVal = 0;
+
+
+describe('Testing CLI interface', function () {
+
+  // TODO: use sinon
+  // Replacement for process.exit()
+  function MyProcessExit( retVal ) {
+    commandRetVal = retVal;
+  }
+
+  // HackMyResume CLI stub. Handle a single HMR invocation.
+  function HackMyResumeStub( argsString ) {
+
+    var args = argsString.split(' ');
+    args.unshift( process.argv[1] );
+    args.unshift( process.argv[0] );
+    process.exit = MyProcessExit;
+
+    try {
+      var HMRMAIN = require('../src/cli/main');
+      HMRMAIN( args );
+    }
+    catch( ex ) {
+      require('../src/cli/error').err( ex, false );
+      //if(ex.stack || (ex.inner && ex.inner.stacl))
+        //console.log(ex.stack || ex.inner.stack);
+    }
+    process.exit = ProcessExitOrg;
+
+  }
+
+  // Run a test through the stub, gathering console.log output into "gather"
+  // and testing against it.
+  function run( args, expErr ) {
+    var title = args;
+    it( 'Testing: "' + title + '"\n\n', function() {
+      commandRetVal = 0;
+      HackMyResumeStub( args );
+      commandRetVal.should.equal( parseInt(expErr, 10) );
+    });
+  }
+
+  var lines = FS.readFileSync( PATH.join( __dirname, './test-hmr.txt'), 'utf8').split('\n');
+  lines.forEach(function(l){
+    if( l && l.trim() ) {
+      if(l[0] !== '#') {
+        var lineInfo = l.split('|');
+        var errCode = lineInfo[0];
+        run( lineInfo.length > 1 ? lineInfo[1] : '', errCode );
+      }
+    }
+  });
+
+});

test/test-fresh-sheet.js

@@ -0,0 +1,71 @@
+
+var chai = require('chai')
+  , expect = chai.expect
+  , should = chai.should()
+  , path = require('path')
+  , _ = require('underscore')
+	, FRESHResume = require('../src/core/fresh-resume')
+  , validator = require('is-my-json-valid');
+
+chai.config.includeStack = false;
+
+function testResume(opts) {
+
+  describe( opts.title + ' (FRESH)', function () {
+
+      var _sheet;
+
+  	  it('should open without throwing an exception', function () {
+        function tryOpen() {
+          _sheet = new FRESHResume().open( opts.path );
+        }
+        tryOpen.should.not.Throw();
+      });
+
+      it('should have one or more of each section', function() {
+        var newObj = _.pick( _sheet, opts.sections );
+        expect( Object.keys(newObj).length ).to.equal( opts.sections.length );
+      });
+
+      it('should have a work duration of ' + opts.duration + ' years', function() {
+        _sheet.computed.numYears.should.equal( opts.duration );
+      });
+
+      it('should save without throwing an exception', function(){
+        function trySave() {
+          _sheet.save( 'test/sandbox/' + opts.title + '.json' );
+        }
+        trySave.should.not.Throw();
+      });
+
+      it('should not be modified after saving', function() {
+        var savedSheet = new FRESHResume().open('test/sandbox/' + opts.title + '.json');
+        _sheet.stringify().should.equal( savedSheet.stringify() );
+      });
+
+      it('should validate against the FRESH resume schema', function() {
+        var result = _sheet.isValid();
+        // var schemaJson = require('fresca');
+        // var validate = validator( schemaJson, { verbose: true } );
+        // var result = validate( JSON.parse( _sheet.imp.raw ) );
+        result || console.log("\n\nOops, resume didn't validate. " +
+          "Validation errors:\n\n", _sheet.imp.validationErrors, "\n\n");
+        result.should.equal( true );
+      });
+
+
+  });
+}
+
+var sects = [ 'info', 'employment', 'service', 'skills', 'education', 'writing', 'recognition', 'references' ];
+testResume({ title: 'jane-q-fullstacker', path: 'node_modules/fresh-test-resumes/src/fresh/jane-fullstacker.json', duration: 7, sections: sects });
+testResume({ title: 'johnny-trouble-resume', path: 'node_modules/fresh-test-resumes/src/fresh/johnny-trouble.json', duration: 4, sections: sects });
+
+sects = [ 'info', 'contact', 'location' ];
+testResume({ title: 'jane-q-fullstacker A', path: 'node_modules/fresh-test-resumes/src/fresh/override/jane-partial-a.json', duration: 0, sections: sects });
+
+sects = [ 'projects', 'social', 'employment', 'education', 'affiliation' ];
+testResume({ title: 'jane-q-fullstacker B', path: 'node_modules/fresh-test-resumes/src/fresh/override/jane-partial-b.json', duration: 7, sections: sects });
+
+sects = [ 'service', 'skills', 'samples', 'writing', 'reading', 'speaking', 'recognition', 'references', 'testimonials', 'languages', 'interests', 'extracurricular', 'governance' ];
+testResume({ title: 'jane-q-fullstacker C', path: 'node_modules/fresh-test-resumes/src/fresh/override/jane-partial-c.json', duration: 0, sections: sects });

test/test-hmr.txt

@@ -0,0 +1,27 @@
+0|
+0|--help
+0|-h
+0|--debug
+0|-d
+5|notacommand
+3|build
+14|build doesnt-exist.json
+14|build doesnt-exist.json -t not-a-theme
+14|build doesnt-exist.json -t node_modules/not-a-theme
+8|new
+0|new test/sandbox/cli-test/new-empty-resume.auto.json
+0|new test/sandbox/cli-test/new-empty-resume.jrs.json -f jrs
+0|new test/sandbox/cli-test/new-empty-resume.fresh.json -f fresh
+3|analyze
+14|analyze doesnt-exist.json
+3|convert
+7|convert doesnt-exist.json
+3|validate
+14|validate doesnt-exist.json
+0|validate node_modules/fresh-test-resumes/src/fresh/jane-fullstacker.json
+3|peek
+14|peek doesnt-exist.json
+14|peek doesnt-exist.json not.a.path
+0|peek test/resumes/jrs-0.0.0/richard-hendriks.json work[0]
+0|peek node_modules/fresh-test-resumes/src/fresh/jane-fullstacker.json employment.history[1]
+0|peek node_modules/fresh-test-resumes/src/fresh/johnny-trouble.json skills.sets

test/test-jrs-sheet.js

@@ -0,0 +1,69 @@
+
+var chai = require('chai')
+  , expect = chai.expect
+  , should = chai.should()
+  , path = require('path')
+  , _ = require('underscore')
+	, JRSResume = require('../src/core/jrs-resume')
+  , validator = require('is-my-json-valid');
+
+chai.config.includeStack = false;
+
+function testResume( opts ) {
+
+  describe( opts.title + ' (JRS)', function() {
+
+    opts.isValid = opts.isValid !== false;
+
+    var _sheet;
+
+    it('should open without throwing an exception', function () {
+      var that = this;
+      function tryOpen() {
+        _sheet = new JRSResume().open(
+          path.join( __dirname, 'resumes/jrs-0.0.0/' + opts.title + '.json' ) );
+      }
+      tryOpen.should.not.Throw();
+    });
+
+    it('should have one or more of each section', function() {
+      var newObj = _.pick( _sheet, opts.sections );
+      expect( Object.keys(newObj).length ).to.equal( opts.sections.length );
+    });
+
+    it('should have a work duration of ' + opts.duration + ' years', function() {
+      _sheet.basics.computed.numYears.should.equal( opts.duration );
+    });
+
+    it('should save without throwing an exception', function() {
+      var that = this;
+      function trySave() {
+        _sheet.save( 'test/sandbox/' + opts.title + '.json' );
+      }
+      trySave.should.not.Throw();
+    });
+
+    it('should not be modified after saving', function() {
+      var savedSheet = new JRSResume().open( 'test/sandbox/' + opts.title + '.json' );
+      _sheet.stringify().should.equal( savedSheet.stringify() );
+    });
+
+    it('should ' + (opts.isValid ? '' : 'NOT ') + 'validate against the JSON Resume schema', function() {
+      var result = _sheet.isValid();
+      // var schemaJson = require('../src/core/resume.json');
+      // var validate = validator( schemaJson, { verbose: true } );
+      // var result = validate( JSON.parse( _sheet.imp.raw ) );
+      result || console.log("\n\nOops, resume didn't validate. " +
+       "Validation errors:\n\n", _sheet.basics.imp.validationErrors, "\n\n");
+      result.should.equal( opts.isValid );
+    });
+
+  });
+}
+
+var sects = [ 'basics', 'work', 'volunteer', 'skills', 'education', 'publications', 'awards', 'references' ];
+
+testResume({ title: 'jane-q-fullstacker', duration: 7, sections: sects });
+testResume({ title: 'jane-incomplete', duration: 0, sections: _.without(sects, 'awards', 'work') });
+testResume({ title: 'richard-hendriks', duration: 1, sections: sects });
+testResume({ title: 'empty', duration: 0, sections: [], isValid: false });

test/test-stdout.js

@@ -0,0 +1,144 @@
+/**
+Output test routines for HackMyResume.
+@module test-stdout.js
+*/
+
+
+
+var chai = require('chai')
+  , expect = chai.expect
+  , HMRMAIN = require('../src/cli/main')
+  , CHALK = require('chalk')
+  , FS = require('fs')
+  , PATH = require('path')
+  , PKG = require('../package.json')
+  , _ = require('underscore');
+
+
+
+var gather = '';
+var ConsoleLogOrg = console.log;
+var ProcessExitOrg = process.exit;
+
+
+
+describe('Testing Ouput interface', function () {
+
+  // TODO: use sinon
+  // Replacement for console.log
+  function MyConsoleLog( msg ) {
+    gather += Array.prototype.slice.call(arguments).join(' ');
+    ConsoleLogOrg.apply(this, arguments);
+  }
+
+  // Replacement for process.exit()
+  function MyProcessExit() {
+
+  }
+
+  // HackMyResume CLI stub. Handle a single HMR invocation.
+  function HackMyResumeStub( args ) {
+
+    console.log = MyConsoleLog;
+    process.exit = MyProcessExit;
+    CHALK.enabled = false;
+
+    try {
+      args.unshift( process.argv[1] );
+      args.unshift( process.argv[0] );
+      var HMRMAIN = require('../src/cli/main');
+      HMRMAIN( args );
+    }
+    catch( ex ) {
+      require('../src/cli/error').err( ex, false );
+    }
+    CHALK.enabled = true;
+    process.exit = ProcessExitOrg;
+    console.log = ConsoleLogOrg;
+
+  }
+
+  // Run a test through the stub, gathering console.log output into "gather"
+  // and testing against it.
+  function run( title, args, tests ) {
+    it( title, function() {
+
+      gather = '';
+      HackMyResumeStub( args );
+
+      expect(
+        _.all( tests, function(t) {
+          return gather.indexOf(t) > -1;
+        })
+      ).to.equal(true);
+
+    });
+  }
+
+  var title = '*** HackMyResume v' + PKG.version + ' ***';
+  var feedMe = 'Please feed me a resume in FRESH or JSON Resume format.';
+  var manPage = FS.readFileSync( PATH.resolve( __dirname, '../src/cli/use.txt' ), 'utf8');
+
+  run('HMR should output a help string when no command is specified',
+      [], [ title, 'Please give me a command (BUILD, ANALYZE, VALIDATE, CONVERT, NEW, or PEEK).' ]);
+
+  run('BUILD should output a tip when no source is specified',
+      ['build'], [ title, feedMe ]);
+
+  run('VALIDATE should output a tip when no source is specified',
+     ['validate'], [ title, feedMe ]);
+
+  run('ANALYZE should output a tip when no source is specified',
+      ['analyze'], [ title, feedMe ]);
+
+  run('BUILD should display an error on a broken resume',
+     ['build',
+      'node_modules/fresh-test-resumes/src/fresh/johnny-trouble.broken.json',
+      '-t', 'modern'
+    ], [ title, 'Error: Invalid or corrupt JSON on line'  ]);
+
+  run('CONVERT should output a tip when no source is specified',
+      ['convert'], [ title, feedMe ]);
+
+  run('NEW should output a tip when no source is specified',
+      ['new'], [ title, 'Please specify the filename of the resume to create.' ]);
+
+  // This will cause the HELP doc to be emitted, followed by an "unknown option --help"
+  // error in the log, based on the way we're calling into HMR. As long as the test
+  // passes, any extraneous error messages can be ignored here.
+  run('HMR should output help doc with --help',
+      ['--help'], [ manPage ]);
+
+  run('HMR should accept raw JSON via --options',
+      [
+        'build',
+        'node_modules/fresh-test-resumes/src/fresh/jane-fullstacker.json',
+        'to',
+        'test/sandbox/temp/janeq-1.all',
+        '-o',
+        "{ theme: 'compact', debug: true, pdf: 'wkhtmltopdf' }"],
+      [ 'Applying COMPACT theme (', '(with wkhtmltopdf)'] );
+
+  run('HMR should accept a JSON settings file via --options',
+      [
+        'build',
+        'node_modules/fresh-test-resumes/src/fresh/jane-fullstacker.json',
+        'to',
+        'test/sandbox/temp/janeq-2.all',
+        '--options',
+        "test/hmr-options.json"],
+      [ 'Applying POSITIVE theme'] );
+
+  run('Explicit command line options should override --options',
+      [
+        'build',
+        'node_modules/fresh-test-resumes/src/fresh/jane-fullstacker.json',
+        'to',
+        'test/sandbox/temp/janeq-3.all',
+        '--options',
+        "test/hmr-options.json",
+        "-t",
+        "modern"
+      ],
+      [ 'Applying MODERN theme'] );
+});

test/test-themes.js

@@ -0,0 +1,86 @@
+
+var chai = require('chai')
+  , expect = chai.expect
+  , should = chai.should()
+  , path = require('path')
+  , _ = require('underscore')
+	, FRESHResume = require('../src/core/fresh-resume')
+  , HMR = require( '../src/hackmyapi')
+  , validator = require('is-my-json-valid')
+  , READFILES = require('recursive-readdir-sync')
+  , fileContains = require('../src/utils/file-contains')
+  , FS = require('fs')
+  , CHALK = require('chalk');
+
+chai.config.includeStack = true;
+
+function genThemes( title, src, fmt ) {
+
+  describe('Testing themes against ' + title.toUpperCase() + ' resume ' + '(' + fmt + ')' , function () {
+
+    var _sheet;
+
+    function genTheme( fmt, src, themeName, themeLoc, testTitle ) {
+      themeLoc = themeLoc || themeName;
+      testTitle = themeName.toUpperCase() + ' theme (' + fmt + ') should generate without throwing an exception';
+      it( testTitle, function () {
+        function tryOpen() {
+          //var src = ['node_modules/jane-q-fullstacker/resume/jane-resume.json'];
+          var dst = ['test/sandbox/' + fmt + '/' + title + '/' + themeName + '/resume.all'];
+          var opts = {
+            theme: themeLoc,
+            format: fmt,
+            prettify: true,
+            silent: false,
+            css: 'embed',
+            debug: true
+          };
+          try {
+            var v = new HMR.verbs.build();
+            v.invoke( src, dst, opts );
+          }
+          catch(ex) {
+            console.error( ex );
+            console.error( ex.stack );
+            throw ex;
+          }
+        }
+        tryOpen.should.not.Throw();
+      });
+    }
+
+    genTheme(fmt, src, 'hello-world');
+    genTheme(fmt, src, 'compact');
+    genTheme(fmt, src, 'modern');
+    genTheme(fmt, src, 'underscore');
+    genTheme(fmt, src, 'awesome');
+    genTheme(fmt, src, 'positive');
+    genTheme(fmt, src, 'jsonresume-theme-boilerplate', 'node_modules/jsonresume-theme-boilerplate' );
+    genTheme(fmt, src, 'jsonresume-theme-sceptile', 'node_modules/jsonresume-theme-sceptile' );
+    genTheme(fmt, src, 'jsonresume-theme-modern', 'node_modules/jsonresume-theme-modern' );
+    genTheme(fmt, src, 'jsonresume-theme-classy', 'node_modules/jsonresume-theme-classy' );
+
+  });
+
+}
+
+function folderContains( needle, haystack ) {
+  return _.some( READFILES( path.join(__dirname, haystack) ), function( absPath ) {
+    if( FS.lstatSync( absPath ).isFile() ) {
+      if( fileContains( absPath, needle ) ) {
+        console.error('Found invalid metadata in ' + absPath);
+        return true;
+      }
+    }
+  });
+}
+
+genThemes( 'jane-q-fullstacker', ['node_modules/fresh-test-resumes/src/fresh/jane-fullstacker.json'], 'FRESH' );
+genThemes( 'johnny-trouble', ['node_modules/fresh-test-resumes/src/fresh/johnny-trouble.json'], 'FRESH' );
+genThemes( 'richard-hendriks', ['test/resumes/jrs-0.0.0/richard-hendriks.json'], 'JRS' );
+
+describe('Verifying generated theme files...', function() {
+  it('Generated files should not contain ICE.', function() {
+    expect( folderContains('@@@@', 'sandbox') ).to.be.false;
+  });
+});

tests/test-sheet.js

@@ -1,67 +0,0 @@
-
-var chai = require('chai')
-  , expect = chai.expect
-  , should = chai.should()
-  , path = require('path')
-  , _ = require('underscore')
-	, Sheet = require('../src/core/sheet')
-  , validator = require('is-my-json-valid');
-
-chai.config.includeStack = false;
-
-describe('fullstack.json', function () {
-
-    var _sheet;
-
-	  it('should open without throwing an exception', function () {
-      function tryOpen() {
-        _sheet = new Sheet().open( 'node_modules/resample/fullstack/in/resume.json' );
-      }
-      tryOpen.should.not.Throw();
-    });
-
-    it('should have one or more of each section', function() {
-      expect(
-        (_sheet.basics) &&
-        (_sheet.work && _sheet.work.length > 0) &&
-        (_sheet.skills && _sheet.skills.length > 0) &&
-        (_sheet.education && _sheet.education.length > 0) &&
-        (_sheet.volunteer && _sheet.volunteer.length > 0) &&
-        (_sheet.publications && _sheet.publications.length > 0) &&
-        (_sheet.awards && _sheet.awards.length > 0)
-      ).to.equal( true );
-    });
-
-    it('should have a work duration of 11 years', function() {
-      _sheet.computed.numYears.should.equal( 11 );
-    });
-
-    it('should save without throwing an exception', function(){
-      function trySave() {
-        _sheet.save( 'tests/sandbox/fullstack.json' );
-      }
-      trySave.should.not.Throw();
-    });
-
-    it('should not be modified after saving', function() {
-      var savedSheet = new Sheet().open( 'tests/sandbox/fullstack.json' );
-      _sheet.stringify().should.equal( savedSheet.stringify() )
-    });
-
-    it('should validate against the JSON Resume schema', function() {
-      var schemaJson = require('../src/core/resume.json');
-      var validate = validator( schemaJson, { verbose: true } );
-      var result = validate( JSON.parse( _sheet.meta.raw ) );
-      result || console.log("\n\nOops, resume didn't validate. " +
-       "Validation errors:\n\n", validate.errors, "\n\n");
-      result.should.equal( true );
-    });
-
-
-});
-
-// describe('subtract', function () {
-// 	it('should return -1 when passed the params (1, 2)', function () {
-// 		expect(math.subtract(1, 2)).to.equal(-1);
-// 	});
-// });