jsonresume-theme-engineering 0.2.0 → 0.3.1

package/Makefile

@@ -2,7 +2,7 @@ HBS_TEMPLATES = $(sort $(wildcard partials/** views/** resume.hbs ))
 
 all: resume.png
 
-resume.json:
+resume.json: sample-resume.json
 	cp sample-resume.json resume.json
 
 resume.pdf: resume.json index.js  $(HBS_TEMPLATES)
@@ -10,3 +10,7 @@ resume.pdf: resume.json index.js  $(HBS_TEMPLATES)
 
 resume.png: resume.pdf
 	pdftoppm -png resume.pdf > resume.png
+
+.PHONY: test
+test:
+	npm run test

package/index.js

@@ -1,23 +1,20 @@
 const
   fs = require('fs'),
-  handlebars = require('handlebars'),
-  handlebarsWax = require('handlebars-wax'),
+  path = require('path'),
+  Handlebars = require('handlebars'),
   addressFormat = require('address-format'),
-  moment = require('moment'),
-  Swag = require('swag');
+  moment = require('moment');
 
-Swag.registerHelpers(handlebars);
-
-handlebars.registerHelper({
+Handlebars.registerHelper({
 
   wrapURL: function (url) {
     const wrappedUrl = '<a href="' + url + '">' + url.replace(/.*?:\/\//g, '') + "</a>";
-    return new handlebars.SafeString(wrappedUrl);
+    return new Handlebars.SafeString(wrappedUrl);
   },
 
   wrapMail: function (address) {
     const wrappedAddress = '<a href="mailto:' + address + '">' + address + "</a>";
-    return new handlebars.SafeString(wrappedAddress);
+    return new Handlebars.SafeString(wrappedAddress);
   },
 
   formatAddress: function (address, city, region, postalCode, countryCode) {
@@ -42,14 +39,49 @@ handlebars.registerHelper({
 });
 
 function render(resume) {
+  if (!resume || typeof resume !== 'object') {
+    throw new Error('Expected input to be a valid resume object');
+  }
+
   let dir = __dirname,
     css = fs.readFileSync(dir + '/style.css', 'utf-8'),
-    resumeTemplate = fs.readFileSync(dir + '/resume.hbs', 'utf-8');
+    resumeTemplate = fs.readFileSync(dir + '/resume.hbs', 'utf-8'),
+    partialsDir = path.join(dir, 'partials'),
+    viewsDir = path.join(dir, 'views');
+
+  // Load partials from partialsDir
+  let partialFilenames = fs.readdirSync(partialsDir);
+  partialFilenames.forEach(function (filename) {
+    var matches = /^([^.]+).hbs$/.exec(filename);
+    if (!matches) {
+      return;
+    }
+    var name = matches[1];
+    var filepath = path.join(partialsDir, filename);
+    var template = fs.readFileSync(filepath, 'utf8');
+
+    Handlebars.registerPartial(name, template);
+  });
 
-  let Handlebars = handlebarsWax(handlebars);
+  // Load partials from viewsDir (if it exists)
+  try {
+    if (fs.existsSync(viewsDir)) {
+      let viewFilenames = fs.readdirSync(viewsDir);
+      viewFilenames.forEach(function (filename) {
+        var matches = /^([^.]+).hbs$/.exec(filename);
+        if (!matches) {
+          return;
+        }
+        var name = matches[1];
+        var filepath = path.join(viewsDir, filename);
+        var template = fs.readFileSync(filepath, 'utf8');
 
-  Handlebars.partials(dir + '/views/**/*.{hbs,js}');
-  Handlebars.partials(dir + '/partials/**/*.{hbs,js}');
+        Handlebars.registerPartial(name, template);
+      });
+    }
+  } catch (err) {
+    console.error('Error loading views directory:', err);
+  }
 
   return Handlebars.compile(resumeTemplate)({
     css: css,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsonresume-theme-engineering",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "JSON Resume theme for engineers",
   "keywords": [
     "jsonresume",
@@ -18,16 +18,21 @@
   "license": "MIT",
   "scripts": {
     "start": "resume serve --theme .",
-    "export": "resume export --theme . resume.pdf"
+    "export": "resume export --theme . resume.pdf",
+    "test": "mocha test/*.test.js"
   },
   "dependencies": {
     "address-format": "0.0.3",
     "handlebars": "^4.7.8",
-    "handlebars-wax": "^6.1.0",
-    "moment": "^2.30.1",
-    "swag": "^0.7.0"
+    "moment": "^2.30.1"
   },
   "devDependencies": {
-    "resume-cli": "^3.1.2"
+    "looks-same": "^9.0.1",
+    "mocha": "^10.0.0",
+    "pdf-img-convert": "^2.0.0",
+    "pdf-parse": "^1.1.1",
+    "pngjs": "^7.0.0",
+    "resume-cli": "^3.1.2",
+    "sinon": "^21.0.0"
   }
 }

package/renovate.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ],
+  "vulnerabilityAlerts": {
+    "labels": ["security"],
+    "automerge": false
+  }
+}

package/style.css

@@ -2,7 +2,15 @@
 body {
     font-family: Georgia, serif;
     font-size: 11px;
-    margin: 24px 48px;
+    display: flex;
+    justify-content: center;
+}
+
+#resume {
+    max-width: 800px;
+    width: 100%;
+    padding: 24px 48px;
+    box-sizing: border-box;
 }
 
 h1 {
@@ -83,7 +91,7 @@ a {
         size: portrait;
         margin: 10mm 25mm;
     }
-    .resume {
+    #resume {
         max-width: 100%;
         border: 0px;
         background: #fff;
@@ -92,7 +100,7 @@ a {
     }
     body,
     html,
-    .resume {
+    #resume {
         margin: 0px;
         padding: 0px;
     }

package/test/01-render.test.js

@@ -0,0 +1,105 @@
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { render } = require('../index');
+
+describe('Render', function() {
+  it('should render a resume with valid input', function() {
+    const resume = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'sample-resume.json'), 'utf-8'));
+    const output = render(resume);
+    assert(output.includes('<title>Richard Hendriks</title>'), 'Output should include the name from the resume');
+  });
+
+  it('should throw an error with invalid input', function() {
+    assert.throws(() => render(null), Error, 'Expected input to be a valid resume object');
+  });
+
+  it('should handle an empty resume object', function() {
+    const emptyResume = {};
+    const output = render(emptyResume);
+    assert(output.includes('<title></title>'), 'Output should handle an empty resume object');
+  });
+
+  it('should handle a resume object missing required fields', function() {
+    const incompleteResume = {
+      basics: {
+        name: 'Jane Doe'
+      }
+    };
+    const output = render(incompleteResume);
+    assert(output.includes('<title>Jane Doe</title>'), 'Output should handle a resume object missing required fields');
+  });
+
+  it('should throw an error with invalid data type', function() {
+    assert.throws(() => render('invalid input'), Error, 'Expected input to be a valid resume object');
+  });
+
+  it('should handle a large resume object', function() {
+    const largeResume = {
+      basics: {
+        name: 'Large Resume',
+        label: 'Test',
+        email: 'large.resume@example.com',
+        phone: '(123) 456-7890',
+        website: 'http://example.com',
+        summary: 'This is a large resume object.',
+        location: {
+          address: '123 Main St',
+          postalCode: '12345',
+          city: 'Anytown',
+          countryCode: 'US',
+          region: 'CA'
+        },
+        profiles: []
+      },
+      work: Array(1000).fill({
+        company: 'Large Company',
+        position: 'Software Engineer',
+        website: 'http://example.com',
+        startDate: '2000-01-01',
+        summary: 'Worked on various projects.',
+        highlights: ['Highlight 1', 'Highlight 2']
+      }),
+      education: [],
+      skills: [],
+      awards: [],
+      publications: [],
+      languages: [],
+      interests: [],
+      references: []
+    };
+    const output = render(largeResume);
+    assert(output.includes('<title>Large Resume</title>'), 'Output should handle a large resume object');
+  });
+
+  it('should handle special characters in fields', function() {
+    const specialCharsResume = {
+      basics: {
+        name: 'Special & Ch@rs',
+        label: 'Test',
+        email: 'special.chars@example.com',
+        phone: '(123) 456-7890',
+        website: 'http://example.com',
+        summary: 'This is a summary with special characters: &, <, >, ", \'.',
+        location: {
+          address: '123 Main St',
+          postalCode: '12345',
+          city: 'Anytown',
+          countryCode: 'US',
+          region: 'CA'
+        },
+        profiles: []
+      },
+      work: [],
+      education: [],
+      skills: [],
+      awards: [],
+      publications: [],
+      languages: [],
+      interests: [],
+      references: []
+    };
+    const output = render(specialCharsResume);
+    assert(output.includes('<title>Special &amp; Ch@rs</title>'), 'Output should handle special characters in fields');
+  });
+});

package/test/02-pdfExport.test.js

@@ -0,0 +1,73 @@
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const sinon = require('sinon');
+const childProcess = require('child_process');
+const pdfHelper = require('./utils/pdf-helper');
+
+describe('PDF Export', function() {
+  let execStub;
+
+  beforeEach(function() {
+    // Backup the original PDF
+    pdfHelper.backupReferencePdf();
+
+    // Create a proper sinon stub for the exec function
+    execStub = sinon.stub(childProcess, 'exec');
+
+    // Configure the stub to simulate successful PDF generation
+    execStub.callsFake((command, callback) => {
+      if (command === 'npm run export') {
+        // Simulate the PDF export process
+        fs.writeFileSync(pdfHelper.referencePdfPath, 'PDF content');
+        callback(null, 'PDF export successful');
+      } else {
+        callback(new Error('Unknown command'));
+      }
+    });
+  });
+
+  afterEach(function() {
+    // Restore all sinon stubs
+    sinon.restore();
+
+    // Restore the original PDF
+    pdfHelper.restoreReferencePdf();
+
+    // Clean up test PDF
+    pdfHelper.cleanupTestPdf();
+  });
+
+  it('should export a PDF with valid input', function(done) {
+    const resume = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'sample-resume.json'), 'utf-8'));
+    fs.writeFileSync(path.join(__dirname, '..', 'resume.json'), JSON.stringify(resume));
+
+    childProcess.exec('npm run export', (error, stdout, stderr) => {
+      if (error) {
+        return done(error);
+      }
+
+      assert(fs.existsSync(pdfHelper.referencePdfPath), 'PDF file should be generated');
+
+      // Read the file as a Buffer instead of utf-8 string since PDF is binary
+      const pdfExists = fs.existsSync(pdfHelper.referencePdfPath);
+      assert(pdfExists, 'PDF file should be generated');
+
+      done();
+    });
+  });
+
+  it('should handle errors during PDF export', function(done) {
+    // Restore the original stub and create a new one that simulates an error
+    sinon.restore();
+    execStub = sinon.stub(childProcess, 'exec');
+    execStub.callsFake((command, callback) => {
+      callback(new Error('Simulated error during PDF export'));
+    });
+
+    childProcess.exec('npm run export', (error, stdout, stderr) => {
+      assert(error, 'An error should be thrown during PDF export');
+      done();
+    });
+  });
+});

package/test/03-content.test.js

@@ -0,0 +1,73 @@
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const sinon = require('sinon');
+const childProcess = require('child_process');
+const pdfHelper = require('./utils/pdf-helper');
+
+describe('PDF Export', function() {
+  let execStub;
+
+  beforeEach(function() {
+    // Backup the original PDF
+    pdfHelper.backupReferencePdf();
+
+    // Create a proper sinon stub for the exec function
+    execStub = sinon.stub(childProcess, 'exec');
+
+    // Configure the stub to simulate successful PDF generation
+    execStub.callsFake((command, callback) => {
+      if (command === 'npm run export') {
+        // Simulate the PDF export process
+        fs.writeFileSync(pdfHelper.referencePdfPath, 'PDF content');
+        callback(null, 'PDF export successful');
+      } else {
+        callback(new Error('Unknown command'));
+      }
+    });
+  });
+
+  afterEach(function() {
+    // Restore all sinon stubs
+    sinon.restore();
+
+    // Restore the original PDF
+    pdfHelper.restoreReferencePdf();
+
+    // Clean up test PDF
+    pdfHelper.cleanupTestPdf();
+  });
+
+  it('should export a PDF with valid input', function(done) {
+    const resume = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'sample-resume.json'), 'utf-8'));
+    fs.writeFileSync(path.join(__dirname, '..', 'resume.json'), JSON.stringify(resume));
+
+    childProcess.exec('npm run export', (error, stdout, stderr) => {
+      if (error) {
+        return done(error);
+      }
+
+      assert(fs.existsSync(pdfHelper.referencePdfPath), 'PDF file should be generated');
+
+      // Read the file as a Buffer instead of utf-8 string since PDF is binary
+      const pdfExists = fs.existsSync(pdfHelper.referencePdfPath);
+      assert(pdfExists, 'PDF file should be generated');
+
+      done();
+    });
+  });
+
+  it('should handle errors during PDF export', function(done) {
+    // Restore the original stub and create a new one that simulates an error
+    sinon.restore();
+    execStub = sinon.stub(childProcess, 'exec');
+    execStub.callsFake((command, callback) => {
+      callback(new Error('Simulated error during PDF export'));
+    });
+
+    childProcess.exec('npm run export', (error, stdout, stderr) => {
+      assert(error, 'An error should be thrown during PDF export');
+      done();
+    });
+  });
+});

package/test/04-structure.test.js

@@ -0,0 +1,139 @@
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+const pdfParse = require('pdf-parse');
+const pdfHelper = require('./utils/pdf-helper');
+
+describe('Resume Structure and Metadata', function() {
+  this.timeout(10000);
+
+  before(function(done) {
+    // Backup the original PDF
+    pdfHelper.backupReferencePdf();
+
+    // Generate a test PDF
+    pdfHelper.generateTestPdf(done);
+  });
+
+  after(function() {
+    // Restore the original PDF
+    pdfHelper.restoreReferencePdf();
+
+    // Clean up test PDF
+    pdfHelper.cleanupTestPdf();
+  });
+
+  it('should maintain proper formatting', function(done) {
+    // Get the appropriate PDF path for testing
+    const pdfToTest = pdfHelper.getPdfPathForTesting();
+
+    // Read and parse the PDF
+    const dataBuffer = fs.readFileSync(pdfToTest);
+    pdfParse(dataBuffer).then(data => {
+      const text = data.text;
+
+      // Check for formatting patterns - more flexible patterns
+      const datePatterns = [
+        /\d{4}\s*-\s*\d{4}/i,                 // 2014-2016
+        /\d{4}\s*-\s*Present/i,               // 2014-Present
+        /\d{1,2}\/\d{4}\s*-\s*\d{1,2}\/\d{4}/i, // 05/2014-06/2016
+        /\d{1,2}\/\d{4}\s*-\s*Present/i,      // 05/2014-Present
+        /[A-Z][a-z]{2}\s+\d{4}/               // May 2014
+      ];
+
+      const hasDatePattern = datePatterns.some(pattern => text.match(pattern));
+      assert(hasDatePattern, 'Some form of date formatting should be present');
+
+      // Check for email pattern - more flexible
+      const emailPattern = /\S+@\S+\.\S+/;
+      assert(text.match(emailPattern), 'Email should be properly formatted');
+
+      done();
+    }).catch(done);
+  });
+
+  it('should have consistent PDF metadata', function(done) {
+    // Get the appropriate PDF path for testing
+    const pdfToTest = pdfHelper.getPdfPathForTesting();
+
+    // Read and parse the PDF
+    const dataBuffer = fs.readFileSync(pdfToTest);
+    pdfParse(dataBuffer).then(data => {
+      // Check PDF metadata
+      assert(data.info, 'PDF should have metadata');
+      assert(data.numpages >= 1, 'PDF should have at least 1 page');
+
+      // Check PDF size is reasonable (not too small, not too large)
+      const pdfSizeKB = dataBuffer.length / 1024;
+      assert(pdfSizeKB > 5, 'PDF should not be too small (< 5KB)');
+      assert(pdfSizeKB < 2000, 'PDF should not be too large (> 2000KB)');
+
+      done();
+    }).catch(done);
+  });
+
+  it('should have consistent file size with reference', function() {
+    // Get the appropriate PDF path for testing
+    const pdfToTest = pdfHelper.getPdfPathForTesting();
+
+    // Get the size of the generated PDF
+    const pdfSize = fs.statSync(pdfToTest).size;
+
+    // Get the size of the reference PDF if it exists
+    let originalReferencePdfPath = path.join(__dirname, '..', 'reference.pdf');
+    if (!fs.existsSync(originalReferencePdfPath)) {
+      // If reference.pdf doesn't exist, create it from the current PDF
+      fs.copyFileSync(pdfToTest, originalReferencePdfPath);
+      this.skip(); // Skip this test for now
+      return;
+    }
+
+    const referencePdfSize = fs.statSync(originalReferencePdfPath).size;
+
+    // Allow for some variation in file size (±20%)
+    const sizeDifferencePercent = Math.abs(pdfSize - referencePdfSize) / referencePdfSize * 100;
+    assert(sizeDifferencePercent < 20, `PDF file size differs by ${sizeDifferencePercent.toFixed(2)}% from reference`);
+  });
+
+  it('should have sections in a logical order', function(done) {
+    // Get the appropriate PDF path for testing
+    const pdfToTest = pdfHelper.getPdfPathForTesting();
+
+    // Read and parse the PDF
+    const dataBuffer = fs.readFileSync(pdfToTest);
+    pdfParse(dataBuffer).then(data => {
+      const text = data.text;
+      const resume = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'sample-resume.json'), 'utf-8'));
+
+      // Get the position of the name in the text
+      const namePos = text.indexOf(resume.basics.name);
+      assert(namePos !== -1, 'Name should be present');
+
+      // Define possible section headers
+      const sectionHeaders = [
+        'Work Experience', 'Experience', 'Employment',
+        'Education', 'Skills', 'Projects'
+      ];
+
+      // Find positions of each section header in the text
+      const positions = {};
+      sectionHeaders.forEach(header => {
+        const pos = text.indexOf(header);
+        if (pos !== -1) {
+          positions[header] = pos;
+        }
+      });
+
+      // Check that we found at least some sections
+      assert(Object.keys(positions).length >= 1, 'At least 1 section header should be present');
+
+      // Check that name appears before any section
+      for (const [header, pos] of Object.entries(positions)) {
+        assert(namePos < pos, `Name should appear before the "${header}" section`);
+      }
+
+      done();
+    }).catch(done);
+  });
+});

package/test/06-accessibility.test.js

@@ -0,0 +1,124 @@
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const pdfParse = require('pdf-parse');
+const pdfHelper = require('./utils/pdf-helper');
+
+describe('Accessibility and Usability', function() {
+  this.timeout(10000);
+
+  before(function(done) {
+    // Backup the original PDF
+    pdfHelper.backupReferencePdf();
+
+    // Generate a test PDF
+    pdfHelper.generateTestPdf(done);
+  });
+
+  after(function() {
+    // Restore the original PDF
+    pdfHelper.restoreReferencePdf();
+
+    // Clean up test PDF
+    pdfHelper.cleanupTestPdf();
+  });
+
+  it('should have a reasonable file size', function() {
+    // Get the appropriate PDF path for testing
+    const pdfToTest = pdfHelper.getPdfPathForTesting();
+
+    const stats = fs.statSync(pdfToTest);
+    const fileSizeInKB = stats.size / 1024;
+
+    console.log(`PDF file size: ${fileSizeInKB.toFixed(2)} KB`);
+
+    // Check that the file size is reasonable (not too small, not too large)
+    assert(fileSizeInKB > 10, 'PDF should not be too small (< 10KB)');
+    assert(fileSizeInKB < 1000, 'PDF should not be too large (> 1000KB)');
+  });
+
+  it('should have extractable text', function(done) {
+    // Get the appropriate PDF path for testing
+    const pdfToTest = pdfHelper.getPdfPathForTesting();
+
+    // Read and parse the PDF
+    const dataBuffer = fs.readFileSync(pdfToTest);
+    pdfParse(dataBuffer).then(data => {
+      const text = data.text;
+
+      // Check that the PDF has extractable text (important for accessibility)
+      assert(text.length > 100, 'PDF should have extractable text');
+
+      // Check that the text contains meaningful content
+      assert(text.split(/\s+/).length > 50, 'PDF should contain a reasonable amount of text');
+
+      done();
+    }).catch(done);
+  });
+
+  it('should have appropriate metadata', function(done) {
+    // Get the appropriate PDF path for testing
+    const pdfToTest = pdfHelper.getPdfPathForTesting();
+
+    // Read and parse the PDF
+    const dataBuffer = fs.readFileSync(pdfToTest);
+    pdfParse(dataBuffer).then(data => {
+      const info = data.info;
+
+      // Check that the PDF has basic metadata
+      assert(info, 'PDF should have metadata');
+
+      // Log the metadata for informational purposes
+      console.log('PDF metadata:', JSON.stringify(info, null, 2));
+
+      done();
+    }).catch(done);
+  });
+
+  it('should have a reasonable page count', function(done) {
+    // Get the appropriate PDF path for testing
+    const pdfToTest = pdfHelper.getPdfPathForTesting();
+
+    // Read and parse the PDF
+    const dataBuffer = fs.readFileSync(pdfToTest);
+    pdfParse(dataBuffer).then(data => {
+      const pageCount = data.numpages;
+
+      console.log(`PDF page count: ${pageCount}`);
+
+      // Check that the PDF has a reasonable number of pages
+      assert(pageCount >= 1, 'PDF should have at least 1 page');
+      assert(pageCount <= 3, 'PDF should not have more than 3 pages for a typical resume');
+
+      done();
+    }).catch(done);
+  });
+
+  it('should include contact information', function(done) {
+    // Get the appropriate PDF path for testing
+    const pdfToTest = pdfHelper.getPdfPathForTesting();
+
+    // Read and parse the PDF
+    const dataBuffer = fs.readFileSync(pdfToTest);
+    pdfParse(dataBuffer).then(data => {
+      const text = data.text;
+      const resume = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'sample-resume.json'), 'utf-8'));
+
+      // Check that contact information is included
+      assert(text.includes(resume.basics.email), 'Email should be included');
+
+      // Phone might be formatted differently
+      const phoneDigits = resume.basics.phone.replace(/\D/g, '');
+      const hasPhone = text.includes(phoneDigits) ||
+                       text.includes(phoneDigits.substring(phoneDigits.length - 4));
+      assert(hasPhone, 'Phone number should be included');
+
+      // Website might be formatted differently
+      const websiteDomain = resume.basics.website.replace(/https?:\/\//i, '').replace(/\/$/, '');
+      const hasWebsite = text.includes(websiteDomain) || text.includes(resume.basics.website);
+      assert(hasWebsite, 'Website should be included');
+
+      done();
+    }).catch(done);
+  });
+});

package/test/utils/pdf-helper.js

@@ -0,0 +1,73 @@
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+
+// Paths
+const referencePdfPath = path.join(__dirname, '..', '..', 'resume.pdf');
+const testPdfPath = path.join(__dirname, '..', '..', 'test-resume.pdf');
+
+// Save original PDF if it exists
+let originalPdfExists = false;
+let originalPdfContent = null;
+
+function backupReferencePdf() {
+  originalPdfExists = fs.existsSync(referencePdfPath);
+  if (originalPdfExists) {
+    originalPdfContent = fs.readFileSync(referencePdfPath);
+  }
+}
+
+function restoreReferencePdf() {
+  if (originalPdfExists && originalPdfContent) {
+    fs.writeFileSync(referencePdfPath, originalPdfContent);
+  } else if (fs.existsSync(referencePdfPath) && !originalPdfExists) {
+    fs.unlinkSync(referencePdfPath);
+  }
+}
+
+function cleanupTestPdf() {
+  if (fs.existsSync(testPdfPath)) {
+    fs.unlinkSync(testPdfPath);
+  }
+}
+
+function generateTestPdf(callback) {
+  const resume = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'sample-resume.json'), 'utf-8'));
+  fs.writeFileSync(path.join(__dirname, '..', '..', 'resume.json'), JSON.stringify(resume));
+
+  // Try to generate a test PDF with a different name using the correct command format
+  exec(`resume export --theme . ${testPdfPath}`, (error) => {
+    if (error) {
+      console.warn('Warning: Could not generate test PDF with custom name. Trying standard export.');
+
+      // Fall back to standard export command from package.json
+      exec('npm run export', (stdError) => {
+        if (stdError) {
+          return callback(new Error('Failed to generate PDF for testing: ' + stdError.message));
+        }
+
+        if (!fs.existsSync(referencePdfPath)) {
+          return callback(new Error('PDF was not generated at expected path: ' + referencePdfPath));
+        }
+
+        callback();
+      });
+    } else {
+      callback();
+    }
+  });
+}
+
+function getPdfPathForTesting() {
+  return fs.existsSync(testPdfPath) ? testPdfPath : referencePdfPath;
+}
+
+module.exports = {
+  referencePdfPath,
+  testPdfPath,
+  backupReferencePdf,
+  restoreReferencePdf,
+  cleanupTestPdf,
+  generateTestPdf,
+  getPdfPathForTesting
+};

package/views/awards.hbs

@@ -6,7 +6,7 @@
         <li>
             {{#if title}}
             {{#if summary}}
-            <strong>{{title}}</strong>: {{summary}}
+            <strong>{{title}}</strong>: {{{summary}}}
             {{else}}
             <strong>{{title}}</strong>
             {{/if}}

package/views/basics.hbs

@@ -18,7 +18,7 @@
     {{#if summary}}
     <div class="summary">
         <h2>Summary</h2>
-        <p>{{summary}}</p>
+        <p>{{{summary}}}</p>
     </div>
     {{/if}}
 </section>

package/views/education.hbs

@@ -22,7 +22,7 @@
     {{#if courses.length}}
     <ul class="courses">
         {{#each courses}}
-        <li>{{.}}</li>
+        <li>{{{.}}}</li>
         {{/each}}
     </ul>
     {{/if}}

package/views/volunteer.hbs

@@ -5,14 +5,14 @@
         {{#> item title=organization subtitle=position location=location startDate=startDate endDate=endDate }}
         {{#if summary}}
         <div class="summary">
-            <p>{{summary}}</p>
+            <p>{{{summary}}}</p>
         </div>
         {{/if}}
 
         {{#if highlights.length}}
         <ul class="highlights">
             {{#each highlights}}
-            <li>{{.}}</li>
+            <li>{{{.}}}</li>
             {{/each}}
         </ul>
         {{/if}}

package/views/work.hbs

@@ -7,7 +7,7 @@
         {{#if highlights.length}}
         <ul class="highlights">
             {{#each highlights}}
-            <li>{{.}}</li>
+            <li>{{{.}}}</li>
             {{/each}}
         </ul>
         {{/if}}

package/.github/dependabot.yml

@@ -1,11 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: "npm"
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"

package/sample-resume.json

@@ -1,156 +0,0 @@
-{
-  "basics": {
-    "name": "Richard Hendriks",
-    "label": "Programmer",
-    "picture": "http://www.piedpiper.com/app/themes/pied-piper/dist/images/richard.png",
-    "email": "richard.hendriks@piedpiper.com",
-    "phone": "(912) 555-4321",
-    "website": "http://piedpiper.com",
-    "summary": "Richard hails from Tulsa. He has earned degrees from the University of Oklahoma and Stanford. (Go Sooners and Cardinals!) Before starting Pied Piper, he worked for Hooli as a part time software developer. While his work focuses on applied information theory, mostly optimizing lossless compression schema of both the length-limited and adaptive variants, his non-work interests range widely, everything from quantum computing to chaos theory. He could tell you about it, but THAT would NOT be a “length-limited” conversation!",
-    "location": {
-      "address": "Newell Road",
-      "postalCode": "94303",
-      "city": "Palo Alto",
-      "countryCode": "US",
-      "region": "CA"
-    },
-    "profiles": [
-      {
-        "network": "Twitter",
-        "username": "siliconHBO",
-        "url": "https://twitter.com/siliconHBO"
-      },
-      {
-        "network": "Facebook",
-        "username": "SiliconHBO",
-        "url": "https://www.facebook.com/SiliconHBO"
-      },
-      {
-        "network": "Instagram",
-        "username": "siliconhbo",
-        "url": "https://www.instagram.com/siliconhbo/"
-      }
-    ]
-  },
-  "work": [
-    {
-      "company": "Pied Piper",
-      "position": "CEO/President",
-      "website": "http://piedpiper.com",
-      "startDate": "2014-04-13",
-      "summary": "Pied Piper is a multi-platform technology based on a proprietary universal compression algorithm that has consistently fielded high Weisman Scores™ that are not merely competitive, but approach the theoretical limit of lossless compression.",
-      "highlights": [
-        "Build an algorithm for artist to detect if their music was violating copy right infringement laws",
-        "Successfully won Techcrunch Disrupt",
-        "Optimized an algorithm that holds the current world record for Weisman Scores"
-      ]
-    },
-    {
-      "company": "Hooli",
-      "position": "Senior Software Engineer",
-      "website": "http://www.hooli.xyz/",
-      "startDate": "2014-01-01",
-      "endDate": "2014-04-06",
-      "highlights": [
-        "Worked on optimizing the backend algorithms for Hooli"
-      ]
-    },
-    {
-      "company": "Hooli",
-      "position": "Software Engineer",
-      "website": "http://www.hooli.xyz/",
-      "startDate": "2013-01-01",
-      "endDate": "2014-01-01",
-      "highlights": [
-        "Contributed bugfixes and smaller features for Hooli"
-      ]
-    }
-  ],
-  "volunteer": [
-    {
-      "organization": "CoderDojo",
-      "position": "Teacher",
-      "website": "http://coderdojo.com/",
-      "startDate": "2012-01-01",
-      "endDate": "2013-01-01",
-      "summary": "Global movement of free coding clubs for young people.",
-      "highlights": [
-        "Awarded 'Teacher of the Month'"
-      ]
-    }
-  ],
-  "education": [
-    {
-      "institution": "Stanford",
-      "area": "Computer Science",
-      "studyType": "B.S",
-      "location": "Palo Alto, CA",
-      "specialization": "Machine Learning",
-      "startDate": "2011-06-01",
-      "endDate": "2014-01-01",
-      "gpa": "GPA 4.0",
-      "courses": [
-        "DB1101 - Basic SQL",
-        "CS2011 - Java Introduction"
-      ]
-    }
-  ],
-  "awards": [
-    {
-      "title": "Digital Compression Pioneer Award",
-      "date": "2014-11-01",
-      "awarder": "Techcrunch",
-      "summary": "There is no spoon."
-    }
-  ],
-  "publications": [
-    {
-      "name": "Video compression for 3d media",
-      "publisher": "Hooli",
-      "releaseDate": "2014-10-01",
-      "website": "http://en.wikipedia.org/wiki/Silicon_Valley_(TV_series)",
-      "summary": "Innovative middle-out compression algorithm that changes the way we store data."
-    }
-  ],
-  "skills": [
-    {
-      "name": "Web Development",
-      "level": "Master",
-      "keywords": [
-        "HTML",
-        "CSS",
-        "Javascript"
-      ]
-    },
-    {
-      "name": "Compression",
-      "level": "Master",
-      "keywords": [
-        "Mpeg",
-        "MP4",
-        "GIF"
-      ]
-    }
-  ],
-  "languages": [
-    {
-      "language": "English",
-      "fluency": "Native speaker"
-    }
-  ],
-  "interests": [
-    {
-      "name": "Wildlife",
-      "keywords": [
-        "Ferrets",
-        "Unicorns"
-      ]
-    }
-  ],
-  "references": [
-    {
-      "name": "Erlich Bachman",
-      "reference": "It is my pleasure to recommend Richard. That is all."
-    }
-  ]
-}