See #58. Fix code format issues

.vscode/settings.json

@@ -5,4 +5,7 @@
     "jest.rootPath": ".",
     "jest.pathToConfig": "jest.config.js",
     "jest.showCoverageOnLoad": true,
+    "prettier.semi": true,
+    "prettier.singleQuote": false,
+    "prettier.trailingComma": "all"
 }

src/DependencyManager/Dependency.ts

@@ -29,7 +29,7 @@ export abstract class Dependency {
       .then(isInstalled => {
         if (this.required && !isInstalled) {
           throw new Error(
-            `Dependency "${this.name}" is required and not installed.`
+            `Dependency "${this.name}" is required and not installed.`,
           );
         }
         return isInstalled;
@@ -82,7 +82,7 @@ export interface BaseDependencyOptions {
 
 export enum DependencyType {
   Node = "node",
-  Executable = "exec"
+  Executable = "exec",
 }
 
 export interface NodeDependencyOptions extends BaseDependencyOptions {

src/DependencyManager/DependencyFactory.ts

@@ -1,8 +1,4 @@
-import {
-  Dependency,
-  DependencyType,
-  DependencyOptions
-} from "./Dependency";
+import { Dependency, DependencyType, DependencyOptions } from "./Dependency";
 import { NodeDependency } from "./NodeDependency";
 import { ExecutableDependency } from "./ExecutableDependency";
 
@@ -18,7 +14,7 @@ export class DependencyFactory {
         return new ExecutableDependency(options);
       default:
         throw new Error(
-          `Dependency type not found for: ${JSON.stringify(options)}`
+          `Dependency type not found for: ${JSON.stringify(options)}`,
         );
     }
   }

src/DependencyManager/DependencyManager.ts

@@ -8,14 +8,14 @@ export class DependencyManager {
 
   constructor(dependencies: DependencyOptions[]) {
     this.dependencies = dependencies.map(dependency =>
-      new DependencyFactory(dependency).dependency()
+      new DependencyFactory(dependency).dependency(),
     );
     this.lookup = this.dependencies.reduce(
       (lookup, dep) => ({
         ...lookup,
-        [dep.name]: dep
+        [dep.name]: dep,
       }),
-      {}
+      {},
     );
   }
 
@@ -31,7 +31,7 @@ export class DependencyManager {
     return Promise.all(
       this.dependencies.map(dep => {
         return dep.load();
-      })
+      }),
     ).then(() => true);
   }
 }

src/DependencyManager/ExecutableDependency.ts

@@ -1,7 +1,4 @@
-import {
-  Dependency,
-  ExecutableDependencyOptions
-} from "./Dependency";
+import { Dependency, ExecutableDependencyOptions } from "./Dependency";
 
 export class ExecutableDependency extends Dependency {
   constructor(protected options: ExecutableDependencyOptions) {
@@ -20,7 +17,7 @@ export class ExecutableDependency extends Dependency {
     return Promise.resolve({
       exitCode: 0,
       stderr: "",
-      stdout: "executable run output"
+      stdout: "executable run output",
     });
   }
 }

src/DependencyManager/NodeDependency.ts

@@ -1,13 +1,9 @@
-import {
-  Dependency,
-  NodeDependencyOptions
-} from "./Dependency";
+import { Dependency, NodeDependencyOptions } from "./Dependency";
 
 // tslint:disable-next-line:no-require-imports no-var-requires
 const requireg = require("requireg");
 
 export class NodeDependency extends Dependency {
-
   constructor(protected options: NodeDependencyOptions) {
     super(options);
   }

test/DependencyManager/DependencyManager.spec.ts

@@ -2,21 +2,21 @@ import {
   DependencyOptions,
   DependencyType,
   DependencyManager,
-  NodeDependency
+  NodeDependency,
 } from "../../src/DependencyManager";
 
 test("should fail to load dependencies", async () => {
   expect.assertions(1);
   const options: DependencyOptions = {
     name: "NotFound",
     package: "notfound",
-    type: DependencyType.Node
+    type: DependencyType.Node,
   };
   const manager = new DependencyManager([options]);
 
   return await manager.load().catch(error => {
     expect(error.message).toMatch(
-      'Dependency "NotFound" is required and not installed.'
+      'Dependency "NotFound" is required and not installed.',
     );
   });
 });
@@ -27,7 +27,7 @@ describe("successfully loads dependency", () => {
     const options: DependencyOptions = {
       name: "FakeDep",
       package: "fakedep",
-      type: DependencyType.Node
+      type: DependencyType.Node,
     };
     const manager = new DependencyManager([options]);
 
@@ -40,7 +40,7 @@ describe("successfully loads dependency", () => {
     const options: DependencyOptions = {
       name: packageName,
       package: packageName,
-      type: DependencyType.Node
+      type: DependencyType.Node,
     };
     const manager = new DependencyManager([options]);
 
@@ -55,7 +55,7 @@ describe("successfully loads dependency", () => {
     const options: DependencyOptions = {
       name: packageName,
       package: packageName,
-      type: DependencyType.Node
+      type: DependencyType.Node,
     };
     const manager = new DependencyManager([options]);
 
@@ -71,7 +71,7 @@ describe("successfully loads dependency", () => {
     const options: DependencyOptions = {
       name: packageName,
       package: packageName,
-      type: DependencyType.Node
+      type: DependencyType.Node,
     };
     const manager = new DependencyManager([options]);
 

test/DependencyManager/NodeDependency.spec.ts

@@ -1,21 +1,21 @@
 import {
   NodeDependency,
   DependencyType,
-  DependencyOptions
+  DependencyOptions,
 } from "../../src/DependencyManager";
 
 test("should fail to load Node dependency", async () => {
   expect.assertions(3);
   const options: DependencyOptions = {
     name: "NotFound",
     package: "NotFound",
-    type: DependencyType.Node
+    type: DependencyType.Node,
   };
   const dependency = new NodeDependency(options);
 
   return await dependency.load().catch(error => {
     expect(error.message).toMatch(
-      'Dependency "NotFound" is required and not installed.'
+      'Dependency "NotFound" is required and not installed.',
     );
     expect(dependency.isInstalled).toBe(false);
     expect(dependency.errors).toHaveLength(1);
@@ -28,7 +28,7 @@ describe("successfully loaded Node dependency", () => {
     const options: DependencyOptions = {
       name: "FakeDep",
       package: "fakedep",
-      type: DependencyType.Node
+      type: DependencyType.Node,
     };
     const dependency = new NodeDependency(options);
 

test/InlineFlagManager.spec.ts

@@ -244,5 +244,4 @@ describe("disable/enable", () => {
     const finalText = manager.text;
     expect(finalText).toEqual(expectedText);
   });
-
 });

test/beautifier/beautifier.spec.ts

@@ -76,7 +76,7 @@ test("should successfully beautify text", () => {
       languageName: "TestLang",
       options: {},
       text: "test",
-    })
+    }),
   ).resolves.toBe(beautifierResult);
 });
 
@@ -98,7 +98,7 @@ test("should fail to find beautifier", () => {
       languageName: "TestLang",
       options: {},
       text: "test",
-    })
+    }),
   ).rejects.toThrowError(`Beautifiers not found for Language: ${lang.name}`);
 });
 
@@ -110,7 +110,7 @@ test("should fail to find language", () => {
       languageName: "TestLang",
       options: {},
       text: "test",
-    })
+    }),
   ).rejects.toThrowError("Cannot find language.");
 });
 
@@ -176,15 +176,15 @@ test("should successfully transform option values for beautifier", () => {
   const result1 = Unibeautify.getOptionsForBeautifier(
     beautifier,
     lang1,
-    options
+    options,
   );
   expect(result1.value1).toEqual(options.value1); // "Allow option"
   expect(result1.value2).toBeUndefined();
   expect(result1.isUndefined).toBeUndefined();
   expect(result1.renamed1).toEqual(options.value1); // "Rename option"
   expect(result1.basicTransform).toEqual(options.basicTransform + 1); // "Perform basic transformation"
   expect(result1.complexTransform).toEqual(
-    options.value1 + options.basicTransform
+    options.value1 + options.basicTransform,
   ); // "Perform complex transformation"
   expect(result1.willBeReplaced).toEqual(options.value1); // "Replace global option with language-specific option"
   expect(result1).toEqual({
@@ -198,13 +198,13 @@ test("should successfully transform option values for beautifier", () => {
   const result2 = Unibeautify.getOptionsForBeautifier(
     beautifier,
     lang2,
-    options
+    options,
   );
 
   const result3 = Unibeautify.getOptionsForBeautifier(
     beautifier,
     lang3,
-    options
+    options,
   );
 });
 
@@ -239,6 +239,6 @@ test("should successfully ignore-next-line", () => {
       languageName: "TestLang",
       options: {},
       text: originalText,
-    })
+    }),
   ).resolves.toBe(originalText);
 });

test/beautifier/dependency.spec.ts

@@ -3,7 +3,7 @@ import {
   Language,
   Beautifier,
   DependencyOptions,
-  DependencyType
+  DependencyType,
 } from "../../src/";
 
 test("should throw Error when dependency type is unknown", () => {
@@ -15,12 +15,12 @@ test("should throw Error when dependency type is unknown", () => {
     namespace: "test",
     since: "0.1.0",
     sublimeSyntaxes: [],
-    vscodeLanguages: []
+    vscodeLanguages: [],
   };
   unibeautify.loadLanguage(lang);
   const beautifierResult = "Testing Result";
   const dependency: any = {
-    type: "wrong"
+    type: "wrong",
   };
   const beautifier: Beautifier = {
     beautify: ({ Promise }) => {
@@ -29,8 +29,8 @@ test("should throw Error when dependency type is unknown", () => {
     dependencies: [dependency],
     name: "TestBeautify",
     options: {
-      TestLang: false
-    }
+      TestLang: false,
+    },
   };
   return expect(() => {
     unibeautify.loadBeautifier(beautifier);
@@ -47,15 +47,15 @@ describe("Node", () => {
       namespace: "test",
       since: "0.1.0",
       sublimeSyntaxes: [],
-      vscodeLanguages: []
+      vscodeLanguages: [],
     };
     unibeautify.loadLanguage(lang);
 
     const beautifierResult = "Testing Result";
     const dependency: DependencyOptions = {
       name: "Fakedep",
       package: "fake",
-      type: DependencyType.Node
+      type: DependencyType.Node,
     };
     const beautifier: Beautifier = {
       beautify: ({ Promise }) => {
@@ -64,19 +64,19 @@ describe("Node", () => {
       dependencies: [dependency],
       name: "TestBeautify",
       options: {
-        TestLang: false
-      }
+        TestLang: false,
+      },
     };
     unibeautify.loadBeautifier(beautifier);
 
     return expect(
       unibeautify.beautify({
         languageName: "TestLang",
         options: {},
-        text: "test"
-      })
+        text: "test",
+      }),
     ).rejects.toThrowError(
-      'Dependency "Fakedep" is required and not installed.'
+      'Dependency "Fakedep" is required and not installed.',
     );
   });
 });
@@ -91,7 +91,7 @@ describe("Executable", () => {
       namespace: "test",
       since: "0.1.0",
       sublimeSyntaxes: [],
-      vscodeLanguages: []
+      vscodeLanguages: [],
     };
     unibeautify.loadLanguage(lang);
 
@@ -100,7 +100,7 @@ describe("Executable", () => {
       name: "Fake Program",
       parseVersion: text => "",
       program: "fakeprogram",
-      type: DependencyType.Executable
+      type: DependencyType.Executable,
     };
     const beautifier: Beautifier = {
       beautify: ({ Promise, dependencies }) => {
@@ -110,19 +110,19 @@ describe("Executable", () => {
       dependencies: [dependency],
       name: "TestBeautify",
       options: {
-        TestLang: false
-      }
+        TestLang: false,
+      },
     };
     unibeautify.loadBeautifier(beautifier);
 
     return expect(
       unibeautify.beautify({
         languageName: "TestLang",
         options: {},
-        text: "test"
-      })
+        text: "test",
+      }),
     ).rejects.toThrowError(
-      'Dependency "Fake Program" is required and not installed.'
+      'Dependency "Fake Program" is required and not installed.',
     );
   });
 });