fix: create command glitch

Add support for a "HELP" verb in the HackMyResume CLI, allowing separate help
pages for each HackMyResume command per #205. The following command invocations
are recognized.

    hackmyresume help
    hackmyresume help build
    hackmyresume help new
    hackmyresume help convert
    hackmyresume help analyze
    hackmyresume help validate
    hackmyresume help peek
    hackmyresume help help

.eslintrc.yml

@@ -0,0 +1,17 @@
+env:
+  es6: true
+  node: true
+extends: 'eslint:recommended'
+rules:
+  # indent:
+  #   - error
+  #   - 4
+  linebreak-style:
+    - error
+    - unix
+  quotes:
+    - error
+    - single
+  semi:
+    - error
+    - always

.gitattributes

@@ -1,9 +1,11 @@
 # Auto detect text files and perform LF normalization
+
 * text=auto
 *.js text eol=lf
 *.json text eol=lf
 
 # Standard to msysgit
+
 *.doc	 diff=astextplain
 *.DOC	 diff=astextplain
 *.docx diff=astextplain
@@ -14,3 +16,7 @@
 *.PDF	 diff=astextplain
 *.rtf	 diff=astextplain
 *.RTF	 diff=astextplain
+
+# Git LFS
+
+*.ai filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,3 +1,40 @@
 node_modules/
-tests/sandbox/
+doc/
 docs/
+local/
+npm-debug.log
+*.map
+
+# 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/

.npmignore

@@ -0,0 +1,13 @@
+assets/
+test/
+doc/
+.travis.yml
+.eslintrc.yml
+Gruntfile.js
+.gitattributes
+ROADMAP.md
+BUILDING.md
+CONTRIBUTING.md
+CHANGELOG.md
+FAQ.md
+*.map

.travis.yml

@@ -0,0 +1,23 @@
+sudo: required
+before_install:
+  # Prevents a shared object .so error when running wkhtmltopdf on certain
+  # platforms (e.g., vanilla Ubuntu 16.04 LTS). Not necessary on current Travis.
+  # - sudo apt-get install libxrender1
+install:
+  # Install & link HackMyResume
+  - npm install && npm link
+  # Download and extract the latest wkhtmltopdf binaries
+  - mkdir tmp && wget https://github.com/wkhtmltopdf/wkhtmltopdf/releases/download/0.12.4/wkhtmltox-0.12.4_linux-generic-amd64.tar.xz -O tmp/wk.tar.xz
+  - tar -xf tmp/wk.tar.xz -C ./tmp
+  # Copy wkhtmltopdf binaries to /usr/bin (also makes them path-accessible)
+  - sudo cp -R ./tmp/wkhtmltox/bin/* /usr/bin/
+  # Now you can invoke "wkhtmltopdf" and "wkhtmltoimage" safely in tests.
+  - wkhtmltopdf -V
+  - wkhtmltoimage -V
+language: node_js
+node_js:
+  - "6"
+  - "7"
+  - "8"
+  - "9"
+  - "lts/*"

BUILDING.md

@@ -0,0 +1,50 @@
+Building
+========
+
+*See [CONTRIBUTING.md][contrib] for more information on contributing to the
+HackMyResume or FluentCV projects.*
+
+HackMyResume is a standard Node.js command line app implemented in a mix of
+CoffeeScript and JavaScript. Setting up a build environment is easy:
+
+
+## Prerequisites ##
+
+1. OS: Linux, OS X, or Windows
+
+2. Install [Node.js][node] and [Grunt][grunt].
+
+
+## Set up a build environment ###
+
+1. Fork [hacksalot/HackMyResume][hmr] to your GitHub account.
+
+2. Clone your fork locally.
+
+3. From within the top-level HackMyResume folder, run `npm install` to install
+project dependencies.
+
+4. Create a new branch, based on the latest HackMyResume `dev` branch, to
+contain your work.
+
+5. Run `npm link` in the HackMyResume folder so that the `hackmyresume` command
+will reference your local installation (you may need to
+`npm uninstall -g hackmyresume` first).
+
+## Making changes
+
+1. HackMyResume sources live in the [`/src`][src] folder.
+
+2. When you're ready to submit your changes, run `grunt test` to run the HMR
+test suite. Fix any errors that occur.
+
+3. Commit and push your changes.
+
+4. Submit a pull request targeting the HackMyResume `dev` branch.
+
+
+[node]: https://nodejs.org/en/
+[grunt]: http://gruntjs.com/
+[hmr]: https://github.com/hacksalot/HackMyResume
+[src]: https://github.com/hacksalot/HackMyResume/tree/master/src
+[contrib]: https://github.com/hacksalot/HackMyResume/blob/master/CONTRIBUTING.md

CHANGELOG.md

@@ -0,0 +1,503 @@
+CHANGELOG
+=========
+
+## v1.9.0-beta
+
+*Welcome to the first new version of HackMyResume in over a year. The purpose of
+this release is to gather feature enhancements and bug fixes collected over the
+past 18 months as we reorganize, rebrand, and prepare for the 2.0 release.*
+
+### Added
+
+- Support for **private resume fields**. Mark any non-leaf node in your resume
+JSON with the `private` property and it will be omitted from outbound resumes.
+
+    ```json
+    "employment": {
+      "history": [
+        {
+          "employer": "Acme Real Estate"
+        },
+        {
+          "employer": "Area 51 Alien Research Laboratory",
+          "private": true
+        },
+        {
+          "employer": "H&R Block"
+        }
+      ]
+    }
+    ```
+- Support for **PDF generation through WeasyPrint** in addition to the
+existing support for wkhtmltopdf and PhantomJS.
+
+- Theme authors can now develop and package **custom Handlebars theme helpers**
+via the `helpers` key of the `theme.json` file (FRESH themes only) (#158).
+
+- Help system has been updated with a `HELP` command and dedicated help pages
+for each command.
+
+- Theme authors can **relocate theme assets** with the `baseFolder` property in
+the FRESH `theme.json`.
+
+- HackMyResume will now **validate the options file** (if any) loaded with `-o`
+or `--options` and warn the user if necessary.
+
+- Ability to **disable Handlebars encoding/escaping** of resume fields with
+`--no-escape`.
+
+- Introduced the [fresh-test-themes][ftt] project as a repository for simple,
+test-only resume themes in the FRESH format.
+
+### Changed
+
+- Dropped support for Node 4 and 5. HackMyResume officially runs on Node 6+.
+
+- The FRESCA project has been renamed to [fresh-resume-schema][fresca]. FRESCA
+is still the nickname.
+
+- The HackMyResume web page has moved to https://fluentdesk.com/hackmyresume.
+
+### Fixed
+
+- Fixed an issue that would cause the `convert` command to detect the inbound
+resume type (FRESH or JRS) incorrectly (#162).
+
+- Fixed an issue where generating new JRS resumes would cause a `null` or
+`undefined` error (#165).
+
+- Fixed an issue preventing mixed-case themes from being loaded (#172).
+
+- Fixed an issue requiring JSON Resume themes contain `json-resume-theme` in the
+theme path (#173).
+
+- Fixed an issue that would cause strange `@@@@` characters to appear in
+generated resumes (#207, #168, #198).
+
+- Fixed an issue that would cause resume generation to hang after a JSON Resume
+themed resume was generated (#182).
+
+- Fixed an issue that would cause nothing to be generated for Markdown (.md)
+formats (#179).
+
+- Fixed an issue that would prevent a JRS resume from being converted to FRESH
+via the `convert` command (#180).
+
+- Fixed an issue that would cause broken styling for JSON Resume themes (#155).
+
+### Internal
+
+- Tests: fixed resume duration tests (#181).
+
+- Style: move to
+
+## v1.8.0
+
+### Added
+
+- Updated `Awesome` theme to latest version of [Awesome-CV][acv].
+
+- Introduced new theme helpers: `pad`, `date`.
+
+### Fixed
+
+- Fixed an issue where the `Awesome` theme wouldn't correctly generate LaTeX
+outputs (#138).
+
+- Emit a line number for syntax errors around embedded newlines in JSON strings
+(#137).
+
+- Fix several PDF / PNG generation errors (#132, others).
+
+- Display a more helpful error message when attempting to generate a PDF or PNG
+on a machine where PhantomJS and/or wkhtmltopdf are either not installed or
+not path-accessible.
+
+- Fixed an issue that would cause long-running PDF/PNG generation to fail in
+certain environments.
+
+- Fixed an issue involving an unhelpful spawn-related exception (#136).
+
+### Internal
+
+- JSHint will no longer gripe at the use of `== null` and `!= null` in
+CoffeeScript transpilation.
+
+- Introduced [template-friendly Awesome-CV fork][awefork] to isolate template
+expansion logic & provide better durability for HackMyResume's `awesome` theme.
+
+- Fixed a couple temporary regressions (#139, #140) on the dev branch.
+
+- Additional tests.
+
+- Minor breaking HackMyResume API changes.
+
+## v1.7.4
+
+### Added
+
+- [Build instructions](https://github.com/hacksalot/HackMyResume/blob/master/BUILDING.md).
+
+### Changed
+
+- More precise date handling.
+
+### Fixed
+
+- Issue with incomplete PDF generation (#127).
+
+- Issue with building JSON Resume themes (#128).
+
+- Issue with generating `.json` output format by itself (#97).
+
+## v1.7.3
+
+### Fixed
+
+- Issue with generated PDFs being chopped off and displaying a mysterious sequence of numbers of unknown and possibly alien origin (#127).
+
+- Unsightly border on Modern:PDF.
+
+- Modern|Positive:PDF formats now correctly reference their PDF-specific CSS files.
+
+- `Incorrect helper use` warning in Positive:DOC.
+
+## v1.7.2
+
+### Changed
+
+- Interim release supporting FluentCV Desktop.
+
+### Internal
+
+- Moved [HackMyCore](https://github.com/hacksalot/HackMyCore) dependency to
+submodule.
+
+## v1.7.1
+
+### Changed
+
+- Caffeinate. CoffeeScript now used throughout
+[HackMyResume](https://github.com/hacksalot/HackMyResume) and
+[HackMyCore](https://github.com/hacksalot/HackMyCore); generated JavaScript
+lives in `/dist`.
+
+### Fixed
+
+- Issue with generating a single PDF with the `.pdf` extension (#99).
+
+## v1.7.0
+
+### Changed
+
+- [Internal] Relocated HMR processing code to the
+[HackMyCore](https://github.com/hacksalot/HackMyCore) project. Shouldn't affect
+normal use.
+
+## 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/fresh-standard/fresh-resume-schema
+[themes]: https://github.com/fresh-standard/fresh-themes
+[awefork]: https://github.com/fluentdesk/Awesome-CV
+[acv]: https://github.com/posquit0/Awesome-CV
+[ftt]: https://github.com/fresh-standard/fresh-test-themes

CONTRIBUTING.md

@@ -0,0 +1,53 @@
+Contributing
+============
+
+*Note: HackMyResume is also available as [FluentCV][fcv]. Contributors are
+credited in both.*
+
+## How To Contribute
+
+*See [BUILDING.md][building] for instructions on setting up a HackMyResume
+development environment.*
+
+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 `grunt 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@fluentdesk.com
+```
+
+You can reach hacksalot directly at:
+
+```
+hacksalot@indevious.com
+```
+
+Thanks for your interest in the HackMyResume project.
+
+[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
+[building]: https://github.com/hacksalot/HackMyResume/blob/master/BUILDING.md

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

@@ -14,46 +14,39 @@ module.exports = function (grunt) {
         ui: 'bdd',
         reporter: 'spec'
       },
-      all: { src: ['tests/*.js'] }
+      all: { src: ['test/*.js'] }
     },
 
-    clean: ['tests/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/'
-        }
-      }
+    clean: {
+      test: ['test/sandbox']
     },
 
-    jshint: {
-      options: {
-        laxcomma: true,
-        expr: true
-      },
-      all: ['Gruntfile.js', 'src/**/*.js', 'test/**/*.js']
+    eslint: {
+      target: ['Gruntfile.js', 'src/**/*.js', 'test/*.js']
     }
 
   };
 
   grunt.initConfig( opts );
-
   grunt.loadNpmTasks('grunt-simple-mocha');
-  grunt.loadNpmTasks('grunt-contrib-yuidoc');
-  grunt.loadNpmTasks('grunt-contrib-jshint');
+  grunt.loadNpmTasks('grunt-eslint');
   grunt.loadNpmTasks('grunt-contrib-clean');
 
-  grunt.registerTask('test', 'Test the HackMyResume library.',
-    function( config ) { grunt.task.run( ['clean','simplemocha:all'] ); });
-  grunt.registerTask('document', 'Generate HackMyResume library documentation.',
-    function( config ) { grunt.task.run( ['yuidoc'] ); });
-  grunt.registerTask('default', [ 'jshint', 'test', 'yuidoc' ]);
+  // Use 'grunt test' for local testing
+  grunt.registerTask('test', 'Test the HackMyResume application.',
+    function() {
+      grunt.task.run(['clean:test','build','eslint','simplemocha:all']);
+    }
+  );
+
+  // Use 'grunt build' to build HMR
+  grunt.registerTask('build', 'Build the HackMyResume application.',
+    function() {
+      grunt.task.run( ['eslint'] );
+    }
+  );
+
+  // Default task does everything
+  grunt.registerTask('default', [ 'test' ]);
 
 };

LICENSE.md

@@ -1,7 +1,7 @@
 The MIT License
 ===============
 
-Copyright (c) 2015 James M. Devlin (https://github.com/hacksalot)
+Copyright (c) 2015-2018 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,11 +1,17 @@
 HackMyResume
-============
+===
+
+[![Latest release][img-release]][latest-release]
+[![Build status (MASTER)][img-master]][travis-url-master]
+[![Build status (DEV)][img-dev]][travis-url-dev]
+[![Join the chat at https://gitter.im/hacksalot/HackMyResume][badge]][gh]
+
 *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.*
 
-![](assets/resume-bouqet.png)
+![](assets/hmr_build.png)
 
 HackMyResume is a dev-friendly, local-only Swiss Army knife for resumes and CVs.
 Use it to:
@@ -13,80 +19,149 @@ 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. **Convert** resumes between [FRESH][fresca] and [JSON Resume][6] formats.
-3. **Validate** resumes against either format.
+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.
+or Windows. View the [FAQ](FAQ.md).
+
+![](assets/hmr_analyze.png)
 
 ## Features
 
 - 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.
+- Updated daily / weekly. Contributions are [welcome](CONTRIBUTING.md).
 
 ## Install
 
-Install HackMyResume with NPM:
+Install the latest stable version of HackMyResume with NPM:
 
 ```bash
 [sudo] npm install hackmyresume -g
 ```
 
-Note: for PDF generation you'll need to install a copy of [wkhtmltopdf][3] for
-your platform. For LaTeX generation you'll need a valid LaTeX environment with
-access to `xelatex` and similar.
+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 one of [Phantom.js][2],
+[wkhtmltopdf][3], or [WeasyPrint][11] to be installed on your system and the
+corresponding binary 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 four basic commands you should be aware of:
+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
+    # 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
+    # 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.
+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
+    # 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
+    # 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:
@@ -95,9 +170,9 @@ 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).
-MS Word | .doc | A Microsoft Word office document.
-Adobe Acrobat (PDF) | .pdf | A binary PDF document driven by an HTML theme.
+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.
@@ -105,22 +180,13 @@ RTF | .rtf | Forthcoming.
 Textile | .textile | Forthcoming.
 image | .png, .bmp | Forthcoming.
 
-## Install
-
-HackMyResume requires a recent version of [Node.js][4] and [NPM][5]. Then:
-
-1. Install the latest official [wkhtmltopdf][3] binary for your platform.
-2. Optionally install an updated LaTeX environment (LaTeX resumes only).
-2. Install **HackMyResume** with `[sudo] npm install hackmyresume -g`.
-3. You're ready to go.
-
 ## Use
 
 Assuming you've got a JSON-formatted resume handy, generating resumes in
-different formats and combinations easy. Just run:
+different formats and combinations is easy. Just run:
 
 ```bash
-hackmyresume BUILD <INPUTS> <OUTPUTS> [-t theme].
+hackmyresume build <inputs> to <outputs> [-t theme].
 ```
 
 Where `<INPUTS>` is one or more .json resume files, separated by spaces;
@@ -129,7 +195,7 @@ theme (default to Modern). For example:
 
 ```bash
 # Generate all resume formats (HTML, PDF, DOC, TXT, YML, etc.)
-hackmyresume build resume.json -o out/resume.all -t modern
+hackmyresume build resume.json TO out/resume.all -t modern
 
 # Generate a specific resume format
 hackmyresume build resume.json TO out/resume.html
@@ -147,7 +213,7 @@ hackmyresume build in1.json in2.json TO out.html out.doc out.pdf
 You should see something to the effect of:
 
 ```
-*** HackMyResume v0.9.0 ***
+*** HackMyResume v1.4.0 ***
 Reading JSON resume: foo/resume.json
 Applying MODERN Theme (7 formats)
 Generating HTML resume: out/resume.html
@@ -163,17 +229,36 @@ 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
-hackmyresume build resume.json -t modern
-hackmyresume build resume.json -t ~/foo/bar/my-custom-theme/
+hackmyresume build resume.json TO out/rez.all -t [theme]
 ```
 
-As of v1.0.0, available predefined themes are `positive`, `modern`, `compact`,
-`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
 
@@ -182,7 +267,7 @@ most generic to most specific:
 
 ```bash
 # Merge specific.json onto base.json and generate all formats
-hackmyresume build 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
@@ -209,14 +294,7 @@ You can specify **multiple output targets** and HackMyResume will build them:
 
 ```bash
 # Generate out1.doc, out1.pdf, and foo.txt from me.json.
-hackmyresume build 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 "hackmyresume resume.json resume.all -t modern"
-hackmyresume build resume.json
+hackmyresume build me.json TO out1.doc out1.pdf foo.txt
 ```
 
 ### Using .all
@@ -226,13 +304,144 @@ formats for the given resume. For example, this...
 
 ```bash
 # Generate all resume formats (HTML, PDF, DOC, TXT, etc.)
-hackmyresume build me.json -o out/resume.all
+hackmyresume build me.json TO out/resume.all
 ```
 
 ..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 any of...
+
+- [wkhtmltopdf][3]
+- [Phantom.js][2]
+- [WeasyPrint][11]
+
+..with support for other engines planned in the future. But for now, **one or
+more 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
+weasyprint 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 weasyprint
+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 /
@@ -247,7 +456,7 @@ hackmyresume validate resumeA.json resumeB.json
 HackMyResume will validate each specified resume in turn:
 
 ```bash
-*** HackMyResume v0.9.0 ***
+*** HackMyResume v1.6.0 ***
 Validating JSON resume: resumeA.json (INVALID)
 Validating JSON resume: resumeB.json (VALID)
 ```
@@ -258,7 +467,7 @@ HackMyResume can convert between the [FRESH][fresca] and [JSON Resume][6]
 formats. Just run:
 
 ```bash
-hackmyresume CONVERT <INPUTS> <OUTPUTS>
+hackmyresume convert <INPUTS> <OUTPUTS>
 ```
 
 where <INPUTS> is one or more resumes in FRESH or JSON Resume format, and
@@ -266,14 +475,52 @@ where <INPUTS> is one or more resumes in FRESH or JSON Resume format, and
 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.
+
+```json
+{
+  "theme": "compact",
+
+  "sectionTitles": {
+    "employment": "Work"
+  },
+
+  "wkhtmltopdf": {
+    "margin-top": "20mm"
+  }
+}
+```
+
+If an option is specified on both the command line and in an external options
+file, the command-line option wins.
+
+```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
 
 HackMyResume applies [js-beautify][10]-style HTML prettification by default to
-HTML-formatted resumes. To disable prettification, the `--nopretty` or `-n` flag
-can be used:
+HTML-formatted resumes. To disable prettification, the `--no-prettify` or `-n`
+flag can be used:
 
 ```bash
-hackmyresume generate resume.json out.all --nopretty
+hackmyresume build resume.json out.all --no-prettify
 ```
 
 ### Silent Mode
@@ -281,10 +528,91 @@ hackmyresume generate resume.json out.all --nopretty
 Use `-s` or `--silent` to run in silent mode:
 
 ```bash
-hackmyresume generate resume.json -o someFile.all -s
-hackmyresume generate 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
+```
+
+### Disable Encoding
+
+Use the `--no-escape` option to disable encoding in Handlebars themes. Note:
+this option has no effect for non-Handlebars themes.
+
+```bash
+hackmyresume build resume.json --no-escape
+```
+
+### Private Resume Fields
+
+Have a gig, education stint, membership, or other relevant history that you'd
+like to hide from *most* (e.g. public) resumes but sometimes show on others? Tag it with
+`"private": true` to omit it from outbound generated resumes by default.
+
+
+```json
+"employment": {
+  "history": [
+    {
+      "employer": "Acme Real Estate"
+    },
+    {
+      "employer": "Area 51 Alien Research Laboratory",
+      "private": true
+    },
+    {
+      "employer": "H&R Block"
+    }
+  ]
+}
+```
+
+Then, when you want a copy of your resume that includes the private gig / stint
+/ etc., tell HackMyResume that it's OK to emit private fields. The way you do
+that is with the `--private` switch.
+
+```bash
+hackmyresume build resume.json private-resume.all --private
+```
+
+
+### Custom theme helpers
+
+You can attach your own custom Handlebars helpers to a FRESH theme with the
+`helpers` key of your theme's `theme.json` file.
+
+```js
+{
+  "title": "my-cool-theme",
+
+  // ...
+
+  "helpers": [
+    "../path/to/helpers/*.js",
+    "some-other-helper.js"
+  ]
+}
+```
+
+HackMyResume will attempt to load each path or glob and register any specified
+files with [Handlebars.registerHelper][hrh], making them available to your
+theme.
+
+
+## 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 in
+time. See [CONTRIBUTING.md][contribute] for details.
+
 ## License
 
 MIT. Go crazy. See [LICENSE.md][1] for details.
@@ -299,6 +627,19 @@ 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
+[11]: http://weasyprint.org/
 [fresh]: https://github.com/fluentdesk/FRESH
-[fresca]: https://github.com/fluentdesk/FRESCA
+[fresca]: https://github.com/fresh-standard/fresh-resume-schema
 [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
+[gh]: https://gitter.im/hacksalot/HackMyResume?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+[badge]: https://badges.gitter.im/hacksalot/HackMyResume.svg
+[hrh]: http://handlebarsjs.com/reference.html#base-registerHelper

ROADMAP.md

@@ -0,0 +1,107 @@
+Development Roadmap
+===================
+
+## Short-Term
+
+### FluentCV Desktop: Beta 1
+
+The **FluentCV Desktop 1.0 beta release** will present HackMyResume
+functionality in a cross-platform desktop application for OS X, Linux, and
+Windows.
+
+### GitHub Integration
+
+HackMyResume will offer GitHub integration for versioned resume storage and
+retrieval via the `COMMIT` or `STORE` command(s) starting in 1.7.0 or 1.8.0.
+
+### fresh-themes 1.0.0
+
+The **fresh-themes 1.0** release will bring 100% coverage of the FRESH and JRS
+object models—all resume sections and fields—along with
+documentation, theme developer's guide, new themes, and a freeze to the FRESH
+theme structure.
+
+### Better LaTeX support
+
+Including Markdown-to-LaTeX translation and more LaTeX-driven themes / formats.
+
+### StackOverflow and LinkedIn support
+
+Will start appearing in v1.7.0, with incremental improvements in 1.8.0 and
+beyond.
+
+### Improved resume sorting and arranging
+
+**Better resume sorting** of items and sections: ascending, descending, by
+date or other criteria ([#67][i67]).
+
+### Remote resume / theme loading
+
+Support remote loading of themes and resumes over `http`, `https`, and
+`git://`. Enable these usage patterns:
+
+    ```bash
+    hackmyresume build https://somesite.com/my-resume.json -t informatic
+
+    hackmyresume build resume.json -t npm:fresh-theme-ergonomic
+
+    hackmyresume analyze https://github.com/foo/my-resume
+    ```
+
+### 100% code coverage
+
+Should reduce certain classes of errors and allow HMR to display a nifty 100%
+code coverage badge.
+
+### Improved **documentation and samples**
+
+Expanded documentation and samples throughout.
+
+## Mid-Term
+
+### Cover letters and job descriptions
+
+Add support for schema-driven **cover letters** and **job descriptions**.
+
+### Character Sheets
+
+HackMyResume 2.0 will ship with support for, yes, RPG-style character sheets.
+This will demonstrate the tool's ability to flow arbitrary JSON to concrete
+document(s) and provide unique albeit niche functionality around various games
+([#117][i117]).
+
+### Rich text (.rtf) output formats
+
+Basic support for **rich text** `.rtf` output formats.
+
+### Investigate: groff support
+
+Investigate adding [**groff**][groff] support, because that would, indeed, be
+[dope][d] ([#37][i37]).
+
+### Investigate: org-mode support
+
+Investigate adding [**org mode**][om] support ([#38][i38]).
+
+### Investigate: Scribus
+
+Investigate adding [**Scribus SLA**][scri] support ([#54][i54]).
+
+### Support JSON Resume 1.0.0
+
+When released.
+
+## Long-Term
+
+- TBD
+
+[groff]: http://www.gnu.org/software/groff/
+[om]: http://orgmode.org/
+[scri]: https://en.wikipedia.org/wiki/Scribus
+[d]: https://github.com/hacksalot/HackMyResume/issues/37#issue-123818674
+[i37]: https://github.com/hacksalot/HackMyResume/issues/37
+[i38]: https://github.com/hacksalot/HackMyResume/issues/38
+[i54]: https://github.com/hacksalot/HackMyResume/issues/54
+[i67]: https://github.com/hacksalot/HackMyResume/issues/67
+[i107]: https://github.com/hacksalot/HackMyResume/issues/107
+[i117]: https://github.com/hacksalot/HackMyResume/issues/117

assets/logo/hackmyresume-logo.ai

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a476ee59e7d86b5a7599780b5efca57ee6b6d60e1a722343277057ea793703b6
+size 1642116

package.json

@@ -1,11 +1,15 @@
 {
   "name": "hackmyresume",
-  "version": "1.2.0",
+  "version": "1.9.0-beta",
   "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/hacksalot/HackMyResume.git"
   },
+  "scripts": {
+    "test": "grunt clean:test && mocha --exit",
+    "grunt": "grunt"
+  },
   "keywords": [
     "resume",
     "CV",
@@ -24,46 +28,82 @@
     "Underscore",
     "template"
   ],
-  "author": "hacksalot <hacksalot@fluentdesk.com> (https://github.com/hacksalot)",
+  "author": "hacksalot <hacksalot@indevious.com> (https://github.com/hacksalot)",
+  "contributors": [
+    "aruberto (https://github.com/aruberto)",
+    "daniele-rapagnani (https://github.com/daniele-rapagnani)",
+    "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)"
+  ],
   "license": "MIT",
   "preferGlobal": "true",
   "bugs": {
     "url": "https://github.com/hacksalot/HackMyResume/issues"
   },
-  "main": "src/hackmycmd.js",
   "bin": {
-    "hackmyresume": "src/index.js"
+    "hackmyresume": "src/cli/index.js"
   },
+  "main": "src/index.js",
   "homepage": "https://github.com/hacksalot/HackMyResume",
   "dependencies": {
-    "colors": "^1.1.2",
-    "fluent-themes": "~0.7.0-beta",
-    "fresca": "~0.2.2",
-    "fs-extra": "^0.24.0",
+    "chalk": "^2.3.1",
+    "commander": "^2.9.0",
+    "copy": "^0.3.1",
+    "escape-latex": "^1.0.0",
+    "extend": "^3.0.0",
+    "fresh-jrs-converter": "^1.0.0",
+    "fresh-resume-schema": "^1.0.0-beta",
+    "fresh-resume-starter": "^0.3.1",
+    "fresh-resume-validator": "^0.2.0",
+    "fresh-themes": "^0.17.0-beta",
+    "fs-extra": "^5.0.0",
+    "glob": "^7.1.2",
     "handlebars": "^4.0.5",
-    "html": "0.0.10",
-    "is-my-json-valid": "^2.12.2",
-    "jst": "0.0.13",
+    "html": "^1.0.0",
+    "is-my-json-valid": "^2.12.4",
+    "json-lint": "^0.1.0",
+    "jsonlint": "^1.6.2",
+    "lodash": "^4.17.5",
     "marked": "^0.3.5",
-    "minimist": "^1.2.0",
     "mkdirp": "^0.5.1",
-    "moment": "^2.10.6",
+    "moment": "^2.11.1",
+    "parse-filepath": "^1.0.2",
+    "path-exists": "^3.0.0",
+    "pinkie-promise": "^2.0.0",
+    "printf": "^0.2.3",
     "recursive-readdir-sync": "^1.0.6",
-    "simple-html-tokenizer": "^0.2.0",
+    "simple-html-tokenizer": "^0.4.3",
+    "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",
+    "word-wrap": "^1.1.0",
     "xml-escape": "^1.0.0",
-    "yamljs": "^0.2.4"
+    "yamljs": "^0.3.0"
   },
   "devDependencies": {
     "chai": "*",
+    "chai-as-promised": "^7.1.1",
+    "dir-compare": "^1.4.0",
+    "fresh-test-resumes": "^0.9.2",
+    "fresh-test-themes": "^0.2.0",
+    "fresh-theme-underscore": "^0.1.1",
     "grunt": "*",
-    "grunt-contrib-clean": "^0.7.0",
-    "grunt-contrib-jshint": "^0.11.3",
-    "grunt-contrib-yuidoc": "^0.10.0",
+    "grunt-contrib-clean": "^1.1.0",
+    "grunt-contrib-coffee": "^2.0.0",
+    "grunt-contrib-copy": "^1.0.0",
+    "grunt-eslint": "^20.1.0",
     "grunt-simple-mocha": "*",
-    "jane-q-fullstacker": "fluentdesk/jane-q-fullstacker",
+    "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"
+    "stripcolorcodes": "^0.1.0"
   }
 }

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,328 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Error-handling routines for HackMyResume.
+@module cli/error
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const HMSTATUS = require('../core/status-codes');
+const FS = require('fs');
+const PATH = require('path');
+const WRAP = require('word-wrap');
+const M2C = require('../utils/md2chalk');
+const chalk = require('chalk');
+const extend = require('extend');
+const printf = require('printf');
+const SyntaxErrorEx = require('../utils/syntax-error-ex');
+require('string.prototype.startswith');
+
+
+
+/** Error handler for HackMyResume. All errors are handled here.
+@class ErrorHandler */
+module.exports = {
+
+  init( debug, assert, silent ) {
+    this.debug = debug;
+    this.assert = assert;
+    this.silent = silent;
+    this.msgs = require('./msg').errors;
+    return this;
+  },
+
+  err( ex, shouldExit ) {
+
+    // Short-circuit logging output if --silent is on
+    let stack;
+    const 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').errors;
+
+    // Handle packaged HMR exceptions
+    if (ex.fluenterror) {
+
+      // Output the error message
+      const objError = assembleError.call(this, ex);
+      o( this[ `format_${objError.etype}` ]( objError.msg ));
+
+      // Output the stack (sometimes)
+      if (objError.withStack) {
+        stack = ex.stack || (ex.inner && ex.inner.stack);
+        stack && o( chalk.gray( stack ) );
+      }
+
+      // Quit if necessary
+      if (shouldExit || ex.exit) {
+        if (this.debug) {
+          o(chalk.cyan(`Exiting with error code ${ex.fluenterror.toString()}`));
+        }
+        if (this.assert) {
+          ex.pass = true;
+          throw ex;
+        }
+        return process.exit(ex.fluenterror);
+      }
+
+    // Handle raw exceptions
+    } else {
+      o(ex);
+      const stackTrace = ex.stack || (ex.inner && ex.inner.stack);
+      if (stackTrace && this.debug) {
+        return o(M2C(ex.stack || ex.inner.stack, 'gray'));
+      }
+    }
+  },
+
+
+
+  format_error( msg ) {
+    msg = msg || '';
+    return chalk.red.bold( msg.toUpperCase().startsWith('ERROR:') ? msg : `Error: ${msg}` );
+  },
+
+
+  format_warning( brief, msg ) {
+    return chalk.yellow(brief) + chalk.yellow(msg || '');
+  },
+
+
+  format_custom( msg ) { return msg; }
+};
+
+
+var _defaultLog = function() { return console.log.apply(console.log, arguments); }; // eslint-disable-line no-console
+
+
+
+
+var assembleError = function( ex ) {
+
+  let se;
+  let msg = '';
+  let withStack = false;
+  let quit = false;
+  let 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' );
+      msg += M2C(FS.readFileSync(
+        PATH.resolve(__dirname, `help/${ex.verb}.txt`), 'utf8' ), 'white', 'yellow');
+      break;
+
+    case HMSTATUS.missingCommand:
+      // msg = M2C( this.msgs.missingCommand.msg + " (", 'yellow');
+      // msg += Object.keys( FCMD.verbs ).map( (v, idx, ar) ->
+      //   return ( if idx == ar.length - 1 then chalk.yellow('or ') else '') +
+      //     chalk.yellow.bold(v.toUpperCase());
+      // ).join( chalk.yellow(', ')) + chalk.yellow(").\n\n");
+
+      msg += M2C(FS.readFileSync(
+        PATH.resolve(__dirname, 'help/use.txt'), 'utf8' ), 'white', 'yellow');
+      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}`); }
+      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) {
+        return 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) {
+        // eslint-disable-next-line no-console
+        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)) {
+        // eslint-disable-next-line no-console
+        console.error(printf( M2C(this.msgs.readError.msg, 'red'), ex.file ));
+        se = new SyntaxErrorEx(ex, ex.raw);
+        if ((se.line != null) && (se.col != null)) {
+          msg = printf(M2C( this.msgs.parseError.msg[0], 'red' ), se.line, se.col);
+        } else if (se.line != null) {
+          msg = printf(M2C( this.msgs.parseError.msg[1], 'red' ), se.line);
+        } else {
+          msg = M2C(this.msgs.parseError.msg[2], 'red');
+        }
+      } else if (ex.inner && (ex.inner.line != null) && (ex.inner.col != null)) {
+        msg = printf( M2C( this.msgs.parseError.msg[0], 'red' ), ex.inner.line, ex.inner.col);
+      } else {
+        msg = ex;
+      }
+      etype = 'error';
+      break;
+
+    case HMSTATUS.createError:
+      // inner.code could be EPERM, EACCES, etc
+      msg = printf(M2C( this.msgs.createError.msg ), ex.inner.path);
+      etype = 'error';
+      break;
+
+    case HMSTATUS.validateError:
+      msg = printf(M2C( this.msgs.validateError.msg ), ex.inner.toString());
+      etype = 'error';
+      break;
+
+    case HMSTATUS.invalidOptionsFile:
+      msg = M2C(this.msgs.invalidOptionsFile.msg[0]);
+      if (SyntaxErrorEx.is(ex.inner)) {
+        // eslint-disable-next-line no-console
+        console.error(printf( M2C(this.msgs.readError.msg, 'red'), ex.file ));
+        se = new SyntaxErrorEx(ex, ex.raw);
+        if ((se.line != null) && (se.col != null)) {
+          msg += printf(M2C( this.msgs.parseError.msg[0], 'red' ), se.line, se.col);
+        } else if (se.line != null) {
+          msg += printf(M2C( this.msgs.parseError.msg[1], 'red' ), se.line);
+        } else {
+          msg += M2C(this.msgs.parseError.msg[2], 'red');
+        }
+      } else if (ex.inner && (ex.inner.line != null) && (ex.inner.col != null)) {
+        msg += printf( M2C( this.msgs.parseError.msg[0], 'red' ), ex.inner.line, ex.inner.col);
+      } else {
+        msg += ex;
+      }
+      msg += this.msgs.invalidOptionsFile.msg[1];
+      etype = 'error';
+      break;
+
+    case HMSTATUS.optionsFileNotFound:
+      msg = M2C( this.msgs.optionsFileNotFound.msg );
+      etype = 'error';
+      break;
+
+    case HMSTATUS.unknownSchema:
+      msg = M2C( this.msgs.unknownSchema.msg[0] );
+      //msg += "\n" + M2C( @msgs.unknownSchema.msg[1], 'yellow' )
+      etype = 'error';
+      break;
+
+    case HMSTATUS.themeHelperLoad:
+      msg = printf(M2C( this.msgs.themeHelperLoad.msg ), ex.glob);
+      etype = 'error';
+      break;
+
+    case HMSTATUS.invalidSchemaVersion:
+      msg = printf(M2C( this.msgs.invalidSchemaVersion.msg ), ex.data);
+      etype = 'error';
+      break;
+  }
+
+  return {
+    msg,              // The error message to display
+    withStack,  // Whether to include the stack
+    quit,
+    etype
+  };
+};

src/cli/help/analyze.txt

@@ -0,0 +1,25 @@
+**analyze** | Analyze a resume for statistical insight
+
+Usage:
+
+   **hackmyresume ANALYZE <resume>**
+
+   The ANALYZE command evaluates the specified resume(s) for
+   coverage, duration, gaps, keywords, and other metrics.
+
+   This command can be run against multiple resumes. Each
+   will be analyzed in turn.
+
+Parameters:
+
+   **<resume>**
+
+      Path to a FRESH or JRS resume. Multiple resumes can be
+      specified, separated by spaces.
+
+      hackmyresume ANALYZE resume.json
+      hackmyresume ANALYZE r1.json r2.json r3.json
+
+Options:
+
+   **None.**

src/cli/help/build.txt

@@ -0,0 +1,69 @@
+**build** | Generate themed resumes in multiple formats
+
+Usage:
+
+   **hackmyresume BUILD <resume> TO <target> [--theme]**
+      **[--pdf] [--no-escape] [--private]**
+
+   The BUILD command generates themed resumes and CVs in
+   multiple formats. Use it to create outbound resumes in
+   specific formats such HTML, MS Word, and PDF.
+
+Parameters:
+
+   **<resume>**
+
+      Path to a FRESH or JRS resume (*.json) containing your
+      resume data. Multiple resumes may be specified.
+
+      If multiple resumes are specified, they will be merged
+      into a single resume prior to transformation.
+
+   **<target>**
+
+      Path to the desired output resume. Multiple resumes
+      may be specified. The file extension will determine
+      the format.
+
+         .all        Generate all supported formats
+         .html       HTML 5
+         .doc        MS Word
+         .pdf        Adobe Acrobat PDF
+         .txt        plain text
+         .md         Markdown
+         .png        PNG Image
+         .latex      LaTeX
+
+      Note: not all formats are supported by all themes!
+      Check the theme's documentation for details or use
+      the .all extension to build all available formats.
+
+Options:
+
+   **--theme -t <theme-name-or-path>**
+
+      Path to a FRESH or JSON Resume theme OR the name of a
+      built-in theme. Valid theme names are 'modern',
+      'positive', 'compact', 'awesome', and 'basis'.
+
+   **--pdf -p <engine>**
+
+      Specify the PDF engine to use. Legal values are
+      'none', 'wkhtmltopdf', 'phantom', or 'weasyprint'.
+
+   **--no-escape**
+
+      Disable escaping / encoding of resume data during
+      resume generation. Handlebars themes only.
+
+   **--private**
+
+      Include resume fields marked as private.
+
+Notes:
+
+The BUILD command can be run against multiple source as well
+as multiple target resumes. If multiple source resumes are
+provided, they will be merged into a single source resume
+before generation. If multiple output resumes are provided,
+each will be generated in turn.

src/cli/help/convert.txt

@@ -0,0 +1,33 @@
+**convert** | Convert resumes between FRESH and JRS formats
+
+Usage:
+
+   **hackmyresume CONVERT <resume> TO <target> [--format]**
+
+   The CONVERT command converts one or more resume documents
+   between the FRESH Resume Schema and JSON Resume formats.
+
+Parameters:
+
+   **<resume>**
+
+      Path to a FRESH or JRS resume. Multiple resumes can be
+      specified.
+
+   **<targets>**
+
+      The path of the converted resume. Multiple resumes can
+      be specified, one per provided input resume.
+
+Options:
+
+   **--format -f <fmt>**
+
+      The desired format for the new resume(s). Valid values
+      are 'FRESH', 'JRS', or, to target the latest edge
+      version of the JSON Resume Schema, 'JRS@1'.
+
+      If this parameter is omitted, the destination format
+      will be inferred from the source resume's format. If
+      the source format is FRESH, the destination format
+      will be JSON Resume, and vice-versa.

src/cli/help/help.txt

@@ -0,0 +1,23 @@
+**help** | View help on a specific HackMyResume command
+
+Usage:
+
+   **hackmyresume HELP [<command>]**
+
+   The HELP command displays help information for a specific
+   HackMyResume command, including the HELP command itself.
+
+Parameters:
+
+   **<command>**
+
+      The HackMyResume command to view help information for.
+      Must be BUILD, NEW, CONVERT, ANALYZE, VALIDATE, PEEK,
+      or HELP.
+
+         hackmyresume help convert
+         hackmyresume help help
+
+Options:
+
+   **None.**

src/cli/help/new.txt

@@ -0,0 +1,29 @@
+**new** | Create a new FRESH or JRS resume document
+
+Usage:
+
+   **hackmyresume NEW <fileName> [--format]**
+
+   The NEW command generates a new resume document in FRESH
+   or JSON Resume format. This document can serve as an
+   official source of truth for your resume and career data
+   as well an input to tools like HackMyResume.
+
+Parameters:
+
+   **<fileName>**
+
+      The filename (relative or absolute path) of the resume
+      to be created. Multiple resume paths can be specified,
+      and each will be created in turn.
+
+         hackmyresume NEW resume.json
+         hackmyresume NEW r1.json foo/r2.json ../r3.json
+
+Options:
+
+   **--format -f <fmt>**
+
+      The desired format for the new resume(s). Valid values
+      are 'FRESH', 'JRS', or, to target the latest edge
+      version of the JSON Resume Schema, 'JRS@1'.

src/cli/help/peek.txt

@@ -0,0 +1,31 @@
+**peek** | View portions of a resume from the command line
+
+Usage:
+
+   **hackmyresume PEEK <resume> <at>**
+
+   The PEEK command displays a specific piece or part of the
+   resume without requiring the resume to be opened in an
+   editor.
+
+Parameters:
+
+   **<resume>**
+
+     Path to a FRESH or JRS resume. Multiple resumes can be
+     specified, separated by spaces.
+
+         hackmyresume PEEK r1.json r2.json r3.json "employment.history[2]"
+
+   **<at>**
+
+      The resume property or field to be displayed. Can be
+      any valid resume path, for example:
+
+         education[0]
+         info.name
+         employment.history[3].start
+
+Options:
+
+   **None.**

src/cli/help/use.txt

@@ -0,0 +1,70 @@
+**HackMyResume** | A Swiss Army knife for resumes and CVs
+
+Usage:
+
+   **hackmyresume [--version] [--help] [--silent] [--debug]**
+      **[--options] [--no-colors] <command> [<args>]**
+
+Commands: (type "hackmyresume help COMMAND" for details)
+
+   **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.
+   **NEW**           Create a new resume in FRESH or JSON Resume format.
+   **CONVERT**       Convert your resume between FRESH and JSON Resume.
+   **PEEK**          View a specific field or element on your resume.
+   **HELP**          View help on a specific HackMyResume command.
+
+Common Tasks:
+
+   Generate a resume in a specific format (HTML, Word, PDF, etc.)
+
+      **hackmyresume build rez.json to out/rez.html**
+      **hackmyresume build rez.json to out/rez.doc**
+      **hackmyresume build rez.json to out/rez.pdf**
+      **hackmyresume build rez.json to out/rez.txt**
+      **hackmyresume build rez.json to out/rez.md**
+      **hackmyresume build rez.json to out/rez.png**
+      **hackmyresume build rez.json to out/rez.tex**
+
+   Build a resume to ALL available formats:
+
+      **hackmyresume build rez.json to out/rez.all**
+
+   Build a resume with a specific theme:
+
+      **hackmyresume build rez.json to out/rez.all -t themeName**
+
+   Create a new empty resume:
+
+      **hackmyresume new rez.json**
+
+   Convert a resume between FRESH and JRS formats:
+
+      **hackmyresume convert rez.json converted.json**
+
+   Analyze a resume for important metrics
+
+      **hackmyresume analyze rez.json**
+
+   Find more resume themes:
+
+      **https://www.npmjs.com/search?q=jsonresume-theme**
+      **https://www.npmjs.com/search?q=fresh-theme**
+      **https://github.com/fresh-standard/fresh-themes**
+
+   Validate a resume's structure and syntax:
+
+      **hackmyresume validate resume.json**
+
+   View help on a specific command:
+
+      **hackmyresume help [build|convert|new|analyze|validate|peek|help]**
+
+   Submit a bug or request:
+
+      **https://githut.com/hacksalot/HackMyResume/issues**
+
+HackMyResume is free and open source software published
+under the MIT license. For more information, visit the
+HackMyResume website or GitHub project page.

src/cli/help/validate.txt

@@ -0,0 +1,26 @@
+**validate** | Validate a resume for correctness
+
+Usage:
+
+   **hackmyresume VALIDATE <resume> [--assert]**
+
+   The VALIDATE command validates a FRESH or JRS document
+   against its governing schema, verifying that the resume
+   is correctly structured and formatted.
+
+Parameters:
+
+   **<resume>**
+
+      Path to a FRESH or JRS resume. Multiple resumes can be
+      specified.
+
+         hackmyresume ANALYZE resume.json
+         hackmyresume ANALYZE r1.json r2.json r3.json
+
+Options:
+
+   **--assert -a**
+
+      Tell HackMyResume to return a non-zero process exit
+      code if a resume fails to validate.

src/cli/index.js

@@ -0,0 +1,22 @@
+#! /usr/bin/env node
+
+
+
+/**
+Command-line interface (CLI) for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module index.js
+*/
+
+
+
+try {
+
+  require('./main')( process.argv );
+
+}
+catch( ex ) {
+
+  require('./error').err( ex, true );
+
+}

src/cli/main.js

@@ -0,0 +1,421 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the `main` function.
+@module cli/main
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const HMR = require('../index');
+const PKG = require('../../package.json');
+const FS = require('fs');
+const EXTEND = require('extend');
+const chalk = require('chalk');
+const PATH = require('path');
+const HMSTATUS = require('../core/status-codes');
+const safeLoadJSON = require('../utils/safe-json-loader');
+//StringUtils = require '../utils/string.js'
+const _ = require('underscore');
+const OUTPUT = require('./out');
+const PAD = require('string-padding');
+const { Command } = require('commander');
+const M2C = require('../utils/md2chalk');
+const printf = require('printf');
+const _opts = { };
+const _title = chalk.white.bold(`\n*** HackMyResume v${PKG.version} ***`);
+const _out = new OUTPUT( _opts );
+const _err = require('./error');
+let _exitCallback = null;
+
+
+
+/*
+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).
+*/
+module.exports = function( rawArgs, exitCallback ) {
+
+  const initInfo = initialize( rawArgs, exitCallback );
+  if (initInfo === null) {
+    return;
+  }
+
+  const { args } = initInfo;
+
+  // Create the top-level (application) command...
+  const 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.')
+    .option('-f --format <fmt>', 'FRESH or JRS format and optional version', undefined)
+    .action(function() {
+      const x = splitSrcDest.call( this );
+      execute.call( this, x.src, x.dst, this.opts(), logMsg);
+    });
+
+  // Create the ANALYZE command
+  program
+    .command('analyze')
+    .arguments('<sources...>')
+    .option('--private', 'Include resume fields marked as private', false)
+    .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(( sources, sectionOrField ) ->
+    .action(function( sources ) {
+      const 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)
+    .option('--private', 'Include resume fields marked as private', false)
+    .option('--no-escape', 'Turn off encoding in Handlebars themes.', false)
+    .description('Generate resume to multiple formats')
+    //.action(( sources, targets, options ) ->
+    .action(function() {
+      const x = splitSrcDest.call( this );
+      execute.call( this, x.src, x.dst, this.opts(), logMsg);
+    });
+
+  // Create the HELP command
+  program
+    .command('help')
+    .arguments('[command]')
+    .description('Get help on a HackMyResume command')
+    .action(function( cmd ) {
+      cmd = cmd || 'use';
+      const manPage = FS.readFileSync(
+        PATH.join(__dirname, `help/${cmd}.txt`),
+        'utf8');
+      _out.log(M2C(manPage, 'white', 'yellow.bold'));
+  });
+
+  program.parse( args );
+
+  if (!program.args.length) {
+    throw {fluenterror: 4};
+  }
+};
+
+
+
+/* Massage command-line args and setup Commander.js. */
+var initialize = function( ar, exitCallback ) {
+
+  _exitCallback = exitCallback || process.exit;
+  const o = initOptions(ar);
+  if (o.ex) {
+    _err.init(false, true, false);
+    if( o.ex.op === 'parse' ) {
+      _err.err({
+        fluenterror: o.ex.op === 'parse' ? HMSTATUS.invalidOptionsFile : HMSTATUS.optionsFileNotFound,
+        inner: o.ex.inner,
+        quit: true
+      });
+    } else {
+      _err.err({fluenterror: HMSTATUS.optionsFileNotFound, inner: o.ex.inner, quit: true});
+    }
+    return null;
+  }
+  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('');
+  }
+
+  _err.init(o.debug, o.assert, o.silent);
+
+  // Handle invalid verbs here (a bit easier here than in commander.js)...
+  if (o.verb && !HMR.verbs[ o.verb ] && !HMR.alias[ o.verb ] && (o.verb !== 'help')) {
+    _err.err({fluenterror: HMSTATUS.invalidCommand, quit: true, attempted: o.orgVerb}, true);
+  }
+
+  // Override the .missingArgument behavior
+  Command.prototype.missingArgument = function() {
+    if (this.name() !== 'help') {
+      _err.err({
+        verb: this.name(),
+        fluenterror: HMSTATUS.resumeNotFound
+      }
+        , true);
+    }
+  };
+
+  // Override the .helpInformation behavior
+  Command.prototype.helpInformation = function() {
+    const manPage = FS.readFileSync(
+      PATH.join(__dirname, 'help/use.txt'), 'utf8' );
+    return M2C(manPage, 'white', 'yellow');
+  };
+
+  return {
+    args: o.args,
+    options: o.json
+  };
+};
+
+
+
+/* Init options prior to setting up command infrastructure. */
+var initOptions = function( ar ) {
+
+  let oJSON, oVerb;
+  oVerb;
+  let verb = '';
+  const args = ar.slice();
+  const cleanArgs = args.slice( 2 );
+  oJSON;
+
+  if (cleanArgs.length) {
+
+    // Support case-insensitive sub-commands (build, generate, validate, etc)
+    const vidx = _.findIndex(cleanArgs, v => v[0] !== '-');
+    if (vidx !== -1) {
+      oVerb = cleanArgs[ vidx ];
+      verb = (args[ vidx + 2 ] = oVerb.trim().toLowerCase());
+    }
+
+    // Remove --options --opts -o and process separately
+    const optsIdx = _.findIndex(cleanArgs, v => (v === '-o') || (v === '--options') || (v === '--opts'));
+
+    if (optsIdx !== -1) {
+      let optStr = cleanArgs[ optsIdx + 1];
+      args.splice( optsIdx + 2, 2 );
+      if (optStr && (optStr = optStr.trim())) {
+        //var myJSON = JSON.parse(optStr);
+        if( optStr[0] === '{') {
+          // TODO: remove use of evil(). - hacksalot
+          /* jshint ignore:start */
+          oJSON = eval(`(${optStr})`); // jshint ignore:line <-- no worky
+          /* jshint ignore:end */
+        } else {
+          const inf = safeLoadJSON( optStr );
+          if( !inf.ex ) {
+            oJSON = inf.json;
+          } else {
+            return inf;
+          }
+        }
+      }
+    }
+  }
+
+  // Grab the --debug flag, --silent, --assert and --no-color flags
+  const isDebug = _.some(args, v => (v === '-d') || (v === '--debug'));
+  const isSilent = _.some(args, v => (v === '-s') || (v === '--silent'));
+  const isAssert = _.some(args, v => (v === '-a') || (v === '--assert'));
+  const isMono = _.some(args, v => v === '--no-color');
+  const isNoEscape = _.some(args, v => v === '--no-escape');
+
+  return {
+    color: !isMono,
+    debug: isDebug,
+    silent: isSilent,
+    assert: isAssert,
+    noescape: isNoEscape,
+    orgVerb: oVerb,
+    verb,
+    json: oJSON,
+    args
+  };
+};
+
+
+
+/* Invoke a HackMyResume verb. */
+var execute = function( src, dst, opts, log ) {
+
+  // Create the verb
+  const v = new (HMR.verbs[ this.name() ])();
+
+  // Initialize command-specific options
+  loadOptions.call(this, opts, this.parent.jsonArgs);
+
+  // Set up error/output handling
+  _opts.errHandler = v;
+  _out.init(_opts);
+
+  // Hook up event notifications
+  v.on('hmr:status', function() { return _out.do.apply(_out, arguments); });
+  v.on('hmr:error', function() {  return _err.err.apply(_err, arguments); });
+
+  // Invoke the verb using promise syntax
+  const prom = v.invoke.call(v, src, dst, _opts, log);
+  prom.then(executeSuccess, executeFail);
+};
+
+
+
+/* Success handler for verb invocations. Calls process.exit by default */
+var executeSuccess = function() {};
+  // Can't call _exitCallback here (process.exit) when PDF is running in BK
+  //_exitCallback 0; return
+
+
+
+/* Failure handler for verb invocations. Calls process.exit by default */
+var executeFail = function(err) {
+  //console.dir err
+  let finalErrorCode = -1;
+  if (err) {
+    if (err.fluenterror) {
+      finalErrorCode = err.fluenterror;
+    } else if (err.length) {
+      finalErrorCode = err[0].fluenterror;
+    } else {
+      finalErrorCode = err;
+    }
+  }
+  if (_opts.debug) {
+    const msgs = require('./msg').errors;
+    logMsg(printf(M2C( msgs.exiting.msg, 'cyan' ), finalErrorCode));
+    if (err.stack) { logMsg(err.stack); }
+  }
+  _exitCallback(finalErrorCode);
+};
+
+
+
+/*
+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.
+*/
+var loadOptions = function( 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, (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 */
+var splitSrcDest = function() {
+
+  const params = this.parent.args.filter(j => String.is(j));
+  if (params.length === 0) {
+    //tmpName = @name()
+    throw { fluenterror: HMSTATUS.resumeNotFound, verb: this.name(), quit: true };
+  }
+
+  // Find the TO keyword, if any
+  const splitAt = _.findIndex( params, p => 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. */
+var logMsg = function() {
+  // eslint-disable-next-line no-console
+  return _opts.silent || console.log.apply( console.log, arguments );
+};

src/cli/msg.js

@@ -0,0 +1,10 @@
+/**
+Message-handling routines for HackMyResume.
+@module cli/msg
+@license MIT. See LICENSE.md for details.
+*/
+
+
+const PATH = require('path');
+const YAML = require('yamljs');
+module.exports = YAML.load(PATH.join(__dirname, 'msg.yml'));

src/cli/msg.yml

@@ -0,0 +1,141 @@
+events:
+  begin:
+    msg: Invoking **%s** command.
+  beforeCreate:
+    msg: Creating new **%s** resume: **%s**
+  afterCreate:
+    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"
+      - "MISSING"
+      - "ERROR"
+  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.
+      - Invalid or corrupt JSON on line %s.
+      - Invalid or corrupt JSON.
+  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.
+  createError:
+    msg: Failed to create **'%s'**.
+  exiting:
+    msg: Exiting with status code **%s**.
+  validateError:
+    msg: "An error occurred during validation:\n%s"
+  invalidOptionsFile:
+    msg:
+      - "The specified options file is invalid:\n"
+      - "\nMake sure the options file contains valid JSON."
+  optionsFileNotFound:
+    msg: "The specified options file is missing or inaccessible."
+  unknownSchema:
+    msg:
+      - "Unknown resume schema. Did you specify a valid FRESH or JRS resume?"
+      - |
+          At a minimum, a FRESH resume must include a "name" field and a "meta"
+          property.
+
+          "name": "John Doe",
+          "meta": {
+            "format": "FRESH@0.1.0"
+          }
+
+          JRS-format resumes must include a "basics" section with a "name":
+
+          "basics": {
+            "name": "John Doe"
+          }
+  themeHelperLoad:
+    msg: >-
+      An error occurred while attempting to load the '%s' theme helper. Is the
+      theme correctly installed?
+    dummy: dontcare
+  invalidSchemaVersion:
+    msg: "'%s' is not recognized as a valid schema version."

src/cli/out.js

@@ -0,0 +1,204 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Output routines for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module cli/out
+*/
+
+
+
+const chalk = require('chalk');
+const HME = require('../core/event-codes');
+const _ = require('underscore');
+const M2C = require('../utils/md2chalk.js');
+const PATH = require('path');
+const FS = require('fs');
+const EXTEND = require('extend');
+const HANDLEBARS = require('handlebars');
+const YAML = require('yamljs');
+let printf = require('printf');
+const pad = require('string-padding');
+const dbgStyle = 'cyan';
+
+
+
+/** A stateful output module. All HMR console output handled here. */
+class OutputHandler {
+
+
+
+  constructor( opts ) {
+    this.init(opts);
+  }
+
+
+
+  init(opts) {
+    this.opts = EXTEND( true, this.opts || { }, opts );
+    this.msgs = YAML.load(PATH.join( __dirname, 'msg.yml' )).events;
+  }
+
+
+
+  log() {
+    printf = require('printf');
+    const finished = printf.apply( printf, arguments );
+    return this.opts.silent || console.log( finished ); // eslint-disable-line no-console
+  }
+
+
+
+  do( evt ) {
+
+    const that = this;
+    const L = function() { return that.log.apply( that, arguments ); };
+
+    switch (evt.sub) {
+
+      case HME.begin:
+        return this.opts.debug &&
+        L( M2C( this.msgs.begin.msg, dbgStyle), evt.cmd.toUpperCase() );
+
+      //when HME.beforeCreate
+        //L( M2C( this.msgs.beforeCreate.msg, 'green' ), evt.fmt, evt.file )
+        //break;
+
+      case HME.afterCreate:
+        L( M2C( this.msgs.beforeCreate.msg, evt.isError ? 'red' : 'green' ), evt.fmt, evt.file );
+        break;
+
+      case HME.beforeTheme:
+        return this.opts.debug &&
+          L( M2C( this.msgs.beforeTheme.msg, dbgStyle), evt.theme.toUpperCase() );
+
+      case HME.afterParse:
+        return L( M2C( this.msgs.afterRead.msg, 'gray', 'white.dim'), evt.fmt.toUpperCase(), evt.file );
+
+      case HME.beforeMerge:
+        var msg = '';
+        evt.f.reverse().forEach(function( a, idx ) {
+          return msg += printf( (idx === 0 ? this.msgs.beforeMerge.msg[0] : this.msgs.beforeMerge.msg[1]), a.file );
+        }
+        , this);
+        return L( M2C(msg, (evt.mixed ? 'yellow' : 'gray'), 'white.dim') );
+
+      case HME.applyTheme:
+        this.theme = evt.theme;
+        var numFormats = Object.keys( evt.theme.formats ).length;
+        return 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' );
+
+      case HME.end:
+        if (evt.cmd === 'build') {
+          const themeName = this.theme.name.toUpperCase();
+          if (this.opts.tips && (this.theme.message || this.theme.render)) {
+            if (this.theme.message) {
+              L( M2C( this.msgs.afterBuild.msg[0], 'cyan' ), themeName );
+              return L( M2C( this.theme.message, 'white' ));
+            } else if (this.theme.render) {
+              L( M2C( this.msgs.afterBuild.msg[0], 'cyan'), themeName);
+              return 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;
+            }
+          }
+        }
+
+        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 ) );
+
+      case HME.beforeAnalyze:
+        return L( M2C( this.msgs.beforeAnalyze.msg, 'green' ), evt.fmt, evt.file);
+
+      case HME.afterAnalyze:
+        var { info } = evt;
+        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(g => tot += g.count);
+        info.keywords.totalKeywords = tot;
+        var output = template( info );
+        return this.log( chalk.cyan(output) );
+
+      case HME.beforeConvert:
+        return L( M2C( this.msgs.beforeConvert.msg, evt.error ? 'red' : 'green' ),
+          evt.srcFile, evt.srcFmt, evt.dstFile, evt.dstFmt
+        );
+
+      case HME.afterInlineConvert:
+        return L( M2C( this.msgs.afterInlineConvert.msg, 'gray', 'white.dim' ),
+          evt.file, evt.fmt );
+
+      case HME.afterValidate:
+        var style = 'red';
+        var adj = '';
+        var msgs = this.msgs.afterValidate.msg;
+        switch (evt.status) {
+          case 'valid': style = 'green'; adj = msgs[1]; break;
+          case 'invalid': style = 'yellow'; adj = msgs[2]; break;
+          case 'broken': style = 'red'; adj = msgs[3]; break;
+          case 'missing': style = 'red'; adj = msgs[4]; break;
+          case 'unknown': style = 'red'; adj = msgs[5]; break;
+        }
+        evt.schema = evt.schema.replace('jars','JSON Resume').toUpperCase();
+        L(M2C( msgs[0], 'white' ) + chalk[style].bold(adj), evt.file, evt.schema);
+
+        if (evt.violations) {
+          _.each(evt.violations, function(err) {
+            L( chalk.yellow.bold('--> ') +
+               chalk.yellow(err.field.replace('data.','resume.').toUpperCase() +
+               ' ' + err.message));
+          }
+          , this);
+        }
+        return;
+
+      case HME.afterPeek:
+        var sty = evt.error ? 'red' : ( evt.target !== undefined ? 'green' : 'yellow' );
+
+        // "Peeking at 'someKey' in 'someFile'."
+        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 the key was present, print it
+        if ((evt.target !== undefined) && !evt.error) {
+          // eslint-disable-next-line no-console
+          return console.dir( evt.target, { depth: null, colors: true } );
+
+        // If the key was not present, but no error occurred, print it
+        } else if (!evt.error) {
+          return L(M2C( this.msgs.afterPeek.msg, 'yellow'), evt.requested, evt.file);
+
+        } else if (evt.error) {
+          return L(chalk.red( evt.error.inner.inner ));
+        }
+        break;
+    }
+  }
+}
+
+module.exports = OutputHandler;

src/core/convert.js

@@ -1,362 +0,0 @@
-/**
-FRESH to JSON Resume conversion routiens.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module convert.js
-*/
-
-(function(){
-
-  /**
-  Convert between FRESH and JRS resume/CV formats.
-  @class FRESHConverter
-  */
-  var FRESHConverter = module.exports = {
-
-
-    /**
-    Convert from JSON Resume format to FRESH.
-    @method toFresh
-    */
-    toFRESH: function( src, foreign ) {
-
-      foreign = (foreign === undefined || foreign === null) ? true : foreign;
-
-      return {
-
-        name: src.basics.name,
-
-        info: {
-          label: src.basics.label,
-          class: src.basics.class, // <--> round-trip
-          image: src.basics.picture,
-          brief: src.basics.summary
-        },
-
-        contact: {
-          email: src.basics.email,
-          phone: src.basics.phone,
-          website: src.basics.website,
-          other: src.basics.other // <--> round-trip
-        },
-
-        meta: meta( true, src.meta ),
-
-        location: {
-          city: src.basics.location.city,
-          region: src.basics.location.region,
-          country: src.basics.location.countryCode,
-          code: src.basics.location.postalCode,
-          address: src.basics.location.address
-        },
-
-        employment: employment( src.work, true ),
-        education: education( src.education, true),
-        service: service( src.volunteer, true),
-        skills: skillsToFRESH( src.skills ),
-        writing: writing( src.publications, true),
-        recognition: recognition( src.awards, true, foreign ),
-        social: social( src.basics.profiles, true ),
-        interests: src.interests,
-        testimonials: references( src.references, true ),
-        languages: src.languages,
-        disposition: src.disposition // <--> round-trip
-      };
-    },
-
-    /**
-    Convert from FRESH format to JSON Resume.
-    @param foreign True if non-JSON-Resume properties should be included in
-    the result, false if those properties should be excluded.
-    */
-    toJRS: function( src, foreign ) {
-
-      foreign = (foreign === undefined || foreign === null) ? false : foreign;
-
-      return {
-
-        basics: {
-          name: src.name,
-          label: src.info.label,
-          class: foreign ? src.info.class : undefined,
-          summary: src.info.brief,
-          website: src.contact.website,
-          phone: src.contact.phone,
-          email: src.contact.email,
-          picture: src.info.image,
-          location: {
-            address: src.location.address,
-            postalCode: src.location.code,
-            city: src.location.city,
-            countryCode: src.location.country,
-            region: src.location.region
-          },
-          profiles: social( src.social, false )
-        },
-
-        work: employment( src.employment, false ),
-        education: education( src.education, false ),
-        skills: skillsToJRS( src.skills, false ),
-        volunteer: service( src.service, false ),
-        awards: recognition( src.recognition, false, foreign ),
-        publications: writing( src.writing, false ),
-        interests: src.interests,
-        references: references( src.testimonials, false ),
-        samples: foreign ? src.samples : undefined,
-        disposition: foreign ? src.disposition : undefined,
-        languages: src.languages
-
-      };
-
-    }
-
-  };
-
-  function meta( direction, obj ) {
-    if( direction ) {
-      obj = obj || { };
-      obj.format = obj.format || "FRESH@0.1.0";
-      obj.version = obj.version || "0.1.0";
-    }
-    return obj;
-  }
-
-  function employment( obj, direction ) {
-    if( !direction ) {
-      return obj && obj.history ?
-        obj.history.map(function(emp){
-          return {
-            company: emp.employer,
-            website: emp.url,
-            position: emp.position,
-            startDate: emp.start,
-            endDate: emp.end,
-            summary: emp.summary,
-            highlights: emp.highlights
-          };
-        }) : undefined;
-    }
-    else {
-      return {
-        history: obj && obj.length ?
-          obj.map( function( job ) {
-            return {
-              position: job.position,
-              employer: job.company,
-              summary: job.summary,
-              current: (!job.endDate || !job.endDate.trim() || job.endDate.trim().toLowerCase() === 'current') || undefined,
-              start: job.startDate,
-              end: job.endDate,
-              url: job.website,
-              keywords: "",
-              highlights: job.highlights
-            };
-          }) : undefined
-      };
-    }
-  }
-
-
-  function education( obj, direction ) {
-    if( direction ) {
-      return obj && obj.length ? {
-        history: obj.map(function(edu){
-          return {
-            institution: edu.institution,
-            start: edu.startDate,
-            end: edu.endDate,
-            grade: edu.gpa,
-            curriculum: edu.courses,
-            url: edu.website || edu.url || null,
-            summary: null,
-            area: edu.area,
-            studyType: edu.studyType
-          };
-        })
-      } : undefined;
-    }
-    else {
-      return obj && obj.history ?
-        obj.history.map(function(edu){
-          return {
-            institution: edu.institution,
-            gpa: edu.grade,
-            courses: edu.curriculum,
-            startDate: edu.start,
-            endDate: edu.end,
-            area: edu.area,
-            studyType: edu.studyType
-          };
-        }) : undefined;
-    }
-  }
-
-  function service( obj, direction, foreign ) {
-    if( direction ) {
-      return {
-        history: obj && obj.length ? obj.map(function(vol) {
-          return {
-            type: 'volunteer',
-            position: vol.position,
-            organization: vol.organization,
-            start: vol.startDate,
-            end: vol.endDate,
-            url: vol.website,
-            summary: vol.summary,
-            highlights: vol.highlights
-          };
-        }) : undefined
-      };
-    }
-    else {
-      return obj && obj.history ?
-        obj.history.map(function(srv){
-          return {
-            flavor: foreign ? srv.flavor : undefined,
-            organization: srv.organization,
-            position: srv.position,
-            startDate: srv.start,
-            endDate: srv.end,
-            website: srv.url,
-            summary: srv.summary,
-            highlights: srv.highlights
-          };
-        }) : undefined;
-    }
-  }
-
-  function social( obj, direction ) {
-    if( direction ) {
-      return obj.map(function(pro){
-        return {
-          label: pro.network,
-          network: pro.network,
-          url: pro.url,
-          user: pro.username
-        };
-      });
-    }
-    else {
-      return obj.map( function( soc ) {
-        return {
-          network: soc.network,
-          username: soc.user,
-          url: soc.url
-        };
-      });
-    }
-  }
-
-  function recognition( obj, direction, foreign ) {
-    if( direction ) {
-      return obj && obj.length ? obj.map(
-        function(awd){
-          return {
-            flavor: foreign ? awd.flavor : undefined,
-            url: foreign ? awd.url: undefined,
-            title: awd.title,
-            date: awd.date,
-            from: awd.awarder,
-            summary: awd.summary
-          };
-      }) : undefined;
-    }
-    else {
-      return obj && obj.length ? obj.map(function(awd){
-        return {
-          flavor: foreign ? awd.flavor : undefined,
-          url: foreign ? awd.url: undefined,
-          title: awd.title,
-          date: awd.date,
-          awarder: awd.from,
-          summary: awd.summary
-        };
-      }) : undefined;
-    }
-  }
-
-  function references( obj, direction ) {
-    if( direction ) {
-      return obj && obj.length && obj.map(function(ref){
-        return {
-          name: ref.name,
-          flavor: 'professional',
-          quote: ref.reference,
-          private: false
-        };
-      });
-    }
-    else {
-      return obj && obj.length && obj.map(function(ref){
-        return {
-          name: ref.name,
-          reference: ref.quote
-        };
-      });
-    }
-  }
-
-  function writing( obj, direction ) {
-    if( direction ) {
-      return obj.map(function( pub ) {
-        return {
-          title: pub.name,
-          flavor: undefined,
-          publisher: pub.publisher,
-          url: pub.website,
-          date: pub.releaseDate,
-          summary: pub.summary
-        };
-      });
-    }
-    else {
-      return obj && obj.length ? obj.map(function(pub){
-        return {
-          name: pub.title,
-          publisher: pub.publisher && pub.publisher.name ? pub.publisher.name : pub.publisher,
-          releaseDate: pub.date,
-          website: pub.url,
-          summary: pub.summary
-        };
-      }) : undefined;
-    }
-  }
-
-  function skillsToFRESH( skills ) {
-
-    return {
-      sets: skills.map(function(set) {
-        return {
-          name: set.name,
-          level: set.level,
-          skills: set.keywords
-        };
-      })
-    };
-  }
-
-  function skillsToJRS( skills ) {
-    var ret = [];
-    if( skills.sets && skills.sets.length ) {
-      ret = skills.sets.map(function(set){
-        return {
-          name: set.name,
-          level: set.level,
-          keywords: set.skills
-        };
-      });
-    }
-    else if( skills.list ) {
-      ret = skills.list.map(function(sk){
-        return {
-          name: sk.name,
-          level: sk.level,
-          keywords: sk.keywords
-        };
-      });
-    }
-    return ret;
-  }
-
-
-
-}());

src/core/default-formats.js

@@ -1,19 +1,18 @@
-(function(){
+/*
+Event code definitions.
+@module core/default-formats
+@license MIT. See LICENSE.md for details.
+*/
 
-  var FLUENT = require('../hackmyapi');
-
-  /**
-  Supported resume formats.
-  */
-  module.exports = [
-    { 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() },
-    { name: 'latex', ext: 'tex', fmt: 'latex', gen: new FLUENT.LaTeXGenerator() }
-  ];
-
-}());
+/** 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

@@ -1,13 +1,15 @@
-(function(){
+/*
+Event code definitions.
+@module core/default-options
+@license MIT. See LICENSE.md for details.
+*/
 
-  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
-    }
-  };
-
-}());
+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/empty-fresh.json

@@ -1,184 +0,0 @@
-{
-
-  "name": "",
-
-  "meta": {
-    "format": "FRESH@0.1.0",
-    "version": "0.1.0"
-  },
-
-  "info": {
-    "label": "",
-    "characterClass": "",
-    "brief": "",
-    "image": ""
-  },
-
-  "contact": {
-    "website": "",
-    "phone": "",
-    "email": "",
-    "other": []
-  },
-
-  "location": {
-    "address": "",
-    "city": "",
-    "region": "",
-    "code": "",
-    "country": ""
-  },
-
-  "social": [
-    {
-      "label": "",
-      "network": "",
-      "user": "",
-      "url": ""
-    }
-  ],
-
-  "employment": {
-    "summary": "",
-    "history": [
-      {
-        "employer": "",
-        "url": "",
-        "position": "",
-        "summary": "",
-        "start": "",
-        "end": "",
-        "keywords": [],
-        "highlights": []
-      }
-    ]
-  },
-
-  "education": {
-    "summary": "",
-    "level": "",
-    "degree": "",
-    "history": [
-      {
-        "institution": "",
-        "url": "",
-        "start": "",
-        "end": "",
-        "grade": "",
-        "summary": "",
-        "curriculum": []
-      }
-    ]
-  },
-
-  "service": {
-    "summary": "",
-    "history": [
-      {
-        "flavor": "",
-        "position": "",
-        "organization": "",
-        "url": "",
-        "start": "",
-        "end": "",
-        "summary": "",
-        "highlights": []
-      }
-    ]
-  },
-
-  "skills": {
-
-    "sets": [
-      {
-        "name": "",
-        "level": "",
-        "skills": []
-      }
-    ],
-
-    "list": [ ]
-  },
-
-  "samples": [
-    {
-      "title": "",
-      "summary": "",
-      "url": "",
-      "date": ""
-    }
-  ],
-
-  "writing": [
-    {
-      "title": "",
-      "flavor": "",
-      "date": "",
-      "publisher": {
-        "name": "",
-        "url": ""
-      },
-      "url": ""
-    }
-  ],
-
-  "reading": [
-    {
-      "title": "",
-      "flavor": "",
-      "url": "",
-      "author": ""
-    }
-  ],
-
-  "recognition": [
-    {
-      "flavor": "",
-      "from": "",
-      "title": "",
-      "event": "",
-      "date": "",
-      "summary": ""
-    }
-  ],
-
-  "references": [
-    {
-      "name": "",
-      "flavor": "",
-      "private": true,
-      "contact": [
-        {
-          "label": "",
-          "flavor": "",
-          "value": ""
-        }
-      ]
-    }
-  ],
-
-  "testimonials": [
-    {
-      "name": "",
-      "flavor": "",
-      "quote": ""
-    }
-  ],
-
-  "languages": [
-    {
-      "language": "",
-      "level": "",
-      "years": 0
-    }
-  ],
-
-  "interests": [
-    {
-      "name": "",
-      "summary": "",
-      "keywords": []
-    }
-  ]
-
-}

src/core/event-codes.js

@@ -0,0 +1,39 @@
+/*
+Event code definitions.
+@module core/event-codes
+@license MIT. See LICENSE.md for details.
+*/
+
+
+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,
+  beforeWrite:      26,
+  afterWrite:       27,
+  applyTheme:       28
+};

src/core/fluent-date.js

@@ -1,10 +1,20 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS104: Avoid inline assignments
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
 /**
 The HackMyResume date representation.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module fluent-date.js
+@license MIT. See LICENSE.md for details.
+@module core/fluent-date
 */
 
-var moment = require('moment');
+
+
+const moment = require('moment');
+require('../utils/string');
 
 /**
 Create a FluentDate from a string or Moment date object. There are a few date
@@ -22,63 +32,64 @@ 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 );
+
+class FluentDate {
+
+  constructor(dt) {
+    this.rep = this.fmt(dt);
+  }
+
+  static isCurrent(dt) {
+    return !dt || (String.is(dt) && /^(present|now|current)$/.test(dt));
+  }
 }
 
-FluentDate/*.prototype*/.fmt = function( dt ) {
-  if( (typeof dt === 'string' || dt instanceof String) ) {
+const months = {};
+const abbr = {};
+moment.months().forEach((m,idx) => months[m.toLowerCase()] = idx+1);
+moment.monthsShort().forEach((m,idx) => abbr[m.toLowerCase()]=idx+1);
+abbr.sept = 9;
+module.exports = FluentDate;
+
+FluentDate.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"
+    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())
+    } else if (/^\D+\s+\d{4}$/.test(dt)) { // "Mar 2015"
+      let left;
+      const parts = dt.split(' ');
+      const month = (months[parts[0]] || abbr[parts[0]]);
+      const temp = parts[1] + '-' + ((left = month < 10) != null ? left : `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)) { // "", " "
+      return moment();
+    } else {
+      const mt = moment(dt);
+      if (mt.isValid()) {
         return mt;
-      throw 'Invalid date format encountered.';
+      }
+      if (throws) {
+        throw 'Invalid date format encountered.';
+      }
+      return null;
     }
-  }
-  else {
-    if( !dt ) {
+  } else {
+    if (!dt) {
       return moment();
-    }
-    else if( dt.isValid && dt.isValid() )
+    } else if (dt.isValid && dt.isValid()) {
       return dt;
-    throw 'Unknown date object encountered.';
+    }
+    if (throws) {
+      throw 'Unknown date object encountered.';
+    }
+    return null;
   }
 };
-
-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;

src/core/fresh-resume.js

@@ -1,207 +1,258 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
 /**
 Definition of the FRESHResume class.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module fresh-resume.js
+@license MIT. See LICENSE.md for details.
+@module core/fresh-resume
 */
 
-(function() {
 
-  var FS = require('fs')
-    , extend = require('../utils/extend')
-    , validator = require('is-my-json-valid')
-    , _ = require('underscore')
-    , PATH = require('path')
-    , moment = require('moment')
-    , MD = require('marked')
-    , CONVERTER = require('./convert')
-    , JRSResume = require('./jrs-resume');
 
-  /**
-  A FRESH-style resume in JSON or YAML.
-  @class FreshResume
-  */
-  function FreshResume() {
+const FS = require('fs');
+const extend = require('extend');
+let validator = require('is-my-json-valid');
+const _ = require('underscore');
+const __ = require('lodash');
+const XML = require('xml-escape');
+const MD = require('marked');
+const CONVERTER = require('fresh-jrs-converter');
+const 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
+*/
+class FreshResume {// extends AbstractResume
+
+
+
+  /** Initialize the the FreshResume from JSON string data. */
+  parse( stringData, opts ) {
+    this.imp = this.imp != null ? this.imp : {raw: stringData};
+    return this.parseJSON(JSON.parse( stringData ), opts);
   }
 
-  /**
-  Open and parse the specified FRESH 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.
-  */
-  FreshResume.prototype.open = function( file, title ) {
-    this.imp = { fileName: file };
-    this.imp.raw = FS.readFileSync( file, 'utf8' );
-    return this.parse( this.imp.raw, title );
-  };
+
 
   /**
-  Save the sheet to disk (for environments that have disk access).
+  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.save = function( filename ) {
-    this.imp.fileName = filename || this.imp.fileName;
-    FS.writeFileSync( this.imp.fileName, this.stringify(), 'utf8' );
+  parseJSON( rep, opts ) {
+
+    let scrubbed;
+    if (opts && opts.privatize) {
+      // Ignore any element with the 'ignore: true' or 'private: true' designator.
+      const scrubber = require('../utils/resume-scrubber');
+      var ret = scrubber.scrubResume(rep, opts);
+      scrubbed = ret.scrubbed;
+    }
+
+    // Now apply the resume representation onto this object
+    extend(true, this, opts && opts.privatize ? scrubbed : rep);
+
+    // If the resume has already been processed, then we are being called from
+    // the .dupe method, and there's no need to do any post processing
+    if (!(this.imp != null ? this.imp.processed : undefined)) {
+      // 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;
+        if (!this.imp.raw) {
+          this.imp.raw = JSON.stringify(rep);
+        }
+      }
+      this.imp.processed = true;
+      // 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). */
+  save( 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 ) {
+  saveAs( filename, format ) {
 
-    if( format !== 'JRS' ) {
-      this.imp.fileName = filename || this.imp.fileName;
-      FS.writeFileSync( this.imp.fileName, this.stringify(), 'utf8' );
-    }
-    else {
-      var newRep = CONVERTER.toJRS( this );
-      FS.writeFileSync( filename, JRSResume.stringify( newRep ), 'utf8' );
+    // If format isn't specified, default to FRESH
+    const safeFormat = (format && format.trim()) || 'FRESH';
+
+    // Validate against the FRESH version regex
+    // freshVersionReg = require '../utils/fresh-version-regex'
+    // if (not freshVersionReg().test( safeFormat ))
+    //   throw badVer: safeFormat
+
+    const parts = safeFormat.split('@');
+
+    if (parts[0] === 'FRESH') {
+      this.imp.file = filename || this.imp.file;
+      FS.writeFileSync(this.imp.file, this.stringify(), 'utf8');
+
+    } else if (parts[0] === 'JRS') {
+      const useEdgeSchema = parts.length > 1 ? parts[1] === '1' : false;
+      const newRep = CONVERTER.toJRS(this, {edge: useEdgeSchema});
+      FS.writeFileSync(filename, JRSResume.stringify( newRep ), 'utf8');
+    } else {
+      throw {badVer: safeFormat};
     }
     return this;
-  };
+  }
+
 
-  FreshResume.prototype.dupe = function() {
-    var rnew = new FreshResume();
-    rnew.parse( this.stringify(), { } );
-    return rnew;
-  };
 
   /**
-  Convert the supplied object to a JSON string, sanitizing meta-properties along
-  the way.
+  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.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 );
-  };
+  dupe() {
+    const jso = extend(true, { }, this);
+    const rnew = new FreshResume();
+    rnew.parseJSON(jso, { });
+    return rnew;
+  }
+
+
+
+  /**
+  Convert this object to a JSON string, sanitizing meta-properties along the
+  way.
+  */
+  stringify() { 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.
+  */
+  transformStrings( filt, transformer ) {
+    const ret = this.dupe();
+    const 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() {
+  markdownify() {
 
-    var that = this;
-    var ret = this.dupe();
+    const MDIN =  txt  => MD(txt || '' ).replace(/^\s*<p>|<\/p>\s*$/gi, '');
 
-    function MDIN(txt){
-      return MD(txt || '' ).replace(/^\s*<p>|<\/p>\s*$/gi, '');
-    }
-
-    // TODO: refactor recursion
-    function markdownifyStringsInObject( 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 ? MDIN(elem) : MD( elem );
-          else
-            markdownifyStringsInObject( elem );
-        });
+    const trx = function( key, val ) {
+      if (key === 'summary') {
+        return MD(val);
       }
-      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','start','end','date'], key) )
-              return;
-            if( key === 'summary' )
-              obj[key] = MD( obj[key] );
-            else
-              obj[key] = inline ? MDIN( obj[key] ) : MD( obj[key] );
-          }
-          else
-            markdownifyStringsInObject( sub );
-        });
+      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.
+  */
+  xmlify() {
+    const trx = (key, val) => XML(val);
+    return this.transformStrings([], trx);
+  }
+
+
+
+  /** Return the resume format. */
+  format() { return 'FRESH'; }
+
+
+
+  /**
+  Return internal metadata. Create if it doesn't exist.
+  */
+  i() { return this.imp = this.imp || { }; }
+
+
+
+  /**
+  Return a unique list of all skills declared in the resume.
+  */
+
+  // TODO: Several problems here:
+  // 1) Confusing name. Easily confused with the keyword-inspector module, which
+  // parses resume body text looking for these same keywords. This should probably
+  // be renamed.
+  //
+  // 2) Doesn't bother trying to integrate skills.list with skills.sets if they
+  // happen to declare different skills, and if skills.sets declares ONE skill and
+  // skills.list declared 50, only 1 skill will be registered.
+  //
+  // 3) In the future, skill.sets should only be able to use skills declared in
+  // skills.list. That is, skills.list is the official record of a candidate's
+  // declared skills. skills.sets is just a way of grouping those into skillsets
+  // for easier consumption.
+
+  keywords() {
+    let flatSkills = [];
+    if (this.skills) {
+      if (this.skills.sets) {
+        flatSkills = this.skills.sets.map(sk => sk.skills).reduce( (a,b) => a.concat(b));
+      } else if (this.skills.list) {
+        flatSkills = flatSkills.concat( this.skills.list.map(sk => sk.name) );
       }
-
+      flatSkills = _.uniq(flatSkills);
     }
-
-    Object.keys( ret ).forEach(function(member){
-      markdownifyStringsInObject( ret[ member ] );
-    });
-
-    return ret;
-  };
-
-  /**
-  Convert this object to a JSON string, sanitizing meta-properties along the
-  way. Don't override .toString().
-  */
-  FreshResume.prototype.stringify = function() {
-    return FreshResume.stringify( this );
-  };
-
-  /**
-  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.
-  */
-  FreshResume.prototype.parse = function( stringData, opts ) {
-
-    // Parse the incoming JSON representation
-    var rep = JSON.parse( stringData );
-
-    // Convert JSON Resume to FRESH if necessary
-    if( rep.basics ) {
-      rep = CONVERTER.toFRESH( rep );
-      rep.imp = rep.imp || { };
-      rep.imp.orgFormat = 'JRS';
-    }
-
-    // Now apply the resume representation onto this object
-    extend( true, this, rep );
-
-    // Set up metadata
-    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;
-  };
-
-  /**
-  Return a unique list of all keywords across all skills.
-  */
-  FreshResume.prototype.keywords = function() {
-    var flatSkills = [];
-    this.skills && this.skills.length &&
-      (flatSkills = this.skills.map(function(sk) { return sk.name;  }));
     return flatSkills;
-  },
+  }
+
+
 
   /**
-  Update the sheet's raw data. TODO: remove/refactor
+  Reset the sheet to an empty state. TODO: refactor/review
   */
-  FreshResume.prototype.updateData = function( str ) {
-    this.clear( false );
-    this.parse( str );
-    return this;
-  };
-
-  /**
-  Reset the sheet to an empty state.
-  */
-  FreshResume.prototype.clear = function( clearMeta ) {
+  clear( clearMeta ) {
     clearMeta = ((clearMeta === undefined) && true) || clearMeta;
-    clearMeta && (delete this.imp);
+    if (clearMeta) { delete this.imp; }
     delete this.computed; // Don't use Object.keys() here
     delete this.employment;
     delete this.service;
@@ -211,207 +262,217 @@ Definition of the FRESHResume class.
     delete this.writing;
     delete this.interests;
     delete this.skills;
-    delete this.social;
-  };
+    return 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;
+  count( 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 (empty) sheet.
-  */
-  FreshResume.default = function() {
-    return new FreshResume().open(
-      PATH.join( __dirname, 'empty-fresh.json'), 'Empty' );
-  };
 
-  /**
-  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] ));
+
+  /** Add work experience to the sheet. */
+  add( moniker ) {
+    const defSheet = FreshResume.default();
+    const 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 );
+    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 ) {
+  hasProfile( socialNetwork ) {
     socialNetwork = socialNetwork.trim().toLowerCase();
-    return this.social && _.some( this.social, function(p) {
-      return p.network.trim().toLowerCase() === socialNetwork;
-    });
-  };
+    return this.social && _.some(this.social, p => p.network.trim().toLowerCase() === socialNetwork);
+  }
 
-  /**
-  Return the specified network profile.
-  */
-  FreshResume.prototype.getProfile = function( socialNetwork ) {
+
+
+  /** Return the specified network profile. */
+  getProfile( socialNetwork ) {
     socialNetwork = socialNetwork.trim().toLowerCase();
-    return this.social && _.find( this.social, function(sn) {
-      return sn.network.trim().toLowerCase() === socialNetwork;
-    });
-  };
+    return this.social && _.find(this.social, sn => 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 ) {
+  getProfiles( socialNetwork ) {
     socialNetwork = socialNetwork.trim().toLowerCase();
-    return this.social && _.filter( this.social, function(sn){
-      return sn.network.trim().toLowerCase() === socialNetwork;
-    });
-  };
+    return this.social && _.filter(this.social, sn => sn.network.trim().toLowerCase() === socialNetwork);
+  }
 
-  /**
-  Determine if the sheet includes a specific skill.
-  */
-  FreshResume.prototype.hasSkill = function( skill ) {
+
+
+  /** Determine if the sheet includes a specific skill. */
+  hasSkill( 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;
-      });
-    });
-  };
+    return this.skills && _.some(this.skills, sk =>
+      sk.keywords && _.some(sk.keywords, kw => 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, { // Note [1]
+
+
+  /** Validate the sheet against the FRESH Resume schema. */
+  isValid() {
+    const schemaObj = require('fresh-resume-schema');
+    validator = require('is-my-json-valid');
+    const 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 ) {
+    const ret = validate(this);
+    if (!ret) {
       this.imp = this.imp || { };
       this.imp.validationErrors = validate.errors;
     }
     return ret;
-  };
+  }
+
+
+
+  duration(unit) {
+    const inspector = require('../inspectors/duration-inspector');
+    return inspector.run(this, 'employment.history', 'start', 'end', unit);
+  }
+
+
 
-  /**
-  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() {
-    if( this.employment.history && this.employment.history.length ) {
-      var firstJob = _.last( this.employment.history );
-      var careerStart = firstJob.start ? firstJob.safe.start : '';
-      if ((typeof careerStart === 'string' || careerStart instanceof String) &&
-          !careerStart.trim())
-        return 0;
-      var careerLast = _.max( this.employment.history, function( w ) {
-        return( w.safe && w.safe.end ) ? w.safe.end.unix() : moment().unix();
-      });
-      return careerLast.safe.end.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().
   */
-  FreshResume.prototype.sort = function( ) {
+  sort() {
 
-    this.employment.history && this.employment.history.sort( byDateDesc );
-    this.education.history && this.education.history.sort( byDateDesc );
-    this.service.history && this.service.history.sort( byDateDesc );
+    const byDateDesc = function(a,b) {
+      if (a.safe.start.isBefore(b.safe.start)) {
+      return 1;
+      } else {  if (a.safe.start.isAfter(b.safe.start)) { return -1; } else { return 0; }  }
+    };
 
-    // 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;
-    });
-
-    function byDateDesc(a,b) {
-      return( a.safe.start.isBefore(b.safe.start) ) ? 1
-        : ( a.safe.start.isAfter(b.safe.start) && -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 );
-        });
+    const sortSection = function( key ) {
+      const ar = __.get(this, key);
+      if (ar && ar.length) {
+        const datedThings = ar.filter(o => o.start);
+        return datedThings.sort( byDateDesc );
       }
-      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 ] );
+    sortSection('employment.history');
+    sortSection('education.history');
+    sortSection('service.history');
+    sortSection('projects');
+
+    return this.writing && this.writing.sort(function(a, b) {
+      if (a.safe.date.isBefore(b.safe.date)) {
+      return 1;
+      } else { return ( a.safe.date.isAfter(b.safe.date) && -1 ) || 0; }
     });
-
   }
+}
+
+
+
+/**
+Get the default (starter) sheet.
+*/
+FreshResume.default = () => new FreshResume().parseJSON(require('fresh-resume-starter').fresh);
+
+
+
+/**
+Convert the supplied FreshResume to a JSON string, sanitizing meta-properties
+along the way.
+*/
+FreshResume.stringify = function( obj ) {
+  const replacer = function( key,value ) { // Exclude these keys from stringification
+    const exKeys = ['imp', 'warnings', 'computed', 'filt', 'ctrl', 'index',
+      'safe', 'result', 'isModified', 'htmlPreview', 'display_progress_bar'];
+    if (_.some( exKeys, val => key.trim() === val)) {
+    return undefined; } else { return value; }
+  };
+  return JSON.stringify(obj, replacer, 2);
+};
+
+
+
+/**
+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.
+*/
+var _parseDates = function() {
+
+  const _fmt = require('./fluent-date').fmt;
+  const that = this;
+
+  // TODO: refactor recursion
+  var replaceDatesInObject = function( obj ) {
+
+    if (!obj) { return; }
+    if (Object.prototype.toString.call( obj ) === '[object Array]') {
+      obj.forEach(elem => replaceDatesInObject( elem ));
+      return;
+    } else if (typeof obj === 'object') {
+      if (obj._isAMomentObject || obj.safe) {
+        return;
+      }
+      Object.keys( obj ).forEach(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');
+            return;
+          }
+        }
+      });
+      return;
+    }
+  };
+  Object.keys( this ).forEach(function(member) {
+    replaceDatesInObject(that[member]);
+  });
+};
+
+
+
+/** Export the Sheet function/ctor. */
+module.exports = FreshResume;
 
-  /**
-  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:

src/core/fresh-theme.js

@@ -0,0 +1,253 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS103: Rewrite code to no longer use __guard__
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the FRESHTheme class.
+@module core/fresh-theme
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const FS = require('fs');
+const _ = require('underscore');
+const PATH = require('path');
+const parsePath = require('parse-filepath');
+const EXTEND = require('extend');
+const HMSTATUS = require('./status-codes');
+const loadSafeJson = require('../utils/safe-json-loader');
+const READFILES = require('recursive-readdir-sync');
+
+
+
+/* A representation of a FRESH theme asset.
+@class FRESHTheme */
+class FRESHTheme {
+
+  constructor() {
+    this.baseFolder = 'src';
+  }
+
+  /* Open and parse the specified theme. */
+  open( themeFolder ) {
+
+    this.folder = themeFolder;
+
+    // Set up a formats hash for the theme
+    let formatsHash = { };
+
+    // Load the theme
+    const themeFile = PATH.join(themeFolder, 'theme.json');
+    const themeInfo = loadSafeJson(themeFile);
+    if (themeInfo.ex) {
+      throw{
+        fluenterror:
+          themeInfo.ex.op === 'parse'
+          ? HMSTATUS.parseError
+          : HMSTATUS.readError,
+      inner: themeInfo.ex.inner
+      };
+    }
+
+    // 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) {
+      const cached = { };
+      _.each(this.inherits, function(th, key) {
+        // First, see if this is one of the predefined FRESH themes. There are
+        // only a handful of these, but they may change over time, so we need to
+        // query the official source of truth: the fresh-themes repository, which
+        // mounts the themes conveniently by name to the module object, and which
+        // is embedded locally inside the HackMyResume installation.
+        // TODO: merge this code with
+        let themePath;
+        const themesObj = require('fresh-themes');
+        if (_.has(themesObj.themes, th)) {
+          themePath = PATH.join(
+            parsePath( require.resolve('fresh-themes') ).dirname,
+            '/themes/',
+            th
+          );
+        } else {
+          const d = parsePath( th ).dirname;
+          themePath = PATH.join(d, th);
+        }
+
+        cached[ th ] = cached[th] || new FRESHTheme().open( themePath );
+        return formatsHash[ key ] = cached[ th ].getFormat( key );
+      });
+    }
+
+    // Load theme files
+    formatsHash = _load.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. */
+  hasFormat( fmt ) { return _.has(this.formats, fmt); }
+
+  /* Determine if the theme supports the specified output format. */
+  getFormat( fmt ) { return this.formats[ fmt ]; }
+}
+
+
+
+/* Load and parse theme source files. */
+var _load = function(formatsHash) {
+
+  const that = this;
+  const tplFolder = PATH.join(this.folder, this.baseFolder);
+
+  // 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.
+  const fmts = READFILES(tplFolder).map(function(absPath) {
+    return _loadOne.call(this, absPath, formatsHash, tplFolder);
+  }
+  , this);
+
+  // Now, get all the CSS files...
+  this.cssFiles = fmts.filter(fmt => 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.
+  this.cssFiles.forEach(function(cssf) {
+    const idx = _.findIndex(fmts,  fmt  => fmt && (fmt.pre === cssf.pre) && (fmt.ext === 'html'));
+    cssf.major = false;
+    if (idx > -1) {
+      fmts[ idx ].css = cssf.data;
+      return 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.
+        return that.overrides = { file: cssf.path, data: cssf.data };
+      }
+    }});
+
+  // Now, save all the javascript file paths to a theme property.
+  const jsFiles = fmts.filter(fmt => fmt && (fmt.ext === 'js'));
+  this.jsFiles = jsFiles.map(jsf => jsf['path']);
+
+  return formatsHash;
+};
+
+
+/* Load a single theme file. */
+var _loadOne = function( absPath, formatsHash, tplFolder ) {
+
+  const pathInfo = parsePath(absPath);
+  if (pathInfo.basename.toLowerCase() === 'theme.json') { return; }
+
+  const absPathSafe = absPath.trim().toLowerCase();
+  let outFmt = '';
+  let act = 'copy';
+  let isPrimary = false;
+
+  // If this is an "explicit" theme, all files of importance are specified in
+  // the "transform" section of the theme.json file.
+  if (this.explicit) {
+
+    outFmt = _.find(Object.keys( this.formats ), function( fmtKey ) {
+      const fmtVal = this.formats[ fmtKey ];
+      return _.some(fmtVal.transform, function(fpath) {
+        const absPathB = PATH.join( this.folder, fpath ).trim().toLowerCase();
+        return absPathB === absPathSafe;
+      }
+      , this);
+    }
+    , this);
+    if (outFmt) { act = 'transform'; }
+  }
+
+  if (!outFmt) {
+    // If this file lives in a specific format folder within the theme,
+    // such as "/latex" or "/html", then that format is the implicit output
+    // format for all files within the folder
+    const portion = pathInfo.dirname.replace(tplFolder,'');
+    if (portion && portion.trim()) {
+      if (portion[1] === '_') { return; }
+      const reg = /^(?:\/|\\)(html|latex|doc|pdf|png|partials)(?:\/|\\)?/ig;
+      const res = reg.exec( portion );
+      if (res) {
+        if (res[1] !== 'partials') {
+          outFmt = res[1];
+          if (!this.explicit) { act = 'transform'; }
+        } else {
+          this.partials = this.partials || [];
+          this.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) {
+    const idx = pathInfo.name.lastIndexOf('-');
+    outFmt = idx === -1 ? pathInfo.name : pathInfo.name.substr(idx+1);
+    if (!this.explicit) { act = 'transform'; }
+    const defFormats = require('./default-formats');
+    isPrimary = _.some(defFormats, form => (form.name === outFmt) && (pathInfo.extname !== '.css'));
+  }
+
+  // Make sure we have a valid formatsHash
+  formatsHash[ outFmt ] = formatsHash[outFmt] || {
+    outFormat: outFmt,
+    files: []
+  };
+
+  // Move symlink descriptions from theme.json to the format
+  if (__guard__(this.formats != null ? this.formats[outFmt ] : undefined, x => x.symLinks)) {
+    formatsHash[ outFmt ].symLinks = this.formats[ outFmt ].symLinks;
+  }
+
+  // Create the file representation object
+  const obj = {
+    action: act,
+    primary: isPrimary,
+    path: absPath,
+    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;
+};
+
+
+
+/* Return a more friendly name for certain formats. */
+var friendlyName = function( val ) {
+  val = (val && val.trim().toLowerCase()) || '';
+  const friendly = { yml: 'yaml', md: 'markdown', txt: 'text' };
+  return friendly[val] || val;
+};
+
+
+
+module.exports = FRESHTheme;
+
+function __guard__(value, transform) {
+  return (typeof value !== 'undefined' && value !== null) ? transform(value) : undefined;
+}

src/core/jrs-resume.js

@@ -1,278 +1,348 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS206: Consider reworking classes to avoid initClass
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
 /**
 Definition of the JRSResume class.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module jrs-resume.js
+@license MIT. See LICENSE.md for details.
+@module core/jrs-resume
 */
 
-(function() {
 
-  var FS = require('fs')
-    , extend = require('../utils/extend')
-    , validator = require('is-my-json-valid')
-    , _ = require('underscore')
-    , PATH = require('path')
-    , moment = require('moment');
 
-  /**
-  The JRSResume 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 JRSResume
-  */
-  function JRSResume() {
+const FS = require('fs');
+const extend = require('extend');
+let validator = require('is-my-json-valid');
+const _ = require('underscore');
+const PATH = require('path');
+const CONVERTER = require('fresh-jrs-converter');
 
+
+/**
+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
+*/
+
+
+class JRSResume {
+
+  static initClass() {
+    /** Reset the sheet to an empty state. */
+    // clear = function( clearMeta ) {
+    //   clearMeta = ((clearMeta === undefined) && true) || clearMeta;
+    //   if (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;
+    //   return delete this.basics.profiles;
+    // };
+    // extends AbstractResume
   }
 
+
+
+  /** Initialize the the JSResume from string. */
+  parse( stringData, opts ) {
+    this.imp = this.imp != null ? this.imp : {raw: stringData};
+    return this.parseJSON(JSON.parse( stringData ), opts);
+  }
+
+
+
   /**
-  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 &
+  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.open = function( file, title ) {
-    //this.imp = { fileName: file }; <-- schema violation, tuck it into .basics instead
-    this.basics = {
-      imp: {
-        fileName: file,
-        raw: FS.readFileSync( file, 'utf8' )
-      }
-    };
-    return this.parse( this.basics.imp.raw, title );
-  };
-
-  /**
-  Save the sheet to disk (for environments that have disk access).
-  */
-  JRSResume.prototype.save = function( filename ) {
-    this.basics.imp.fileName = filename || this.basics.imp.fileName;
-    FS.writeFileSync( this.basics.imp.fileName, this.stringify( this ), 'utf8' );
-    return this;
-  };
-
-  /**
-  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 );
-  };
-
-  /**
-  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.
-  */
-  JRSResume.prototype.parse = function( stringData, opts ) {
+  parseJSON( rep, opts ) {
+    let scrubbed;
     opts = opts || { };
-    var rep = JSON.parse( stringData );
+    if (opts.privatize) {
+      const scrubber = require('../utils/resume-scrubber');
+      // Ignore any element with the 'ignore: true' or 'private: true' designator.
+      var ret = scrubber.scrubResume(rep, opts);
+      scrubbed = ret.scrubbed;
+    }
+
+    // Extend resume properties onto ourself.
+    extend(true, this, opts.privatize ? scrubbed : rep);
 
-    extend( true, this, rep );
     // 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;
+    if (!(this.imp != null ? this.imp.processed : undefined)) {
+      // 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.basics.name;
+        if (!this.imp.raw) {
+          this.imp.raw = JSON.stringify(rep);
+        }
+      }
+      this.imp.processed = true;
     }
     // 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()
-    });
+    ((opts.date === undefined) || opts.date) && _parseDates.call( this );
+    ((opts.sort === undefined) || opts.sort) && this.sort();
+    if ((opts.compute === undefined) || opts.compute) {
+      this.basics.computed = {
+        numYears: this.duration(),
+        keywords: this.keywords()
+      };
+    }
     return 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 );
-      });
+
+
+  /** Save the sheet to disk (for environments that have disk access). */
+  save( filename ) {
+    this.imp.file = filename || this.imp.file;
+    FS.writeFileSync(this.imp.file, this.stringify( this ), 'utf8');
+    return this;
+  }
+
+
+
+  /** Save the sheet to disk in a specific format, either FRESH or JRS. */
+  saveAs( filename, format ) {
+    if (format === 'JRS') {
+      this.imp.file = filename || this.imp.file;
+      FS.writeFileSync( this.imp.file, this.stringify(), 'utf8' );
+    } else {
+      const newRep = CONVERTER.toFRESH(this);
+      const stringRep = CONVERTER.toSTRING(newRep);
+      FS.writeFileSync(filename, stringRep, 'utf8');
+    }
+    return this;
+  }
+
+
+
+  /** Return the resume format. */
+  format() { return 'JRS'; }
+
+
+
+  stringify() { return JRSResume.stringify( this ); }
+
+
+
+  /** Return a unique list of all keywords across all skills. */
+  keywords() {
+    let flatSkills = [];
+    if (this.skills && this.skills.length) {
+      this.skills.forEach( s  => flatSkills = _.union(flatSkills, s.keywords));
     }
     return flatSkills;
-  };
+  }
+
+
 
   /**
-  Update the sheet's raw data. TODO: remove/refactor
+  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.updateData = function( str ) {
-    this.clear( false );
-    this.parse( str );
-    return this;
-  };
+  i() {
+    return this.imp = this.imp != null ? this.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] );
+  /** Add work experience to the sheet. */
+  add( moniker ) {
+    const defSheet = JRSResume.default();
+    const 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 ) {
+
+
+  /** Determine if the sheet includes a specific social profile (eg, GitHub). */
+  hasProfile( socialNetwork ) {
     socialNetwork = socialNetwork.trim().toLowerCase();
-    return this.basics.profiles && _.some( this.basics.profiles, function(p) {
-      return p.network.trim().toLowerCase() === socialNetwork;
-    });
-  };
+    return this.basics.profiles && _.some(this.basics.profiles, p => p.network.trim().toLowerCase() === socialNetwork);
+  }
 
-  /**
-  Determine if the sheet includes a specific skill.
-  */
-  JRSResume.prototype.hasSkill = function( skill ) {
+
+
+  /** Determine if the sheet includes a specific skill. */
+  hasSkill( 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;
-      });
-    });
-  };
+    return this.skills && _.some(this.skills, sk =>
+      sk.keywords && _.some(sk.keywords, kw => 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]
+
+
+  /** Validate the sheet against the JSON Resume schema. */
+  isValid( ) { // TODO: ↓ fix this path ↓
+    const schema = FS.readFileSync(PATH.join( __dirname, 'resume.json' ), 'utf8');
+    const schemaObj = JSON.parse(schema);
+    validator = require('is-my-json-valid');
+    const 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;
+    const temp = this.imp;
+    delete this.imp;
+    const ret = validate(this);
+    this.imp = temp;
+    if (!ret) {
+      this.imp = this.imp || { };
+      this.imp.validationErrors = validate.errors;
     }
     return ret;
-  };
+  }
+
+
+
+  duration(unit) {
+    const inspector = require('../inspectors/duration-inspector');
+    return inspector.run(this, 'work', 'startDate', 'endDate', unit);
+  }
+
 
-  /**
-  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() {
-    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().
   */
-  JRSResume.prototype.sort = function( ) {
+  sort( ) {
 
-    this.work && this.work.sort( byDateDesc );
-    this.education && this.education.sort( byDateDesc );
-    this.volunteer && this.volunteer.sort( byDateDesc );
+    const byDateDesc = function(a,b) {
+      if (a.safeStartDate.isBefore(b.safeStartDate)) {
+      return 1;
+      } else { return ( a.safeStartDate.isAfter(b.safeStartDate) && -1 ) || 0; }
+    };
 
-    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;
+    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) {
+      if (a.safeDate.isBefore(b.safeDate)) {
+      return 1;
+      } else { return (a.safeDate.isAfter(b.safeDate) && -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 );
+    return this.publications && this.publications.sort(function(a, b) {
+      if ( a.safeReleaseDate.isBefore(b.safeReleaseDate) ) {
+      return 1;
+      } else { return ( a.safeReleaseDate.isAfter(b.safeReleaseDate) && -1 ) || 0; }
     });
   }
 
-  /**
-  Export the JRSResume function/ctor.
-  */
-  module.exports = JRSResume;
 
-}());
+
+  dupe() {
+    const rnew = new JRSResume();
+    rnew.parse(this.stringify(), { });
+    return rnew;
+  }
+
+
+
+  /**
+  Create a copy of this resume in which all fields have been interpreted as
+  Markdown.
+  */
+  harden() {
+
+    const ret = this.dupe();
+
+    const HD = txt => `@@@@~${txt}~@@@@`;
+
+    // const HDIN = txt =>
+    //   //return MD(txt || '' ).replace(/^\s*<p>|<\/p>\s*$/gi, '');
+    //   HD(txt)
+    // ;
+
+    const transformer = require('../utils/string-transformer');
+    return transformer(ret,
+      [ 'skills','url','website','startDate','endDate', 'releaseDate', 'date',
+      'phone','email','address','postalCode','city','country','region',
+      'safeStartDate','safeEndDate' ],
+      (key, val) => HD(val));
+  }
+}
+
+JRSResume.initClass();
+
+
+
+
+/** Get the default (empty) sheet. */
+JRSResume.default = () => new JRSResume().parseJSON(require('fresh-resume-starter').jrs);
+
+
+
+/**
+Convert this object to a JSON string, sanitizing meta-properties along the
+way. Don't override .toString().
+*/
+JRSResume.stringify = function( obj ) {
+  const replacer = function( key,value ) { // Exclude these keys from stringification
+    const temp = _.some(['imp', 'warnings', 'computed', 'filt', 'ctrl', 'index',
+      'safeStartDate', 'safeEndDate', 'safeDate', 'safeReleaseDate', 'result',
+      'isModified', 'htmlPreview', 'display_progress_bar'],
+       val  => key.trim() === val);
+    if (temp) { return undefined; } else { return value; }
+  };
+  return JSON.stringify(obj, replacer, 2);
+};
+
+
+
+/**
+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.
+*/
+var _parseDates = function() {
+
+  const _fmt = require('./fluent-date').fmt;
+
+  this.work && this.work.forEach(function(job) {
+    job.safeStartDate = _fmt( job.startDate );
+    return job.safeEndDate = _fmt( job.endDate );
+  });
+  this.education && this.education.forEach(function(edu) {
+    edu.safeStartDate = _fmt( edu.startDate );
+    return edu.safeEndDate = _fmt( edu.endDate );
+  });
+  this.volunteer && this.volunteer.forEach(function(vol) {
+    vol.safeStartDate = _fmt( vol.startDate );
+    return vol.safeEndDate = _fmt( vol.endDate );
+  });
+  this.awards && this.awards.forEach(awd => awd.safeDate = _fmt( awd.date ));
+  return this.publications && this.publications.forEach(pub => pub.safeReleaseDate = _fmt( pub.releaseDate ));
+};
+
+
+
+/**
+Export the JRSResume class.
+*/
+module.exports = JRSResume;

src/core/jrs-theme.js

@@ -0,0 +1,96 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the JRSTheme class.
+@module core/jrs-theme
+@license MIT. See LICENSE.MD for details.
+*/
+
+
+
+const _ = require('underscore');
+const PATH = require('path');
+const pathExists = require('path-exists').sync;
+const errors = require('./status-codes');
+
+
+
+/**
+The JRSTheme class is a representation of a JSON Resume theme asset.
+@class JRSTheme
+*/
+class JRSTheme {
+
+
+
+  /**
+  Open and parse the specified JRS theme.
+  @method open
+  */
+  open( thFolder ) {
+
+    this.folder = thFolder;
+    //const pathInfo = parsePath(thFolder);
+
+    // Open and parse the theme's package.json file
+    const pkgJsonPath = PATH.join(thFolder, 'package.json');
+    if (pathExists(pkgJsonPath)) {
+      const thApi = require(thFolder);     // Requiring the folder yields whatever the package.json's "main" is set to
+      const thPkg = require(pkgJsonPath);  // Get the package.json as JSON
+      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,
+            primary: true,
+            ext: 'html',
+            css: null
+          }]
+        },
+        pdf: {
+          outFormat: 'pdf',
+          files: [{
+            action: 'transform',
+            render: this.render,
+            primary: true,
+            ext: 'pdf',
+            css: null
+          }]
+        }
+      };
+    } else {
+      throw {fluenterror: errors.missingPackageJSON};
+    }
+    return this;
+  }
+
+
+
+  /**
+  Determine if the theme supports the output format.
+  @method hasFormat
+  */
+  hasFormat( fmt ) {  return _.has(this.formats, fmt); }
+
+
+
+  /**
+  Return the requested output format.
+  @method getFormat
+  */
+  getFormat( fmt ) { return this.formats[ fmt ]; }
+}
+
+
+module.exports = JRSTheme;

src/core/load-source-resumes.js

@@ -1,13 +0,0 @@
-(function(){
-
-  var FRESHResume = require('../core/fresh-resume');
-
-  module.exports = function loadSourceResumes( src, log, fn ) {
-    return src.map( function( res ) {
-      log( 'Reading '.info + 'SOURCE'.infoBold + ' resume: '.info +
-        res.cyan.bold );
-      return (fn && fn(res)) || (new FRESHResume()).open( res );
-    });
-  };
-
-}());

src/core/resume-factory.js

@@ -0,0 +1,127 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the ResumeFactory class.
+@license MIT. See LICENSE.md for details.
+@module core/resume-factory
+*/
+
+
+
+const FS              = require('fs');
+const HMS    = require('./status-codes');
+const HME             = require('./event-codes');
+const ResumeConverter = require('fresh-jrs-converter');
+const resumeDetect    = require('../utils/resume-detector');
+require('string.prototype.startswith');
+
+
+
+/**
+A simple factory class for FRESH and JSON Resumes.
+@class 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( sources, opts, emitter ) {
+    return sources.map( function(src) {
+      return this.loadOne( src, opts, emitter );
+    }
+    , this);
+  },
+
+
+  /** Load a single resume from disk.  */
+  loadOne( src, opts, emitter ) {
+
+    let toFormat = opts.format;     // Can be null
+
+    // Get the destination format. Can be 'fresh', 'jrs', or null/undefined.
+    toFormat && (toFormat = toFormat.toLowerCase().trim());
+
+    // Load and parse the resume JSON
+    const info = _parse(src, opts, emitter);
+    if (info.fluenterror) { return info; }
+
+    // Determine the resume format: FRESH or JRS
+    let { json } = info;
+    const orgFormat = resumeDetect(json);
+    if (orgFormat === 'unk') {
+      info.fluenterror = HMS.unknownSchema;
+      return info;
+    }
+
+    // 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.
+    let rez = null;
+    if (opts.objectify) {
+      const reqLib = `../core/${toFormat || orgFormat}-resume`;
+      const ResumeClass = require(reqLib);
+      rez = new ResumeClass().parseJSON( json, opts.inner );
+      rez.i().file = src;
+    }
+
+    return {
+      file: src,
+      json: info.json,
+      rez
+    };
+  }
+};
+
+
+var _parse = function( fileName, opts, eve ) {
+
+  let rawData = null;
+  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 });
+    const ret = { json: JSON.parse( rawData ) };
+    const 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 (err) {
+    // Can be ENOENT, EACCES, SyntaxError, etc.
+    return {
+      fluenterror: rawData ? HMS.parseError : HMS.readError,
+      inner: err,
+      raw: rawData,
+      file: fileName
+    };
+  }
+};

src/core/status-codes.js

@@ -0,0 +1,41 @@
+/**
+Status codes for HackMyResume.
+@module core/status-codes
+@license MIT. See LICENSE.MD for details.
+*/
+
+
+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,
+  createError: 25,
+  validateError: 26,
+  invalidOptionsFile: 27,
+  optionsFileNotFound: 28,
+  unknownSchema: 29,
+  themeHelperLoad: 30,
+  invalidSchemaVersion: 31
+};

src/core/theme.js

@@ -1,274 +0,0 @@
-/**
-Definition of the Theme class.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module theme.js
-*/
-
-(function() {
-
-  var FS = require('fs')
-    , extend = require('../utils/extend')
-    , validator = require('is-my-json-valid')
-    , _ = require('underscore')
-    , PATH = require('path')
-    , EXTEND = require('../utils/extend')
-    , moment = require('moment')
-    , RECURSIVE_READ_DIR = require('recursive-readdir-sync');
-
-  /**
-  The Theme class is a representation of a HackMyResume theme asset.
-  @class Theme
-  */
-  function Theme() {
-
-  }
-
-  /**
-  Open and parse the specified theme.
-  */
-  Theme.prototype.open = function( themeFolder ) {
-
-    // Open the [theme-name].json file; should have the same name as folder
-    this.folder = themeFolder;
-    var pathInfo = PATH.parse( themeFolder );
-    var themeFile = PATH.join( themeFolder, pathInfo.base + '.json' );
-    var themeInfo = JSON.parse( FS.readFileSync( themeFile, 'utf8' ) );
-    var that = this;
-
-    // Move properties from the theme JSON file to the theme object
-    EXTEND( true, this, themeInfo );
-
-    // Set up a formats has for the theme
-    var formatsHash = { };
-
-    // 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 );
-      this.explicit = true;
-    }
-    else {
-      formatsHash = loadImplicit.call( this );
-    }
-
-    // Add freebie formats every theme gets
-    formatsHash.json = { title: 'json', outFormat: 'json', pre: 'json', ext: 'json', path: null, data: null };
-    formatsHash.yml = { title: 'yaml', outFormat: 'yml', pre: 'yml', ext: 'yml', path: null, data: null };
-
-    // Cache
-    this.formats = formatsHash;
-
-    // Set the official theme name
-    this.name = PATH.parse( this.folder ).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 ];
-  };
-
-  function loadImplicit() {
-
-    // Set up a hash of formats supported by this theme.
-    var formatsHash = { };
-    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 = RECURSIVE_READ_DIR( 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 = PATH.parse(absPath);
-      var outFmt = '', isMajor = false;
-      var portion = pathInfo.dir.replace(tplFolder,'');
-      if( portion && portion.trim() ) {
-        if( portion[1] === '_' ) return;
-        var reg = /^(?:\/|\\)(html|latex|doc|pdf|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.ext.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'); }))
-    .forEach(function( cssf ) {
-      // For each CSS file, get its corresponding HTML file
-      var idx = _.findIndex(fmts, function( fmt ) {
-        return fmt && fmt.pre === cssf.pre && fmt.ext === 'html';
-      });
-      cssf.action = null;
-      fmts[ idx ].css = cssf.data;
-      fmts[ idx ].cssPath = cssf.path;
-    });
-
-    // Remove CSS files from the formats array
-    fmts = fmts.filter( function( fmt) {
-      return fmt && (fmt.ext !== 'css');
-    });
-
-    return formatsHash;
-  }
-
-  function loadExplicit() {
-
-    var that = this;
-    // Set up a hash of formats supported by this theme.
-    var formatsHash = { };
-
-    // Establish the base theme folder
-    var tplFolder = PATH.join( this.folder, 'src' );
-
-    var act = null;
-
-    // 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 = RECURSIVE_READ_DIR( tplFolder ).map( function( absPath ) {
-
-      act = null;
-      // If this file is mentioned in the theme's JSON file under "transforms"
-      var pathInfo = PATH.parse(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.dir.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.ext.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'; }))
-    .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;
-  }
-
-  function friendlyName( val ) {
-    val = val.trim().toLowerCase();
-    var friendly = { yml: 'yaml', md: 'markdown', txt: 'text' };
-    return friendly[val] || val;
-  }
-
-  module.exports = Theme;
-
-}());

src/eng/generic-helpers.js

@@ -1,169 +0,0 @@
-/**
-Generic template helper definitions for FluentCV.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module generic-helpers.js
-*/
-
-
-(function() {
-
-  var MD = require('marked')
-    , H2W = require('../utils/html-to-wpml')
-    , moment = require('moment')
-    , _ = require('underscore');
-
-  /**
-  Generic template helper function definitions.
-  @class GenericHelpers
-  */
-  var GenericHelpers = module.exports = {
-
-    /**
-    Convert the input date to a specified format through Moment.js.
-    @method formatDate
-    */
-    formatDate: function(datetime, format) {
-      return moment ? moment( datetime ).format( format ) : datetime;
-    },
-
-    /**
-    Convert inline Markdown to inline WordProcessingML.
-    @method wpml
-    */
-    wpml: function( txt, inline ) {
-      if(!txt) return '';
-      inline = (inline && !inline.hash) || false;
-      txt = inline ?
-        MD(txt.trim()).replace(/^\s*<p>|<\/p>\s*$/gi, '') :
-        MD(txt.trim());
-      txt = H2W( txt.trim() );
-      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.
-    @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.
-    @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() : '';
-    },
-
-    /**
-    Return true if either value is truthy.
-    @method either
-    */
-    either: function( lhs, rhs, options ) {
-      if (lhs || rhs) return options.fn(this);
-    },
-
-    /**
-    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);
-    }
-
-  };
-
-  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;
-  }
-
-}());

src/eng/handlebars-generator.js

@@ -1,50 +0,0 @@
-/**
-Definition of the HandlebarsGenerator class.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module handlebars-generator.js
-*/
-
-(function() {
-
-
-
-  var _ = require('underscore')
-    , HANDLEBARS = require('handlebars')
-    , FS = require('fs')
-    , registerHelpers = require('./handlebars-helpers');
-
-
-
-  /**
-  Perform template-based resume generation using Handlebars.js.
-  @class HandlebarsGenerator
-  */
-  var HandlebarsGenerator = module.exports = {
-
-    generate: function( json, jst, format, cssInfo, opts, theme ) {
-
-      // Pre-compile any partials present in the theme.
-      _.each( theme.partials, function( el ) {
-        var tplData = FS.readFileSync( el.path, 'utf8' );
-        var compiledTemplate = HANDLEBARS.compile( tplData );
-        HANDLEBARS.registerPartial( el.name, compiledTemplate );
-      });
-
-      // Register necessary helpers.
-      registerHelpers( theme );
-
-      // Compile and run the Handlebars template.
-      var template = HANDLEBARS.compile(jst);
-      return template({
-        r: format === 'html' || format === 'pdf' ? json.markdownify() : json,
-        RAW: json,
-        filt: opts.filters,
-        cssInfo: cssInfo,
-        headFragment: opts.headFragment || ''
-      });
-
-    }
-
-  };
-
-}());

src/eng/handlebars-helpers.js

@@ -1,25 +0,0 @@
-/**
-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 ) {
-
-    helpers.theme = theme;
-    HANDLEBARS.registerHelper( helpers );
-
-  };
-
-}());

src/eng/underscore-generator.js

@@ -1,52 +0,0 @@
-/**
-Definition of the UnderscoreGenerator class.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module underscore-generator.js
-*/
-
-(function() {
-
-
-
-  var _ = require('underscore');
-
-
-
-  /**
-  Perform template-based resume generation using Underscore.js.
-  @class UnderscoreGenerator
-  */
-  var UnderscoreGenerator = module.exports = {
-
-    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, '');
-
-      // Compile and run the template. TODO: avoid unnecessary recompiles.
-      var compiled = _.template(jst);
-      var ret = compiled({
-        r: format === 'html' || format === 'pdf' ? json.markdownify() : json,
-        filt: opts.filters,
-        XML: require('xml-escape'),
-        RAW: json,
-        cssInfo: cssInfo,
-        headFragment: opts.headFragment || ''
-      });
-      return ret;
-    }
-
-  };
-
-  
-
-}());

src/gen/base-generator.js

@@ -1,46 +0,0 @@
-/**
-Definition of the BaseGenerator class.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module base-generator.js
-*/
-
-(function() {
-
-  // Use J. Resig's nifty class implementation
-  var Class = require( '../utils/class' );
-
-  /**
-  The BaseGenerator class is the root of the generator hierarchy. Functionality
-  common to ALL generators lives here.
-  */
-
-  var BaseGenerator = module.exports = Class.extend({
-
-    /**
-    Base-class initialize.
-    */
-    init: function( outputFormat ) {
-      this.format = outputFormat;
-    },
-
-    /**
-    Status codes.
-    */
-    codes: {
-      success: 0,
-      themeNotFound: 1,
-      copyCss: 2,
-      resumeNotFound: 3,
-      missingCommand: 4,
-      invalidCommand: 5
-    },
-
-    /**
-    Generator options.
-    */
-    opts: {
-
-    }
-
-  });
-}());

src/gen/html-generator.js

@@ -1,31 +0,0 @@
-/**
-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');
-
-  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 ) {
-      return this.opts.prettify ?
-        HTML.prettyPrint( info.mk, this.opts.prettify ) : info.mk;
-    }
-
-  });
-
-}());

src/gen/html-pdf-generator.js

@@ -1,72 +0,0 @@
-/**
-Definition of the HtmlPdfGenerator class.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module html-pdf-generator.js
-*/
-
-(function() {
-
-  var TemplateGenerator = require('./template-generator')
-    , FS = require('fs-extra')
-    , HTML = require( 'html' );
-
-  /**
-  An HTML-based PDF resume generator for HackMyResume.
-  */
-  var HtmlPdfGenerator = module.exports = TemplateGenerator.extend({
-
-    init: function() {
-      this._super( 'pdf', 'html' );
-    },
-
-    /**
-    Generate the binary PDF.
-    */
-    onBeforeSave: function( info ) {
-      pdf( info.mk, info.outputFile );
-      return null; // halt further processing
-    }
-
-  });
-
-  /**
-  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/json-generator.js

@@ -1,36 +0,0 @@
-/**
-Definition of the JsonGenerator class.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module json-generator.js
-*/
-
-var BaseGenerator = require('./base-generator');
-var FS = require('fs');
-var _ = require('underscore');
-
-/**
-The JsonGenerator generates a JSON resume directly.
-*/
-var JsonGenerator = module.exports = BaseGenerator.extend({
-
-  init: function(){
-    this._super( 'json' );
-  },
-
-  invoke: function( rez ) {
-    // TODO: merge with FCVD
-    function replacer( key,value ) { // Exclude these keys from stringification
-      return _.some(['imp', 'warnings', 'computed', 'filt', 'ctrl', 'index',
-        'safeStartDate', 'safeEndDate', 'safeDate', 'safeReleaseDate', 'result',
-      'isModified', 'htmlPreview', 'safe' ],
-        function( val ) { return key.trim() === val; }
-      ) ? undefined : value;
-    }
-    return JSON.stringify( rez, replacer, 2 );
-  },
-
-  generate: function( rez, f ) {
-    FS.writeFileSync( f, this.invoke(rez), 'utf8' );
-  }
-
-});

src/gen/json-yaml-generator.js

@@ -1,37 +0,0 @@
-/**
-Definition of the JsonYamlGenerator class.
-@module json-yaml-generator.js
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-*/
-
-(function() {
-
-  var BaseGenerator = require('./base-generator');
-  var FS = require('fs');
-  var YAML = require('yamljs');
-
-  /**
-  JsonYamlGenerator takes a JSON resume object and translates it directly to
-  JSON without a template, producing an equivalent YAML-formatted resume. See
-  also YamlGenerator (yaml-generator.js).
-  */
-
-  var JsonYamlGenerator = module.exports = BaseGenerator.extend({
-
-    init: function(){
-      this._super( 'yml' );
-    },
-
-    invoke: function( rez, themeMarkup, cssInfo, opts ) {
-      return YAML.stringify( JSON.parse( rez.stringify() ), Infinity, 2 );
-    },
-
-    generate: function( rez, f, opts ) {
-      var data = YAML.stringify( JSON.parse( rez.stringify() ), Infinity, 2 );
-      FS.writeFileSync( f, data, 'utf8' );
-    }
-
-
-  });
-
-}());

src/gen/latex-generator.js

@@ -1,18 +0,0 @@
-/**
-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/gen/markdown-generator.js

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

src/gen/template-generator.js

@@ -1,297 +0,0 @@
-/**
-Definition of the TemplateGenerator class.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module template-generator.js
-*/
-
-(function() {
-
-
-
-  var FS = require( 'fs-extra' )
-    , _ = require( 'underscore' )
-    , MD = require( 'marked' )
-    , XML = require( 'xml-escape' )
-    , PATH = require('path')
-    , MKDIRP = require('mkdirp')
-    , BaseGenerator = require( './base-generator' )
-    , EXTEND = require('../utils/extend')
-    , Theme = require('../core/theme');
-
-
-
-  // Default 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
-    }
-  };
-
-
-
-  /**
-  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({
-
-
-
-    init: function( outputFormat, templateFormat, cssFile ){
-      this._super( outputFormat );
-      this.tplFormat = templateFormat || outputFormat;
-    },
-
-
-    /**
-    String-based template generation method.
-    @method invoke
-    @param rez A FreshResume object.
-    @param opts Generator options.
-    @returns An array of strings representing generated output files.
-    */
-    invoke: function( rez, opts ) {
-
-      // Carry over options
-      this.opts = EXTEND( true, { }, _defaultOpts, opts );
-
-      // Load the theme
-      var themeInfo = themeFromMoniker.call( this );
-      var theme = themeInfo.theme;
-      var tFolder = themeInfo.folder;
-      var tplFolder = PATH.join( tFolder, 'src' );
-      var curFmt = theme.getFormat( this.format );
-      var that = this;
-
-      // "Generate": process individual files within the theme
-      return {
-        files: curFmt.files.map( function( tplInfo ) {
-          return {
-            info: tplInfo,
-            data: tplInfo.action === 'transform' ?
-              transform.call( that, rez, tplInfo, theme ) : undefined
-          };
-        }).filter(function(item){ return item !== null; }),
-        themeInfo: themeInfo
-      };
-
-    },
-
-
-
-    /**
-    File-based template generation method.
-    @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 ) {
-
-      // Call the generation method
-      var genInfo = this.invoke( rez, opts );
-
-      // Carry over options
-      this.opts = EXTEND( true, { }, _defaultOpts, opts );
-
-      // Load the theme
-      var themeInfo = genInfo.themeInfo;
-      var theme = themeInfo.theme;
-      var tFolder = themeInfo.folder;
-      var tplFolder = PATH.join( tFolder, 'src' );
-      var outFolder = PATH.parse(f).dir;
-      var curFmt = theme.getFormat( this.format );
-      var that = this;
-
-      // "Generate": process individual files within the theme
-      genInfo.files.forEach(function( file ){
-
-        var thisFilePath;
-
-        if( file.info.action === 'transform' ) {
-          thisFilePath = PATH.join( outFolder, file.info.orgPath );
-          try {
-            if( that.onBeforeSave ) {
-              file.data = that.onBeforeSave({
-                theme: theme,
-                outputFile: (file.info.major ? f : thisFilePath),
-                mk: file.data
-              });
-              if( !file.data ) return; // PDF etc
-            }
-            var fileName = file.info.major ? f : thisFilePath;
-            MKDIRP.sync( PATH.dirname( fileName ) );
-            FS.writeFileSync( fileName, file.data,
-              { encoding: 'utf8', flags: 'w' } );
-            that.onAfterSave && that.onAfterSave(
-              { outputFile: fileName, mk: file.data } );
-          }
-          catch(ex) {
-            console.log(ex);
-          }
-        }
-        else if( file.info.action === null/* && theme.explicit*/ ) {
-          thisFilePath = PATH.join( outFolder, file.info.orgPath );
-          try {
-            MKDIRP.sync( PATH.dirname(thisFilePath) );
-            FS.copySync( file.info.path, thisFilePath );
-          }
-          catch(ex) {
-            console.log(ex);
-          }
-        }
-      });
-
-      // 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 = PATH.parse( absLoc ).ext ? 'file' : 'junction';
-          FS.symlinkSync( absTarg, absLoc, type);
-        });
-      }
-
-    },
-
-
-
-    /**
-    Perform a single resume JSON-to-DEST resume transformation.
-    @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, cssInfo, opts, theme ) {
-      this.opts.freezeBreaks && ( jst = freeze(jst) );
-
-      var eng = require( '../eng/' + theme.engine  + '-generator' );
-      var result = eng.generate( json, jst, format, cssInfo, opts, theme );
-
-      this.opts.freezeBreaks && ( result = unfreeze(result) );
-      return result;
-    }
-
-
-  });
-
-
-
-  /**
-  Export the TemplateGenerator function/ctor.
-  */
-  module.exports = TemplateGenerator;
-
-
-
-  /**
-  Given a theme title, load the corresponding theme.
-  */
-  function themeFromMoniker() {
-    // Verify the specified theme name/path
-    var tFolder = PATH.join(
-      PATH.parse( require.resolve('fluent-themes') ).dir,
-      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};
-      }
-    }
-
-    var t = this.opts.themeObj || new Theme().open( tFolder );
-
-    // Load the theme and format
-    return {
-      theme: t,
-      folder: tFolder
-    };
-  }
-
-
-
-  function transform( rez, tplInfo, theme ) {
-    try {
-      var cssInfo = {
-        file: tplInfo.css ? tplInfo.cssPath : null,
-        data: tplInfo.css || null
-      };
-
-      return this.single( rez, tplInfo.data, this.format, cssInfo, this.opts,
-        theme );
-    }
-    catch(ex) {
-      console.log(ex);
-    }
-  }
-
-
-
-  /**
-  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/text-generator.js

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

src/gen/word-generator.js

@@ -1,19 +0,0 @@
-/**
-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/gen/xml-generator.js

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

src/gen/yaml-generator.js

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

src/generators/base-generator.js

@@ -0,0 +1,37 @@
+/*
+ * decaffeinate suggestions:
+ * DS206: Consider reworking classes to avoid initClass
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the BaseGenerator class.
+@module generators/base-generator
+@license MIT. See LICENSE.md for details.
+*/
+
+
+/**
+The BaseGenerator class is the root of the generator hierarchy. Functionality
+common to ALL generators lives here.
+*/
+
+let BaseGenerator;
+module.exports = (BaseGenerator = (function() {
+  BaseGenerator = class BaseGenerator {
+    static initClass() {
+  
+      /** Status codes. */
+      this.prototype.codes = require('../core/status-codes');
+  
+      /** Generator options. */
+      this.prototype.opts = { };
+    }
+
+    /** Base-class initialize. */
+    constructor( format ) {
+      this.format = format;
+    }
+  };
+  BaseGenerator.initClass();
+  return BaseGenerator;
+})());

src/generators/html-generator.js

@@ -0,0 +1,39 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the HTMLGenerator class.
+@module generators/html-generator
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const TemplateGenerator = require('./template-generator');
+const HTML = require('html');
+require('string.prototype.endswith');
+
+
+
+class HtmlGenerator extends TemplateGenerator {
+
+  constructor() { super('html'); }
+
+  /**
+  Copy satellite CSS files to the destination and optionally pretty-print
+  the HTML resume prior to saving.
+  */
+  onBeforeSave( info ) {
+    if (info.outputFile.endsWith('.css')) {
+      return info.mk;
+    }
+    if (this.opts.prettify) {
+    return HTML.prettyPrint(info.mk, this.opts.prettify);
+    } else { return info.mk; }
+  }
+}
+
+
+module.exports = HtmlGenerator;

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

@@ -0,0 +1,129 @@
+/*
+ * decaffeinate suggestions:
+ * DS103: Rewrite code to no longer use __guard__
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the HtmlPdfCLIGenerator class.
+@module generators/html-pdf-generator.js
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const TemplateGenerator = require('./template-generator');
+const FS = require('fs-extra');
+const PATH = require('path');
+const SLASH = require('slash');
+const _ = require('underscore');
+const HMSTATUS = require('../core/status-codes');
+const SPAWN = require('../utils/safe-spawn');
+
+
+/**
+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.
+*/
+
+class HtmlPdfCLIGenerator extends TemplateGenerator {
+
+
+
+  constructor() { super('pdf', 'html'); }
+
+
+
+  /** Generate the binary PDF. */
+  onBeforeSave( info ) {
+    //console.dir _.omit( info, 'mk' ), depth: null, colors: true
+    if ((info.ext !== 'html') && (info.ext !== 'pdf')) { return info.mk; }
+    let safe_eng = info.opts.pdf || 'wkhtmltopdf';
+    if (safe_eng === 'phantom') { safe_eng = 'phantomjs'; }
+    if (_.has(engines, safe_eng)) {
+      this.errHandler = info.opts.errHandler;
+      engines[ safe_eng ].call(this, info.mk, info.outputFile, info.opts, this.onError);
+      return null; // halt further processing
+    }
+  }
+
+
+
+  /* Low-level error callback for spawn(). May be called after HMR process
+  termination, so object references may not be valid here. That's okay; if
+  the references are invalid, the error was already logged. We could use
+  spawn-watch here but that causes issues on legacy Node.js. */
+  onError(ex, param) {
+    __guardMethod__(param.errHandler, 'err', o => o.err(HMSTATUS.pdfGeneration, ex));
+  }
+}
+
+module.exports = HtmlPdfCLIGenerator;
+
+// 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(markup, fOut, opts, on_error) {
+    // Save the markup to a temporary file
+    const tempFile = fOut.replace(/\.pdf$/i, '.pdf.html');
+    FS.writeFileSync(tempFile, markup, 'utf8');
+
+    // Prepare wkhtmltopdf arguments.
+    let wkopts = _.extend({'margin-top': '10mm', 'margin-bottom': '10mm'}, opts.wkhtmltopdf);
+    wkopts = _.flatten(_.map(wkopts, (v, k) => [`--${k}`, v]));
+    const wkargs = wkopts.concat([ tempFile, fOut  ]);
+
+    SPAWN('wkhtmltopdf', wkargs , false, on_error, this);
+  },
+
+
+
+  /**
+  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
+  */
+  phantomjs( markup, fOut, opts, on_error ) {
+    // Save the markup to a temporary file
+    const tempFile = fOut.replace(/\.pdf$/i, '.pdf.html');
+    FS.writeFileSync(tempFile, markup, 'utf8');
+    let scriptPath = PATH.relative(process.cwd(), PATH.resolve( __dirname, '../utils/rasterize.js' ));
+    scriptPath = SLASH(scriptPath);
+    const sourcePath = SLASH(PATH.relative( process.cwd(), tempFile));
+    const destPath = SLASH(PATH.relative( process.cwd(), fOut));
+    SPAWN('phantomjs', [ scriptPath, sourcePath, destPath ], false, on_error, this);
+  },
+
+  /**
+  Generate a PDF from HTML using WeasyPrint's CLI interface.
+  Spawns a child process with `weasyprint <source> <target>`. Weasy Print
+  must be installed and path-accessible.
+  TODO: If HTML generation has run, reuse that output
+  */
+  weasyprint( markup, fOut, opts, on_error ) {
+    // Save the markup to a temporary file
+    const tempFile = fOut.replace(/\.pdf$/i, '.pdf.html');
+    FS.writeFileSync(tempFile, markup, 'utf8');
+
+    SPAWN('weasyprint', [tempFile, fOut], false, on_error, this);
+  }
+};
+
+function __guardMethod__(obj, methodName, transform) {
+  if (typeof obj !== 'undefined' && obj !== null && typeof obj[methodName] === 'function') {
+    return transform(obj, methodName);
+  } else {
+    return undefined;
+  }
+}

src/generators/html-png-generator.js

@@ -0,0 +1,58 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the HtmlPngGenerator class.
+@module generators/html-png-generator
+@license MIT. See LICENSE.MD for details.
+*/
+
+
+
+const TemplateGenerator = require('./template-generator');
+const FS = require('fs-extra');
+const SLASH = require('slash');
+const SPAWN = require('../utils/safe-spawn');
+const PATH = require('path');
+
+
+/**
+An HTML-based PNG resume generator for HackMyResume.
+*/
+class HtmlPngGenerator extends TemplateGenerator {
+
+  constructor() { super('png', 'html'); }
+
+  invoke( /*rez, themeMarkup, cssInfo, opts*/ ) {}
+    // TODO: Not currently called or callable.
+
+  generate( rez, f, opts ) {
+    const htmlResults = opts.targets.filter(t => t.fmt.outFormat === 'html');
+    const htmlFile = htmlResults[0].final.files.filter(fl => fl.info.ext === 'html');
+    phantom(htmlFile[0].data, f);
+  }
+}
+
+module.exports = HtmlPngGenerator;
+
+/**
+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
+*/
+
+var phantom = function( markup, fOut ) {
+
+  // Save the markup to a temporary file
+  const tempFile = fOut.replace(/\.png$/i, '.png.html');
+  FS.writeFileSync(tempFile, markup, 'utf8');
+  const scriptPath = SLASH( PATH.relative( process.cwd(),
+    PATH.resolve( __dirname, '../utils/rasterize.js' ) ) );
+  const sourcePath = SLASH( PATH.relative( process.cwd(), tempFile) );
+  const destPath = SLASH( PATH.relative( process.cwd(), fOut) );
+  SPAWN('phantomjs', [ scriptPath, sourcePath, destPath ]);
+};

src/generators/json-generator.js

@@ -0,0 +1,33 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the JsonGenerator class.
+@module generators/json-generator
+@license MIT. See LICENSE.md for details.
+*/
+
+const BaseGenerator = require('./base-generator');
+const FS = require('fs');
+const FJCV = require('fresh-jrs-converter');
+
+/** The JsonGenerator generates a FRESH or JRS resume as an output. */
+
+class JsonGenerator extends BaseGenerator {
+
+  constructor() { super('json'); }
+
+  invoke( rez ) {
+    let altRez = FJCV[ `to${rez.format() === 'FRESH' ? 'JRS' : 'FRESH'}` ](rez);
+    return altRez = FJCV.toSTRING( altRez );
+  }
+    //altRez.stringify()
+
+  generate( rez, f ) {
+    FS.writeFileSync(f, this.invoke(rez), 'utf8');
+  }
+}
+
+module.exports = JsonGenerator;

src/generators/json-yaml-generator.js

@@ -0,0 +1,41 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the JsonYamlGenerator class.
+@module generators/json-yaml-generator
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const BaseGenerator = require('./base-generator');
+const FS = require('fs');
+const YAML = require('yamljs');
+
+
+
+/**
+JsonYamlGenerator takes a JSON resume object and translates it directly to
+JSON without a template, producing an equivalent YAML-formatted resume. See
+also YamlGenerator (yaml-generator.js).
+*/
+
+class JsonYamlGenerator extends BaseGenerator {
+
+  constructor() { super('yml'); }
+
+  invoke( rez/*, themeMarkup, cssInfo, opts*/ ) {
+    return YAML.stringify(JSON.parse( rez.stringify() ), Infinity, 2);
+  }
+
+  generate( rez, f/*, opts */) {
+    const data = YAML.stringify(JSON.parse( rez.stringify() ), Infinity, 2);
+    FS.writeFileSync(f, data, 'utf8');
+    return data;
+  }
+}
+
+module.exports = JsonYamlGenerator;

src/generators/latex-generator.js

@@ -0,0 +1,17 @@
+/**
+Definition of the LaTeXGenerator class.
+@module generators/latex-generator
+@license MIT. See LICENSE.md for details.
+*/
+
+const TemplateGenerator = require('./template-generator');
+
+/**
+LaTeXGenerator generates a LaTeX resume via TemplateGenerator.
+*/
+class LaTeXGenerator extends TemplateGenerator {
+
+  constructor() { super('latex', 'tex'); }
+}
+
+module.exports = LaTeXGenerator;

src/generators/markdown-generator.js

@@ -0,0 +1,17 @@
+/**
+Definition of the MarkdownGenerator class.
+@module generators/markdown-generator
+@license MIT. See LICENSE.md for details.
+*/
+
+const TemplateGenerator = require('./template-generator');
+
+/**
+MarkdownGenerator generates a Markdown-formatted resume via TemplateGenerator.
+*/
+class MarkdownGenerator extends TemplateGenerator {
+
+  constructor() { super('md', 'txt'); }
+}
+
+module.exports = MarkdownGenerator;

src/generators/template-generator.js

@@ -0,0 +1,283 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the TemplateGenerator class. TODO: Refactor
+@module generators/template-generator
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const FS = require('fs-extra');
+const _ = require('underscore');
+const MD = require('marked');
+const XML = require('xml-escape');
+const PATH = require('path');
+const parsePath = require('parse-filepath');
+const MKDIRP = require('mkdirp');
+const BaseGenerator = require('./base-generator');
+const EXTEND = require('extend');
+
+
+
+/**
+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
+*/
+
+class TemplateGenerator extends BaseGenerator {
+
+
+
+  /** Constructor. Set the output format and template format for this
+  generator. Will usually be called by a derived generator such as
+  HTMLGenerator or MarkdownGenerator. */
+
+  constructor( outputFormat, templateFormat/*, cssFile */) {
+    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( rez, opts ) {
+
+    opts =
+      opts
+      ? (this.opts = EXTEND( true, { }, _defaultOpts, opts ))
+      : this.opts;
+
+    // Sort such that CSS files are processed before others
+    const curFmt = opts.themeObj.getFormat( this.format );
+    curFmt.files = _.sortBy(curFmt.files, fi => fi.ext !== 'css');
+
+    // Run the transformation!
+    const results = curFmt.files.map(function( tplInfo, idx ) {
+      let trx;
+      if (tplInfo.action === 'transform') {
+        trx = this.transform(rez, tplInfo.data, this.format, opts, opts.themeObj, curFmt);
+        if (tplInfo.ext === 'css') {
+          curFmt.files[idx].data = trx;
+        } else { tplInfo.ext === 'html'; }
+      }
+          //tplInfo.css contains the CSS data loaded by theme
+          //tplInfo.cssPath contains the absolute path to the source CSS File
+      //else {}
+        // Images and non-transformable binary files
+      if (typeof opts.onTransform === 'function') {
+        opts.onTransform(tplInfo);
+      }
+      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( rez, f, opts ) {
+
+    // Prepare
+    this.opts = EXTEND(true, { }, _defaultOpts, opts);
+
+    // Call the string-based generation method
+    const genInfo = this.invoke(rez, null);
+    const outFolder = parsePath( f ).dirname;
+    const 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 ) {
+
+      // console.dir _.omit(file.info,'cssData','data','css' )
+
+      // Pre-processing
+      file.info.orgPath = file.info.orgPath || '';
+      const thisFilePath =
+        file.info.primary
+        ? f
+        : PATH.join(outFolder, file.info.orgPath);
+
+      if ((file.info.action !== 'copy') && this.onBeforeSave) {
+        file.data = this.onBeforeSave({
+          theme: opts.themeObj,
+          outputFile: thisFilePath,
+          mk: file.data,
+          opts: this.opts,
+          ext: file.info.ext
+        });
+        if (!file.data) {
+          return;
+        }
+      }
+
+      // Write the file
+      if (typeof opts.beforeWrite === 'function') {
+        opts.beforeWrite({data: thisFilePath});
+      }
+      MKDIRP.sync(PATH.dirname( thisFilePath ));
+
+      if (file.info.action !== 'copy') {
+        FS.writeFileSync(thisFilePath, file.data, {encoding: 'utf8', flags: 'w'});
+      } else {
+        FS.copySync(file.info.path, thisFilePath);
+      }
+      if (typeof opts.afterWrite === 'function') {
+        opts.afterWrite({data: thisFilePath});
+      }
+
+      // Post-processing
+      if (this.onAfterSave) {
+        return this.onAfterSave({outputFile: thisFilePath, mk: file.data, opts: this.opts});
+      }
+    }
+
+    , this);
+
+    // Some themes require a symlink structure. If so, create it.
+    createSymLinks(curFmt, outFolder);
+
+    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. */
+
+  transform( json, jst, format, opts, theme, curFmt ) {
+    if (this.opts.freezeBreaks) {
+      jst = freeze(jst);
+    }
+    const eng = require(`../renderers/${theme.engine}-generator`);
+    let result = eng.generate(json, jst, format, curFmt, opts, theme);
+    if (this.opts.freezeBreaks) {
+      result = unfreeze(result);
+    }
+    return result;
+  }
+}
+
+
+module.exports = TemplateGenerator;
+
+
+
+var createSymLinks = function( curFmt, outFolder ) {
+  // Some themes require a symlink structure. If so, create it.
+  if (curFmt.symLinks) {
+    Object.keys( curFmt.symLinks ).forEach(function(loc) {
+      const absLoc = PATH.join(outFolder, loc);
+      const absTarg = PATH.join(PATH.dirname(absLoc), curFmt.symLinks[loc]);
+      // Set type to 'file', 'dir', or 'junction' (Windows only)
+      const type = parsePath( absLoc ).extname ? 'file' : 'junction';
+
+      try {
+        return FS.symlinkSync(absTarg, absLoc, type);
+      } catch (err) {
+        let succeeded = false;
+        if (err.code === 'EEXIST') {
+          FS.unlinkSync(absLoc);
+          try {
+            FS.symlinkSync(absTarg, absLoc, type);
+            succeeded = true;
+          } catch (error) {
+            throw error;
+          }
+        }
+        if (!succeeded) {
+          throw err;
+        }
+      }
+    });
+    return;
+  }
+};
+
+
+/** Freeze newlines for protection against errant JST parsers. */
+var freeze = function( markup ) {
+  markup.replace( _reg.regN, _defaultOpts.nSym );
+  return markup.replace( _reg.regR, _defaultOpts.rSym );
+};
+
+
+
+/** Unfreeze newlines when the coast is clear. */
+var unfreeze = function( markup ) {
+  markup.replace(_reg.regSymR, '\r');
+  return markup.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( txt ) { return txt; },
+    raw( txt ) { return txt; },
+    xml( txt ) { return XML(txt); },
+    md( txt ) { return MD( txt || '' ); },
+    mdin( txt ) { return MD(txt || '' ).replace(/^\s*<p>|<\/p>\s*$/gi, ''); },
+    lower( txt ) { return txt.toLowerCase(); },
+    link( name, url ) {
+      if (url) { return `<a href="${url}">${name}</a>`; } else { return 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. */
+/* eslint-disable no-control-regex */
+var _reg = {
+  regN: new RegExp( '\n', 'g' ),
+  regR: new RegExp( '\r', 'g' ),
+  regSymN: new RegExp( _defaultOpts.nSym, 'g' ),
+  regSymR: new RegExp( _defaultOpts.rSym, 'g' )
+};
+/* eslint-enable no-control-regex */

src/generators/text-generator.js

@@ -0,0 +1,16 @@
+/**
+Definition of the TextGenerator class.
+@module generators/text-generator
+@license MIT. See LICENSE.md for details.
+*/
+
+const TemplateGenerator = require('./template-generator');
+
+/**
+The TextGenerator generates a plain-text resume via the TemplateGenerator.
+*/
+class TextGenerator extends TemplateGenerator {
+  constructor() { super('txt'); }
+}
+
+module.exports = TextGenerator;

src/generators/word-generator.js

@@ -0,0 +1,14 @@
+/*
+Definition of the WordGenerator class.
+@module generators/word-generator
+@license MIT. See LICENSE.md for details.
+*/
+
+
+const TemplateGenerator = require('./template-generator');
+
+class WordGenerator extends TemplateGenerator {
+  constructor() { super('doc', 'xml'); }
+}
+
+module.exports = WordGenerator;

src/generators/xml-generator.js

@@ -0,0 +1,14 @@
+/**
+Definition of the XMLGenerator class.
+@license MIT. See LICENSE.md for details.
+@module generatprs/xml-generator
+*/
+
+const BaseGenerator = require('./base-generator');
+
+/** The XmlGenerator generates an XML resume via the TemplateGenerator. */
+class XMLGenerator extends BaseGenerator {
+  constructor() { super('xml'); }
+}
+
+module.exports = XMLGenerator;

src/generators/yaml-generator.js

@@ -0,0 +1,19 @@
+/**
+Definition of the YAMLGenerator class.
+@module yaml-generator.js
+@license MIT. See LICENSE.md for details.
+*/
+
+
+const TemplateGenerator = require('./template-generator');
+
+/**
+YamlGenerator generates a YAML-formatted resume via TemplateGenerator.
+*/
+
+class YAMLGenerator extends TemplateGenerator {
+  constructor() { super('yml', 'yml'); }
+}
+
+
+module.exports = YAMLGenerator;

src/hackmyapi.js

@@ -1,22 +0,0 @@
-/**
-External API surface for HackMyResume.
-@license MIT. Copyright (c) 2015 James M. Devlin / FluentDesk.
-@module hackmyapi.js
-*/
-
-module.exports = {
-  Sheet: require('./core/fresh-resume'),
-  FRESHResume: require('./core/fresh-resume'),
-  JRSResume: require('./core/jrs-resume'),
-  Theme: require('./core/theme'),
-  FluentDate: require('./core/fluent-date'),
-  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'),
-  LaTeXGenerator: require('./gen/latex-generator')
-};

src/hackmycmd.js

@@ -1,45 +0,0 @@
-/**
-Internal resume generation logic for HackMyResume.
-@license MIT. Copyright (c) 2015 James M. Devlin / FluentDesk.
-@module hackmycmd.js
-*/
-
-(function() {
-  module.exports = function () {
-
-    var unused = require('./utils/string')
-      , PATH = require('path');
-
-
-    /**
-    Display help documentation.
-    */
-    function help() {
-      console.log( FS.readFileSync( PATH.join(__dirname, 'use.txt'), 'utf8' )
-        .useful.bold );
-    }
-
-    /**
-    Internal module interface. Used by FCV Desktop and HMR.
-    */
-    return {
-      verbs: {
-        generate: require('./verbs/generate'),
-        build: require('./verbs/generate'),
-        validate: require('./verbs/validate'),
-        convert: require('./verbs/convert'),
-        create: require('./verbs/create'),
-        new: require('./verbs/create'),
-        help: help
-      },
-      lib: require('./hackmyapi'),
-      options: require('./core/default-options'),
-      formats: require('./core/default-formats')
-    };
-
-  }();
-
-}());
-
-// [1]: JSON.parse throws SyntaxError on invalid JSON. See:
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse

src/helpers/block-helpers.js

@@ -0,0 +1,77 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Block helper definitions for HackMyResume / FluentCV.
+@license MIT. See LICENSE.md for details.
+@module helpers/generic-helpers
+*/
+
+
+
+const LO = require('lodash');
+const _ = require('underscore');
+require('../utils/string');
+
+
+
+/** Block helper function definitions. */
+module.exports = {
+
+
+
+  /**
+  Emit the enclosed content if the resume has a section with
+  the specified name. Otherwise, emit an empty string ''.
+  */
+
+  section( title, options ) {
+    title = title.trim().toLowerCase();
+    const obj = LO.get(this.r, title);
+    let ret = '';
+    if (obj) {
+      if (_.isArray(obj)) {
+        if (obj.length) {
+          ret = options.fn(this);
+        }
+      } else if (_.isObject(obj)) {
+        if ((obj.history && obj.history.length) || (obj.sets && obj.sets.length)) {
+            ret = options.fn(this);
+          }
+      }
+    }
+    return ret;
+  },
+
+
+
+  ifHasSkill( rez, skill, options ) {
+    const skUp = skill.toUpperCase();
+    const ret = _.some(rez.skills.list, sk => (skUp.toUpperCase() === sk.name.toUpperCase()) && sk.years
+    , this);
+    if (ret) { return options.fn(this); }
+  },
+
+
+  /**
+  Emit the enclosed content if the resume has the named
+  property or subproperty.
+  */
+
+  has( title, options ) {
+    title = title && title.trim().toLowerCase();
+    if (LO.get(this.r, title)) {
+      return options.fn(this);
+    }
+  },
+
+
+
+  /**
+  Return true if either value is truthy.
+  @method either
+  */
+  either( lhs, rhs, options ) { if (lhs || rhs) { return options.fn(this); } }
+};

src/helpers/console-helpers.js

@@ -0,0 +1,67 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Generic template helper definitions for command-line output.
+@module console-helpers.js
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const PAD   = require('string-padding');
+const LO    = require('lodash');
+const CHALK = require('chalk');
+const _     = require('underscore');
+require('../utils/string');
+
+
+
+module.exports = {
+
+  v( val, defaultVal, padding, style ) {
+    let retVal = ( (val === null) || (val === undefined) ) ? defaultVal : val;
+    let 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(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( val, style ) {
+    return LO.get( CHALK, style )( val );
+  },
+
+  isPlural( val, options ) {
+    if (val > 1) {
+      return options.fn(this);
+    }
+  },
+
+  pad( val, spaces ) {
+    return PAD(val, Math.abs(spaces), null, spaces > 0 ? PAD.LEFT : PAD.RIGHT);
+  }
+};

src/helpers/generic-helpers.js

@@ -0,0 +1,703 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Generic template helper definitions for HackMyResume / FluentCV.
+@license MIT. See LICENSE.md for details.
+@module helpers/generic-helpers
+*/
+
+
+
+const MD = require('marked');
+const H2W = require('../utils/html-to-wpml');
+const XML = require('xml-escape');
+const FluentDate = require('../core/fluent-date');
+const HMSTATUS = require('../core/status-codes');
+const moment = require('moment');
+const FS = require('fs');
+const LO = require('lodash');
+const PATH = require('path');
+const printf = require('printf');
+const _ = require('underscore');
+require('../utils/string');
+
+
+
+/** Generic template helper function definitions. */
+var GenericHelpers = (module.exports = {
+
+
+
+  /**
+  Emit a formatted string representing the specified datetime.
+  Convert the input date to the specified format through Moment.js. If date is
+  valid, return the formatted date string. If date is null, undefined, or other
+  falsy value, return the value of the 'fallback' parameter, if specified, or
+  null if no fallback was specified. If date is invalid, but not null/undefined/
+  falsy, return it as-is.
+  @param {string|Moment} datetime A date value.
+  @param {string} [dtFormat='YYYY-MM'] The desired datetime format. Must be a
+  Moment.js-compatible datetime format.
+  @param {string|Moment} fallback A fallback value to use if the specified date
+  is null, undefined, or falsy.
+  */
+  formatDate(datetime, dtFormat, fallback) {
+
+    if (datetime == null) { datetime = undefined; }
+    if (dtFormat == null) { dtFormat = 'YYYY-MM'; }
+
+    // If a Moment.js object was passed in, just call format on it
+    if (datetime && moment.isMoment(datetime)) {
+      return datetime.format(dtFormat);
+    }
+
+    if (String.is(datetime)) {
+      // If a string was passed in, convert to Moment using the 2-paramter
+      // constructor with an explicit format string.
+      let momentDate = moment(datetime, dtFormat);
+      if (momentDate.isValid()) { return momentDate.format(dtFormat); }
+
+      // If that didn't work, try again with the single-parameter constructor
+      // but this may throw a deprecation warning
+      momentDate = moment(datetime);
+      if (momentDate.isValid()) { return momentDate.format(dtFormat); }
+    }
+
+    // We weren't able to format the provided datetime. Now do one of three
+    // things.
+    //   1. If datetime is non-null/non-falsy, return it. For this helper,
+    // string date values that we can't parse are assumed to be display dates.
+    //   2. If datetime IS null or falsy, use the value from the fallback.
+    //   3. If the fallback value is specifically 'true', emit 'Present'.
+    return datetime ||
+      (typeof fallback === 'string'
+      ? fallback
+      : (fallback === true ? 'Present' : ''));
+  },
+
+
+
+  /**
+  Emit a formatted string representing the specified datetime.
+  @param {string} dateValue A raw date value from the FRESH or JRS resume.
+  @param {string} [dateFormat='YYYY-MM'] The desired datetime format. Must be
+  compatible with Moment.js datetime formats.
+  @param {string} [dateDefault=null] The default date value to use if the dateValue
+  parameter is null, undefined, or falsy.
+  */
+  date(dateValue, dateFormat, dateDefault) {
+
+    if (!dateDefault || !String.is(dateDefault)) { dateDefault = 'Current'; }
+    if (!dateFormat || !String.is(dateFormat)) { dateFormat = 'YYYY-MM'; }
+    if (!dateValue || !String.is(dateValue)) { dateValue = null; }
+    if (!dateValue) { return dateDefault; }
+
+    const reserved = ['current', 'present', 'now'];
+    const dateValueSafe = dateValue.trim().toLowerCase();
+    if (_.contains(reserved, dateValueSafe)) { return dateValue; }
+
+    const dateValueMoment = moment(dateValue, dateFormat);
+    if (dateValueMoment.isValid()) { return dateValueMoment.format(dateFormat); }
+    return dateValue;
+  },
+
+
+
+  /**
+  Given a resume sub-object with a start/end date, format a representation of
+  the date range.
+  */
+  dateRange( obj, fmt, sep, fallback ) {
+    if (!obj) { return ''; }
+    return _fromTo(obj.start, obj.end, fmt, sep, fallback);
+  },
+
+
+
+  /**
+  Format a from/to date range for display.
+  @method toFrom
+  */
+  fromTo() { return _fromTo.apply(this, arguments); },
+
+
+
+  /**
+  Return a named color value as an RRGGBB string.
+  @method toFrom
+  */
+  color( colorName, colorDefault ) {
+    // Key must be specified
+    if (!(colorName && colorName.trim())) {
+      return _reportError(HMSTATUS.invalidHelperUse,
+        {helper: 'fontList', error: HMSTATUS.missingParam, expected: 'name'});
+    } else {
+      if (!GenericHelpers.theme.colors) { return colorDefault; }
+      const ret = GenericHelpers.theme.colors[ colorName ];
+      if (!(ret && ret.trim())) {
+        return colorDefault;
+      }
+      return ret;
+    }
+  },
+
+
+
+  /**
+  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( key, defSize/*, units*/ ) {
+
+    let ret = '';
+    const 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) {
+      let 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( key, defFont ) {
+
+    let ret = '';
+    const 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 ) {
+      let 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( key, defFontList, sep ) {
+
+    let ret = '';
+    const 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) {
+      let 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( ff  => `'${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. TODO: Rename
+  @method section
+  */
+  camelCase(val) {
+    val = (val && val.trim()) || '';
+    if (val) { return (val.charAt(0).toUpperCase() + val.slice(1)); } else { return val; }
+  },
+
+
+
+  /**
+  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( 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.
+    // TODO: not actually sure that's true, given that we _.wrap these functions
+    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. */
+  wpml( 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( text, url ) {
+    if (url && url.trim()) { return (`<a href="${url}">${text}</a>`); } else { return text; }
+  },
+
+
+
+  /**
+  Emit a conditional Markdown link.
+  @method link
+  */
+  linkMD( text, url ) {
+    if (url && url.trim()) { return (`[${text}](${url})`); } else { return text; }
+  },
+
+
+
+  /**
+  Return the last word of the specified text.
+  @method lastWord
+  */
+  lastWord( txt ) {
+    if (txt && txt.trim()) { return _.last( txt.split(' ') ); } else { return ''; }
+  },
+
+
+
+  /**
+  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( lvl ) {
+    const idx = _skillLevelToIndex(lvl);
+    const 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( lvl ) {
+    const idx = _skillLevelToIndex(lvl);
+    return ['38.25', '30', '16', '8', '0'][idx];
+  },
+
+
+
+  /**
+  Return all but the last word of the input text.
+  @method initialWords
+  */
+  initialWords( txt ) {
+    if (txt && txt.trim()) { return _.initial( txt.split(' ') ).join(' '); } else { return ''; }
+  },
+
+
+
+  /**
+  Trim the protocol (http or https) from a URL/
+  @method trimURL
+  */
+  trimURL( url ) {
+    if (url && url.trim()) { return url.trim().replace(/^https?:\/\//i, ''); } else { return ''; }
+  },
+
+
+
+  /**
+  Convert text to lowercase.
+  @method toLower
+  */
+  toLower( txt ) { if (txt && txt.trim()) { return txt.toLowerCase(); } else { return ''; } },
+
+
+
+  /**
+  Convert text to lowercase.
+  @method toLower
+  */
+  toUpper( txt ) { if (txt && txt.trim()) { return txt.toUpperCase(); } else { return ''; } },
+
+
+
+  /**
+  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( url, linkage ) {
+
+    // Establish the linkage style
+    linkage = this.opts.css || linkage || 'embed';
+
+    // Create the <link> or <style> tag
+    let ret = '';
+    if (linkage === 'link') {
+      ret = printf('<link href="%s" rel="stylesheet" type="text/css">', url);
+    } else {
+      const rawCss = FS.readFileSync(
+        PATH.join( this.opts.themeObj.folder, '/src/', url ), 'utf8' );
+      const 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(lvalue, rvalue, options) {
+    if (arguments.length < 3) {
+      throw new Error('Template helper \'compare\' needs 2 parameters');
+    }
+    const operator = options.hash.operator || '==';
+    const operators = {
+        '=='(l,r) { return l === r; },
+        '==='(l,r) { return l === r; },
+        '!='(l,r) { return l !== r; },
+        '<'(l,r) { return l < r; },
+        '>'(l,r) { return l > r; },
+        '<='(l,r) { return l <= r; },
+        '>='(l,r) { return l >= r; },
+        'typeof'(l,r) { return typeof l === r; }
+      };
+    if (!operators[operator]) {
+      throw new Error(`Helper 'compare' doesn't know the operator ${operator}`);
+    }
+    const result = operators[operator]( lvalue, rvalue );
+    if (result) { return options.fn(this); } else { return options.inverse(this); }
+  },
+
+
+
+  /**
+  Emit padded text.
+  */
+  pad(stringOrArray, padAmount/*, unused*/ ) {
+    stringOrArray = stringOrArray || '';
+    padAmount = padAmount || 0;
+    let ret = '';
+    const PAD = require('string-padding');
+    if (!String.is(stringOrArray)) {
+      ret = stringOrArray
+        .map(line => PAD(line, line.length + Math.abs(padAmount), null, padAmount < 0 ? PAD.LEFT : PAD.RIGHT))
+        .join('\n');
+    } else {
+      ret = PAD(stringOrArray, stringOrArray.length + Math.abs(padAmount), null, padAmount < 0 ? PAD.LEFT : PAD.RIGHT);
+    }
+    return ret;
+  },
+
+
+
+  /**
+  Given the name of a skill ("JavaScript" or "HVAC repair"), return the number
+  of years assigned to that skill in the resume.skills.list collection.
+  */
+  skillYears( skill, rez ) {
+    const sk = _.find(rez.skills.list, sk => sk.name.toUpperCase() === skill.toUpperCase());
+    if (sk) { return sk.years; } else { return '?'; }
+  },
+
+
+
+  /**
+  Given an object that may be a string or an object, return it as-is if it's a
+  string, otherwise return the value at obj[objPath].
+  */
+  stringOrObject( obj, objPath/*, rez */) {
+    if (_.isString(obj)) { return obj; } else { return LO.get(obj, objPath); }
+  }
+});
+
+
+
+/**
+Report an error to the outside world without throwing an exception. Currently
+relies on kludging the running verb into. opts.
+*/
+var _reportError = ( code, params ) => GenericHelpers.opts.errHandler.err( code, params );
+
+
+
+/**
+Format a from/to date range for display.
+*/
+var _fromTo = function( 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 '';
+  }
+
+  let dateFrom = null;
+  let dateTo = null;
+  let dateTemp = null;
+
+  // Check for 'current', 'present', 'now', '', null, and undefined
+  dateA = dateA || '';
+  dateB = dateB || '';
+  const dateATrim = dateA.trim().toLowerCase();
+  const dateBTrim = dateB.trim().toLowerCase();
+  const 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 || 'Present';
+  } else {
+    dateTemp = FluentDate.fmt( dateB );
+    dateTo = dateTemp.format( fmt );
+  }
+
+
+  if (dateFrom === dateTo) {
+    return dateFrom;
+  } else if (dateFrom && dateTo) {
+    return dateFrom + sep + dateTo;
+  } else if (dateFrom || dateTo) {
+    return dateFrom || dateTo;
+  }
+  return '';
+};
+
+
+
+var _skillLevelToIndex = function( lvl ) {
+  let idx = 0;
+  if (String.is( lvl )) {
+    lvl = lvl.trim().toLowerCase();
+    const 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,89 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+
+/**
+Template helper definitions for Handlebars.
+@license MIT. See LICENSE.md for details.
+@module handlebars-helpers.js
+*/
+
+const HANDLEBARS = require('handlebars');
+const _ = require('underscore');
+const helpers = require('./generic-helpers');
+const path = require('path');
+const blockHelpers = require('./block-helpers');
+const HMS = require('../core/status-codes');
+
+/**
+Register useful Handlebars helpers.
+@method registerHelpers
+*/
+
+module.exports = function( theme, rez, opts ) {
+
+  helpers.theme = theme;
+  helpers.opts = opts;
+  helpers.type = 'handlebars';
+
+  // Prepare generic helpers for use with Handlebars. We do this by wrapping them
+  // in a Handlebars-aware wrapper which calls the helper internally.
+  const wrappedHelpers = _.mapObject(helpers, function( hVal/*, hKey*/ ) {
+    if (_.isFunction(hVal)) {
+      return _.wrap(hVal, function(func) {
+        const args = Array.prototype.slice.call(arguments);
+        args.shift();                  // lose the 1st element (func) [^1]
+        //args.pop()                   # lose the last element (HB options hash)
+        args[ args.length - 1 ] = rez; // replace w/ resume object
+        return func.apply(this, args);
+      });            // call the generic helper
+    }
+    return hVal;
+  }
+  , this);
+  HANDLEBARS.registerHelper(wrappedHelpers);
+
+  // Prepare Handlebars-specific helpers - "blockHelpers" is really a misnomer
+  // since any kind of Handlebars-specific helper can live here
+  HANDLEBARS.registerHelper(blockHelpers);
+
+  // Register any theme-provided custom helpers...
+
+  // Normalize "theme.helpers" (string or array) to an array
+  if (_.isString(theme.helpers)) { theme.helpers = [ theme.helpers ]; }
+
+  if (_.isArray(theme.helpers)) {
+    const glob = require('glob');
+    const slash = require('slash');
+    let curGlob = null;
+    try {
+      _.each(theme.helpers, function(fGlob) {            // foreach theme.helpers entry
+        curGlob = fGlob;                           // ..cache in case of exception
+        fGlob = path.join(theme.folder, fGlob);     // ..make relative to theme
+        const files = glob.sync(slash(fGlob));             // ..expand the glob
+        if (files.length > 0) {                       // ..guard against empty glob
+          _.each(files, function(f) {                    // ..loop over concrete paths
+            HANDLEBARS.registerHelper(require(f));   // ..register the path
+          });
+        } else {
+          throw {fluenterror: HMS.themeHelperLoad, inner: null, glob: fGlob};
+        }
+      });
+      return;
+    } catch (ex) {
+      throw{
+        fluenterror: HMS.themeHelperLoad,
+        inner: ex,
+        glob: curGlob, exit: true
+      };
+    }
+  }
+};
+
+// [^1]: This little bit of acrobatics ensures that our generic helpers are
+// called as generic helpers, not as Handlebars-specific helpers. This allows
+// them to be used in other templating engines, like Underscore. If you need a
+// Handlebars-specific helper with normal Handlebars context and options, put it
+// in block-helpers.coffee.

src/helpers/underscore-helpers.js

@@ -0,0 +1,35 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Template helper definitions for Underscore.
+@license MIT. See LICENSE.md for details.
+@module handlebars-helpers.js
+*/
+
+
+
+const _ = require('underscore');
+const 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 ) {
+    if (_.isFunction(hVal)) {
+      return _.bind(hVal, ctx);
+    }
+  }
+  , this);
+};

src/index.js

@@ -1,133 +1,46 @@
-#! /usr/bin/env node
-
 /**
-Command-line interface (CLI) for HackMyResume.
-@license MIT. Copyright (c) 2015 James M. Devlin / FluentDesk.
-@module index.js
+External API surface for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module hackmycore/index
 */
 
-var ARGS = require( 'minimist' )
-  , FCMD  = require( './hackmycmd')
-  , PKG = require('../package.json')
-  , COLORS = require('colors')
-  , FS = require('fs')
-  , PATH = require('path')
-  , opts = { }
-  , title = ('\n*** HackMyResume v' + PKG.version + ' ***').bold.white
-  , _ = require('underscore');
 
 
+/** API facade for HackMyResume. */
 
-try {
-  main();
-}
-catch( ex ) {
-  handleError( ex );
-}
+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')
+  },
 
-function main() {
-
-  // Colorize
-  COLORS.setTheme({
-    title: ['white','bold'],
-    info: process.platform === 'win32' ? 'gray' : ['white','dim'],
-    infoBold: ['white','dim'],
-    warn: 'yellow',
-    error: 'red',
-    guide: 'yellow',
-    status: 'gray',//['white','dim'],
-    useful: 'green',
-  });
-
-  // Setup
-  if( process.argv.length <= 2 ) { throw { fluenterror: 4 }; }
-  var a = ARGS( process.argv.slice(2) );
-  opts = getOpts( a );
-  logMsg( title );
-
-  // Get the action to be performed
-  var params = a._.map( function(p){ return p.toLowerCase().trim(); });
-  var verb = params[0];
-  if( !FCMD.verbs[ verb ] ) {
-    logMsg('Invalid command: "'.warn + verb.warn.bold + '"'.warn);
-    return;
-  }
-
-  // Find the TO keyword, if any
-  var splitAt = _.indexOf( params, 'to' );
-  if( splitAt === a._.length - 1 ) {
-    // 'TO' cannot be the last argument
-    logMsg('Please '.warn + 'specify an output file'.warn.bold +
-      ' for this operation or '.warn + 'omit the TO keyword'.warn.bold +
-      '.'.warn );
-    return;
-  }
-
-  // Massage inputs and outputs
-  var src = a._.slice(1, splitAt === -1 ? undefined : splitAt );
-  var dst = splitAt === -1 ? [] : a._.slice( splitAt + 1 );
-  ( splitAt === -1 ) && src.length > 1 && dst.push( src.pop() ); // Allow omitting TO keyword
-  var parms = [ src, dst, opts, logMsg ];
-
-  // Invoke the action
-  FCMD.verbs[ verb ].apply( null, parms );
-
-}
-
-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',
-    format: args.f || 'FRESH',
-    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 '.guide + 'specify a valid input resume'.guide.bold + ' in FRESH or JSON Resume format.'.guide; break;
-      case 4: msg = title + "\nPlease ".guide + "specify a command".guide.bold + " (".guide +
-        Object.keys( FCMD.verbs ).map( function(v, idx, ar) {
-          return (idx === ar.length - 1 ? 'or '.guide : '') +
-            v.toUpperCase().guide;
-        }).join(', '.guide) + ").\n\n".guide + FS.readFileSync( PATH.join(__dirname, 'use.txt'), 'utf8' ).info.bold;
-        break;
-      //case 4: msg = title + '\n' + ; break;
-      case 5: msg = 'Please '.guide + 'specify the output resume file'.guide.bold + ' that should be created.'.guide; break;
-      case 6: msg = 'Please '.guide + 'specify a valid input resume'.guide.bold + ' in either FRESH or JSON Resume format.'.guide; break;
-      case 7: msg = 'Please '.guide + 'specify an output file name'.guide.bold + ' for every input file you wish to convert.'.guide; break;
-      case 8: msg = 'Please '.guide + 'specify the filename of the resume'.guide.bold + ' to create.'.guide; break;
-    }
-    exitCode = ex.fluenterror;
-
-  }
-  else {
-    msg = ex.toString();
-    exitCode = 4;
-  }
-
-  var idx = msg.indexOf('Error: ');
-  var trimmed = idx === -1 ? msg : msg.substring( idx + 7 );
-  if( !ex.fluenterror || ex.fluenterror < 3 )
-    console.log( ('ERROR: ' + trimmed.toString()).red.bold );
-  else
-    console.log( trimmed.toString() );
-
-  process.exit( exitCode );
-
-}
+  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'),
+  ResumeFactory:        require('./core/resume-factory'),
+  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/inspectors/duration-inspector.js

@@ -0,0 +1,54 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+const FluentDate = require('../core/fluent-date');
+const _ = require('underscore');
+const lo = require('lodash');
+
+module.exports = {
+
+  /**
+  Compute the total duration of the work history.
+  @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.
+  */
+  run(rez, collKey, startKey, endKey, unit) {
+    unit = unit || 'years';
+    const hist = lo.get(rez, collKey);
+    if (!hist || !hist.length) { return 0; }
+
+    // BEGIN CODE DUPLICATION --> src/inspectors/gap-inspector.coffee (TODO)
+
+    // 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.
+    let new_e = hist.map(function( job ) {
+      let obj = _.pick( job, [startKey, endKey] );
+      // Synthesize an end date if this is a "current" gig
+      if (!_.has(obj, endKey)) { obj[endKey] = 'current'; }
+      if (obj && (obj[startKey] || obj[endKey])) {
+        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 ), v => v && v.length && v[0] && v[0].length);
+    if (!new_e || !new_e.length) { return 0; }
+    new_e = _.sortBy(new_e,  elem  => elem[1].unix());
+
+    // END CODE DUPLICATION
+
+    const firstDate = _.first( new_e )[1];
+    const lastDate = _.last( new_e )[1];
+    return lastDate.diff(firstDate, unit);
+  }
+};

src/inspectors/gap-inspector.js

@@ -0,0 +1,157 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Employment gap analysis for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module inspectors/gap-inspector
+*/
+
+
+
+const _ = require('underscore');
+const FluentDate = require('../core/fluent-date');
+const moment = require('moment');
+const LO = require('lodash');
+
+
+
+/**
+Identify gaps in the candidate's employment history.
+*/
+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(rez) {
+
+    // This is what we'll return
+    const coverage = {
+      gaps: [],
+      overlaps: [],
+      pct: '0%',
+      duration: {
+        total: 0,
+        work: 0,
+        gaps: 0
+      }
+    };
+
+    // Missing employment section? Bye bye.
+    const 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.
+    let new_e = hist.map( function( job ) {
+      let 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 ), v => v && v.length && v[0] && v[0].length);
+
+    if (!new_e || !new_e.length) { return coverage; }
+    new_e = _.sortBy(new_e,  elem  => 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.
+
+    let ref_count = 0;
+    let total_gap_days = 0;
+
+    new_e.forEach(function(point) {
+
+      const inc = point[0] === 'start' ? 1 : -1;
+      ref_count += inc;
+
+      // If the ref count just reached 0, start a new GAP
+      if (ref_count === 0) {
+        return 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)) {
+        const lastGap = _.last( coverage.gaps );
+        if (lastGap) {
+          lastGap.end = point[1];
+          lastGap.duration = lastGap.end.diff( lastGap.start, 'days' );
+          return total_gap_days += lastGap.duration;
+        }
+
+      // If the ref count reaches 2 by rising, start a new OVERLAP
+      } else if ((ref_count === 2) && (inc === 1)) {
+        return 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)) {
+        const lastOver = _.last( coverage.overlaps );
+        if (lastOver) {
+          lastOver.end = point[1];
+          lastOver.duration = lastOver.end.diff( lastOver.start, 'days' );
+          if (lastOver.duration === 0) {
+            return 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) {
+      const o = _.last( coverage.overlaps );
+      if (o && !o.end) {
+        o.end = moment();
+        o.duration = o.end.diff( o.start, 'days' );
+      }
+    }
+
+    if (coverage.gaps.length) {
+      const 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
+    const tdur = rez.duration('days');
+    const 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,74 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Keyword analysis for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module inspectors/keyword-inspector
+*/
+
+/**
+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
+*/
+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( 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
+    const regex_quote = str => (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.
+    let searchable = '';
+    rez.transformStrings(['imp', 'computed', 'safe'], ( key, val ) => searchable += ` ${val}`);
+
+    // Assemble a regex skeleton we can use to test for keywords with a bit
+    // more
+    const prefix = `(?:${['^', '\\s+', '[\\.,]+'].join('|')})`;
+    const 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.
+
+      const regex_str = prefix + regex_quote( kw ) + suffix;
+      const regex = new RegExp( regex_str, 'ig');
+      let count = 0;
+      while (regex.exec( searchable ) !== null) {
+        count++;
+      }
+      return {
+        name: kw,
+        count
+      };
+    });
+  }
+};

src/inspectors/totals-inspector.js

@@ -0,0 +1,46 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Section analysis for HackMyResume.
+@license MIT. See LICENSE.md for details.
+@module inspectors/totals-inspector
+*/
+
+const _ = require('underscore');
+
+/**
+Retrieve sectional overview and summary information.
+@class 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( rez ) {
+
+    const sectionTotals = { };
+    _.each(rez, function(val, key) {
+      if (_.isArray( val ) && !_.isString(val)) {
+        return sectionTotals[ key ] = val.length;
+      } else if (val.history && _.isArray( val.history )) {
+        return sectionTotals[ key ] = val.history.length;
+      } else if (val.sets && _.isArray( val.sets )) {
+        return sectionTotals[ key ] = val.sets.length;
+      }
+    });
+
+    return {
+      totals: sectionTotals,
+      numSections: Object.keys( sectionTotals ).length
+    };
+  }
+};

src/renderers/handlebars-generator.js

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

src/renderers/jrs-generator.js

@@ -0,0 +1,45 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the JRSGenerator class.
+@license MIT. See LICENSE.md for details.
+@module renderers/jrs-generator
+*/
+
+const MD = require('marked');
+
+/**
+Perform template-based resume generation for JSON Resume themes.
+@class JRSGenerator
+*/
+
+module.exports = {
+
+  generate( json, jst, format, cssInfo, opts, theme ) {
+
+    // Disable JRS theme chatter (console.log, console.error, etc.)
+    const turnoff = ['log', 'error', 'dir'];
+    const org = turnoff.map(function(c) {
+      const ret = console[c]; // eslint-disable-line no-console
+      console[c] = function() {}; // eslint-disable-line no-console
+      return ret;
+    });
+
+    // Freeze and render
+    let rezHtml = theme.render(json.harden());
+
+    // Turn logging back on
+    turnoff.forEach((c, idx) => console[c] = org[idx]); // eslint-disable-line no-console
+
+    // Unfreeze and apply Markdown
+    return rezHtml = rezHtml.replace(/@@@@~[\s\S]*?~@@@@/g, val => MDIN( val.replace( /~@@@@/g,'' ).replace( /@@@@~/g,'' ) ));
+  }
+};
+
+
+var MDIN = txt => // TODO: Move this
+  MD(txt || '' ).replace(/^\s*<p>|<\/p>\s*$/gi, '')
+;

src/renderers/underscore-generator.js

@@ -0,0 +1,90 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the UnderscoreGenerator class.
+@license MIT. See LICENSE.md for details.
+@module underscore-generator.js
+*/
+
+
+
+const _ = require('underscore');
+const registerHelpers = require('../helpers/underscore-helpers');
+require('../utils/string');
+const escapeLaTeX = require('escape-latex');
+
+/**
+Perform template-based resume generation using Underscore.js.
+@class UnderscoreGenerator
+*/
+module.exports = {
+
+
+
+  generateSimple( data, tpl ) {
+    let t;
+    try {
+      // Compile and run the Handlebars template.
+      t = _.template(tpl);
+      return t(data);
+    } catch (err) {
+      //console.dir _error
+      const HMS = require('../core/status-codes');
+      throw{
+        fluenterror: HMS[t ? 'invokeTemplate' : 'compileTemplate'],
+        inner: err
+      };
+    }
+  },
+
+
+
+  generate( json, jst, format, cssInfo, opts, theme ) {
+
+    // Tweak underscore's default template delimeters
+    let delims = (opts.themeObj && opts.themeObj.delimeters) || opts.template;
+    if (opts.themeObj && opts.themeObj.delimeters) {
+      delims = _.mapObject(delims, (val) => new RegExp(val, 'ig'));
+    }
+    _.templateSettings = delims;
+
+    // Massage resume strings / text
+    let r = null;
+    switch (format) {
+      case 'html': r = json.markdownify(); break;
+      case 'pdf': r = json.markdownify(); break;
+      case 'png': r = json.markdownify(); break;
+      case 'latex':
+        var traverse = require('traverse');
+        r = traverse(json).map(function() {
+          if (this.isLeaf && String.is(this.node)) {
+            return escapeLaTeX(this.node);
+          }
+          return this.node;
+        });
+        break;
+      default: r = json;
+    }
+
+    // Set up the context
+    const ctx = {
+      r,
+      filt: opts.filters,
+      XML: require('xml-escape'),
+      RAW: json,
+      cssInfo,
+      //engine: @
+      headFragment: opts.headFragment || '',
+      opts
+    };
+
+    // Link to our helpers
+    registerHelpers(theme, opts, cssInfo, ctx, this);
+
+    // Generate!
+    return this.generateSimple(ctx, jst);
+  }
+};

src/use.txt

@@ -1,25 +0,0 @@
-Usage:
-
-    hackmyresume <COMMAND> <SOURCES> [TO <TARGETS>] [-t <THEME>] [-f <FORMAT>]
-
-<COMMAND> should be BUILD, NEW, CONVERT, VALIDATE, or HELP. <SOURCES> should
-be the path to one or more FRESH or JSON Resume format resumes. <TARGETS>
-should be the name of the destination resume to be created, if any. The
-<THEME> parameter should be the name of a predefined theme (for example:
-COMPACT, MINIMIST, MODERN, or HELLO-WORLD) or the relative path to a custom
-theme. <FORMAT> should be either FRESH (for a FRESH-format resume) or JRS
-(for a JSON Resume-format resume).
-
-    hackmyresume BUILD resume.json TO out/resume.all
-    hackmyresume NEW resume.json
-    hackmyresume CONVERT resume.json TO resume-jrs.json
-    hackmyresume VALIDATE resume.json
-
-Both SOURCES and TARGETS can accept multiple files:
-
-    hackmyresume BUILD r1.json r2.json TO out/resume.all out2/resume.html
-    hackmyresume NEW r1.json r2.json r3.json
-    hackmyresume VALIDATE resume.json resume2.json resume3.json
-
-See https://github.com/hacksalot/hackmyresume/blob/master/README.md for more
-information.

src/utils/class.js

@@ -1,72 +0,0 @@
-/**
-Definition of John Resig's `Class` class.
-@module class.js
-*/
-
-/* Simple JavaScript Inheritance
- * By John Resig http://ejohn.org/
- * MIT Licensed.
- * http://ejohn.org/blog/simple-javascript-inheritance/
- */
-// Inspired by base2 and Prototype
-(function(){
-  var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
-
-  // The base Class implementation (does nothing)
-  this.Class = function(){};
-  module.exports = Class;
-
-  // Create a new Class that inherits from this class
-  Class.extend = function(prop) {
-    var _super = this.prototype;
-
-    // Instantiate a base class (but only create the instance,
-    // don't run the init constructor)
-    initializing = true;
-    var prototype = new this();
-    initializing = false;
-
-    // Copy the properties over onto the new prototype
-    for (var name in prop) {
-      // Check if we're overwriting an existing function
-      prototype[name] = typeof prop[name] == "function" &&
-        typeof _super[name] == "function" && fnTest.test(prop[name]) ?
-        (function(name, fn){
-          return function() {
-            var tmp = this._super;
-
-            // Add a new ._super() method that is the same method
-            // but on the super-class
-            this._super = _super[name];
-
-            // The method only need to be bound temporarily, so we
-            // remove it when we're done executing
-            var ret = fn.apply(this, arguments);
-            this._super = tmp;
-
-            return ret;
-          };
-        })(name, prop[name]) : // jshint ignore:line
-        prop[name];
-    }
-
-    // The dummy class constructor
-    function Class() {
-      // All construction is actually done in the init method
-      if ( !initializing && this.init )
-        this.init.apply(this, arguments);
-    }
-
-    // Populate our constructed prototype object
-    Class.prototype = prototype;
-
-    // Enforce the constructor to be what we expect
-    Class.prototype.constructor = Class;
-
-    // And make this class extendable
-    Class.extend = arguments.callee;
-
-    return Class;
-  };
-
-})();

src/utils/extend.js

@@ -1,79 +0,0 @@
-/**
-Definition of the `extend` method.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module extend.js
-*/
-
-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,11 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the SyntaxErrorEx class.
+@module file-contains.js
+*/
+
+module.exports = ( file, needle ) => require('fs').readFileSync(file,'utf-8').indexOf( needle ) > -1;

src/utils/file-exists.js

@@ -1,19 +0,0 @@
-/**
-Definition of the `fileExists` method.
-@license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module file-exists.js
-*/
-
-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/fresh-version-regex.js

@@ -0,0 +1,27 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Defines a regex suitable for matching FRESH versions.
+@module file-contains.js
+*/
+
+// Set up a regex that matches all of the following:
+//
+//   - FRESH
+//   - JRS
+//   - FRESCA
+//   - FRESH@1.0.0
+//   - FRESH@1.0
+//   - FRESH@1
+//   - JRS@0.16.0
+//   - JRS@0.16
+//   - JRS@0
+//
+// Don't use a SEMVER regex (eg, NPM's semver-regex) because a) we want to
+// support partial semvers like "0" or "1.2" and b) we'll expand this later to
+// support fully scoped FRESH versions.
+
+module.exports = () => RegExp('^(FRESH|FRESCA|JRS)(?:@(\\d+(?:\\.\\d+)?(?:\\.\\d+)?))?$');

src/utils/html-to-wpml.js

@@ -1,64 +1,65 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
 /**
 Definition of the Markdown to WordProcessingML conversion routine.
 @license MIT. Copyright (c) 2015 James Devlin / FluentDesk.
-@module html-to-wpml.js
+@module utils/html-to-wpml
 */
 
-(function(){
 
-  var _ = require('underscore');
-  var HTML5Tokenizer = require('simple-html-tokenizer');
+const XML = require('xml-escape');
+const _ = require('underscore');
+const HTML5Tokenizer = require('simple-html-tokenizer');
 
-  module.exports = function( html ) {
+module.exports = function( html ) {
 
-    // Tokenize the HTML stream.
-    var tokens = HTML5Tokenizer.tokenize( html );
+  // Tokenize the HTML stream.
+  let is_bold, is_italic, is_link, link_url;
+  const tokens = HTML5Tokenizer.tokenize( html );
+  let final = (is_bold = (is_italic = (is_link = (link_url = ''))));
 
-    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 ) {
 
-    // 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) {
 
-      switch( tok.type ) {
+      case 'StartTag':
+        switch (tok.tagName) {
+          case 'p': return final += '<w:p>';
+          case 'strong': return is_bold = true;
+          case 'em': return is_italic = true;
+          case 'a':
+            is_link = true;
+            return link_url = tok.attributes.filter(attr => attr[0] === 'href')[0][1];
+        }
+        break;
 
-        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': return final += '</w:p>';
+          case 'strong': return is_bold = false;
+          case 'em': return is_italic = false;
+          case 'a': return is_link = false;
+        }
+        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':
-          var style = is_bold ? '<w:b/>' : '';
-          style += is_italic ? '<w:i/>': '';
+      case 'Chars':
+        if( tok.chars.trim().length ) {
+          let 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 +
+          return final +=
+            (is_link ? (`<w:hlink w:dest="${link_url}">`) : '') +
+            '<w:r><w:rPr>' + style + '</w:rPr><w:t>' + XML(tok.chars) +
             '</w:t></w:r>' + (is_link ? '</w:hlink>' : '');
-          break;
-      }
-    });
-    return final;
-
-  };
-
-}());
+        }
+        break;
+    }
+  });
+  return final;
+};