Merge branch 'class'

index.js

@@ -14,15 +14,20 @@ const gerberFiles = [
   'CAMOutputs/GerberFiles/profile.gbr',
 ];
 
-/**
+class ImageGenerator {
- * Configures the folders used
+  constructor(folderConfig, imgConfig) {
- * @param {Object} folderConfig Object with properties tmpDir and imgDir containing paths to temporary and image output folders
+    // this.folderConfig = folderConfig;
- */
+    this.tmpDir = folderConfig.tmpDir;
-function config(folderConfig) {
+    this.imgDir = folderConfig.imgDir;
-  // Create tmpDir if it does not exist
+    this.imgConfig = imgConfig;
-  fs.ensureDirSync(folderConfig.tmpDir);
+
-  // Create imgDir if it does not exist
+    // Ensure that the folders exist
-  fs.ensureDirSync(folderConfig.imgDir);
+    try {
+      fs.ensureDirSync(this.tmpDir);
+      fs.ensureDirSync(this.imgDir);
+    } catch (error) {
+      throw new Error(error);
+    }
   }
 
   /**
@@ -31,7 +36,7 @@ function config(folderConfig) {
    * @param {string} tmpDir Temporary directory to extract to
    * @returns {Promise} Promise object represents number of files extracted
    */
-function extractArchive(fileName, tmpDir) {
+  static extractArchive(fileName, tmpDir) {
     // Check archive exists
     try {
       if (!fs.existsSync(fileName)) {
@@ -53,7 +58,7 @@ function extractArchive(fileName, tmpDir) {
    * @param {string} dir Directory containing layer files
    * @returns {Array} Array of paths to the layers files
    */
-function getLayers(dir) {
+  static getLayers(dir) {
     return new Promise((resolve, reject) => {
       // Make sure the directory exists
       if (!fs.existsSync(dir)) {
@@ -78,7 +83,7 @@ function getLayers(dir) {
    * Clean up the archive folder in the specified directory
    * @param {string} dir Path to a directory to clean up
    */
-function cleanupFiles(dir) {
+  static cleanupFiles(dir) {
     try {
       const folder = path.join(dir, 'archive');
       fs.emptyDirSync(folder);
@@ -91,14 +96,12 @@ function cleanupFiles(dir) {
    * Take an archive containing gerber files, config object, temporary dir
    * and output dir and create a PNG image from the gerber in the output dir
    * @param {string} gerber Path to an archive file containing gerber
- * @param {Object} config Object containing sharp settings for resizeWidth, compLevel and density
+   * @returns {Promise.<string>} Promise to return path to image
- * @param {string} tmpDir Temporary directory to extract the archive to
- * @param {string} outputDir Directory to save the image to
    */
-function gerberToImage(gerber, imgConfig, tmpDir, outputDir) {
+  gerberToImage(gerber) {
     // Create output dir if it doesn't exist
     try {
-    fs.ensureDirSync(outputDir, 0o644);
+      fs.ensureDirSync(this.imgDir, 0o644);
     } catch (e) {
       throw new Error(e);
     }
@@ -108,10 +111,10 @@ function gerberToImage(gerber, imgConfig, tmpDir, outputDir) {
       if (!fs.existsSync(gerber)) {
         throw Error('Archive does not exist.');
       }
-    if (!fs.existsSync(tmpDir)) {
+      if (!fs.existsSync(this.tmpDir)) {
         throw Error('Temporary folder does not exist.');
       }
-    if (!fs.existsSync(outputDir)) {
+      if (!fs.existsSync(this.imgDir)) {
         throw Error('Output folder does not exist.');
       }
     } catch (e) {
@@ -120,33 +123,32 @@ function gerberToImage(gerber, imgConfig, tmpDir, outputDir) {
 
     // Set filenames
     const imageName = path.basename(gerber, '.zip');
-  const destFile = `${path.join(outputDir, imageName)}.png`;
+    const destFile = `${path.join(this.imgDir, imageName)}.png`;
 
     return new Promise((resolve, reject) => {
-    extractArchive(gerber, tmpDir);
+      ImageGenerator.extractArchive(gerber, this.tmpDir);
-    getLayers(path.join(tmpDir, 'archive'))
+      ImageGenerator.getLayers(path.join(this.tmpDir, 'archive'))
         .then(pcbStackup)
         .then((stackup) => {
-        sharp(Buffer.from(stackup.top.svg), { density: imgConfig.density })
+          sharp(Buffer.from(stackup.top.svg), {
-          .resize({ width: imgConfig.resizeWidth })
+            density: this.imgConfig.density,
-          .png({ compressionLevel: imgConfig.compLevel })
+          })
+            .resize({ width: this.imgConfig.resizeWidth })
+            .png({ compressionLevel: this.imgConfig.compLevel })
             .toFile(destFile);
         })
         .then(() => {
-        cleanupFiles(tmpDir);
+          ImageGenerator.cleanupFiles(this.tmpDir);
           resolve(destFile);
         })
         .catch((e) => {
-        cleanupFiles(tmpDir);
+          ImageGenerator.cleanupFiles(this.tmpDir);
           reject(new Error(e));
         });
     });
   }
+}
 
 module.exports = {
-  cleanupFiles,
+  ImageGenerator,
-  getLayers,
-  extractArchive,
-  config,
-  gerberToImage,
 };

test/index.test.js

@@ -1,24 +1,45 @@
 /* eslint-disable */
 const path = require('path');
 const fs = require('fs-extra');
-const fileProc = require('../index.js');
+const { ImageGenerator } = require('../index.js');
+require('../index.js');
 
 const testGerber = path.join(__dirname, 'Arduino-Pro-Mini.zip');
 const testLayers = path.join(__dirname, 'layers');
 const emptyFolder = path.join(__dirname, 'layers', 'Empty');
-const tmpDir = path.join(__dirname, 'tmp');
+// const tmpDir = path.join(__dirname, 'tmp');
-const imgDir = path.join(__dirname, 'tmp');
+// const imgDir = path.join(__dirname, 'tmp');
-const nonWritableDir = fs.ensureDirSync(path.join(tmpDir, 'no-write'), 0o400);
+const folderConfig = {
-
+  tmpDir: path.join(__dirname, 'tmp'),
+  imgDir: path.join(__dirname, 'tmp'),
+};
+const noTempConfig = {
+  tmpDir: emptyFolder,
+  imgDir: path.join(__dirname, 'tmp'),
+};
+const noImageConfig = {
+  tmpDir: path.join(__dirname, 'tmp'),
+  imgDir: emptyFolder,
+};
+const nonWritableDir = fs.ensureDirSync(path.join(folderConfig.tmpDir, 'no-write'), 0o400);
 const imgConfig = {
   resizeWidth: 600,
   density: 1000,
   compLevel: 1,
 };
 
+const fileProc = new ImageGenerator(folderConfig, imgConfig);
+const fileProcNoTemp = new ImageGenerator(noTempConfig, imgConfig);
+const fileProcNoImage = new ImageGenerator(noImageConfig, imgConfig);
+
+/**************
+ * Tests
+ ***************/
+
 // getLayers
 test('Promise of an array of layers from a given folder', () => {
-  return fileProc.getLayers(testLayers).then((data) => {
+  expect.assertions(1);
+  return ImageGenerator.getLayers(testLayers).then((data) => {
     expect(data).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
@@ -31,59 +52,64 @@ test('Promise of an array of layers from a given folder', () => {
 });
 
 test('Non-existent folder should reject promise with error', () => {
-  return expect(fileProc.getLayers('./invalid_folder')).rejects.toThrow(
+  expect.assertions(1);
-    'Layers folder does not exist.'
+  return expect(ImageGenerator.getLayers('./invalid_folder')).rejects.toThrow(
+    new Error('Layers folder does not exist.')
   );
 });
 
 test('Folder with incorrect number of layers should reject promise with error', () => {
-  return expect(fileProc.getLayers(emptyFolder)).rejects.toThrow(
+  expect.assertions(1);
-    'Layer not found.'
+  return expect(ImageGenerator.getLayers(emptyFolder)).rejects.toThrow(
+    new Error('Layer not found.')
   );
 });
 
 // extractArchive
 test('Non-existent archive should throw an error', () => {
-  expect(() => fileProc.extractArchive('invalid.zip', tmpDir).toThrow(Error));
+  expect(() =>
+    ImageGenerator.extractArchive('invalid.zip', folderConfig.tmpDir).toThrow(Error)
+  );
 });
 
 test('Temp dir not existing should throw an error', () => {
   expect(() =>
-    fileProc.extractArchive(testGerber, './invalid_dir').toThrow(Error)
+    ImageGenerator.extractArchive(testGerber, './invalid_dir').toThrow(Error)
   );
 });
 
 test('Should extract archive and resolve with the number of files extracted', () => {
-  expect(() => fileProc.extractArchive(testGerber, tmpDir).toBe(12));
+  expect(() => ImageGenerator.extractArchive(testGerber, folderConfig.tmpDir).toBe(12));
 });
 
 // gerberToImage
 test('Temp dir not existing should throw an error', () => {
   expect(() =>
-    fileProc
+    fileProcNoTemp
-      .gerberToImage(testGerber, imgConfig, './invalid_dir', imgDir)
+      .gerberToImage(testGerber)
-      .toThrow('Temporary folder does not exist.')
+      .toThrow(new Error('Temporary folder does not exist.'))
   );
 });
 
 test('Output dir not existing should throw an error', () => {
   expect(() =>
-    fileProc
+    fileProcNoImage
-      .gerberToImage(testGerber, imgConfig, tmpDir, './invalid_dir')
+      .gerberToImage(testGerber)
-      .toThrow('Output folder does not exist.')
+      .toThrow(new Error('Output folder does not exist.'))
   );
 });
 
 test('Invalid archive file should throw an error', () => {
   expect(() =>
     fileProc
-      .gerberToImage('invalid.zip', imgConfig, tmpDir, imgDir)
+      .gerberToImage('invalid.zip')
-      .toThrow('Archive does not exist.')
+      .toThrow(new Error('Archive does not exist.'))
   );
 });
 
 test('Gerber archive should resolve promise and return a filename of an image', () => {
+  expect.assertions(1);
   return expect(
-    fileProc.gerberToImage(testGerber, imgConfig, tmpDir, imgDir)
+    fileProc.gerberToImage(testGerber)
   ).resolves.toEqual(expect.stringContaining('Arduino-Pro-Mini.png'));
 });