Updates prettier config to 120 and trailing commas

.prettierrc

@@ -1,3 +1,4 @@
 {
-    "printWidth": 80
+    "printWidth": 120,
+    "trailingComma": "es5"
 }

packages/cli/src/index.ts

@@ -26,12 +26,12 @@ export default function run() {
         y
           .option("verbose", {
             count: true,
-            type: "boolean"
+            type: "boolean",
           })
           .option("fix", {
-            type: "boolean"
+            type: "boolean",
           }),
-      handler: handleCheck
+      handler: handleCheck,
     })
     .demandCommand(1, "At least one command required")
     .help()
@@ -47,11 +47,7 @@ interface Args {
 function handleCheck(args: Args) {
   const configPath = path.resolve(process.cwd(), "monorepo-lint.config.ts");
   const config = Config.check(require(configPath));
-  const resolvedConfig = resolveConfig(
-    config,
-    args,
-    findWorkspaceDir(process.cwd())!
-  );
+  const resolvedConfig = resolveConfig(config, args, findWorkspaceDir(process.cwd())!);
 
   if (!check(resolvedConfig, process.cwd())) {
     // tslint:disable-next-line:no-console

packages/core/src/Config.ts

@@ -13,21 +13,20 @@ export const RuleEntry = r.Partial({
   options: r.Unknown,
   excludePackages: r.Array(r.String),
   includePackages: r.Array(r.String),
-  includeWorkspaceRoot: r.Boolean
+  includeWorkspaceRoot: r.Boolean,
 });
 export type RuleEntry = r.Static<typeof RuleEntry>;
 
 export const Config = r.Record({
-  rules: r.Dictionary(RuleEntry)
+  rules: r.Dictionary(RuleEntry),
 });
 export type Config = r.Static<typeof Config>;
 
 export const RuleModule = r.Record({
   check: r.Function,
-  optionsRuntype: r.Unknown
+  optionsRuntype: r.Unknown,
 });
-export interface RuleModule<T extends Runtype = Runtype>
-  extends r.Static<typeof RuleModule> {
+export interface RuleModule<T extends Runtype = Runtype> extends r.Static<typeof RuleModule> {
   check: Checker<T>;
   optionsRuntype: T;
 }
@@ -37,10 +36,7 @@ export interface Options {
   fix: boolean;
 }
 
-export type Checker<T extends Runtype> = (
-  context: Context,
-  args: r.Static<T>
-) => void;
+export type Checker<T extends Runtype> = (context: Context, args: r.Static<T>) => void;
 export type ResolvedRule = RuleModule & RuleEntry;
 export interface ResolvedConfig extends Options {
   readonly rules: ReadonlyArray<ResolvedRule>;

packages/core/src/PackageContext.ts

@@ -70,14 +70,10 @@ export class PackageContext implements Context {
 
     if (this.resolvedConfig.fix && fixer) {
       fixer();
-      this.print(
-        `${chalk.green("Fixed!")} ${chalk.magenta(shortFile)}: ${message}`
-      );
+      this.print(`${chalk.green("Fixed!")} ${chalk.magenta(shortFile)}: ${message}`);
     } else {
       this.setFailed();
-      this.print(
-        `${chalk.red("Error!")} ${chalk.magenta(shortFile)}: ${message}`
-      );
+      this.print(`${chalk.red("Error!")} ${chalk.magenta(shortFile)}: ${message}`);
 
       if (this.resolvedConfig.verbose && longMessage) {
         for (let i = 0; i <= this.depth + 1; i++) {

packages/core/src/check.ts

@@ -11,10 +11,7 @@ import { ResolvedConfig } from "./Config";
 import { Context } from "./Context";
 import { WorkspaceContext } from "./WorkspaceContext";
 
-export function check(
-  resolvedConfig: ResolvedConfig,
-  cwd = process.cwd()
-): boolean {
+export function check(resolvedConfig: ResolvedConfig, cwd = process.cwd()): boolean {
   const workspaceDir = findWorkspaceDir(cwd);
   if (workspaceDir === undefined) {
     throw new Error(`Unable to find a workspace from ${cwd}`);
@@ -40,18 +37,13 @@ function checkPackage(context: Context) {
     console.log(`Starting check against ${context.getName()}`);
   }
   for (const ruleConfig of context.resolvedConfig.rules) {
-    const exclude = (ruleConfig.excludePackages || []).some(a =>
-      minimatch(context.getName(), a)
-    );
+    const exclude = (ruleConfig.excludePackages || []).some(a => minimatch(context.getName(), a));
     const include =
       ruleConfig.includePackages === undefined
         ? true
         : ruleConfig.includePackages.some(a => minimatch(context.getName(), a));
 
-    if (
-      context.getWorkspaceContext() === context &&
-      !ruleConfig.includeWorkspaceRoot
-    ) {
+    if (context.getWorkspaceContext() === context && !ruleConfig.includeWorkspaceRoot) {
       continue;
     }
 

packages/core/src/index.ts

@@ -6,15 +6,7 @@
  */
 
 export { Context, Failure } from "./Context";
-export {
-  Config,
-  RuleModule,
-  Checker,
-  Options,
-  ResolvedConfig,
-  ResolvedRule,
-  RuleEntry
-} from "./Config";
+export { Config, RuleModule, Checker, Options, ResolvedConfig, ResolvedRule, RuleEntry } from "./Config";
 export { check } from "./check";
 export { PackageContext } from "./PackageContext";
 export { WorkspaceContext } from "./WorkspaceContext";

packages/core/src/resolveConfig.ts

@@ -7,63 +7,42 @@
 
 import * as path from "path";
 import { ValidationError } from "runtypes";
-import {
-  Config,
-  Options,
-  ResolvedConfig,
-  ResolvedRule,
-  RuleEntry,
-  RuleModule
-} from "./Config";
+import { Config, Options, ResolvedConfig, ResolvedRule, RuleEntry, RuleModule } from "./Config";
 
-export function resolveConfig(
-  config: Config,
-  options: Options,
-  workspaceRootDir: string
-): ResolvedConfig {
+export function resolveConfig(config: Config, options: Options, workspaceRootDir: string): ResolvedConfig {
   try {
     return {
       ...options,
       rules: Object.entries(config.rules).map(([type, ruleEntry]) => ({
         ...ruleEntry,
-        ...resolveRule(type, workspaceRootDir, ruleEntry)
-      }))
+        ...resolveRule(type, workspaceRootDir, ruleEntry),
+      })),
     };
   } catch (err) {
     if (err instanceof ValidationError) {
       // tslint:disable-next-line:no-console
-      console.error(
-        `Failed to parse config for key '${err.key}':`,
-        err.message,
-        err
-      );
+      console.error(`Failed to parse config for key '${err.key}':`, err.message, err);
     }
     return process.exit(10);
   }
 }
 
-function resolveRule(
-  type: string,
-  workspaceRootDir: string,
-  ruleEntry: RuleEntry
-): ResolvedRule {
+function resolveRule(type: string, workspaceRootDir: string, ruleEntry: RuleEntry): ResolvedRule {
   const ruleModule = loadRuleModule(type, workspaceRootDir);
 
   try {
     ruleModule.optionsRuntype.check(ruleEntry.options);
 
     const ret: ResolvedRule = {
       ...ruleModule,
-      ...ruleEntry
+      ...ruleEntry,
     };
 
     return ret;
   } catch (err) {
     if (err instanceof ValidationError) {
       // tslint:disable:no-console
-      console.error(
-        `Failed to validate the configuration for the rule '${type}'`
-      );
+      console.error(`Failed to validate the configuration for the rule '${type}'`);
       console.group();
       console.error("Recieved:", ruleEntry.options);
       console.error("Error Message:", err.message);

packages/rule-alphabetical-dependencies/src/alphabeticalDependencies.ts

@@ -18,13 +18,10 @@ export default {
     checkAlpha(context, "devDependencies");
     checkAlpha(context, "peerDependencies");
   },
-  optionsRuntype: Options
+  optionsRuntype: Options,
 } as RuleModule<typeof Options>;
 
-function checkAlpha(
-  context: Context,
-  block: "dependencies" | "devDependencies" | "peerDependencies"
-) {
+function checkAlpha(context: Context, block: "dependencies" | "devDependencies" | "peerDependencies") {
   const packageJson = context.getPackageJson();
   const packagePath = context.getPackageJsonPath();
 
@@ -52,7 +49,7 @@ function checkAlpha(
         const newPackageJson = { ...packageJson };
         newPackageJson[block] = expectedDependencies;
         writeJson(packagePath, newPackageJson);
-      }
+      },
     });
   }
 }

packages/rule-banned-dependencies/src/bannedDependencies.ts

@@ -11,21 +11,18 @@ import diff from "jest-diff";
 import * as r from "runtypes";
 
 export const Options = r.Record({
-  bannedDependencies: r.Array(r.String)
+  bannedDependencies: r.Array(r.String),
 });
 export type Options = r.Static<typeof Options>;
 const ruleModule: RuleModule<typeof Options> = {
-  check: function expectAlphabeticalDependencies(
-    context: Context,
-    opts: Options
-  ) {
+  check: function expectAlphabeticalDependencies(context: Context, opts: Options) {
     const { bannedDependencies } = opts;
 
     checkBanned(context, bannedDependencies, "dependencies");
     checkBanned(context, bannedDependencies, "devDependencies");
     checkBanned(context, bannedDependencies, "peerDependencies");
   },
-  optionsRuntype: Options
+  optionsRuntype: Options,
 };
 export default ruleModule;
 
@@ -51,10 +48,7 @@ function checkBanned(
     }
   }
 
-  if (
-    Object.keys(expectedDependencies).length !==
-    Object.keys(dependencies).length
-  ) {
+  if (Object.keys(expectedDependencies).length !== Object.keys(dependencies).length) {
     context.addError({
       file: packagePath,
       message: `Banned depdendencies in ${block} in package.json`,
@@ -63,7 +57,7 @@ function checkBanned(
         const newPackageJson = { ...packageJson };
         newPackageJson[block] = expectedDependencies;
         writeJson(packagePath, newPackageJson);
-      }
+      },
     });
   }
 }

packages/rule-consistent-dependencies/src/consistentDependencies.ts

@@ -19,13 +19,10 @@ export default {
     checkDeps(context, "devDependencies");
     // we don't check peer deps since they can be more lenient
   },
-  optionsRuntype: Options
+  optionsRuntype: Options,
 } as RuleModule<typeof Options>;
 
-function checkDeps(
-  context: Context,
-  block: "dependencies" | "devDependencies" | "peerDependencies"
-) {
+function checkDeps(context: Context, block: "dependencies" | "devDependencies" | "peerDependencies") {
   const packageJson = context.getPackageJson();
   const packagePath = context.getPackageJsonPath();
   const dependencies = packageJson[block];
@@ -39,7 +36,7 @@ function checkDeps(
 
   const expectedDependencies = {
     ...dependencies,
-    ...filterKeys(workspaceDependencies, dependencies)
+    ...filterKeys(workspaceDependencies, dependencies),
   };
 
   if (JSON.stringify(dependencies) !== JSON.stringify(expectedDependencies)) {
@@ -51,15 +48,12 @@ function checkDeps(
         const newPackageJson = { ...packageJson };
         newPackageJson[block] = expectedDependencies;
         writeJson(packagePath, newPackageJson);
-      }
+      },
     });
   }
 }
 
-function filterKeys(
-  ob: Record<string, string>,
-  filterOb: Record<string, string>
-) {
+function filterKeys(ob: Record<string, string>, filterOb: Record<string, string>) {
   const newOb: Record<string, any> = {};
 
   for (const key of Object.keys(filterOb)) {

packages/rule-file-contents/src/fileContents.ts

@@ -17,21 +17,21 @@ const Options = r.Union(
     file: r.String,
     generator: r.Function,
     template: r.Undefined,
-    templateFile: r.Undefined
+    templateFile: r.Undefined,
   }),
 
   r.Record({
     file: r.String,
     generator: r.Undefined,
     template: r.String,
-    templateFile: r.Undefined
+    templateFile: r.Undefined,
   }),
 
   r.Record({
     file: r.String,
     generator: r.Undefined,
     template: r.Undefined,
-    templateFile: r.String
+    templateFile: r.String,
   })
 );
 
@@ -43,9 +43,7 @@ export default {
     const generator = getGenerator(context, opts);
     const expectedContent = generator(context);
 
-    const actualContent = fs.existsSync(fullPath)
-      ? fs.readFileSync(fullPath, "utf-8")
-      : undefined;
+    const actualContent = fs.existsSync(fullPath) ? fs.readFileSync(fullPath, "utf-8") : undefined;
 
     if (actualContent !== expectedContent) {
       context.addError({
@@ -58,11 +56,11 @@ export default {
           } else {
             fs.writeFileSync(fullPath, expectedContent);
           }
-        }
+        },
       });
     }
   },
-  optionsRuntype: Options
+  optionsRuntype: Options,
 } as RuleModule<typeof Options>;
 
 function getGenerator(context: Context, opts: Options) {