feat(style): Configure prettier (#243)

There's now a local git commit hook that reformats staged files
(including partial stages I think?).  This includes the initial
reformatting pass, so future PRs can continue to have clean diffs.

While not everyone loves `prettier`'s default output (you could argue
that no one does), it puts everyone in the same situation as far as
styling goes: "it could be better, but it could be much worse".

.circleci/config.yml

@@ -15,6 +15,9 @@ jobs:
       - run:
           name: Lint
           command: yarn lint
+      - run:
+          name: Prettier
+          command: yarn prettier
       - run:
           name: Test
           command: yarn test --ci --runInBand --testResultsProcessor=jest-junit

.editorconfig

@@ -0,0 +1,7 @@
+root = true
+
+[*.{js,ts}]
+charset = utf-8
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true

.prettierignore

@@ -0,0 +1,4 @@
+types
+lib
+package.json
+**/*.js.snap

bin/cli.js

@@ -7,11 +7,7 @@ const brs = require("../lib/");
 
 // read current version from package.json
 // I'll _definitely_ forget to do this one day
-const packageJson = JSON.parse(
-    fs.readFileSync(
-        path.join(__dirname, "..", "package.json")
-    )
-);
+const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json")));
 
 program
     .description("Off-Roku BrightScript interpreter")
@@ -24,7 +20,7 @@ program
     .action(async (brsFiles, program) => {
         if (brsFiles.length > 0) {
             try {
-                await brs.execute(brsFiles, { root: program.root })
+                await brs.execute(brsFiles, { root: program.root });
             } catch (err) {
                 if (err.messages && err.messages.length) {
                     err.messages.forEach(message => console.error(message));

package.json

@@ -14,7 +14,9 @@
     "clean": "rimraf ./lib ./types",
     "test": "jest",
     "lint": "tslint --project .",
-    "prepublishOnly": "npm-run-all --serial clean build lint test"
+    "prettier:write": "prettier --write '{bin,src,test}/**/*.{js,ts}'",
+    "prettier": "prettier --check '{bin,src,test}/**/*.{js,ts}'",
+    "prepublishOnly": "npm-run-all --serial clean build lint:check prettier:check test"
   },
   "files": [
     "bin/",
@@ -37,16 +39,35 @@
     "@types/memory-fs": "^0.3.2",
     "@types/node": "^8.5.2",
     "@types/p-settle": "^2.0.1",
+    "husky": ">=1",
     "jest": "^24.0.0",
     "jest-junit": "^6.1.0",
+    "lint-staged": ">=8",
     "npm-run-all": "^4.1.2",
+    "prettier": "^1.17.0",
     "rimraf": "^2.6.2",
     "tslint": "^5.11.0",
-    "tslint-language-service": "^0.9.9",
+    "tslint-config-prettier": "^1.18.0",
     "typescript": "3"
   },
   "repository": "https://github.com/sjbarag/brs",
   "jest": {
     "testEnvironment": "node"
+  },
+  "prettier": {
+    "trailingComma": "es5",
+    "tabWidth": 4,
+    "printWidth": 100
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{ts,js}": [
+      "prettier --write",
+      "git add"
+    ]
   }
 }

src/Error.ts

@@ -25,7 +25,9 @@ export class BrsError extends Error {
             }
             formattedLocation = `${location.file}(${location.start.line},${columns})`;
         } else {
-            formattedLocation = `${location.file}(${location.start.line},${location.start.column},${location.end.line},${location.end.line})`;
+            formattedLocation = `${location.file}(${location.start.line},${location.start.column},${
+                location.end.line
+            },${location.end.line})`;
         }
 
         return `${formattedLocation}: ${this.message}`;
@@ -38,18 +40,18 @@ export interface TypeMismatchMetadata {
      * The base message to use for this error. Should be as helpful as possible, e.g.
      * "Attempting to subtract non-numeric values".
      */
-    message: string,
+    message: string;
     /** The value on the left-hand side of a binary operator, or the *only* value for a unary operator. */
-    left: TypeAndLocation,
+    left: TypeAndLocation;
     /** The value on the right-hand side of a binary operator. */
-    right?: TypeAndLocation,
+    right?: TypeAndLocation;
 }
 
 export type TypeAndLocation = {
     /** The type of a value involved in a type mismatch. */
-    type: BrsType | ValueKind,
+    type: BrsType | ValueKind;
     /** The location at which the offending value was resolved. */
-    location: Location
+    location: Location;
 };
 
 /**
@@ -60,13 +62,13 @@ export class TypeMismatch extends BrsError {
     constructor(mismatchMetadata: TypeMismatchMetadata) {
         let messageLines = [
             mismatchMetadata.message,
-            `    left: ${ValueKind.toString(getKind(mismatchMetadata.left.type))}`
+            `    left: ${ValueKind.toString(getKind(mismatchMetadata.left.type))}`,
         ];
         let location = mismatchMetadata.left.location;
 
         if (mismatchMetadata.right) {
             messageLines.push(
-            `    right: ${ValueKind.toString(getKind(mismatchMetadata.right.type))}`
+                `    right: ${ValueKind.toString(getKind(mismatchMetadata.right.type))}`
             );
 
             location.end = mismatchMetadata.right.location.end;
@@ -87,4 +89,4 @@ function getKind(maybeType: BrsType | ValueKind): ValueKind {
     } else {
         return maybeType.kind;
     }
-}
+}

src/brsTypes/BrsType.ts

@@ -13,7 +13,7 @@ export enum ValueKind {
     Uninitialized,
     Dynamic,
     Void,
-    Object
+    Object,
 }
 
 export namespace ValueKind {
@@ -23,18 +23,30 @@ export namespace ValueKind {
      */
     export function toString(kind: ValueKind): string {
         switch (kind) {
-            case ValueKind.Invalid: return "Invalid";
-            case ValueKind.Boolean: return "Boolean";
-            case ValueKind.String: return "String";
-            case ValueKind.Int32: return "Integer";
-            case ValueKind.Int64: return "LongInteger";
-            case ValueKind.Float: return "Float";
-            case ValueKind.Double: return "Double";
-            case ValueKind.Callable: return "Function";
-            case ValueKind.Dynamic: return "Dynamic";
-            case ValueKind.Void: return "Void";
-            case ValueKind.Uninitialized: return "<UNINITIALIZED>";
-            case ValueKind.Object: return "Object";
+            case ValueKind.Invalid:
+                return "Invalid";
+            case ValueKind.Boolean:
+                return "Boolean";
+            case ValueKind.String:
+                return "String";
+            case ValueKind.Int32:
+                return "Integer";
+            case ValueKind.Int64:
+                return "LongInteger";
+            case ValueKind.Float:
+                return "Float";
+            case ValueKind.Double:
+                return "Double";
+            case ValueKind.Callable:
+                return "Function";
+            case ValueKind.Dynamic:
+                return "Dynamic";
+            case ValueKind.Void:
+                return "Void";
+            case ValueKind.Uninitialized:
+                return "<UNINITIALIZED>";
+            case ValueKind.Object:
+                return "Object";
         }
     }
 
@@ -45,19 +57,32 @@ export namespace ValueKind {
      */
     export function fromString(kind: string): ValueKind | undefined {
         switch (kind.toLowerCase()) {
-            case "invalid": return ValueKind.Invalid;
-            case "boolean": return ValueKind.Boolean;
-            case "string": return ValueKind.String;
-            case "integer": return ValueKind.Int32;
-            case "longinteger": return ValueKind.Int64;
-            case "float": return ValueKind.Float;
-            case "double": return ValueKind.Double;
-            case "function": return ValueKind.Callable;
-            case "dynamic": return ValueKind.Dynamic;
-            case "void": return ValueKind.Void;
-            case "<uninitialized>": return ValueKind.Uninitialized;
-            case "object": return ValueKind.Object;
-            default: return undefined;
+            case "invalid":
+                return ValueKind.Invalid;
+            case "boolean":
+                return ValueKind.Boolean;
+            case "string":
+                return ValueKind.String;
+            case "integer":
+                return ValueKind.Int32;
+            case "longinteger":
+                return ValueKind.Int64;
+            case "float":
+                return ValueKind.Float;
+            case "double":
+                return ValueKind.Double;
+            case "function":
+                return ValueKind.Callable;
+            case "dynamic":
+                return ValueKind.Dynamic;
+            case "void":
+                return ValueKind.Void;
+            case "<uninitialized>":
+                return ValueKind.Uninitialized;
+            case "object":
+                return ValueKind.Object;
+            default:
+                return undefined;
         }
     }
 }
@@ -253,9 +278,7 @@ export class Uninitialized implements BrsValue, Comparable {
         if (other.kind === ValueKind.String) {
             // Allow variables to be compared to the string "<UNINITIALIZED>" to test if they've
             // been initialized
-            return BrsBoolean.from(
-                other.value === this.toString()
-            );
+            return BrsBoolean.from(other.value === this.toString());
         }
 
         return BrsBoolean.False;