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(), ".monorepolint.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/__tests__/shouldSkipPackage.spec.ts

@@ -1,3 +1,10 @@
+/*!
+ * Copyright (c) 2018 monorepolint (http://monorepolint.com). All Right Reserved.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
 /*!
  * Copyright (c) 2018 monorepo-lint (http://monorepo-lint.com). All Right Reserved.
  *
@@ -13,7 +20,7 @@ describe("shouldSkipPackage", () => {
   const resolvedConfig: ResolvedConfig = {
     rules: [],
     verbose: false,
-    fix: false
+    fix: false,
   };
   const workspaceContext = new WorkspaceContext(".", resolvedConfig);
   jest.spyOn(workspaceContext, "getName").mockImplementation(() => "root");
@@ -25,7 +32,7 @@ describe("shouldSkipPackage", () => {
       check: () => true,
       excludePackages: [fooContext.getName(), "other"],
       includePackages: [fooContext.getName()],
-      optionsRuntype: {} as any
+      optionsRuntype: {} as any,
     });
 
     expect(actual).toEqual(true);
@@ -35,7 +42,7 @@ describe("shouldSkipPackage", () => {
     const actual = shouldSkipPackage(fooContext, {
       check: () => true,
       includePackages: [],
-      optionsRuntype: {} as any
+      optionsRuntype: {} as any,
     });
 
     expect(actual).toEqual(true);
@@ -44,7 +51,7 @@ describe("shouldSkipPackage", () => {
   it("should not skip if excludes and includes are omitted", () => {
     const actual = shouldSkipPackage(fooContext, {
       check: () => true,
-      optionsRuntype: {} as any
+      optionsRuntype: {} as any,
     });
 
     expect(actual).toEqual(false);
@@ -53,7 +60,7 @@ describe("shouldSkipPackage", () => {
   it("should skip root by default", () => {
     const actual = shouldSkipPackage(workspaceContext, {
       check: () => true,
-      optionsRuntype: {} as any
+      optionsRuntype: {} as any,
     });
 
     expect(actual).toEqual(true);
@@ -63,7 +70,7 @@ describe("shouldSkipPackage", () => {
     const actual = shouldSkipPackage(workspaceContext, {
       check: () => true,
       excludePackages: ["@foo/*", "other"],
-      optionsRuntype: {} as any
+      optionsRuntype: {} as any,
     });
 
     expect(actual).toEqual(true);
@@ -73,7 +80,7 @@ describe("shouldSkipPackage", () => {
     const actual = shouldSkipPackage(workspaceContext, {
       check: () => true,
       includePackages: ["@foo/*", "other"],
-      optionsRuntype: {} as any
+      optionsRuntype: {} as any,
     });
 
     expect(actual).toEqual(true);

packages/core/src/check.ts

@@ -11,10 +11,7 @@ import { ResolvedConfig, ResolvedRule } 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}`);
@@ -57,18 +54,13 @@ function checkPackage(context: Context) {
  * @param ruleConfig
  */
 export function shouldSkipPackage(context: Context, ruleConfig: ResolvedRule) {
-  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) {
     return true;
   }
 

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);
-      }
+      },
     });
   }
 }