codebase: refactor and improve test coverage

src/location.js

@@ -21,48 +21,33 @@ const Location = function (instance, source, destination) {
             throw error.invalidPathError("destination", destination);
         }
     }
-    this.original = {
-        source: source,
-    };
+    this.original = { source };
     var locations = { source, destination };
     for (var location in locations) {
-        locations[location] = this.makeAbsolute(locations[location]);
-        locations[location] = locations[location].replace(/\\/gu, "/");
+        locations[location] = path.resolve(locations[location]).replace(/\\/gu, "/");
     }
-    source = locations.source;
-    source = this.processSource(source);
-    destination = locations.destination;
-    this.source = source;
-    this.destination = destination;
+    this.source = this.process(locations.source);
+    this.destination = locations.destination;
 };
 
 Location.prototype = {
-    basename: function (location) {
-        if (process.platform == "win32") {
-            return path.win32.basename(location);
-        }
-
-        return path.posix.basename(location);
-    },
     exists: function (location) {
         return fs.existsSync(location);
     },
-    makeAbsolute: function (location) {
-        if (!path.isAbsolute(location)) {
-            location = path.resolve(location);
-        }
-
-        return location;
-    },
-    toGlob: function (location) {
-        return fg.sync(path.join(location, path.join("/", "*.svg")).replace(/\\/gu, "/"));
-    },
-    processSource: function (source) {
-        if (is.pathToDir(source)) {
-            source = this.toGlob(source);
-        } else {
-            source = [source];
+    process: function (source) {
+        source = [source];
+        if (is.pathToDir(source[0])) {
+            source = fg.sync(
+                path.join(source[0], path.join("/", "*.svg")).replace(/\\/gu, "/")
+            );
         }
+        source.forEach((svgPath) => {
+            if (!is.pathToFile(svgPath) || path.extname(svgPath) != ".svg") {
+                throw new Error(
+                    `one of the source file paths does not point to a .svg file. ${svgPath}`
+                );
+            }
+        });
 
         return source;
     },

src/option.js

@@ -37,7 +37,7 @@ Option.prototype = {
     },
     update: function (options) {
         for (var key in options) {
-            if (Object.prototype.hasOwnProperty.call(options, key)) {
+            if (Object.prototype.hasOwnProperty.call(this.data, key)) {
                 this.data[key] = options[key];
             }
         }

src/processor.js

@@ -4,7 +4,6 @@ const fs = require("fs");
 const path = require("path");
 const Svg = require("./svg");
 const colors = require("colors");
-const is = require("oslllo-validator");
 const cliprogress = require("cli-progress");
 
 const Processor = function (fixer) {
@@ -25,13 +24,8 @@ Processor.prototype = {
         svgs = svgs.map((source) => {
             var destination = path.join(
                 this.destination,
-                this.fixer.location.basename(source)
+                path.basename(source)
             );
-            if (!is.pathToFile(source) || path.extname(source) != ".svg") {
-                throw new Error(
-                    `expected a direct path to a svg file, ${source} was given.`
-                );
-            }
 
             return { source, destination };
         });

src/svg.js

@@ -10,13 +10,13 @@ const Svg = function (path) {
     this.svg2 = Svg2(this.path);
     this.element = this.svg2.toElement();
     this.outerHTML = this.element.outerHTML;
-    this.resized = this._resized();
-    this.original = this._original();
-    this.scale = this._scale();
+    this.resized = this.getResized();
+    this.original = this.getOriginal();
+    this.scale = this.getScale();
 };
 
 Svg.prototype = {
-    _resized: function () {
+    getResized: function () {
         var element = Svg2(this.outerHTML).svg
             .resize({
                 width: 600,
@@ -28,7 +28,7 @@ Svg.prototype = {
 
         return { element, svg2, dimensions };
     },
-    _original: function () {
+    getOriginal: function () {
         var element = this.element.cloneNode(true);
         var dimensions = this.svg2.svg.dimensions();
         var attributes = Object.values(element.attributes).map(function (attribute) {
@@ -37,10 +37,10 @@ Svg.prototype = {
 
         return { element, dimensions, attributes };
     },
-    _scale: function () {
+    getScale: function () {
         return this.original.dimensions.height / this.resized.dimensions.height;
     },
-    _restore: function (outerHTML) {
+    toOriginal: function (outerHTML) {
         var element = Svg2(outerHTML).toElement();
         while (element.attributes.length > 0) {
             element.removeAttribute(element.attributes[0].name);
@@ -59,7 +59,7 @@ Svg.prototype = {
     process: async function () {
         var pngBuffer = await this.resized.svg2.png().toBuffer();
         var traced = await Potrace(pngBuffer, { svgSize: this.scale }).trace();
-        traced = this._restore(traced);
+        traced = this.toOriginal(traced);
 
         return traced;
     },

test/assets/.gitignore

@@ -1,2 +1,3 @@
 failed-icons/
 fixed-icons/
+temp-fixed-icons/

test/src/test.exceptions.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const path = require("path");
+const fs = require("fs-extra");
 const is = require("oslllo-validator");
 const error = require("../../src/error");
 const { SVGFixer, assert, path2 } = require("./helper");
@@ -33,6 +34,16 @@ describe("test.exceptions", () => {
                 );
             });
         });
+        it("throws if source file is not a svg file", () => {
+            var source = path.resolve("test/assets/images/svg.png");
+            var destination = path2.fixed.relative;
+            assert.isTrue(fs.existsSync(source), "source test image does not exist");
+            assert.throws(
+                () => SVGFixer(source, destination),
+                Error,
+                `one of the source file paths does not point to a .svg file. ${source}`
+            );
+        });
     });
 
     describe("invalid destination arguments", () => {
@@ -71,6 +82,12 @@ describe("test.exceptions", () => {
                 );
             });
         });
+        it("does not throw if destination folder does not exist and options.throwIfDestinationDoesNotExist is set to false", () => {
+            var source = path2.single.absolute;
+            var destination = "test/assets/temp-fixed-icons";
+            var options = { throwIfDestinationDoesNotExist: false };
+            assert.doesNotThrow(() => SVGFixer(source, destination, options));
+        });
     });
 
     describe("options", () => {

test/src/test.parameters.js

@@ -3,22 +3,43 @@
 const { SVGFixer, assert, path2 } = require("./helper");
 
 describe("test.parameters", () => {
-    it("can set the options parameter", async () => {
-        var options = {
-            showProgressBar: true,
-            throwIfDestinationDoesNotExist: false,
-        };
-        var instance = await SVGFixer(
-            path2.direct.absolute,
-            path2.fixed.absolute,
-            options
-        ).fix();
-        var set = instance.options.all();
-        var keys = {
-            set: Object.values(set),
-            options: Object.values(options),
-        };
-        assert.deepEqual(keys.set, keys.options, "option parameter keys do not match");
-        assert.deepEqual(set, options, "option parameters do not match");
+    describe("options parameters", () => {
+        it("can set the options parameter", async () => {
+            var options = {
+                showProgressBar: true,
+                throwIfDestinationDoesNotExist: false,
+            };
+            var instance = await SVGFixer(
+                path2.direct.absolute,
+                path2.fixed.absolute,
+                options
+            ).fix();
+            var set = instance.options.all();
+            var keys = {
+                set: Object.values(set),
+                options: Object.values(options),
+            };
+            assert.deepEqual(
+                keys.set,
+                keys.options,
+                "option parameter keys do not match"
+            );
+            assert.deepEqual(set, options, "option parameters do not match");
+        });
+        it("won't update invalid options parameters", () => {
+            var valid = {
+                showProgressBar: false,
+                throwIfDestinationDoesNotExist: true,
+            };
+            var invalid = {
+                invalidoptions: true,
+            };
+            var instance = SVGFixer(path2.direct.absolute, path2.fixed.absolute, invalid);
+            assert.deepEqual(
+                valid,
+                instance.options.all(),
+                "option parameters do not match"
+            );
+        });
     });
 });