resume-cli 0.0.0-development

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# resume-cli
+
+[![matrix](https://img.shields.io/badge/matrix-join%20chat-%230dbd8b)](https://matrix.to/#/#json-resume:one.ems.host)
+[![Build status](https://img.shields.io/github/actions/workflow/status/jsonresume/resume-cli/test.yml?branch=master)](https://github.com/jsonresume/resume-cli/actions)
+[![npm package](https://badge.fury.io/js/resume-cli.svg)](https://www.npmjs.org/package/resume-cli)
+
+This is the command line tool for [JSON Resume](https://jsonresume.org), the open-source initiative to create a JSON-based standard for resumes.
+
+## Project Status
+
+This repository is not actively maintained. It's recommended to use one of the third-party clients that support the JSON Resume standard instead:
+
+* [Resumed](https://github.com/rbardini/resumed)
+
+## Getting Started
+
+Install the command-line tool:
+
+```
+npm install -g resume-cli
+```
+
+## Usage
+
+### Commands at a Glance
+
+| Command | Description |
+|---|---|
+| init | Initialize a `resume.json` file. |
+| validate | Schema validation test your `resume.json`. |
+| export path/to/file.html | Export to `.html`. |
+| serve | Serve resume at `http://localhost:4000/`. |
+
+### `resume --help`
+
+Show a list of options and commands for the <abbr title="Command-line Interface">CLI</abbr>.
+
+### `resume init`
+
+Creates a new `resume.json` file in your current working directory.
+
+Complete the `resume.json` with your text editor. Be sure to follow the schema (available at https://jsonresume.org/schema/).
+
+### `resume validate`
+
+Validates your `resume.json` against our schema to ensure it complies with the standard. Tries to identify where any errors may be occurring.
+
+### `resume export [fileName]`
+
+Exports your resume in a stylized HTML or PDF format.
+
+A list of available themes can be found here:  
+https://jsonresume.org/themes/
+
+Please npm install the theme you wish to use before attempting to export it.
+
+Options:
+
+- `--format <file type>` Example: `--format pdf`
+- `--theme <name>` Example: `--theme even`
+
+### `resume serve`
+
+Starts a web server that serves your local `resume.json`. It will live reload when you make changes to your `resume.json`.
+
+Options:
+
+- `--port <port>`
+- `--theme <name>`
+
+When developing themes, change into your theme directory and run `resume serve --theme .`, which tells it to run the local folder as the specified theme.
+
+This is not intended for production use, it's a convenience for theme development or to visualize changes to your resume while editing it.
+
+## Supported Resume Input Types
+
+- [`json`](https://www.json.org/json-en.html): via `JSON.parse`.
+- [`yaml`](https://yaml.org/): via [`yaml-js`](https://www.npmjs.com/package/yaml-js)
+- `quaff`: if `--resume` is a directory, then the path is passed to [`quaff`](https://www.npmjs.com/package/quaff) and the resulting json is used as the resume. quaff supports a variety of formats in the directory, including javascript modules.
+
+## Resume Data
+
+- Setting `--resume -` tells the CLI to read resume data from standard input (`STDIN`), and defaults `--type` to `application/json`.
+- Setting `--resume <path>` reads resume data from `path`.
+- Leaving `--resume` unset defaults to reading from `resume.json` on the current working directory.
+
+## Resume MIME Types
+
+Supported resume data MIME types are:
+
+- `application/json`
+- `text/yaml`
+
+## License
+
+Available under [the MIT license](http://mths.be/mit).

package/build/builder.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const themeServer = process.env.THEME_SERVER || 'https://themes.jsonresume.org/theme/';
+const fs = require('fs');
+const request = require('superagent');
+const chalk = require('chalk');
+const renderHtml = require('./render-html');
+const denormalizeTheme = value => {
+  return value.match(/jsonresume-theme-(.*)/)[1];
+};
+const sendExportHTML = (resumeJson, theme, callback) => {
+  console.log(resumeJson, theme);
+  console.log('Requesting theme from server...');
+  request.post(themeServer + denormalizeTheme(theme)).send({
+    resume: resumeJson
+  }).set('Accept', 'application/json').end((err, response) => {
+    if (err) {
+      callback('There was an error downloading your generated html resume from our server: ' + err);
+    } else if (response.text) {
+      callback(null, response.text);
+    } else {
+      callback('There was an error downloading your generated html resume from our server.');
+    }
+  });
+};
+module.exports = function resumeBuilder(theme, dir, resumeFilename, cb) {
+  fs.readFile(resumeFilename, async (err, resumeJson) => {
+    if (err) {
+      console.log(chalk.yellow('Could not find:'), resumeFilename);
+      console.log(chalk.cyan('Using example resume.json from resume-schema instead...'));
+      resumeJson = require('resume-schema').resumeJson;
+    } else {
+      try {
+        // todo: test resume schema
+        resumeJson = JSON.parse(resumeJson);
+      } catch (e) {
+        err = 'Parse error: ' + resumeFilename;
+        return cb(err);
+      }
+    }
+    try {
+      const html = await renderHtml({
+        resume: resumeJson,
+        themePath: theme
+      });
+      cb(null, html);
+    } catch (err) {
+      console.log(err);
+      console.log(chalk.yellow('Could not run the render function from local theme.'));
+      sendExportHTML(resumeJson, theme, cb);
+    }
+  });
+};

package/build/export-resume.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _renderHtml = _interopRequireDefault(require("./render-html"));
+var _util = require("util");
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const writeFile = (0, _util.promisify)(_fs.default.writeFile);
+const path = require('path');
+const puppeteer = require('puppeteer');
+const btoa = require('btoa');
+module.exports = ({
+  resume: resumeJson,
+  fileName,
+  theme,
+  format
+}, callback) => {
+  if (!fileName) {
+    console.error('Please enter a export destination.');
+    process.exit(1);
+  }
+  const fileNameAndFormat = getFileNameAndFormat(fileName, format);
+  fileName = fileNameAndFormat.fileName;
+  const fileFormatToUse = fileNameAndFormat.fileFormatToUse;
+  const formatToUse = '.' + fileFormatToUse;
+  if (formatToUse === '.html') {
+    createHtml(resumeJson, fileName, theme, formatToUse, error => {
+      if (error) {
+        console.error(error, '`createHtml` errored out');
+      }
+      callback(error, fileName, formatToUse);
+    });
+  } else if (formatToUse === '.pdf') {
+    createPdf(resumeJson, fileName, theme, formatToUse, error => {
+      if (error) {
+        console.error(error, '`createPdf` errored out');
+      }
+      callback(error, fileName, formatToUse);
+    });
+  } else {
+    console.error(`JSON Resume does not support the ${formatToUse} format`);
+    process.exit(1);
+  }
+};
+const extractFileFormat = fileName => {
+  const dotPos = fileName.lastIndexOf('.');
+  if (dotPos === -1) {
+    return null;
+  }
+  return fileName.substring(dotPos + 1).toLowerCase();
+};
+const getThemePkg = theme => {
+  if (theme[0] === '.') {
+    theme = path.join(process.cwd(), theme, 'index.js');
+  } else {
+    theme = path.join(process.cwd(), 'node_modules', theme, 'index.js');
+  }
+  try {
+    const themePkg = require(theme);
+    return themePkg;
+  } catch (err) {
+    // Theme not installed
+    console.log('You have to install this theme relative to the folder to use it e.g. `npm install ' + theme + '`');
+    process.exit();
+  }
+};
+async function createHtml(resumeJson, fileName, themePath, format, callback) {
+  const html = await (0, _renderHtml.default)({
+    resume: resumeJson,
+    themePath
+  });
+  const pathToStream = path.resolve(process.cwd(), fileName + format);
+  await writeFile(pathToStream, ''); // workaround for https://github.com/streamich/unionfs/issues/428
+  const stream = _fs.default.createWriteStream(pathToStream);
+  stream.write(html, () => {
+    stream.close(callback);
+  });
+}
+const createPdf = (resumeJson, fileName, theme, format, callback) => {
+  (async () => {
+    const themePkg = getThemePkg(theme);
+    const puppeteerLaunchArgs = [];
+    if (process.env.RESUME_PUPPETEER_NO_SANDBOX) {
+      puppeteerLaunchArgs.push('--no-sandbox');
+    }
+    const html = await (0, _renderHtml.default)({
+      resume: resumeJson,
+      themePath: theme
+    });
+    const browser = await puppeteer.launch({
+      args: puppeteerLaunchArgs
+    });
+    const page = await browser.newPage();
+    await page.emulateMediaType(themePkg.pdfRenderOptions && themePkg.pdfRenderOptions.mediaType || 'screen');
+    await page.goto(`data:text/html;base64,${btoa(unescape(encodeURIComponent(html)))}`, {
+      waitUntil: 'networkidle0'
+    });
+    if (themePkg.pdfViewport) {
+      await page.setViewport(themePkg.pdfViewport);
+    }
+    await page.pdf({
+      path: fileName + format,
+      format: 'Letter',
+      printBackground: true,
+      ...themePkg.pdfRenderOptions
+    });
+    await browser.close();
+  })().then(callback).catch(callback);
+};
+const getFileNameAndFormat = (fileName, format) => {
+  const fileFormatFound = extractFileFormat(fileName);
+  let fileFormatToUse = format;
+  if (format && fileFormatFound && format === fileFormatFound) {
+    fileName = fileName.substring(0, fileName.lastIndexOf('.'));
+  } else if (fileFormatFound) {
+    fileFormatToUse = fileFormatFound;
+    fileName = fileName.substring(0, fileName.lastIndexOf('.'));
+  }
+  return {
+    fileName: fileName,
+    fileFormatToUse: fileFormatToUse
+  };
+};

package/build/get-resume.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _mimeTypes = require("mime-types");
+var _path = require("path");
+var _quaff = _interopRequireDefault(require("quaff"));
+var _streamToString = _interopRequireDefault(require("stream-to-string"));
+var _yamlJs = _interopRequireDefault(require("yaml-js"));
+var _util = require("util");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  createReadStream
+} = _fs.default;
+const stat = (0, _util.promisify)(_fs.default.stat);
+const parsers = {
+  'text/yaml': string => _yamlJs.default.load(string),
+  'application/json': string => JSON.parse(string)
+};
+var _default = async ({
+  path,
+  mime: inputMime
+}) => {
+  let input;
+  let mime;
+  if ('-' === path) {
+    mime = inputMime || (0, _mimeTypes.lookup)('.json');
+    input = process.stdin;
+  } else if (path && (await stat(path)).isDirectory()) {
+    return (0, _quaff.default)(path);
+  }
+  if (!input) {
+    mime = inputMime || (0, _mimeTypes.lookup)(path);
+    input = createReadStream((0, _path.resolve)(process.cwd(), path));
+  }
+  if (!input) {
+    throw new Error('resume could not be gotten from path or stdin');
+  }
+  const resumeString = await (0, _streamToString.default)(input);
+  const parser = parsers[mime];
+  if (!parser) {
+    throw new Error(`no parser available for detected mime type ${mime}`);
+  }
+  return parser(resumeString);
+};
+exports.default = _default;

package/build/get-resume.test.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _waait = _interopRequireDefault(require("waait"));
+var _getResume = _interopRequireDefault(require("./get-resume"));
+var _mockStdin = require("mock-stdin");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+jest.mock('fs', () => {
+  const build = require('./test-utils/mocked-volume-builder');
+  const {
+    createFsFromVolume
+  } = require('memfs');
+  const vol = build();
+  return createFsFromVolume(vol);
+});
+describe('get-resume', () => {
+  it('should consume yaml', async () => {
+    expect(await (0, _getResume.default)({
+      path: '/resume.yaml'
+    })).toMatchInlineSnapshot(`
+      Object {
+        "basics": Object {
+          "email": "thomas@example.com",
+          "name": "thomas",
+        },
+      }
+    `);
+  });
+  it('should consume json', async () => {
+    expect(await (0, _getResume.default)({
+      path: '/resume.json'
+    })).toMatchInlineSnapshot(`
+        Object {
+          "basics": Object {
+            "email": "thomas@example.com",
+            "name": "thomas",
+          },
+        }
+      `);
+  });
+  it('should consume an entire directory as if it were a json object', async () => {
+    expect(await (0, _getResume.default)({
+      path: '/quaff'
+    })).toMatchInlineSnapshot(`
+      Object {
+        "basics": Object {
+          "email": "thomas@example.com",
+          "name": "thomas",
+        },
+        "work": Array [
+          Object {
+            "company": "Pied Piper",
+            "endDate": "2014-12-01",
+            "position": "CEO/President",
+            "startDate": "2013-12-01",
+          },
+        ],
+      }
+    `);
+  });
+  it('should read from process.stdin when path is a dash', async () => {
+    const stdin = (0, _mockStdin.stdin)();
+    const gotResume = (0, _getResume.default)({
+      path: '-'
+    });
+    await (0, _waait.default)();
+    stdin.send(JSON.stringify({
+      basics: {
+        name: 'thomas',
+        email: 'thomas@example.com'
+      }
+    }));
+    stdin.send(null);
+    expect(await gotResume).toMatchInlineSnapshot(`
+      Object {
+        "basics": Object {
+          "email": "thomas@example.com",
+          "name": "thomas",
+        },
+      }
+    `);
+  });
+});

package/build/get-schema.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = require("fs");
+var _util = require("util");
+const readFile = (0, _util.promisify)(_fs.readFile);
+var _default = async ({
+  path: pathArg
+} = {}) => {
+  let path = pathArg;
+  if (!path) {
+    path = require.resolve('resume-schema/schema.json');
+  }
+  return JSON.parse(await readFile(path, {
+    encoding: 'utf-8'
+  }));
+};
+exports.default = _default;

package/build/init.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _util = require("util");
+var _fs = _interopRequireDefault(require("fs"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _yesno = _interopRequireDefault(require("yesno"));
+var _objectPathImmutable = require("object-path-immutable");
+var _fileExists = _interopRequireDefault(require("file-exists"));
+var _read = _interopRequireDefault(require("read"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const writeFile = (0, _util.promisify)(_fs.default.writeFile);
+const read = (0, _util.promisify)(_read.default);
+const resume = require('resume-schema/sample.resume.json');
+var _default = async ({
+  resumePath
+}) => {
+  if (await (0, _fileExists.default)(resumePath)) {
+    console.log(_chalk.default.yellow('There is already a resume.json file in this directory.'));
+    if (!(await (0, _yesno.default)({
+      question: 'Do you want to override?'
+    }))) {
+      return;
+    }
+  }
+  console.log(`This utility will generate a file at ${resumePath}.`);
+  console.log('Fill out your name and email to get started, or leave the fields blank.');
+  console.log('All fields are optional.\n');
+  console.log('Press ^C at any time to quit.');
+  const name = await read({
+    prompt: 'name: '
+  });
+  const email = await read({
+    prompt: 'email: '
+  });
+  const personalizedResume = Object.entries({
+    name,
+    email
+  }).reduce((acc, [key, value]) => (0, _objectPathImmutable.set)(acc, `basics.${key}`, value), resume);
+  await writeFile(resumePath, JSON.stringify(personalizedResume, undefined, 2));
+  console.log(`Your resume has been created at ${resumePath}`);
+  console.log('');
+  console.log('To generate a formatted .html .md .txt or .pdf resume from your resume');
+  console.log('type: `resume export [someFileName]` including file extension eg: `resume export myresume.html`');
+  console.log('\nYou can optionally specify an available theme for html and pdf resumes using the --theme flag.');
+  console.log('Example: `resume export myresume.pdf --theme even`');
+  console.log('Or simply type: `resume export` and follow the prompts.');
+  console.log('');
+};
+exports.default = _default;

package/build/main.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+"use strict";
+
+require("dotenv/config");
+var _init = _interopRequireDefault(require("./init"));
+var _getResume = _interopRequireDefault(require("./get-resume"));
+var _getSchema = _interopRequireDefault(require("./get-schema"));
+var _validate = _interopRequireDefault(require("./validate"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const pkg = require('../package.json');
+const exportResume = require('./export-resume');
+const serve = require('./serve');
+const program = require('commander');
+const chalk = require('chalk');
+const path = require('path');
+const normalizeTheme = (value, defaultValue) => {
+  const theme = value || defaultValue;
+  // TODO - This is not great, but bypasses this function if it is a relative path
+  if (theme[0] === '.') {
+    return theme;
+  }
+  return theme.match('jsonresume-theme-.*') ? theme : `jsonresume-theme-${theme}`;
+};
+(async () => {
+  program.name('resume').usage('[command] [options]').version(pkg.version).option('-F, --force', 'Used by `publish` and `export` - bypasses schema testing.').option('-t, --theme <theme name>', 'Specify theme used by `export` and `serve` or specify a path starting with . (use . for current directory or ../some/other/dir)', normalizeTheme, 'jsonresume-theme-even').option('-f, --format <file type extension>', 'Used by `export`.').option('-r, --resume <resume filename>', "path to the resume in json format. Use '-' to read from stdin", 'resume.json').option('-p, --port <port>', 'Used by `serve` (default: 4000)', 4000).option('-s, --silent', 'Used by `serve` to tell it if open browser auto or not.', false).option('-d, --dir <path>', 'Used by `serve` to indicate a public directory path.', 'public').option('--schema <relativePath>', 'Used by `validate` to validate against a custom schema.');
+  program.command('init').description('Initialize a resume.json file').action(async () => {
+    await (0, _init.default)({
+      resumePath: program.resume
+    });
+  });
+  program.command('validate').description("Validate your resume's schema").action(async () => {
+    const resume = await (0, _getResume.default)({
+      path: program.resume
+    });
+    const schema = await (0, _getSchema.default)({
+      path: program.schema
+    });
+    try {
+      await (0, _validate.default)({
+        resume,
+        schema
+      });
+    } catch (e) {
+      console.error(e.message);
+      process.exitCode = 1;
+    }
+  });
+  program.command('export [fileName]').description('Export locally to .html or .pdf. Supply a --format <file format> flag and argument to specify export format.').action(async fileName => {
+    const resume = await (0, _getResume.default)({
+      path: program.resume
+    });
+    exportResume({
+      ...program,
+      resume,
+      fileName
+    }, (err, fileName, format) => {
+      console.log(chalk.green('\nDone! Find your new', format, 'resume at:\n', path.resolve(process.cwd(), fileName + format)));
+    });
+  });
+  program.command('serve').description('Serve resume at http://localhost:4000/').action(async () => {
+    serve({
+      ...program,
+      resumeFilename: program.resume
+    });
+  });
+  await program.parseAsync(process.argv);
+  const validCommands = program.commands.map(cmd => {
+    return cmd._name;
+  });
+
+  // https://github.com/tj/commander.js/blob/master/CHANGELOG.md#testing-for-no-arguments
+  if (program.rawArgs.length < 3) {
+    console.log(chalk.cyan('resume-cli:'), 'https://jsonresume.org', '\n');
+    program.help();
+  } else if (validCommands.indexOf(process.argv[2]) === -1) {
+    console.log(chalk.red('Invalid argument:'), process.argv[2]);
+    console.log(chalk.cyan('resume-cli:'), 'https://jsonresume.org', '\n');
+    program.help();
+  }
+})();

package/build/main.test.js

@@ -0,0 +1,136 @@
+"use strict";
+
+var _child_process = require("child_process");
+var _streamToString = _interopRequireDefault(require("stream-to-string"));
+var _util = require("util");
+var _package = _interopRequireDefault(require("../package.json"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const exec = (0, _util.promisify)(_child_process.exec);
+const run = async (argv, {
+  waitForVolumeExport = true,
+  stdin = ''
+} = {}) => {
+  let volume;
+  let exitCode;
+  const child = (0, _child_process.spawn)(process.execPath, ['build/test-utils/cli-test-entry.js', ...argv], {
+    stdio: ['pipe', 'pipe', 2, 'ipc']
+  });
+  const allChecks = Promise.all([waitForVolumeExport ? new Promise(volumeSet => {
+    child.on('message', async message => {
+      if (message.type === 'volumeExport') {
+        volume = message.data;
+        volumeSet();
+      }
+    });
+  }) : true, new Promise(processExited => {
+    child.on('exit', code => {
+      exitCode = code;
+      processExited();
+    });
+  })]);
+  child.stdin.write(stdin);
+  child.stdin.end();
+  const stdout = await (0, _streamToString.default)(child.stdout);
+  await allChecks;
+  return {
+    volume,
+    code: exitCode,
+    stdout
+  };
+};
+describe('cli configuration', () => {
+  beforeAll(() => exec(_package.default.scripts.prepare));
+  it('should show help', async () => {
+    const {
+      stdout
+    } = await run(['help'], {
+      waitForVolumeExport: false
+    });
+    expect(stdout).toMatchInlineSnapshot(`
+      "Usage: resume [command] [options]
+
+      Options:
+        -V, --version                       output the version number
+        -F, --force                         Used by \`publish\` and \`export\` - bypasses
+                                            schema testing.
+        -t, --theme <theme name>            Specify theme used by \`export\` and
+                                            \`serve\` or specify a path starting with .
+                                            (use . for current directory or
+                                            ../some/other/dir) (default:
+                                            \\"jsonresume-theme-even\\")
+        -f, --format <file type extension>  Used by \`export\`.
+        -r, --resume <resume filename>      path to the resume in json format. Use
+                                            '-' to read from stdin (default:
+                                            \\"resume.json\\")
+        -p, --port <port>                   Used by \`serve\` (default: 4000) (default:
+                                            4000)
+        -s, --silent                        Used by \`serve\` to tell it if open
+                                            browser auto or not. (default: false)
+        -d, --dir <path>                    Used by \`serve\` to indicate a public
+                                            directory path. (default: \\"public\\")
+        --schema <relativePath>             Used by \`validate\` to validate against a
+                                            custom schema.
+        -h, --help                          display help for command
+
+      Commands:
+        init                                Initialize a resume.json file
+        validate                            Validate your resume's schema
+        export [fileName]                   Export locally to .html or .pdf. Supply
+                                            a --format <file format> flag and
+                                            argument to specify export format.
+        serve                               Serve resume at http://localhost:4000/
+        help [command]                      display help for command
+      "
+    `);
+  });
+  describe('validate', () => {
+    it('should use the schema override arg', async () => {
+      const {
+        stdout
+      } = await run(['validate', '--schema', '/test-resumes/only-number-schema.json', '--resume', '/test-resumes/only-number.json']);
+      expect(stdout).toMatchInlineSnapshot(`""`);
+    });
+    it('should fail when trying to validate an invalid resume specified by the --resume option', async () => {
+      expect((await run(['validate', '--resume', '/test-resumes/invalid-resume.json'])).code).toEqual(1);
+    });
+    it('should validate a resume specified by the --resume option', async () => {
+      const {
+        stdout
+      } = await run(['validate', '--resume', '/test-resumes/resume.json']);
+      expect(stdout).toMatchInlineSnapshot(`""`);
+    });
+  });
+  describe('export', () => {
+    it('should read from stdin when path is a dash', async () => {
+      const {
+        stdout,
+        volume
+      } = await run(['export', '/test-resumes/exported-resume-from-stdin.html', '--resume', '-' // this is the dash
+      ], {
+        stdin: JSON.stringify({
+          basics: {
+            name: 'thomas-from-stdin'
+          }
+        })
+      });
+      expect(volume['/test-resumes/exported-resume-from-stdin.html']).toEqual(expect.stringContaining('thomas-from-stdin'));
+      expect(stdout).toMatchInlineSnapshot(`
+        "
+        Done! Find your new .html resume at:
+         /test-resumes/exported-resume-from-stdin.html
+        "
+      `);
+    });
+    it('should export a resume from the path specified by --resume to the path specified immediately after the export command', async () => {
+      const {
+        stdout
+      } = await run(['export', '/test-resumes/exported-resume.html', '--resume', '/test-resumes/resume.json']);
+      expect(stdout).toMatchInlineSnapshot(`
+        "
+        Done! Find your new .html resume at:
+         /test-resumes/exported-resume.html
+        "
+      `);
+    });
+  });
+});

package/build/render-html.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const tryResolve = (...args) => {
+  try {
+    return require.resolve(...args);
+  } catch (err) {
+    return false;
+  }
+};
+var _default = async ({
+  resume,
+  themePath
+}) => {
+  const cwd = process.cwd();
+  let path;
+  if (themePath[0] === '.') {
+    path = tryResolve(path.join(cwd, themePath), {
+      paths: [cwd]
+    });
+    throw new Error(`Theme ${themePath} could not be resolved relative to ${cwd}`);
+  }
+  if (!path) {
+    path = tryResolve(themePath, {
+      paths: [cwd]
+    });
+  }
+  if (!path && /^[a-z0-9]/i.test(path)) {
+    path = tryResolve(`jsonresume-theme-${themePath}`, {
+      paths: [cwd]
+    });
+  }
+  if (!path) {
+    throw new Error(`theme path ${themePath} could not be resolved from current working directory`);
+  }
+  const theme = require(path);
+  if (typeof (theme === null || theme === void 0 ? void 0 : theme.render) !== 'function') {
+    throw new Error('theme.render is not a function');
+  }
+  return theme.render(resume);
+};
+exports.default = _default;

package/build/render-html.test.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _renderHtml = _interopRequireDefault(require("./render-html"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+describe('renderHTML', () => {
+  beforeAll(() => {
+    const originalRequireResolve = require.resolve;
+    const mockThemePath = 'mock/path/to/jsonresume-theme-even';
+    require.resolve = (...args) => {
+      if (args[0] === 'jsonresume-theme-even') {
+        return mockThemePath;
+      }
+      if (args[0] === 'jsonresume-theme-even') {
+        return mockThemePath;
+      }
+      return originalRequireResolve.apply(require, ...args);
+    };
+    require.cache[mockThemePath] = {
+      render: () => 'here-is-your-mocked-theme'
+    };
+  });
+  const resume = {
+    basics: {
+      name: 'test',
+      label: 'Programmer',
+      email: 'test4@test.com'
+    }
+  };
+  it('should reject when theme is not availlable', async () => {
+    await expect((0, _renderHtml.default)({
+      resume,
+      themePath: 'unknown'
+    })).rejects.toBeTruthy();
+  });
+  describe('should render html when theme is availlable', () => {
+    it('with long theme name', async () => {
+      expect(await (0, _renderHtml.default)({
+        resume,
+        themePath: 'jsonresume-theme-even'
+      })).toStartWith('<!doctype html>');
+    });
+    it('with short theme name', async () => {
+      expect(await (0, _renderHtml.default)({
+        resume,
+        themePath: 'even'
+      })).toStartWith('<!doctype html>');
+    });
+  });
+});

package/build/serve.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const bs = require('browser-sync').create();
+const builder = require('./builder');
+const reBuildResume = (theme, dir, resumeFilename, cb) => {
+  builder(theme, dir, resumeFilename, (err, html) => {
+    if (err) {
+      readline.cursorTo(process.stdout, 0);
+      console.log(err);
+      html = err;
+    }
+    fs.writeFile(path.join(process.cwd(), dir, 'index.html'), html, err => {
+      if (err) {
+        console.log(err);
+      }
+      cb();
+    });
+  });
+};
+module.exports = function ({
+  port,
+  theme,
+  silent,
+  dir,
+  resumeFilename
+}) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+  bs.watch(resumeFilename).on('change', () => {
+    reBuildResume(theme, dir, resumeFilename, () => {
+      bs.reload();
+    });
+  });
+  reBuildResume(theme, dir, resumeFilename, () => {
+    bs.init({
+      server: dir,
+      port: port,
+      open: !silent && 'local',
+      ui: false
+    });
+  });
+  console.log('');
+  const previewUrl = 'http://localhost:' + port;
+  console.log('Preview: ' + previewUrl);
+  console.log('Press ctrl-c to stop');
+  console.log('');
+};

package/build/test-utils/cli-test-entry.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _mockedVolumeBuilder = _interopRequireDefault(require("./mocked-volume-builder"));
+var _fsMonkey = require("fs-monkey");
+var _unionfs = require("unionfs");
+var fs = _interopRequireWildcard(require("fs"));
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const mockVolume = (0, _mockedVolumeBuilder.default)({
+  mount: '/test-resumes'
+});
+const vol = _unionfs.ufs.use(mockVolume).use(fs);
+(0, _fsMonkey.patchFs)(vol);
+require('../main.js');
+process.once('beforeExit', () => {
+  process.send({
+    data: mockVolume.toJSON(),
+    type: 'volumeExport'
+  });
+});

package/build/test-utils/mocked-volume-builder.js

@@ -0,0 +1,47 @@
+"use strict";
+
+module.exports = ({
+  mount = '/'
+} = {}) => {
+  const dedent = require('dedent');
+  const flat = require('flat');
+  const {
+    Volume
+  } = require('memfs');
+  return Volume.fromJSON(flat({
+    'only-number-schema.json': JSON.stringify({
+      type: 'number'
+    }),
+    'only-number.json': '123',
+    'invalid-resume.json': JSON.stringify({
+      notAValidKey: {
+        foo: 'bar'
+      }
+    }),
+    'resume.json': JSON.stringify({
+      basics: {
+        name: 'thomas',
+        email: 'thomas@example.com'
+      }
+    }),
+    'resume.yaml': dedent`
+        basics: 
+          name: thomas
+          email: thomas@example.com
+      `,
+    quaff: {
+      'basics.yaml': dedent`
+          name: thomas
+          email: thomas@example.com
+        `,
+      'work.json': JSON.stringify([{
+        company: 'Pied Piper',
+        endDate: '2014-12-01',
+        position: 'CEO/President',
+        startDate: '2013-12-01'
+      }])
+    }
+  }, {
+    delimiter: '/'
+  }), mount);
+};

package/build/validate.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _util = require("util");
+var _zSchema = _interopRequireDefault(require("z-schema"));
+var _zSchemaErrors = _interopRequireDefault(require("z-schema-errors"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const reporter = _zSchemaErrors.default.init();
+const validator = new _zSchema.default();
+const validate = (0, _util.promisify)((...args) => validator.validate(...args)); // maintains context
+var _default = async ({
+  resume,
+  schema
+}) => {
+  try {
+    return await validate(resume, schema);
+  } catch (errors) {
+    throw new Error(reporter.extractMessage({
+      report: {
+        errors
+      }
+    }));
+  }
+};
+exports.default = _default;

package/build/validate.test.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _validate = _interopRequireDefault(require("./validate"));
+var _getSchema = _interopRequireDefault(require("./get-schema"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+describe('validate', () => {
+  let defaultSchema;
+  beforeEach(async () => {
+    defaultSchema = await (0, _getSchema.default)();
+  });
+  it('should not throw an error for a valid resume object', async () => {
+    await (0, _validate.default)({
+      resume: {
+        basics: {}
+      },
+      schema: defaultSchema
+    });
+  });
+  it('should throw an error for an invalid resume object', async () => {
+    await expect((0, _validate.default)({
+      resume: {
+        notInTheSchema: true
+      },
+      schema: defaultSchema
+    })).rejects.toMatchInlineSnapshot(`[Error: An error occurred 'Additional properties not allowed: notInTheSchema'.]`);
+  });
+  it('should accept a schema override', async () => {
+    await (0, _validate.default)({
+      resume: 123,
+      schema: {
+        type: 'number'
+      }
+    });
+    await expect((0, _validate.default)({
+      resume: 'thomas',
+      schema: {
+        type: 'number'
+      }
+    })).rejects.toMatchInlineSnapshot(`[Error: An error occurred 'Expected type number but found type string'.]`);
+  });
+});

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "resume-cli",
+  "version": "0.0.0-development",
+  "description": "The JSON Resume command line interface",
+  "main": "index.js",
+  "engines": {
+    "node": ">=12 <18"
+  },
+  "files": [
+    "build/*",
+    "!test-utils",
+    "!*.test.js"
+  ],
+  "scripts": {
+    "dev": "babel-node lib/main.js",
+    "lint": "eslint --ignore-path .gitignore .",
+    "_postinstall": "husky install",
+    "prepublishOnly": "pinst --disable",
+    "postpublish": "pinst --enable",
+    "prepare": "babel lib -d build --copy-files",
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jsonresume/resume-cli.git"
+  },
+  "license": "MIT",
+  "bin": {
+    "resume": "build/main.js"
+  },
+  "dependencies": {
+    "async": "^3.2.0",
+    "browser-sync": "^2.29.3",
+    "btoa": "^1.2.1",
+    "chalk": "^4.1.0",
+    "commander": "^6.0.0",
+    "dotenv": "^8.2.0",
+    "file-exists": "^5.0.1",
+    "jest-extended": "^0.11.5",
+    "jsonresume-theme-even": "^0.6.0",
+    "mime-types": "^2.1.27",
+    "object-path-immutable": "^4.1.1",
+    "puppeteer": "^18.2.1",
+    "quaff": "^4.2.0",
+    "read": "^1.0.7",
+    "resume-schema": "^1.0.0",
+    "stream-to-string": "^1.2.1",
+    "superagent": "^6.0.0",
+    "yaml-js": "^0.2.3",
+    "yesno": "^0.3.1",
+    "z-schema": "^5.0.0",
+    "z-schema-errors": "^0.2.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.12.10",
+    "@babel/core": "7.12.10",
+    "@babel/eslint-parser": "7.12.1",
+    "@babel/node": "7.12.10",
+    "@babel/plugin-proposal-optional-chaining": "7.12.7",
+    "@babel/preset-env": "7.12.11",
+    "babel-eslint": "10.1.0",
+    "babel-jest": "28.1.2",
+    "dedent": "0.7.0",
+    "eslint": "7.15.0",
+    "eslint-config-prettier": "7.0.0",
+    "eslint-plugin-jest": "24.1.3",
+    "eslint-plugin-prettier": "3.2.0",
+    "flat": "5.0.2",
+    "fs-monkey": "1.0.1",
+    "husky": "5.0.6",
+    "jest": "28.1.2",
+    "lint-staged": "10.5.3",
+    "memfs": "3.2.0",
+    "mock-stdin": "1.0.0",
+    "prettier": "2.2.1",
+    "unionfs": "4.4.0",
+    "waait": "1.0.5"
+  }
+}