feat(list-different): add list-different functionality

Author: skovy

__tests__/complex.scss.d.ts

@@ -0,0 +1,3 @@
+export const someStyles: string;
+export const nestedClass: string;
+export const nestedAnother: string;

__tests__/core/generate.test.ts

@@ -14,10 +14,11 @@ describe("generate", () => {
 
     await generate(pattern, {
       watch: false,
-      exportType: "named"
+      exportType: "named",
+      listDifferent: false
     });
 
     // Three files should match but one is empty
-    expect(fs.writeFileSync).toBeCalledTimes(2);
+    expect(fs.writeFileSync).toBeCalledTimes(3);
   });
 });

__tests__/core/list-different.test.ts

@@ -0,0 +1,43 @@
+import { listDifferent } from "../../lib/core";
+
+describe("writeFile", () => {
+  let exit: jest.SpyInstance;
+
+  beforeEach(() => {
+    console.log = jest.fn();
+    exit = jest.spyOn(process, "exit").mockImplementation();
+  });
+
+  afterEach(() => {
+    exit.mockRestore();
+  });
+
+  test("logs invalid type definitions and exits with 1", async () => {
+    const pattern = `${__dirname}/../**/*.scss`;
+
+    await listDifferent(pattern, {
+      watch: false,
+      exportType: "named",
+      listDifferent: true
+    });
+
+    expect(exit).toHaveBeenCalledWith(1);
+    expect(console.log).toBeCalledWith(
+      expect.stringContaining(`[INVALID TYPES] Check type definitions for`)
+    );
+    expect(console.log).toBeCalledWith(expect.stringContaining(`invalid.scss`));
+  });
+
+  test("logs nothing and does not exit if all files are valid", async () => {
+    const pattern = `${__dirname}/../**/style.scss`;
+
+    await listDifferent(pattern, {
+      watch: false,
+      exportType: "named",
+      listDifferent: true
+    });
+
+    expect(exit).not.toHaveBeenCalled();
+    expect(console.log).not.toHaveBeenCalled();
+  });
+});

__tests__/core/write-file.test.ts

@@ -16,7 +16,8 @@ describe("writeFile", () => {
 
     await writeFile(testFile, {
       watch: false,
-      exportType: "named"
+      exportType: "named",
+      listDifferent: false
     });
 
     expect(fs.writeFileSync).toBeCalledWith(
@@ -34,7 +35,8 @@ describe("writeFile", () => {
 
     await writeFile(testFile, {
       watch: false,
-      exportType: "named"
+      exportType: "named",
+      listDifferent: false
     });
 
     expect(fs.writeFileSync).not.toBeCalled();

__tests__/invalid.scss

@@ -0,0 +1,3 @@
+.random-class {
+  color: pink;
+}

__tests__/invalid.scss.d.ts

@@ -0,0 +1 @@
+export const nope: string;

__tests__/main.test.ts

@@ -14,11 +14,12 @@ describe("main", () => {
 
     await main(pattern, {
       watch: false,
-      exportType: "named"
+      exportType: "named",
+      listDifferent: false
     });
 
     // Three files should match but one is empty
-    expect(fs.writeFileSync).toBeCalledTimes(2);
+    expect(fs.writeFileSync).toBeCalledTimes(3);
 
     expect(fs.writeFileSync).toBeCalledWith(
       `${__dirname}/complex.scss.d.ts`,

__tests__/style.scss.d.ts

@@ -0,0 +1 @@
+export const someClass: string;

jest.config.js

@@ -1,5 +1,9 @@
 module.exports = {
   preset: "ts-jest",
   testEnvironment: "node",
-  testPathIgnorePatterns: ["<rootDir>/dist/", "<rootDir>/node_modules/"]
+  testPathIgnorePatterns: [
+    "<rootDir>/dist/",
+    "<rootDir>/node_modules/",
+    "(.*).d.ts"
+  ]
 };

lib/cli.ts

@@ -55,6 +55,13 @@ const { _: patterns, ...rest } = yargs
     describe:
       "Watch for added or changed files and (re-)generate the type definitions."
   })
+  .option("listDifferent", {
+    boolean: true,
+    default: false,
+    alias: "l",
+    describe:
+      "List any type definitions that are different than those that would be generated."
+  })
   .option("includePaths", {
     array: true,
     string: true,

lib/core/alerts.ts

@@ -1,9 +1,9 @@
 import chalk from "chalk";
 
-const error = (message: string) => console.log(chalk.red(`[ERROR] ${message}`));
-const warn = (message: string) => console.log(chalk.yellowBright(`${message}`));
-const notice = (message: string) => console.log(chalk.gray(`${message}`));
-const info = (message: string) => console.log(chalk.blueBright(`${message}`));
+const error = (message: string) => console.log(chalk.red(message));
+const warn = (message: string) => console.log(chalk.yellowBright(message));
+const notice = (message: string) => console.log(chalk.gray(message));
+const info = (message: string) => console.log(chalk.blueBright(message));
 const success = (message: string) => console.log(chalk.green(message));
 
 export const alerts = { error, warn, notice, info, success };

lib/core/index.ts

@@ -1,5 +1,6 @@
 export { alerts } from "./alerts";
 export { generate } from "./generate";
+export { listDifferent } from "./list-different";
 export { MainOptions } from "./types";
 export { watch } from "./watch";
 export { writeFile } from "./write-file";

lib/core/list-different.ts

@@ -0,0 +1,61 @@
+import glob from "glob";
+import fs from "fs";
+
+import { alerts } from "./alerts";
+import { MainOptions } from "./types";
+import { fileToClassNames } from "../sass";
+import {
+  classNamesToTypeDefinitions,
+  getTypeDefinitionPath
+} from "../typescript";
+
+export const listDifferent = async (
+  pattern: string,
+  options: MainOptions
+): Promise<void> => {
+  // Find all the files that match the provied pattern.
+  const files = glob.sync(pattern);
+
+  if (!files || !files.length) {
+    alerts.notice("No files found.");
+    return;
+  }
+
+  // Wait for all the files to be checked.
+  await Promise.all(files.map(file => checkFile(file, options))).then(
+    results => {
+      results.includes(false) && process.exit(1);
+    }
+  );
+};
+
+export const checkFile = (
+  file: string,
+  options: MainOptions
+): Promise<boolean> => {
+  return new Promise(resolve =>
+    fileToClassNames(file, options).then(classNames => {
+      const typeDefinition = classNamesToTypeDefinitions(
+        classNames,
+        options.exportType
+      );
+
+      if (!typeDefinition) {
+        // Assume if no type defs are necessary it's fine
+        resolve(true);
+        return;
+      }
+
+      const path = getTypeDefinitionPath(file);
+
+      const content = fs.readFileSync(path, { encoding: "UTF8" });
+
+      if (content === typeDefinition) {
+        resolve(true);
+      } else {
+        alerts.error(`[INVALID TYPES] Check type definitions for ${file}`);
+        resolve(false);
+      }
+    })
+  );
+};

lib/core/types.ts

@@ -3,5 +3,6 @@ import { ExportType } from "../typescript";
 
 export interface MainOptions extends Options {
   exportType: ExportType;
+  listDifferent: boolean;
   watch: boolean;
 }

lib/main.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 
-import { watch, MainOptions, generate } from "./core";
+import { watch, MainOptions, generate, listDifferent } from "./core";
 
 export const main = async (pattern: string, options: MainOptions) => {
   // When the provided pattern is a directory construct the proper glob to find
@@ -19,6 +19,11 @@ export const main = async (pattern: string, options: MainOptions) => {
     pattern = path.resolve(pattern, "**/*.scss");
   }
 
+  if (options.listDifferent) {
+    listDifferent(pattern, options);
+    return;
+  }
+
   if (options.watch) {
     watch(pattern, options);
   } else {