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 +1,40 @@
 node_modules/
+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

@@ -0,0 +1,52 @@
+module.exports = function (grunt) {
+
+  'use strict';
+
+  var opts = {
+
+    pkg: grunt.file.readJSON('package.json'),
+
+    simplemocha: {
+      options: {
+        globals: ['expect', 'should'],
+        timeout: 3000,
+        ignoreLeaks: false,
+        ui: 'bdd',
+        reporter: 'spec'
+      },
+      all: { src: ['test/*.js'] }
+    },
+
+    clean: {
+      test: ['test/sandbox']
+    },
+
+    eslint: {
+      target: ['Gruntfile.js', 'src/**/*.js', 'test/*.js']
+    }
+
+  };
+
+  grunt.initConfig( opts );
+  grunt.loadNpmTasks('grunt-simple-mocha');
+  grunt.loadNpmTasks('grunt-eslint');
+  grunt.loadNpmTasks('grunt-contrib-clean');
+
+  // 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/devlinjd)
+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,77 +1,219 @@
-fluentcmd
-=========
-*Generate beautiful, targeted resumes from your command line or shell.*
+HackMyResume
+===
 
-FluentCMD is a **hackable, data-driven, dev-friendly resume authoring tool** with support for HTML, Markdown, Word, PDF, plain text, smoke signal, carrier pigeon, and other arbitrary-format resumes and CVs.
+[![Latest release][img-release]][latest-release]
+[![Build status (MASTER)][img-master]][travis-url-master]
+[![Build status (DEV)][img-dev]][travis-url-dev]
+[![Join the chat at https://gitter.im/hacksalot/HackMyResume][badge]][gh]
 
-```bash
->fluentcmd resume.json -o out/resume.all -t modern
+*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.*
 
-*** FluentCMD v0.5.0 ***
-Reading JSON resume: foo/resume.json
-Applying MODERN Theme (7 formats)
-Generating HTML resume: out/resume.html
-Generating TXT resume: out/resume.txt
-Generating DOC resume: out/resume.doc
-Generating PDF resume: out/resume.pdf
-Generating JSON resume: out/resume.json
-Generating MARKDOWN resume: out/resume.md
-Generating YAML resume: out/resume.yml
-```
+![](assets/hmr_build.png)
 
-Looking for a desktop GUI version with pretty timelines and graphs? Check out [FluentCV Desktop][7].
+HackMyResume is a dev-friendly, local-only Swiss Army knife for resumes and CVs.
+Use it to:
+
+1. **Generate** HTML, Markdown, LaTeX, MS Word, PDF, plain text, JSON, XML,
+YAML, print, smoke signal, carrier pigeon, and other arbitrary-format resumes
+and CVs, from a single source of truth—without violating DRY.
+2. **Analyze** your resume for keyword density, gaps/overlaps, and other
+metrics.
+3. **Convert** resumes between [FRESH][fresca] and [JSON Resume][6] formats.
+4. **Validate** resumes against either format.
+
+HackMyResume is built with Node.js and runs on recent versions of OS X, Linux,
+or Windows. View the [FAQ](FAQ.md).
+
+![](assets/hmr_analyze.png)
 
 ## Features
 
-- Runs on OS X, Linux, and Windows.
-- Store your resume data as a durable, versionable JSON, YML, or XML document.
-- Generate multiple targeted resumes in multiple formats, based on your needs.
-- Output to HTML, PDF, Markdown, Word, JSON, YAML, XML, or a custom format.
-- Never update one piece of information in four different resumes again.
-- Compatible with the [JSON Resume standard][6] and [authoring tools][7].
+- OS X, Linux, and Windows.
+- Choose from dozens of FRESH or JSON Resume themes.
+- Private, local-only resume authoring and analysis.
+- Analyze your resume for keywords, gaps, and other metrics.
+- Store your resume data as a durable, versionable JSON or YAML document.
+- Generate polished resumes in multiple formats without violating [DRY][dry].
+- Output to HTML, Markdown, LaTeX, PDF, MS Word, JSON, YAML, plain text, or XML.
+- Validate resumes against the FRESH or JSON Resume schema.
+- Support for multiple input and output resumes.
+- Convert between FRESH and JSON Resume resumes.
+- Use from your command line or [desktop][7].
 - Free and open-source through the MIT license.
-- Forthcoming: StackOverflow and LinkedIn support.
-- Forthcoming: More themes!
+- Updated daily / weekly. Contributions are [welcome](CONTRIBUTING.md).
 
 ## Install
 
-FluentCMD requires a recent version of [Node.js][4] and [NPM][5]. Then:
+Install the latest stable version of HackMyResume with NPM:
 
-1. (Optional, for PDF support) Install the latest official [wkhtmltopdf][3] binary for your platform.
-2. Install **fluentcmd** by running `npm install fluentcmd -g`.
-3. You're ready to go.
+```bash
+[sudo] npm install hackmyresume -g
+```
+
+Alternately, install the latest bleeding-edge version (updated daily):
+
+```bash
+[sudo] npm install hacksalot/hackmyresume#dev -g
+```
+
+## Installing PDF Support (optional)
+
+HackMyResume tries not to impose a specific PDF engine requirement on
+the user, but will instead work with whatever PDF engines you have installed.
+
+Currently, HackMyResume's PDF generation requires 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 five basic commands you should be aware of:
+
+- **build** generates resumes in HTML, Word, Markdown, PDF, and other formats.
+Use it when you need to submit, upload, print, or email resumes in specific
+formats.
+
+    ```bash
+    # hackmyresume build <INPUTS...> TO <OUTPUTS...> [-t THEME]
+    hackmyresume build resume.json TO out/resume.all
+    hackmyresume build r1.json r2.json TO out/rez.html out/rez.md foo/rez.all
+    ```
+
+- **new** creates a new resume in FRESH or JSON Resume format.
+
+    ```bash
+    # hackmyresume new <OUTPUTS...> [-f <FORMAT>]
+    hackmyresume new resume.json
+    hackmyresume new resume.json -f fresh
+    hackmyresume new r1.json r2.json -f jrs
+    ```
+
+- **analyze** inspects your resume for keywords, duration, and other metrics.
+
+    ```bash
+    # hackmyresume analyze <INPUTS...>
+    hackmyresume analyze resume.json
+    hackmyresume analyze r1.json r2.json
+    ```
+
+- **convert** converts your source resume between FRESH and JSON Resume
+formats. Use it to convert between the two formats to take advantage of tools
+and services.
+
+    ```bash
+    # hackmyresume convert <INPUTS...> TO <OUTPUTS...>
+    hackmyresume convert resume.json TO resume-jrs.json
+    hackmyresume convert 1.json 2.json 3.json TO out/1.json out/2.json out/3.json
+    ```
+
+- **validate** validates the specified resume against either the FRESH or JSON
+Resume schema. Use it to make sure your resume data is sufficient and complete.
+
+    ```bash
+    # hackmyresume validate <INPUTS...>
+    hackmyresume validate resume.json
+    hackmyresume validate r1.json r2.json r3.json
+    ```
+
+- **peek** echoes your resume or any field, property, or object path on your
+resume to standard output.
+
+    ```bash
+    # hackmyresume peek <INPUTS...> [OBJECT-PATH]
+    hackmyresume peek rez.json # Echo the whole resume
+    hackmyresume peek rez.json info.brief # Echo the "info.brief" field
+    hackmyresume peek rez.json employment.history[1] # Echo the 1st job
+    hackmyresume peek rez.json rez2.json info.brief # Compare value
+    ```    
+
+## Supported Output Formats
+
+HackMyResume supports these output formats:
+
+Output Format | Ext | Notes
+------------- | --- | -----
+HTML | .html | A standard HTML 5 + CSS resume format that can be viewed in a browser, deployed to a website, etc.
+Markdown | .md | A structured Markdown document that can be used as-is or used to generate HTML.
+LaTeX | .tex | A structured LaTeX document (or collection of documents) that can be processed with pdflatex, xelatex, and similar tools.
+MS Word | .doc | A Microsoft Word office document (XML-driven; WordProcessingML).
+Adobe Acrobat (PDF) | .pdf | A binary PDF document driven by an HTML theme (through wkhtmltopdf).
+plain text | .txt | A formatted plain text document appropriate for emails or copy-paste.
+JSON | .json | A JSON representation of the resume.
+YAML | .yml | A YAML representation of the resume.
+RTF | .rtf | Forthcoming.
+Textile | .textile | Forthcoming.
+image | .png, .bmp | Forthcoming.
 
 ## Use
 
-Assuming you've got a JSON-formatted resume handy, generating resumes in different formats and combinations easy. Just run:
+Assuming you've got a JSON-formatted resume handy, generating resumes in
+different formats and combinations is easy. Just run:
 
 ```bash
-fluentcmd [inputs] [outputs] [-t theme].
+hackmyresume build <inputs> to <outputs> [-t theme].
 ```
 
-Where `[inputs]` is one or more .json resume files, separated by spaces; `[outputs]` is one or more destination resumes, each prefaced with the `-o` option; and `[theme]` is the desired theme. For example:
+Where `<INPUTS>` is one or more .json resume files, separated by spaces;
+`<OUTPUTS>` is one or more destination resumes, and `<THEME>` is the desired
+theme (default to Modern). For example:
 
 ```bash
 # Generate all resume formats (HTML, PDF, DOC, TXT, YML, etc.)
-fluentcmd resume.json -o out/resume.all -t modern
+hackmyresume build resume.json TO out/resume.all -t modern
 
 # Generate a specific resume format
-fluentcmd resume.json -o out/resume.html
-fluentcmd resume.json -o out/resume.pdf
-fluentcmd resume.json -o out/resume.md
-fluentcmd resume.json -o out/resume.doc
-fluentcmd resume.json -o out/resume.json
-fluentcmd resume.json -o out/resume.txt
-fluentcmd resume.json -o out/resume.yml
+hackmyresume build resume.json TO out/resume.html
+hackmyresume build resume.json TO out/resume.pdf
+hackmyresume build resume.json TO out/resume.md
+hackmyresume build resume.json TO out/resume.doc
+hackmyresume build resume.json TO out/resume.json
+hackmyresume build resume.json TO out/resume.txt
+hackmyresume build resume.json TO out/resume.yml
 
 # Specify 2 inputs and 3 outputs
-fluentcmd in1.json in2.json -o out.html -o out.doc -o out.pdf
+hackmyresume build in1.json in2.json TO out.html out.doc out.pdf
 ```
 
 You should see something to the effect of:
 
 ```
-*** FluentCMD v0.5.0 ***
+*** HackMyResume v1.4.0 ***
 Reading JSON resume: foo/resume.json
 Applying MODERN Theme (7 formats)
 Generating HTML resume: out/resume.html
@@ -87,28 +229,56 @@ Generating YAML resume: out/resume.yml
 
 ### Applying a theme
 
-You can specify a predefined or custom theme via the optional `-t` parameter. For a predefined theme, include the theme name. For a custom theme, include the path to the custom theme's folder.
+HackMyResume can work with any FRESH or JSON Resume theme (the latter must be
+installed first). To specify a theme when generating your resume, use the `-t`
+or `--theme` parameter:
 
 ```bash
-fluentcmd resume.json -t modern
-fluentcmd resume.json -t ~/foo/bar/my-custom-theme/
+hackmyresume build resume.json TO out/rez.all -t [theme]
 ```
 
-As of v0.5.0, available predefined themes are `modern`, `minimist`, and `hello-world`.
+The `[theme]` parameter can be the name of a predefined theme OR the path to any
+FRESH or JSON Resume theme folder:
+
+```bash
+hackmyresume build resume.json TO out/rez.all -t modern
+hackmyresume build resume.json TO OUT.rez.all -t ../some-folder/my-custom-theme/
+hackmyresume build resume.json TO OUT.rez.all -t node_modules/jsonresume-theme-classy
+```
+
+FRESH themes are currently pre-installed with HackMyResume. JSON Resume themes
+can be installed prior to use:
+
+```bash
+# Install a JSON Resume theme into a local node_modules subfolder:
+npm install jsonresume-theme-[name]
+# Use it with HackMyResume
+hackmyresume build resume.json -t node_modules/jsonresume-theme-[name]
+```
+
+As of v1.6.0, available predefined FRESH themes are `positive`, `modern`,
+`compact`, `minimist`, and `hello-world`. For a list of JSON Resume themes,
+check the [NPM Registry](https://www.npmjs.com/search?q=jsonresume-theme).
 
 ### Merging resumes
 
-You can **merge multiple resumes together** by specifying them in order from most generic to most specific:
+You can **merge multiple resumes together** by specifying them in order from
+most generic to most specific:
 
 ```bash
 # Merge specific.json onto base.json and generate all formats
-fluentcmd base.json specific.json -o resume.all
+hackmyresume build base.json specific.json TO resume.all
 ```
 
-This can be useful for overriding a base (generic) resume with information from a specific (targeted) resume. For example, you might override your generic catch-all "software developer" resume with specific details from your targeted "game developer" resume, or combine two partial resumes into a "complete" resume. Merging follows conventional [extend()][9]-style behavior and there's no arbitrary limit to how many resumes you can merge:
+This can be useful for overriding a base (generic) resume with information from
+a specific (targeted) resume. For example, you might override your generic
+catch-all "software developer" resume with specific details from your targeted
+"game developer" resume, or combine two partial resumes into a "complete"
+resume. Merging follows conventional [extend()][9]-style behavior and there's
+no arbitrary limit to how many resumes you can merge:
 
 ```bash
-fluentcmd in1.json in2.json in3.json in4.json -o out.html -o out.doc
+hackmyresume build in1.json in2.json in3.json in4.json TO out.html out.doc
 Reading JSON resume: in1.json
 Reading JSON resume: in2.json
 Reading JSON resume: in3.json
@@ -120,37 +290,237 @@ Generating WORD resume: out.doc
 
 ### Multiple targets
 
-You can specify **multiple output targets** and FluentCMD will build them:
+You can specify **multiple output targets** and HackMyResume will build them:
 
 ```bash
 # Generate out1.doc, out1.pdf, and foo.txt from me.json.
-fluentcmd 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 "fluentcmd resume.json resume.all -t modern"
-fluentcmd resume.json
+hackmyresume build me.json TO out1.doc out1.pdf foo.txt
 ```
 
 ### Using .all
 
-The special `.all` extension tells FluentCMD to generate all supported output formats for the given resume. For example, this...
+The special `.all` extension tells HackMyResume to generate all supported output
+formats for the given resume. For example, this...
 
 ```bash
 # Generate all resume formats (HTML, PDF, DOC, TXT, etc.)
-fluentcmd me.json -o out/resume.all
+hackmyresume build me.json TO out/resume.all
 ```
 
-..tells FluentCV to read `me.json` and generate `out/resume.md`, `out/resume.doc`, `out/resume.html`, `out/resume.txt`, `out/resume.pdf`, and `out/resume.json`.
+..tells HackMyResume to read `me.json` and generate `out/resume.md`,
+`out/resume.doc`, `out/resume.html`, `out/resume.txt`, `out/resume.pdf`, and
+`out/resume.json`.
+
+### Building PDFs
+
+*Users who don't care about PDFs can turn off PDF generation across all themes
+and formats with the `--pdf none` switch.*
+
+HackMyResume takes a unique approach to PDF generation. Instead of enforcing
+a specific PDF engine on users, HackMyResume will attempt to work with whatever
+PDF engine you have installed through the engine's command-line interface (CLI).
+Currently that means 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 /
+FRESCA][fresca] or [JSON Resume][6] formats. To validate one or more existing
+resumes, use the `validate` command:
+
+```bash
+# Validate myresume.json against either the FRESH or JSON Resume schema.
+hackmyresume validate resumeA.json resumeB.json
+```
+
+HackMyResume will validate each specified resume in turn:
+
+```bash
+*** HackMyResume v1.6.0 ***
+Validating JSON resume: resumeA.json (INVALID)
+Validating JSON resume: resumeB.json (VALID)
+```
+
+### Converting
+
+HackMyResume can convert between the [FRESH][fresca] and [JSON Resume][6]
+formats. Just run:
+
+```bash
+hackmyresume convert <INPUTS> <OUTPUTS>
+```
+
+where <INPUTS> is one or more resumes in FRESH or JSON Resume format, and
+<OUTPUTS> is a corresponding list of output file names. HackMyResume will
+autodetect the format (FRESH or JRS) of each input resume and convert it to the
+other format (JRS or FRESH).
+
+### File-based Options
+
+You can pass options into HackMyResume via an external options or ".hackmyrc"
+file with the `--options` or `-o` switch:
+
+```bash
+hackmyresume build resume.json -o path/to/options.json
+```
+
+The options file can contain any documented HackMyResume option, including
+`theme`, `silent`, `debug`, `pdf`, `css`, and other settings.
+
+```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
 
-FluentCMD applies [js-beautify][10]-style HTML prettification by default to HTML-formatted resumes. To disable prettification, the `--nopretty` or `-n` flag can be used:
+HackMyResume applies [js-beautify][10]-style HTML prettification by default to
+HTML-formatted resumes. To disable prettification, the `--no-prettify` or `-n`
+flag can be used:
 
 ```bash
-fluentcmd resume.json out.all --nopretty
+hackmyresume build resume.json out.all --no-prettify
 ```
 
 ### Silent Mode
@@ -158,10 +528,91 @@ fluentcmd resume.json out.all --nopretty
 Use `-s` or `--silent` to run in silent mode:
 
 ```bash
-fluentcmd resume.json -o someFile.all -s
-fluentcmd 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.
@@ -176,3 +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/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,33 +1,109 @@
 {
-  "name": "fluentcmd",
-  "version": "0.5.0",
-  "description": "Generate beautiful, targeted resumes from your command line or shell.",
+  "name": "hackmyresume",
+  "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/fluentdesk/fluentcmd.git"
+    "url": "https://github.com/hacksalot/HackMyResume.git"
+  },
+  "scripts": {
+    "test": "grunt clean:test && mocha --exit",
+    "grunt": "grunt"
   },
   "keywords": [
     "resume",
     "CV",
     "portfolio",
-    "Markdown"
+    "employment",
+    "career",
+    "Markdown",
+    "JSON",
+    "Word",
+    "PDF",
+    "YAML",
+    "HTML",
+    "LaTeX",
+    "CLI",
+    "Handlebars",
+    "Underscore",
+    "template"
+  ],
+  "author": "hacksalot <hacksalot@indevious.com> (https://github.com/hacksalot)",
+  "contributors": [
+    "aruberto (https://github.com/aruberto)",
+    "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)"
   ],
-  "author": "James M. Devlin",
   "license": "MIT",
   "preferGlobal": "true",
   "bugs": {
-    "url": "https://github.com/fluentdesk/fluentcmd/issues"
+    "url": "https://github.com/hacksalot/HackMyResume/issues"
   },
-  "main": "src/fluentcmd.js",
   "bin": {
-    "fluentcmd": "src/index.js"
+    "hackmyresume": "src/cli/index.js"
   },
-  "homepage": "https://github.com/fluentdesk/fluentcmd",
+  "main": "src/index.js",
+  "homepage": "https://github.com/hacksalot/HackMyResume",
   "dependencies": {
-    "fluentlib": "fluentdesk/fluentlib#v0.4.0",
-    "minimist": "^1.2.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": "^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",
     "mkdirp": "^0.5.1",
+    "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.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",
-    "watermark": "fluentdesk/watermark#v0.3.1-alpha"
+    "word-wrap": "^1.1.0",
+    "xml-escape": "^1.0.0",
+    "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": "^1.1.0",
+    "grunt-contrib-coffee": "^2.0.0",
+    "grunt-contrib-copy": "^1.0.0",
+    "grunt-eslint": "^20.1.0",
+    "grunt-simple-mocha": "*",
+    "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": "*",
+    "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/default-formats.js

@@ -0,0 +1,18 @@
+/*
+Event code definitions.
+@module core/default-formats
+@license MIT. See LICENSE.md for details.
+*/
+
+/** Supported resume formats. */
+module.exports = [
+  { name: 'html', ext: 'html', gen: new (require('../generators/html-generator'))() },
+  { name: 'txt',  ext: 'txt', gen: new (require('../generators/text-generator'))()  },
+  { name: 'doc',  ext: 'doc',  fmt: 'xml', gen: new (require('../generators/word-generator'))() },
+  { name: 'pdf',  ext: 'pdf', fmt: 'html', is: false, gen: new (require('../generators/html-pdf-cli-generator'))() },
+  { name: 'png',  ext: 'png', fmt: 'html', is: false, gen: new (require('../generators/html-png-generator'))() },
+  { name: 'md', ext: 'md', fmt: 'txt', gen: new (require('../generators/markdown-generator'))() },
+  { name: 'json', ext: 'json', gen: new (require('../generators/json-generator'))() },
+  { name: 'yml', ext: 'yml', fmt: 'yml', gen: new (require('../generators/json-yaml-generator'))() },
+  { name: 'latex', ext: 'tex', fmt: 'latex', gen: new (require('../generators/latex-generator'))() }
+];

src/core/default-options.js

@@ -0,0 +1,15 @@
+/*
+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

src/core/empty-jrs.json

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

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

@@ -0,0 +1,95 @@
+/*
+ * 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. See LICENSE.md for details.
+@module core/fluent-date
+*/
+
+
+
+const moment = require('moment');
+require('../utils/string');
+
+/**
+Create a FluentDate from a string or Moment date object. There are a few date
+formats to be aware of here.
+1. The words "Present" and "Now", referring to the current date
+2. The default "YYYY-MM-DD" format used in JSON Resume ("2015-02-10")
+3. Year-and-month only ("2015-04")
+4. Year-only "YYYY" ("2015")
+5. The friendly HackMyResume "mmm YYYY" format ("Mar 2015" or "Dec 2008")
+6. Empty dates ("", " ")
+7. Any other date format that Moment.js can parse from
+Note: Moment can transparently parse all or most of these, without requiring us
+to specify a date format...but for maximum parsing safety and to avoid Moment
+deprecation warnings, it's recommended to either a) explicitly specify the date
+format or b) use an ISO format. For clarity, we handle these cases explicitly.
+@class FluentDate
+*/
+
+class FluentDate {
+
+  constructor(dt) {
+    this.rep = this.fmt(dt);
+  }
+
+  static isCurrent(dt) {
+    return !dt || (String.is(dt) && /^(present|now|current)$/.test(dt));
+  }
+}
+
+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"
+      return moment();
+    } 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;
+      }
+      if (throws) {
+        throw 'Invalid date format encountered.';
+      }
+      return null;
+    }
+  } else {
+    if (!dt) {
+      return moment();
+    } else if (dt.isValid && dt.isValid()) {
+      return dt;
+    }
+    if (throws) {
+      throw 'Unknown date object encountered.';
+    }
+    return null;
+  }
+};

src/core/fresh-resume.js

@@ -0,0 +1,481 @@
+/*
+ * 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. See LICENSE.md for details.
+@module core/fresh-resume
+*/
+
+
+
+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);
+  }
+
+
+
+  /**
+  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.
+  }
+  */
+  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.
+  */
+  saveAs( filename, format ) {
+
+    // 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;
+  }
+
+
+
+  /**
+  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.
+  */
+  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.
+  */
+  markdownify() {
+
+    const MDIN =  txt  => MD(txt || '' ).replace(/^\s*<p>|<\/p>\s*$/gi, '');
+
+    const trx = function( key, val ) {
+      if (key === 'summary') {
+        return MD(val);
+      }
+      return MDIN(val);
+    };
+
+    return this.transformStrings(['skills','url','start','end','date'], trx);
+  }
+
+
+
+  /**
+  Create a copy of this resume in which all fields have been interpreted as
+  Markdown.
+  */
+  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);
+    }
+    return flatSkills;
+  }
+
+
+
+  /**
+  Reset the sheet to an empty state. TODO: refactor/review
+  */
+  clear( clearMeta ) {
+    clearMeta = ((clearMeta === undefined) && true) || clearMeta;
+    if (clearMeta) { delete this.imp; }
+    delete this.computed; // Don't use Object.keys() here
+    delete this.employment;
+    delete this.service;
+    delete this.education;
+    delete this.recognition;
+    delete this.reading;
+    delete this.writing;
+    delete this.interests;
+    delete this.skills;
+    return delete this.social;
+  }
+
+
+
+  /**
+  Get a safe count of the number of things in a section.
+  */
+  count( obj ) {
+    if (!obj) { return 0; }
+    if (obj.history) { return obj.history.length; }
+    if (obj.sets) { return obj.sets.length; }
+    return obj.length || 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);
+    }
+    return newObject;
+  }
+
+
+
+  /**
+  Determine if the sheet includes a specific social profile (eg, GitHub).
+  */
+  hasProfile( socialNetwork ) {
+    socialNetwork = socialNetwork.trim().toLowerCase();
+    return this.social && _.some(this.social, p => p.network.trim().toLowerCase() === socialNetwork);
+  }
+
+
+
+  /** Return the specified network profile. */
+  getProfile( socialNetwork ) {
+    socialNetwork = socialNetwork.trim().toLowerCase();
+    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.
+  */
+  getProfiles( socialNetwork ) {
+    socialNetwork = socialNetwork.trim().toLowerCase();
+    return this.social && _.filter(this.social, sn => sn.network.trim().toLowerCase() === socialNetwork);
+  }
+
+
+
+  /** Determine if the sheet includes a specific skill. */
+  hasSkill( skill ) {
+    skill = skill.trim().toLowerCase();
+    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. */
+  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})?)?$/ }
+    });
+    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);
+  }
+
+
+
+
+  /**
+  Sort dated things on the sheet by start date descending. Assumes that dates
+  on the sheet have been processed with _parseDates().
+  */
+  sort() {
+
+    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; }  }
+    };
+
+    const sortSection = function( key ) {
+      const ar = __.get(this, key);
+      if (ar && ar.length) {
+        const datedThings = ar.filter(o => o.start);
+        return datedThings.sort( byDateDesc );
+      }
+    };
+
+    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;
+
+
+
+// Note 1: Adjust default date validation to allow YYYY and YYYY-MM formats
+// in addition to YYYY-MM-DD. The original regex:
+//
+//     /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}$/
+//

src/core/fresh-theme.js

@@ -0,0 +1,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

@@ -0,0 +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. See LICENSE.md for details.
+@module core/jrs-resume
+*/
+
+
+
+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);
+  }
+
+
+
+  /**
+  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.
+  }
+  */
+  parseJSON( rep, opts ) {
+    let scrubbed;
+    opts = opts || { };
+    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);
+
+    // Set up metadata
+    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();
+    if ((opts.compute === undefined) || opts.compute) {
+      this.basics.computed = {
+        numYears: this.duration(),
+        keywords: this.keywords()
+      };
+    }
+    return this;
+  }
+
+
+
+  /** Save the sheet to disk (for environments that have disk access). */
+  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;
+  }
+
+
+
+  /**
+  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.
+  */
+  i() {
+    return this.imp = this.imp != null ? this.imp : { };
+  }
+
+
+
+  /** 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). */
+  hasProfile( socialNetwork ) {
+    socialNetwork = socialNetwork.trim().toLowerCase();
+    return this.basics.profiles && _.some(this.basics.profiles, p => p.network.trim().toLowerCase() === socialNetwork);
+  }
+
+
+
+  /** Determine if the sheet includes a specific skill. */
+  hasSkill( skill ) {
+    skill = skill.trim().toLowerCase();
+    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. */
+  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})?)?$/ }
+    });
+    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);
+  }
+
+
+
+  /**
+  Sort dated things on the sheet by start date descending. Assumes that dates
+  on the sheet have been processed with _parseDates().
+  */
+  sort( ) {
+
+    const byDateDesc = function(a,b) {
+      if (a.safeStartDate.isBefore(b.safeStartDate)) {
+      return 1;
+      } else { return ( a.safeStartDate.isAfter(b.safeStartDate) && -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; }
+    });
+
+    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; }
+    });
+  }
+
+
+
+  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/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/resume.json

@@ -0,0 +1,380 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Resume Schema",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "basics": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "label": {
+          "type": "string",
+          "description": "e.g. Web Developer"
+        },
+        "picture": {
+          "type": "string",
+          "description": "URL (as per RFC 3986) to a picture in JPEG or PNG format"
+        },
+        "email": {
+          "type": "string",
+          "description": "e.g. thomas@gmail.com",
+          "format": "email"
+        },
+        "phone": {
+          "type": "string",
+          "description": "Phone numbers are stored as strings so use any format you like, e.g. 712-117-2923"
+        },
+        "website": {
+          "type": "string",
+          "description": "URL (as per RFC 3986) to your website, e.g. personal homepage",
+          "format": "uri"
+        },
+        "summary": {
+          "type": "string",
+          "description": "Write a short 2-3 sentence biography about yourself"
+        },
+        "location": {
+          "type": "object",
+          "additionalProperties": true,
+          "properties": {
+            "address": {
+              "type": "string",
+              "description": "To add multiple address lines, use \n. For example, 1234 Glücklichkeit Straße\nHinterhaus 5. Etage li."
+            },
+            "postalCode": {
+              "type": "string"
+            },
+            "city": {
+              "type": "string"
+            },
+            "countryCode": {
+              "type": "string",
+              "description": "code as per ISO-3166-1 ALPHA-2, e.g. US, AU, IN"
+            },
+            "region": {
+              "type": "string",
+              "description": "The general region where you live. Can be a US state, or a province, for instance."
+            }
+          }
+        },
+        "profiles": {
+          "type": "array",
+          "description": "Specify any number of social networks that you participate in",
+          "additionalItems": false,
+          "items": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+              "network": {
+                "type": "string",
+                "description": "e.g. Facebook or Twitter"
+              },
+              "username": {
+                "type": "string",
+                "description": "e.g. neutralthoughts"
+              },
+              "url": {
+                "type": "string",
+                "description": "e.g. http://twitter.com/neutralthoughts"
+              }
+            }
+          }
+        }
+      }
+    },
+    "work": {
+      "type": "array",
+      "additionalItems": false,
+      "items": {
+        "type": "object",
+        "additionalProperties": true,
+      "properties": {
+          "company": {
+            "type": "string",
+            "description": "e.g. Facebook"
+          },
+          "position": {
+            "type": "string",
+            "description": "e.g. Software Engineer"
+          },
+          "website": {
+            "type": "string",
+            "description": "e.g. http://facebook.com",
+            "format": "uri"
+          },
+          "startDate": {
+            "type": "string",
+            "description": "resume.json uses the ISO 8601 date standard e.g. 2014-06-29",
+            "format": "date"
+          },
+          "endDate": {
+            "type": "string",
+            "description": "e.g. 2012-06-29",
+            "format": "date"
+          },
+          "summary": {
+            "type": "string",
+            "description": "Give an overview of your responsibilities at the company"
+          },
+          "highlights": {
+            "type": "array",
+            "description": "Specify multiple accomplishments",
+            "additionalItems": false,
+            "items": {
+              "type": "string",
+              "description": "e.g. Increased profits by 20% from 2011-2012 through viral advertising"
+            }
+          }
+        }
+
+      }
+    },
+    "volunteer": {
+      "type": "array",
+      "additionalItems": false,
+      "items": {
+        "type": "object",
+        "additionalProperties": true,
+      "properties": {
+          "organization": {
+            "type": "string",
+            "description": "e.g. Facebook"
+          },
+          "position": {
+            "type": "string",
+            "description": "e.g. Software Engineer"
+          },
+          "website": {
+            "type": "string",
+            "description": "e.g. http://facebook.com",
+            "format": "uri"
+          },
+          "startDate": {
+            "type": "string",
+            "description": "resume.json uses the ISO 8601 date standard e.g. 2014-06-29",
+            "format": "date"
+          },
+          "endDate": {
+            "type": "string",
+            "description": "e.g. 2012-06-29",
+            "format": "date"
+          },
+          "summary": {
+            "type": "string",
+            "description": "Give an overview of your responsibilities at the company"
+          },
+          "highlights": {
+            "type": "array",
+            "description": "Specify multiple accomplishments",
+            "additionalItems": false,
+            "items": {
+              "type": "string",
+              "description": "e.g. Increased profits by 20% from 2011-2012 through viral advertising"
+            }
+          }
+        }
+
+      }
+    },
+    "education": {
+      "type": "array",
+      "additionalItems": false,
+      "items": {
+        "type": "object",
+        "additionalProperties": true,
+      "properties": {
+            "institution": {
+              "type": "string",
+              "description": "e.g. Massachusetts Institute of Technology"
+            },
+            "area": {
+              "type": "string",
+              "description": "e.g. Arts"
+            },
+            "studyType": {
+              "type": "string",
+              "description": "e.g. Bachelor"
+            },
+            "startDate": {
+              "type": "string",
+              "description": "e.g. 2014-06-29",
+              "format": "date"
+            },
+            "endDate": {
+              "type": "string",
+              "description": "e.g. 2012-06-29",
+              "format": "date"
+            },
+            "gpa": {
+              "type": "string",
+              "description": "grade point average, e.g. 3.67/4.0"
+            },
+            "courses": {
+              "type": "array",
+              "description": "List notable courses/subjects",
+              "additionalItems": false,
+              "items": {
+                "type": "string",
+                "description": "e.g. H1302 - Introduction to American history"
+              }
+            }
+          }
+
+
+      }
+    },
+    "awards": {
+      "type": "array",
+      "description": "Specify any awards you have received throughout your professional career",
+      "additionalItems": false,
+      "items": {
+          "type": "object",
+          "additionalProperties": true,
+        "properties": {
+            "title": {
+              "type": "string",
+              "description": "e.g. One of the 100 greatest minds of the century"
+            },
+            "date": {
+              "type": "string",
+              "description": "e.g. 1989-06-12",
+              "format": "date"
+            },
+            "awarder": {
+              "type": "string",
+              "description": "e.g. Time Magazine"
+            },
+            "summary": {
+              "type": "string",
+              "description": "e.g. Received for my work with Quantum Physics"
+            }
+        }
+      }
+    },
+    "publications": {
+      "type": "array",
+      "description": "Specify your publications through your career",
+      "additionalItems": false,
+      "items": {
+          "type": "object",
+          "additionalProperties": true,
+        "properties": {
+            "name": {
+              "type": "string",
+              "description": "e.g. The World Wide Web"
+            },
+            "publisher": {
+              "type": "string",
+              "description": "e.g. IEEE, Computer Magazine"
+            },
+            "releaseDate": {
+              "type": "string",
+              "description": "e.g. 1990-08-01"
+            },
+            "website": {
+              "type": "string",
+              "description": "e.g. http://www.computer.org/csdl/mags/co/1996/10/rx069-abs.html"
+            },
+            "summary": {
+              "type": "string",
+              "description": "Short summary of publication. e.g. Discussion of the World Wide Web, HTTP, HTML."
+            }
+          }
+      }
+    },
+    "skills": {
+      "type": "array",
+      "description": "List out your professional skill-set",
+      "additionalItems": false,
+      "items": {
+          "type": "object",
+          "additionalProperties": true,
+        "properties": {
+            "name": {
+              "type": "string",
+              "description": "e.g. Web Development"
+            },
+            "level": {
+              "type": "string",
+              "description": "e.g. Master"
+            },
+            "keywords": {
+              "type": "array",
+              "description": "List some keywords pertaining to this skill",
+              "additionalItems": false,
+              "items": {
+                "type": "string",
+                "description": "e.g. HTML"
+              }
+            }
+        }
+      }
+    },
+    "languages": {
+      "type": "array",
+      "description": "List any other languages you speak",
+      "additionalItems": false,
+      "items": {
+        "type": "object",
+        "additionalProperties": true,
+        "properties": {
+          "language": {
+            "type": "string",
+            "description": "e.g. English, Spanish"
+          },
+          "fluency": {
+            "type": "string",
+            "description": "e.g. Fluent, Beginner"
+          }
+        }
+      }
+    },
+    "interests": {
+      "type": "array",
+      "additionalItems": false,
+      "items": {
+        "type": "object",
+        "additionalProperties": true,
+      "properties": {
+          "name": {
+            "type": "string",
+            "description": "e.g. Philosophy"
+          },
+          "keywords": {
+            "type": "array",
+            "additionalItems": false,
+            "items": {
+              "type": "string",
+              "description": "e.g. Friedrich Nietzsche"
+            }
+          }
+        }
+
+      }
+    },
+    "references": {
+      "type": "array",
+      "description": "List references you have received",
+      "additionalItems": false,
+      "items": {
+        "type": "object",
+        "additionalProperties": true,
+      "properties": {
+          "name": {
+            "type": "string",
+            "description": "e.g. Timothy Cook"
+          },
+          "reference": {
+            "type": "string",
+            "description": "e.g. Joe blogs was a great employee, who turned up to work at least once a week. He exceeded my expectations when it came to doing nothing."
+          }
+        }
+
+      }
+    }
+  }
+}

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/fluentcmd.js

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

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

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

src/utils/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

@@ -0,0 +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 utils/html-to-wpml
+*/
+
+
+const XML = require('xml-escape');
+const _ = require('underscore');
+const HTML5Tokenizer = require('simple-html-tokenizer');
+
+module.exports = function( 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 = ''))));
+
+  // Process <em>, <strong>, and <a> elements in the HTML stream, producing
+  // equivalent WordProcessingML that can be dumped into a <w:p> or other
+  // text container element.
+  _.each(tokens, function( tok ) {
+
+    switch (tok.type) {
+
+      case 'StartTag':
+        switch (tok.tagName) {
+          case 'p': 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 '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 '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"/>' : '';
+          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;
+};

src/utils/md2chalk.js

@@ -0,0 +1,20 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Inline Markdown-to-Chalk conversion routines.
+@license MIT. See LICENSE.md for details.
+@module utils/md2chalk
+*/
+
+
+const CHALK = require('chalk');
+const LO = require('lodash');
+
+module.exports = function( v, style, boldStyle ) {
+  boldStyle = boldStyle || 'bold';
+  const temp = v.replace(/\*\*(.*?)\*\*/g, LO.get( CHALK, boldStyle )('$1'));
+  if (style) { return LO.get( CHALK, style )(temp); } else { return temp; }
+};

src/utils/rasterize.js

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

src/utils/resume-detector.js

@@ -0,0 +1,20 @@
+/*
+ * 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 ResumeDetector class.
+@module utils/resume-detector
+@license MIT. See LICENSE.md for details.
+*/
+
+module.exports = function( rez ) {
+  if (rez.meta && rez.meta.format) { //&& rez.meta.format.substr(0, 5).toUpperCase() == 'FRESH'
+    return 'fresh';
+  } else if (rez.basics) {
+    return 'jrs';
+  } else {
+    return 'unk';
+  }
+};

src/utils/resume-scrubber.js

@@ -0,0 +1,62 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+
+const _ = require('underscore');
+
+module.exports = {
+
+  /**
+  Removes ignored or private fields from a resume object
+  @returns an object with the following structure:
+  {
+    scrubbed: the processed resume object
+    ignoreList: an array of ignored nodes that were removed
+    privateList: an array of private nodes that were removed
+  }
+  */
+  scrubResume(rep, opts) {
+    const traverse = require('traverse');
+    const ignoreList = [];
+    const privateList = [];
+    const includePrivates = opts && opts.private;
+
+    const scrubbed = traverse( rep ).map(function() { // [^1]
+      if (!this.isLeaf) {
+        if ((this.node.ignore === true) || (this.node.ignore === 'true')) {
+          ignoreList.push(this.node);
+          this.delete();
+        } else if (((this.node.private === true) || (this.node.private === 'true')) && !includePrivates) {
+          privateList.push(this.node);
+          this.delete();
+        }
+      }
+      if (_.isArray(this.node)) { // [^2]
+        this.after(function() {
+          this.update(_.compact(this.node));
+        });
+      }
+    });
+
+    return {
+      scrubbed,
+      ingoreList: ignoreList,
+      privateList
+    };
+  }
+};
+
+
+
+// [^1]: As of v0.6.6, the NPM traverse library has a quirk when attempting
+// to remove array elements directly using traverse's `this.remove`. See:
+//
+// https://github.com/substack/js-traverse/issues/48
+//
+// [^2]: The workaround is to use traverse's 'this.delete' to nullify the value
+// first, followed by removal with something like _.compact.
+//
+// https://github.com/substack/js-traverse/issues/48#issuecomment-142607200
+//

src/utils/safe-json-loader.js

@@ -0,0 +1,34 @@
+/*
+ * 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 SafeJsonLoader class.
+@module utils/safe-json-loader
+@license MIT. See LICENSE.md for details.
+*/
+
+const FS = require('fs');
+const SyntaxErrorEx = require('./syntax-error-ex');
+
+module.exports = function( file ) {
+  const ret = { };
+  try {
+    ret.raw = FS.readFileSync( file, 'utf8' );
+    ret.json = JSON.parse( ret.raw );
+  } catch (err) {
+    // If we get here, either FS.readFileSync or JSON.parse failed.
+    // We'll return HMSTATUS.readError or HMSTATUS.parseError.
+    const retRaw = ret.raw && ret.raw.trim();
+    ret.ex = {
+      op: retRaw ? 'parse' : 'read',
+      inner:
+        SyntaxErrorEx.is( err )
+        ? (new SyntaxErrorEx( err, retRaw ))
+        : err,
+      file
+    };
+  }
+  return ret;
+};

src/utils/safe-spawn.js

@@ -0,0 +1,44 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Safe spawn utility for HackMyResume / FluentCV.
+@module utils/safe-spawn
+@license MIT. See LICENSE.md for details.
+*/
+
+/** Safely spawn a process synchronously or asynchronously without throwing an
+exception */
+module.exports = function( cmd, args, isSync, callback, param ) {
+
+  try {
+    // .spawnSync not available on earlier Node.js, so default to .spawn
+    const spawn = require('child_process')[ isSync ? 'spawnSync' : 'spawn'];
+    const info = spawn(cmd, args);
+
+    // Check for error depending on whether we're sync or async TODO: Promises
+    if (!isSync) {
+      info.on('error', function(err) {
+        if (typeof callback === 'function') {
+          callback(err, param);
+        }
+      });
+      return;
+    } else {
+      if (info.error) {
+        if (typeof callback === 'function') {
+          callback(info.error, param);
+        }
+        return {cmd, inner: info.error};
+      }
+    }
+
+  } catch (ex) {
+    if (typeof callback === 'function') {
+      callback(ex, param);
+    }
+    return ex;
+  }
+};

src/utils/string-transformer.js

@@ -0,0 +1,56 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Object string transformation.
+@module utils/string-transformer
+@license MIT. See LICENSE.md for details.
+*/
+
+const _ = require('underscore');
+const moment = require('moment');
+
+/**
+Create a copy of this object in which all string fields have been run through
+a transformation function (such as a Markdown filter or XML encoder).
+*/
+
+module.exports = function( ret, filt, transformer ) {
+
+  // TODO: refactor recursion
+  var transformStringsInObject = function( obj, filters ) {
+    if (!obj) { return; }
+    if (moment.isMoment(obj)) { return; }
+
+    if (_.isArray( obj )) {
+      return obj.forEach(function(elem, idx, ar) {
+        if ((typeof elem === 'string') || elem instanceof String) {
+          return ar[idx] = transformer( null, elem );
+        } else if (_.isObject(elem)) {
+          return transformStringsInObject( elem, filters );
+        }
+      });
+    } else if (_.isObject( obj )) {
+      return Object.keys( obj ).forEach(function(k) {
+        if (filters.length && _.contains(filters, k)) {
+          return;
+        }
+        const sub = obj[k];
+        if ((typeof sub === 'string') || sub instanceof String) {
+          return obj[k] = transformer( k, sub );
+        } else if (_.isObject( sub )) {
+          return transformStringsInObject( sub, filters );
+        }
+      });
+    }
+  };
+
+  Object.keys( ret ).forEach(function(member) {
+    if (!filt || !filt.length || !_.contains(filt, member)) {
+      return transformStringsInObject( ret[ member ], filt || [] );
+    }
+  });
+  return ret;
+};

src/utils/string.js

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

src/utils/syntax-error-ex.js

@@ -0,0 +1,43 @@
+/*
+ * decaffeinate suggestions:
+ * DS101: Remove unnecessary use of Array.from
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Definition of the SyntaxErrorEx class.
+@module utils/syntax-error-ex
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+/**
+Represents a SyntaxError exception with line and column info.
+Collect syntax error information from the provided exception object. The
+JavaScript `SyntaxError` exception isn't interpreted uniformly across environ-
+ments, so we reparse on error to grab the line and column.
+See: http://stackoverflow.com/q/13323356
+@class SyntaxErrorEx
+*/
+
+class SyntaxErrorEx {
+  constructor( ex, rawData ) {
+    let JSONLint = require('json-lint');
+    const lint = JSONLint(rawData, { comments: false });
+    if (lint.error) { [this.line, this.col] = Array.from([lint.line, lint.character]); }
+    if (!lint.error) {
+      JSONLint = require('jsonlint');
+      try {
+        JSONLint.parse(rawData);
+      } catch (err) {
+        this.line = (/on line (\d+)/.exec(err))[1];
+      }
+    }
+  }
+}
+
+
+// Return true if the supplied parameter is a JavaScript SyntaxError
+SyntaxErrorEx.is =  ex  => ex instanceof SyntaxError;
+
+module.exports = SyntaxErrorEx;

src/verbs/analyze.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
+ */
+/**
+Implementation of the 'analyze' verb for HackMyResume.
+@module verbs/analyze
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const HMEVENT       = require('../core/event-codes');
+const HMSTATUS      = require('../core/status-codes');
+const _             = require('underscore');
+const ResumeFactory = require('../core/resume-factory');
+const Verb          = require('../verbs/verb');
+
+
+
+/** An invokable resume analysis command. */
+class AnalyzeVerb extends Verb {
+  constructor() { super('analyze', _analyze); }
+}
+
+module.exports = AnalyzeVerb;
+
+
+
+/** Private workhorse for the 'analyze' command. */
+var _analyze = function( sources, dst, opts ) {
+
+  if (!sources || !sources.length) {
+    this.err(HMSTATUS.resumeNotFound, { quit: true });
+    return null;
+  }
+
+  const nlzrs = _loadInspectors();
+  const results = _.map(sources, function(src) {
+    const r = ResumeFactory.loadOne(src, { format: 'FRESH', objectify: true, inner: {
+      private: opts.private === true
+    }
+  }, this);
+    if (opts.assert && this.hasError()) { return { }; }
+
+    if (r.fluenterror) {
+      r.quit = opts.assert;
+      this.err(r.fluenterror, r);
+      return r;
+    } else {
+      return _analyzeOne.call(this, r, nlzrs, opts);
+    }
+  }
+  , this);
+
+
+  if (this.hasError() && !opts.assert) {
+    this.reject(this.errorCode);
+  } else if (!this.hasError()) {
+    this.resolve(results);
+  }
+  return results;
+};
+
+
+
+/** Analyze a single resume. */
+var _analyzeOne = function( resumeObject, nlzrs ) {
+  const { rez } = resumeObject;
+  const safeFormat =
+    rez.meta && rez.meta.format && rez.meta.format.startsWith('FRESH')
+    ? 'FRESH' : 'JRS';
+
+  this.stat( HMEVENT.beforeAnalyze, { fmt: safeFormat, file: resumeObject.file });
+  const info = _.mapObject(nlzrs, (val) => val.run(rez));
+  this.stat(HMEVENT.afterAnalyze, { info });
+  return info;
+};
+
+
+
+var _loadInspectors = () =>
+  ({
+    totals: require('../inspectors/totals-inspector'),
+    coverage: require('../inspectors/gap-inspector'),
+    keywords: require('../inspectors/keyword-inspector')
+  })
+;

src/verbs/build.js

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

src/verbs/convert.js

@@ -0,0 +1,171 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Implementation of the 'convert' verb for HackMyResume.
+@module verbs/convert
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const ResumeFactory = require('../core/resume-factory');
+const Verb = require('../verbs/verb');
+const HMSTATUS = require('../core/status-codes');
+const _ = require('underscore');
+const HMEVENT = require('../core/event-codes');
+
+
+
+class ConvertVerb extends Verb {
+  constructor() { super('convert', _convert); }
+}
+
+module.exports = ConvertVerb;
+
+
+
+/** Private workhorse method. Convert 0..N resumes between FRESH and JRS
+formats. */
+
+var _convert = function( srcs, dst, opts ) {
+
+  // If no source resumes are specified, error out
+  let fmtUp;
+  if (!srcs || !srcs.length) {
+    this.err(HMSTATUS.resumeNotFound, { quit: true });
+    return null;
+  }
+
+  // If no destination resumes are specified, error out except for the special
+  // case of two resumes:
+  //   hackmyresume CONVERT r1.json r2.json
+  if (!dst || !dst.length) {
+    if (srcs.length === 1) {
+      this.err(HMSTATUS.inputOutputParity, { quit: true });
+    } else if (srcs.length === 2) {
+      dst = dst || []; dst.push( srcs.pop() );
+    } else {
+      this.err(HMSTATUS.inputOutputParity, { quit: true });
+    }
+  }
+
+  // Different number of source and dest resumes? Error out.
+  if (srcs && dst && srcs.length && dst.length && (srcs.length !== dst.length)) {
+    this.err(HMSTATUS.inputOutputParity, { quit: true });
+  }
+
+  // Validate the destination format (if specified)
+  //const targetVer = null;
+  if (opts.format) {
+    fmtUp = opts.format.trim().toUpperCase();
+    if (!_.contains(['FRESH','FRESCA','JRS','JRS@1','JRS@edge'], fmtUp)) {
+      this.err(HMSTATUS.invalidSchemaVersion, {data: opts.format.trim(), quit: true});
+    }
+  }
+    // freshVerRegex = require '../utils/fresh-version-regex'
+    // matches = fmtUp.match freshVerRegex()
+    // # null
+    // # [ 'JRS@1.0', 'JRS', '1.0', index: 0, input: 'FRESH' ]
+    // # [ 'FRESH', 'FRESH', undefined, index: 0, input: 'FRESH' ]
+    // if not matches
+    //   @err HMSTATUS.invalidSchemaVersion, data: opts.format.trim(), quit: true
+    // targetSchema = matches[1]
+    // targetVer = matches[2] || '1'
+
+  // If any errors have occurred this early, we're done.
+  if (this.hasError()) {
+    this.reject(this.errorCode);
+    return null;
+  }
+
+  // Map each source resume to the converted destination resume
+  const results = _.map(srcs, function( src, idx ) {
+
+    // Convert each resume in turn
+    const r = _convertOne.call(this, src, dst, idx, fmtUp);
+
+    // Handle conversion errors
+    if (r.fluenterror) {
+      r.quit = opts.assert;
+      this.err(r.fluenterror, r);
+    }
+    return r;
+  }
+  , this);
+
+
+  if (this.hasError() && !opts.assert) {
+    this.reject(results);
+  } else if (!this.hasError()) {
+    this.resolve(results);
+  }
+  return results;
+};
+
+
+
+/** Private workhorse method. Convert a single resume. */
+var _convertOne = function(src, dst, idx, targetSchema) {
+
+  // Load the resume
+  const rinfo = ResumeFactory.loadOne(src, {
+    format: null,
+    objectify: true,
+    inner: {
+      privatize: false
+    }
+  }
+  );
+
+  // If a load error occurs, report it and move on to the next file (if any)
+  if (rinfo.fluenterror) {
+    this.stat(HMEVENT.beforeConvert, {
+      srcFile: src, //rinfo.file
+      srcFmt: '???',
+      dstFile: dst[idx],
+      dstFmt: '???',
+      error: true
+    }
+    );
+    //@err rinfo.fluenterror, rinfo
+    return rinfo;
+  }
+
+  // Determine the resume's SOURCE format
+  // TODO: replace with detector component
+  const { rez } = rinfo;
+  let srcFmt = '';
+  if (rez.meta && rez.meta.format) { //&& rez.meta.format.substr(0, 5).toUpperCase() == 'FRESH'
+    srcFmt = 'FRESH';
+  } else if (rez.basics) {
+    srcFmt = 'JRS';
+  } else {
+    rinfo.fluenterror = HMSTATUS.unknownSchema;
+    return rinfo;
+  }
+
+  // Determine the TARGET format for the conversion
+  const targetFormat = targetSchema || (srcFmt === 'JRS' ? 'FRESH' : 'JRS');
+
+  // Fire the beforeConvert event
+  this.stat(HMEVENT.beforeConvert, {
+    srcFile: rinfo.file,
+    srcFmt,
+    dstFile: dst[idx],
+    dstFmt: targetFormat
+  }
+  );
+
+  // Save it to the destination format
+  try {
+    rez.saveAs(dst[idx], targetFormat);
+  } catch (err) {
+    if (err.badVer) {
+      return {fluenterror: HMSTATUS.invalidSchemaVersion, quit: true, data: err.badVer};
+    }
+  }
+  return rez;
+};

src/verbs/create.js

@@ -0,0 +1,84 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Implementation of the 'create' verb for HackMyResume.
+@module verbs/create
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const MKDIRP = require('mkdirp');
+const PATH = require('path');
+const Verb = require('../verbs/verb');
+const _ = require('underscore');
+const HMSTATUS = require('../core/status-codes');
+const HMEVENT = require('../core/event-codes');
+
+
+
+class CreateVerb extends Verb {
+
+  constructor() { super('new', _create); }
+}
+
+
+module.exports = CreateVerb;
+
+
+
+/** Create a new empty resume in either FRESH or JRS format. */
+var _create = function( src, dst, opts ) {
+
+  if (!src || !src.length) {
+    this.err(HMSTATUS.createNameMissing, { quit: true });
+    return null;
+  }
+
+  const results = _.map(src, function( t ) {
+    if (opts.assert && this.hasError()) { return { }; }
+    const r = _createOne.call(this, t, opts);
+    if (r.fluenterror) {
+      r.quit = opts.assert;
+      this.err(r.fluenterror, r);
+    }
+    return r;
+  }
+  , this);
+
+  if (this.hasError() && !opts.assert) {
+    this.reject(this.errorCode);
+  } else if (!this.hasError()) {
+    this.resolve(results);
+  }
+  return results;
+};
+
+
+
+/** Create a single new resume */
+var _createOne = function( t, opts ) {
+  let ret, safeFmt;
+  try {
+    ret = null;
+    safeFmt = opts.format.toUpperCase();
+    this.stat(HMEVENT.beforeCreate, { fmt: safeFmt, file: t });
+    MKDIRP.sync(PATH.dirname( t )); // Ensure dest folder exists;
+    const RezClass = require(`../core/${safeFmt.toLowerCase()}-resume`);
+    const newRez = RezClass.default();
+    newRez.save(t);
+    ret = newRez;
+  } catch (err) {
+    ret = {
+      fluenterror: HMSTATUS.createError,
+      inner: err
+    };
+  }
+  finally {
+    this.stat(HMEVENT.afterCreate, { fmt: safeFmt, file: t, isError: ret.fluenterror });
+  }
+  return ret;
+};

src/verbs/peek.js

@@ -0,0 +1,103 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Implementation of the 'peek' verb for HackMyResume.
+@module verbs/peek
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const Verb = require('../verbs/verb');
+const _ = require('underscore');
+const __ = require('lodash');
+const safeLoadJSON = require('../utils/safe-json-loader');
+const HMSTATUS = require('../core/status-codes');
+const HMEVENT = require('../core/event-codes');
+
+
+
+class PeekVerb extends Verb {
+
+  constructor() { super('peek', _peek); }
+
+}
+
+
+module.exports = PeekVerb;
+
+/** Peek at a resume, resume section, or resume field. */
+var _peek = function( src, dst, opts ) {
+
+  if (!src || !src.length) {
+    this.err(HMSTATUS.resumeNotFound, { quit: true });
+    return null;
+  }
+
+  const objPath = (dst && dst[0]) || '';
+
+  const results = _.map(src, function( t ) {
+
+    if (opts.assert && this.hasError()) { return { }; }
+
+    const tgt = _peekOne.call(this, t, objPath);
+    if (tgt.error) {
+      this.setError(tgt.error.fluenterror, tgt.error);
+    }
+      //tgt.error.quit = opts.assert
+      //@err tgt.error.fluenterror, tgt.error
+    return tgt;
+  }
+  , this);
+
+  if (this.hasError() && !opts.assert) {
+    this.reject(this.errorCode);
+  } else if (!this.hasError()) {
+    this.resolve(results);
+  }
+  return results;
+};
+
+
+
+/** Peek at a single resume, resume section, or resume field. */
+var _peekOne = function( t, objPath ) {
+
+  this.stat(HMEVENT.beforePeek, { file: t, target: objPath });
+
+  // Load the input file JSON 1st
+  const obj = safeLoadJSON(t);
+
+  // Fetch the requested object path (or the entire file)
+  let tgt = null;
+  if (!obj.ex) {
+    tgt = objPath ? __.get(obj.json, objPath) : obj.json;
+  }
+
+  //# safeLoadJSON can only return a READ error or a PARSE error
+  let pkgError = null;
+  if (obj.ex) {
+    const errCode = obj.ex.op === 'parse' ? HMSTATUS.parseError : HMSTATUS.readError;
+    if (errCode === HMSTATUS.readError) {
+      obj.ex.quiet = true;
+    }
+    pkgError = {fluenterror: errCode, inner: obj.ex};
+  }
+
+  // Fire the 'afterPeek' event with collected info
+  this.stat(HMEVENT.afterPeek, {
+    file: t,
+    requested: objPath,
+    target: obj.ex ? undefined : tgt,
+    error: pkgError
+  }
+  );
+
+  return {
+    val: obj.ex ? undefined : tgt,
+    error: pkgError
+  };
+};

src/verbs/validate.js

@@ -0,0 +1,113 @@
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+/**
+Implementation of the 'validate' verb for HackMyResume.
+@module verbs/validate
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const Verb = require('../verbs/verb');
+const HMSTATUS = require('../core/status-codes');
+const HMEVENT = require('../core/event-codes');
+const _ = require('underscore');
+const safeLoadJSON = require('../utils/safe-json-loader');
+
+
+
+/** An invokable resume validation command. */
+class ValidateVerb extends Verb {
+  constructor() { super('validate', _validate); }
+}
+
+
+
+// Validate 1 to N resumes in FRESH or JSON Resume format.
+var _validate = function(sources, unused, opts)  {
+
+  if (!sources || !sources.length) {
+    this.err(HMSTATUS.resumeNotFoundAlt, {quit: true});
+    return null;
+  }
+
+  const validator = require('is-my-json-valid');
+  const schemas = {
+    fresh: require('fresh-resume-schema'),
+    jars: require('../core/resume.json')
+  };
+
+  const results = _.map(sources, function(t)  {
+    const r = _validateOne.call(this, t, validator, schemas, opts);
+    if (r.error) { this.err(r.error.fluenterror, r.error); }
+    return r;
+  }
+  , this);
+
+  if (this.hasError() && !opts.assert) {
+    this.reject(this.errorCode);
+  } else if (!this.hasError()) {
+    this.resolve(results);
+  }
+  return results;
+};
+
+module.exports = ValidateVerb;
+
+/**
+Validate a single resume.
+@returns {
+  file: <fileName>,
+  isValid: <validFlag>,
+  status: <validationStatus>,
+  violations: <validationErrors>,
+  schema: <schemaType>,
+  error: <errorObject>
+}
+*/
+var _validateOne = function(t, validator, schemas) {
+
+  const ret = {file: t, isValid: false, status: 'unknown', schema: '-----'};
+
+  try {
+
+    // Read and parse the resume JSON. Won't throw.
+    const obj = safeLoadJSON(t);
+
+    // If success, validate the resume against the schema
+    if (!obj.ex) {
+      if (obj.json.basics) { ret.schema = 'jars'; } else { ret.schema = 'fresh'; }
+      const validate = validator(schemas[ ret.schema ], // Note [1]
+        {formats: { date: /^\d{4}(?:-(?:0[0-9]{1}|1[0-2]{1})(?:-[0-9]{2})?)?$/ }});
+      ret.isValid = validate(obj.json);
+      ret.status = ret.isValid ? 'valid' : 'invalid';
+      if (!ret.isValid) { ret.violations = validate.errors; }
+
+    // If failure, package JSON read/parse errors
+    } else {
+      let errCode;
+      if (obj.ex.op === 'parse') {
+        errCode = HMSTATUS.parseError;
+        ret.status = 'broken';
+      } else {
+        errCode = HMSTATUS.readError;
+        ret.status = 'missing';
+      }
+      ret.error = {
+        fluenterror: errCode,
+        inner: obj.ex.inner,
+        quiet: errCode === HMSTATUS.readError
+      };
+    }
+
+  } catch (err) {
+    // Package any unexpected exceptions
+    ret.error = {fluenterror: HMSTATUS.validateError, inner: err};
+  }
+
+  this.stat(HMEVENT.afterValidate, ret);
+  return ret;
+};

src/verbs/verb.js

@@ -0,0 +1,115 @@
+/*
+ * 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 Verb class.
+@module verbs/verb
+@license MIT. See LICENSE.md for details.
+*/
+
+
+
+const EVENTS = require('events');
+const HMEVENT = require('../core/event-codes');
+const Promise = require('pinkie-promise');
+
+
+
+/**
+An abstract invokable verb.
+Provides base class functionality for verbs. Provide common services such as
+error handling, event management, and promise support.
+@class Verb
+*/
+
+class Verb {
+
+
+
+  /** Constructor. Automatically called at creation. */
+  constructor( moniker, workhorse ) {
+    this.moniker = moniker;
+    this.workhorse = workhorse;
+    this.emitter = new EVENTS.EventEmitter();
+  }
+
+
+
+  /** Invoke the command. */
+  invoke() {
+
+    // Sent the 'begin' notification for this verb
+    this.stat(HMEVENT.begin, {cmd: this.moniker});
+
+    // Prepare command arguments
+    const argsArray = Array.prototype.slice.call(arguments);
+
+    // Create a promise for this verb instance
+    const that = this;
+    return this.promise = new Promise(function(res, rej) {
+      that.resolve = res;
+      that.reject = rej;
+      that.workhorse.apply(that, argsArray);
+    });
+  }
+
+
+
+  /** Forward subscriptions to the event emitter. */
+  on() { return this.emitter.on.apply(this.emitter, arguments); }
+
+
+
+  /** Fire an arbitrary event, scoped to "hmr:". */
+  fire(evtName, payload) {
+    payload = payload || { };
+    payload.cmd = this.moniker;
+    this.emitter.emit(`hmr:${evtName}`, payload);
+    return true;
+  }
+
+
+
+  /** Handle an error condition. */
+  err( errorCode, payload, hot ) {
+    payload = payload || { };
+    payload.sub = (payload.fluenterror = errorCode);
+    payload.throw = hot;
+    this.setError(errorCode, payload);
+    if (payload.quit) {
+      this.reject(errorCode);
+    }
+    this.fire('error', payload);
+    if (hot) {
+      throw payload;
+    }
+    return true;
+  }
+
+
+
+  /** Fire the 'hmr:status' error event. */
+  stat( subEvent, payload ) {
+    payload = payload || { };
+    payload.sub = subEvent;
+    this.fire('status', payload);
+    return true;
+  }
+
+
+
+  /** Has an error occurred during this verb invocation? */
+  hasError() { return this.errorCode || this.errorObj; }
+
+
+
+  /** Associate error info with the invocation. */
+  setError( code, obj ) {
+    this.errorCode = code;
+    this.errorObj = obj;
+  }
+}
+
+module.exports = Verb;

test/.gitignore

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

test/all.js

@@ -0,0 +1,12 @@
+
+var MKDIRP = require('mkdirp');
+var PATH = require('path');
+MKDIRP( PATH.join( __dirname, '/sandbox' ) );
+
+require('./scripts/test-cli');
+require('./scripts/test-fresh-sheet');
+require('./scripts/test-jrs-sheet');
+require('./scripts/test-themes');
+require('./scripts/test-verbs');
+require('./scripts/test-output');
+require('./scripts/test-dates');

test/expected/modern/modern-html.css

@@ -0,0 +1,204 @@
+
+* {
+  box-sizing: border-box;
+}
+
+main {
+  display: block;
+}
+
+body {
+  font-family: 'Helvetica Neue', 'Helvetica', 'Segoe UI', 'Calibri', 'sans-serif';
+  font-size: 15px;
+  color: #333;
+  line-height: 1.42857143;
+  background-color: #F0F0F0;
+  margin: 0;
+  padding: 0;
+}
+
+/* Typical page borders are awkward when rendered to PDF. */
+body.pdf {
+  background-color: #FFFFFF;
+}
+
+/* Adobe or wkhtmltopdf has issues with the <main> tag, so we use <div> for
+the PDF case, <main> for the HTML case, and style both via an ID. */
+#main {
+  background-color: #FFF;
+  margin: 10px;
+  padding: 10px;
+  border: 1px solid #E6E6E6;
+}
+
+body.pdf > #main {
+  border: none;
+}
+
+#container > header {
+  padding-top: 6em;
+  padding-bottom: 1em;
+}
+
+body.pdf #container > header {
+  padding: 0;
+}
+
+#main > #container > section {
+  margin-left: 5em;
+  position: relative;
+  display: block;
+}
+
+span.fa
+{
+  position: absolute;
+  top: 4px;
+  left: -50px;
+  font-size: 30px;
+  color: #BFC1C3;
+}
+
+hr {
+  margin-top: 20px;
+  margin-bottom: 20px;
+  border: 0;
+  border-top: 1px solid #EEE;
+}
+
+.tenure, .keywords {
+  font-size: 75%;
+}
+
+h1 {
+  margin: 0;
+  font-size: 46px;
+}
+
+h2 {
+  font-size: 24px;
+  color: #BFC1C3;
+  text-transform: uppercase;
+  font-weight: normal;
+}
+
+h3 {
+  margin-bottom: 0;
+  font-size: 18px;
+}
+
+a, a:visited {
+  color: #428BCA;
+  text-decoration: none;
+  font-weight: bold;
+}
+
+a:hover {
+  text-decoration: underline;
+}
+
+.defunct {
+  color: #989898;
+  font-weight: bold;
+}
+
+#summary > p > strong {
+  font-size: 1.25em;
+}
+
+
+.label-keyword {
+  display: inline-block;
+  background: #7eb0db;
+  color: white;
+  font-size: 0.9em;
+  padding: 5px;
+  border: 1px solid #357ebd;
+  border-radius: 5px;
+  margin-top: 2px;
+}
+
+.card-skills {
+    position: relative;
+}
+.card-nested {
+    min-height: 0;
+    margin-bottom: 10px;
+    border-width: 1px 0 0 0;
+}
+.card {
+    background: #FFF;
+    border-radius: 3px;
+    padding: 10px;
+}
+
+.skill-level {
+  border-radius: 3px;
+  position: absolute;
+  top: 10px;
+  bottom: 10px;
+  left: 0;
+  width: 10px;
+  box-shadow: inset 0 0 1px rgba(0, 0, 0, 0.5);
+}
+.skill-level .skill-progress {
+  position: absolute;
+  border-radius: 3px;
+  bottom: 0;
+  width: 100%;
+  -webkit-transition: height 1s ease;
+}
+.skill-level .skill-progress.beginner {
+  height: 50%;
+  background: #e74c3c;
+}
+.skill-level .skill-progress.intermediate {
+  height: 70%;
+  background: #f1c40f;
+}
+.skill-level .skill-progress.advanced {
+  height: 80%;
+  background: #428bca;
+}
+.skill-level .skill-progress.master {
+  height: 95%;
+  background: #5cb85c;
+}
+.skill-info {
+  margin-left: 10px;
+}
+@media (max-width: 480px) {
+  .skill-info {
+    margin-left: 20px;
+  }
+}
+
+.list-unstyled {
+  padding-left: 0;
+  list-style: none;
+}
+
+.card-skills {
+  position: relative;
+}
+
+.space-top {
+    margin-top: 10px;
+}
+
+#container {
+  max-width: 800px;
+  margin: 0 auto;
+}
+
+#elevator-pitch {
+  text-align: center;
+  font-size: 24px;
+  color: #BFC1C3;
+  text-transform: uppercase;
+  font-weight: normal;
+}
+
+.res-label {
+  font-style: italic;
+}

test/expected/modern/modern-pdf.css

@@ -0,0 +1,203 @@
+* {
+  box-sizing: border-box;
+}
+
+main {
+  display: block;
+}
+
+body {
+  font-family: 'Helvetica Neue', 'Helvetica', 'Segoe UI', 'Calibri', 'sans-serif';
+  font-size: 15px;
+  color: #333;
+  line-height: 1.42857143;
+  background-color: #F0F0F0;
+  margin: 0;
+  padding: 0;
+}
+
+/* Typical page borders are awkward when rendered to PDF. */
+body {
+  background-color: #FFFFFF;
+}
+
+/* Adobe or wkhtmltopdf has issues with the <main> tag, so we use <div> for
+the PDF case, <main> for the HTML case, and style both via an ID. */
+#main {
+  background-color: #FFF;
+  margin: 10px;
+  padding: 10px;
+  border: 1px solid #E6E6E6;
+}
+
+body > #main {
+  border: none;
+}
+
+#container > header {
+  padding-top: 6em;
+  padding-bottom: 1em;
+}
+
+body.pdf #container > header {
+  padding: 0;
+}
+
+#main > #container > section {
+  margin-left: 5em;
+  position: relative;
+  display: block;
+}
+
+span.fa
+{
+  position: absolute;
+  top: 4px;
+  left: -50px;
+  font-size: 30px;
+  color: #BFC1C3;
+}
+
+hr {
+  margin-top: 20px;
+  margin-bottom: 20px;
+  border: 0;
+  border-top: 1px solid #EEE;
+}
+
+.tenure, .keywords {
+  font-size: 75%;
+}
+
+h1 {
+  margin: 0;
+  font-size: 46px;
+}
+
+h2 {
+  font-size: 24px;
+  color: #BFC1C3;
+  text-transform: uppercase;
+  font-weight: normal;
+}
+
+h3 {
+  margin-bottom: 0;
+  font-size: 18px;
+}
+
+a, a:visited {
+  color: #428BCA;
+  text-decoration: none;
+  font-weight: bold;
+}
+
+a:hover {
+  text-decoration: underline;
+}
+
+.defunct {
+  color: #989898;
+  font-weight: bold;
+}
+
+#summary > p > strong {
+  font-size: 1.25em;
+}
+
+
+.label-keyword {
+  display: inline-block;
+  background: #7eb0db;
+  color: white;
+  font-size: 0.9em;
+  padding: 5px;
+  border: 1px solid #357ebd;
+  border-radius: 5px;
+  margin-top: 2px;
+}
+
+.card-skills {
+    position: relative;
+}
+.card-nested {
+    min-height: 0;
+    margin-bottom: 10px;
+    border-width: 1px 0 0 0;
+}
+.card {
+    background: #FFF;
+    border-radius: 3px;
+    padding: 10px;
+}
+
+.skill-level {
+  border-radius: 3px;
+  position: absolute;
+  top: 10px;
+  bottom: 10px;
+  left: 0;
+  width: 10px;
+  box-shadow: inset 0 0 1px rgba(0, 0, 0, 0.5);
+}
+.skill-level .skill-progress {
+  position: absolute;
+  border-radius: 3px;
+  bottom: 0;
+  width: 100%;
+  -webkit-transition: height 1s ease;
+}
+.skill-level .skill-progress.beginner {
+  height: 50%;
+  background: #e74c3c;
+}
+.skill-level .skill-progress.intermediate {
+  height: 70%;
+  background: #f1c40f;
+}
+.skill-level .skill-progress.advanced {
+  height: 80%;
+  background: #428bca;
+}
+.skill-level .skill-progress.master {
+  height: 95%;
+  background: #5cb85c;
+}
+.skill-info {
+  margin-left: 10px;
+}
+@media (max-width: 480px) {
+  .skill-info {
+    margin-left: 20px;
+  }
+}
+
+.list-unstyled {
+  padding-left: 0;
+  list-style: none;
+}
+
+.card-skills {
+  position: relative;
+}
+
+.space-top {
+    margin-top: 10px;
+}
+
+#container {
+  max-width: 800px;
+  margin: 0 auto;
+}
+
+#elevator-pitch {
+  text-align: center;
+  font-size: 24px;
+  color: #BFC1C3;
+  text-transform: uppercase;
+  font-weight: normal;
+}
+
+.res-label {
+  font-style: italic;
+}