resume-cli 3.0.2 → 3.0.6

package/lib/builder.js

@@ -1,66 +0,0 @@
-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/lib/get-resume.js

@@ -1,38 +0,0 @@
-import fs from 'fs';
-import { lookup } from 'mime-types';
-import { resolve as resolvePath } from 'path';
-import quaff from 'quaff';
-import toString from 'stream-to-string';
-import yaml from 'yaml-js';
-import { promisify } from 'util';
-
-const { createReadStream } = fs;
-const stat = promisify(fs.stat);
-
-const parsers = {
-  'text/yaml': (string) => yaml.load(string),
-  'application/json': (string) => JSON.parse(string),
-};
-export default async ({ path, mime: inputMime }) => {
-  let input;
-  let mime;
-  if ('-' === path) {
-    mime = inputMime || lookup('.json');
-    input = process.stdin;
-  } else if (path && (await stat(path)).isDirectory()) {
-    return quaff(path);
-  }
-  if (!input) {
-    mime = inputMime || lookup(path);
-    input = createReadStream(resolvePath(process.cwd(), path));
-  }
-  if (!input) {
-    throw new Error('resume could not be gotten from path or stdin');
-  }
-  const resumeString = await toString(input);
-  const parser = parsers[mime];
-  if (!parser) {
-    throw new Error(`no parser available for detected mime type ${mime}`);
-  }
-  return parser(resumeString);
-};

package/lib/get-resume.test.js

@@ -1,73 +0,0 @@
-import wait from 'waait';
-import getResume from './get-resume';
-import { stdin as mockStdin } from 'mock-stdin';
-
-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 getResume({ path: '/resume.yaml' })).toMatchInlineSnapshot(`
-      Object {
-        "basics": Object {
-          "email": "thomas@example.com",
-          "name": "thomas",
-        },
-      }
-    `);
-  });
-  it('should consume json', async () => {
-    expect(await getResume({ 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 getResume({ 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 = mockStdin();
-    const gotResume = getResume({ path: '-' });
-    await wait();
-    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/lib/get-schema.js

@@ -1,16 +0,0 @@
-import { readFile as readFileCB } from 'fs';
-import { promisify } from 'util';
-
-const readFile = promisify(readFileCB);
-
-export 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',
-    }),
-  );
-};

package/lib/init.js

@@ -1,56 +0,0 @@
-import { promisify } from 'util';
-import fs from 'fs';
-import chalk from 'chalk';
-import yesno from 'yesno';
-import { set } from 'object-path-immutable';
-import exists from 'file-exists';
-import readCB from 'read';
-
-const writeFile = promisify(fs.writeFile);
-const read = promisify(readCB);
-const resume = require('resume-schema/sample.resume.json');
-
-export default async ({ resumePath }) => {
-  if (await exists(resumePath)) {
-    console.log(
-      chalk.yellow('There is already a resume.json file in this directory.'),
-    );
-    if (!(await yesno({ 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]) => 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('');
-};

package/lib/main.js

@@ -1,136 +0,0 @@
-#!/usr/bin/env node
-
-import 'dotenv/config';
-
-import init from './init';
-import getResume from './get-resume';
-import getSchema from './get-schema';
-import validate from './validate';
-
-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 init({ resumePath: program.resume });
-    });
-
-  program
-    .command('validate')
-    .description("Validate your resume's schema")
-    .action(async () => {
-      const resume = await getResume({ path: program.resume });
-      const schema = await getSchema({ path: program.schema });
-      try {
-        await validate({
-          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 getResume({ 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/lib/main.test.js

@@ -1,155 +0,0 @@
-import { spawn, exec as execCB } from 'child_process';
-import streamToString from 'stream-to-string';
-import { promisify } from 'util';
-import packageJson from '../package.json';
-
-const exec = promisify(execCB);
-
-const run = async (argv, { waitForVolumeExport = true, stdin = '' } = {}) => {
-  let volume;
-  let exitCode;
-  const child = 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 streamToString(child.stdout);
-  await allChecks;
-  return {
-    volume,
-    code: exitCode,
-    stdout,
-  };
-};
-
-describe('cli configuration', () => {
-  beforeAll(() => exec(packageJson.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/lib/render-html.js

@@ -1,35 +0,0 @@
-const tryResolve = (...args) => {
-  try {
-    return require.resolve(...args);
-  } catch (err) {
-    return false;
-  }
-};
-
-export 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?.render !== 'function') {
-    throw new Error('theme.render is not a function');
-  }
-
-  return theme.render(resume);
-};

package/lib/render-html.test.js

@@ -1,47 +0,0 @@
-import renderHTML from './render-html';
-
-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(
-      renderHTML({ resume, themePath: 'unknown' }),
-    ).rejects.toBeTruthy();
-  });
-
-  describe('should render html when theme is availlable', () => {
-    it('with long theme name', async () => {
-      expect(
-        await renderHTML({ resume, themePath: 'jsonresume-theme-even' }),
-      ).toStartWith('<!doctype html>');
-    });
-
-    it('with short theme name', async () => {
-      expect(await renderHTML({ resume, themePath: 'even' })).toStartWith(
-        '<!doctype html>',
-      );
-    });
-  });
-});

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

@@ -1,12 +0,0 @@
-import build from './mocked-volume-builder';
-import { patchFs } from 'fs-monkey';
-import { ufs } from 'unionfs';
-import * as fs from 'fs';
-
-const mockVolume = build({ mount: '/test-resumes' });
-const vol = ufs.use(mockVolume).use(fs);
-patchFs(vol);
-require('../main.js');
-process.once('beforeExit', () => {
-  process.send({ data: mockVolume.toJSON(), type: 'volumeExport' });
-});

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

@@ -1,45 +0,0 @@
-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,
-  );
-};