feat: add ruleset-add command

Author: dastrong-codiga

graphql/queries.js

@@ -27,3 +27,12 @@ export const GET_RULESETS_FOR_CLIENT = gql`
     }
   }
 `;
+
+export const GET_RULESET = gql`
+  query getRuleset($name: String!) {
+    ruleSet(name: $name) {
+      id
+      name
+    }
+  }
+`;

src/addRuleset.js

@@ -0,0 +1,137 @@
+import { writeFile } from "fs/promises";
+import {
+  ACTION_RULESET_ADD,
+  ACTION_TOKEN_ADD,
+  CODIGA_CONFIG_FILE,
+} from "../utils/constants";
+import { readFile, parseYamlFile } from "../utils/file";
+import { getGitDirectory } from "../utils/git";
+import {
+  printCommandSuggestion,
+  printEmptyLine,
+  printFailure,
+  printInfo,
+  printSuggestion,
+} from "../utils/print";
+import { convertRulesetsToString, getRuleset } from "../utils/ruleset";
+
+/**
+ * Creates a codiga.yml file's content with the rulesets given
+ * Note: because this overrides the file, you need to pass any old rulesets that should remain
+ * @param {string[]} rulesets
+ */
+export async function createCodigaYml(codigaFileLocation, rulesets) {
+  if (isTestMode) return;
+  try {
+    await writeFile(codigaFileLocation, convertRulesetsToString(rulesets), {
+      encoding: "utf-8",
+    });
+  } catch (err) {
+    // console.debug(err);
+    printEmptyLine();
+    printFailure(`We were unable to write to: ${codigaFileLocation}`);
+    printSuggestion(
+      " ↳ Please try again and contact us, if the issue persists:",
+      "https://app.codiga.io/support"
+    );
+    printEmptyLine();
+    process.exit(1);
+  }
+}
+
+/**
+ * Handles adding a ruleset to a codiga.yml file
+ * @param {string[]} rulesetNames
+ */
+export async function addRuleset(rulesetNames) {
+  // TODO - change to a prompt when no rulesets are given
+  const rulesetName = rulesetNames[0];
+  if (!rulesetName) {
+    printEmptyLine();
+    printFailure("You need to specify a ruleset to add");
+    printSuggestion(
+      " ↳ You can search for rulesets here:",
+      "https://app.codiga.io/hub/rulesets"
+    );
+    printCommandSuggestion(
+      " ↳ Then follow this command structure:",
+      `${ACTION_RULESET_ADD} <ruleset-name>`
+    );
+    printEmptyLine();
+    process.exit(1);
+  }
+
+  // Check if the ruleset exists before continuing onwards
+  const ruleset = await getRuleset({ name: rulesetName });
+  if (!ruleset) {
+    printEmptyLine();
+    printFailure(
+      "That ruleset either doesn't exist or you lack the permissions to access it"
+    );
+    printCommandSuggestion(
+      " ↳ Ensure you have a Codiga API token set with one of the following commands:",
+      ACTION_TOKEN_ADD
+    );
+    printSuggestion(
+      " ↳ You can find more rulesets here:",
+      "https://app.codiga.io/hub/rulesets"
+    );
+    printEmptyLine();
+    process.exit(1);
+  }
+
+  /**
+   * Get the `codiga.yml` file location and content.
+   * We'll look in the git directory, if it exists.
+   * Otherwise, we'll look in the current directory
+   */
+  const gitDirectory = getGitDirectory();
+  const dir = gitDirectory || process.cwd();
+  const codigaFileLocation = `${dir}/${CODIGA_CONFIG_FILE}`;
+  const codigaFileContent = readFile(codigaFileLocation);
+
+  /**
+   * If we found a `codiga.yml` file, add the rule to it
+   * If we don't find a `codiga.yml` file, create the file and add the rule to it
+   */
+  if (codigaFileContent) {
+    const parsedFile = parseYamlFile(codigaFileContent, codigaFileLocation);
+    const codigaRulesets = parsedFile.rulesets;
+    if (codigaRulesets.includes(rulesetName)) {
+      printEmptyLine();
+      printInfo(
+        `The ruleset (${rulesetName}) already exists in your \`codiga.yml\``
+      );
+      printSuggestion;
+      printEmptyLine();
+      process.exit(1);
+    } else {
+      // adding the new ruleset to the file
+      await createCodigaYml(codigaFileLocation, [
+        ...codigaRulesets,
+        rulesetName,
+      ]);
+      printSuggestion(
+        `We added ${rulesetName} to your codiga.yml file:`,
+        codigaFileLocation
+      );
+      printSuggestion(
+        " ↳ Find more rulesets to add here:",
+        "https://app.codiga.io/hub/rulesets"
+      );
+    }
+  } else {
+    // creating a new codiga.yml with the ruleset here
+    await createCodigaYml(codigaFileLocation, [rulesetName]);
+    printSuggestion(
+      `No codiga.yml file found, so we created one and added ${rulesetName} to it:`,
+      codigaFileLocation
+    );
+    printSuggestion(
+      " ↳ Find more rulesets to add here:",
+      "https://app.codiga.io/hub/rulesets"
+    );
+  }
+
+  process.exit(0);
+}

src/cli.js

@@ -4,6 +4,7 @@ import {
   ACTION_TOKEN_ADD,
   ACTION_TOKEN_CHECK,
   ACTION_TOKEN_DELETE,
+  ACTION_RULESET_ADD,
   OPTION_LANGUAGE,
   OPTION_LOCAL_SHA,
   OPTION_REMOTE_SHA,
@@ -19,6 +20,7 @@ import {
   checkCodigaToken,
   deleteCodigaToken,
 } from "./codigaToken";
+import { addRuleset } from "./addRuleset";
 
 /**
  * Parses the given command into a readable object to execute
@@ -50,6 +52,7 @@ function parseCommand(args) {
         },
       }
     )
+    .command(ACTION_RULESET_ADD, "Add a ruleset to a `codiga.yml` file")
     .help(true).argv;
 
   // format any actions into a single object with default values
@@ -58,6 +61,7 @@ function parseCommand(args) {
     [ACTION_TOKEN_CHECK]: yargV["_"].includes(ACTION_TOKEN_CHECK) || false,
     [ACTION_TOKEN_DELETE]: yargV["_"].includes(ACTION_TOKEN_DELETE) || false,
     [ACTION_GIT_PUSH_HOOK]: yargV["_"].includes(ACTION_GIT_PUSH_HOOK) || false,
+    [ACTION_RULESET_ADD]: yargV["_"].includes(ACTION_RULESET_ADD) || false,
   };
 
   // how many actions were detected in the command ran
@@ -90,10 +94,13 @@ function parseCommand(args) {
     [OPTION_LANGUAGE]: yargV[OPTION_LANGUAGE] || null,
   };
 
+  const parameters = yargV["_"].slice(1);
+
   // the parsed/formatted result
   return {
     action: selectedAction,
     options,
+    parameters,
   };
 }
 
@@ -105,6 +112,7 @@ export async function cli(args) {
       [OPTION_REMOTE_SHA]: remoteSha,
       [OPTION_LANGUAGE]: language,
     },
+    parameters,
   } = parseCommand(args);
 
   switch (action) {
@@ -116,6 +124,8 @@ export async function cli(args) {
       return await deleteCodigaToken();
     case ACTION_GIT_PUSH_HOOK:
       return await checkPush(remoteSha, localSha);
+    case ACTION_RULESET_ADD:
+      return await addRuleset(parameters);
     default:
       return (() => {
         printEmptyLine();

tests/add-ruleset.test.js

@@ -0,0 +1,29 @@
+import { ACTION_RULESET_ADD } from "../utils/constants";
+import { executeCommand } from "./test-utils";
+
+describe("codiga ruleset-add", () => {
+  test("an invalid ruleset name should throw", async () => {
+    // run the command
+    await executeCommand([ACTION_RULESET_ADD, "invalid-ruleset"])
+      .then((output) => {
+        expect(output).toBeUndefined();
+      })
+      .catch(({ stdout }) => {
+        expect(stdout).toMatch(
+          /That ruleset either doesn't exist or you lack the permissions to access it/
+        );
+      });
+  });
+
+  test("a ruleset that's already present should throw", async () => {
+    // run the command
+    await executeCommand([ACTION_RULESET_ADD, "great-ruleset"])
+      .then((output) => {
+        expect(output).toBeUndefined();
+      })
+      .catch(({ stdout }) => {
+        console.log(stdout);
+        expect(stdout).toMatch(/already exists in your/);
+      });
+  });
+});

tests/fixtures/codiga.yml

@@ -1,3 +1,5 @@
 rulesets:
   - react-best-practices
-  - jsx-a11y
+  - jsx-a11y
+  - great-ruleset
+  

tests/fixtures/rulesetMock.js

@@ -0,0 +1,27 @@
+export const mockedRuleset1 = {
+  id: 1,
+  name: "test-ruleset",
+};
+
+export const mockedRuleset2 = {
+  id: 2,
+  name: "great-ruleset",
+};
+
+export const mockedRuleset3 = {
+  id: 3,
+  name: "fantastic-ruleset",
+};
+
+export function getRulesetMock(rulesetName) {
+  switch (rulesetName) {
+    case "test-ruleset":
+      return mockedRuleset1;
+    case "great-ruleset":
+      return mockedRuleset2;
+    case "fantastic-ruleset":
+      return mockedRuleset3;
+    default:
+      return null;
+  }
+}

tests/yaml.test.js

@@ -1,4 +1,5 @@
 import { parseYamlFile } from "../utils/file";
+import { convertRulesetsToString } from "../utils/ruleset";
 import {
   CODIGA_CONFIG_MISSING_RULESETS,
   CODIGA_CONFIG_MISSING_RULESETS_LIST,
@@ -20,3 +21,28 @@ test("parse a valid file accurately", async () => {
     rulesets: ["react-best-practices", "jsx-a11y"],
   });
 });
+
+test("ruleset is converted correctly", () => {
+  const input = ["codiga-ruleset"];
+  const output = "rulesets:\n" + "  - codiga-ruleset\n";
+  expect(convertRulesetsToString(input)).toBe(output);
+});
+
+test("empty strings are removed", () => {
+  const input = ["codiga-ruleset", "", "daniel-ruleset"];
+  const output =
+    "rulesets:\n" + "  - codiga-ruleset\n" + "  - daniel-ruleset\n";
+  expect(convertRulesetsToString(input)).toBe(output);
+});
+
+test("null values are removed", () => {
+  const input = ["codiga-ruleset", "", null];
+  const output = "rulesets:\n" + "  - codiga-ruleset\n";
+  expect(convertRulesetsToString(input)).toBe(output);
+});
+
+test("undefined values are removed", () => {
+  const input = ["codiga-ruleset", "", undefined];
+  const output = "rulesets:\n" + "  - codiga-ruleset\n";
+  expect(convertRulesetsToString(input)).toBe(output);
+});

utils/constants.js

@@ -6,6 +6,7 @@ export const ACTION_TOKEN_ADD = "token-add";
 export const ACTION_TOKEN_CHECK = "token-check";
 export const ACTION_TOKEN_DELETE = "token-delete";
 export const ACTION_GIT_PUSH_HOOK = "git-push-hook";
+export const ACTION_RULESET_ADD = "ruleset-add";
 
 // COMMAND OPTIONS
 export const OPTION_LANGUAGE = "language";

utils/ruleset.js

@@ -0,0 +1,21 @@
+import { GET_RULESET } from "../graphql/queries";
+import { getRulesetMock } from "../tests/fixtures/rulesetMock";
+import { isTestMode } from "../tests/test-utils";
+import { codigaApiFetch } from "./api";
+
+export async function getRuleset({ name }) {
+  try {
+    if (isTestMode) return getRulesetMock(name);
+    const resp = await codigaApiFetch(GET_RULESET, { name });
+    return resp.ruleSet;
+  } catch (err) {
+    return null;
+  }
+}
+
+export function convertRulesetsToString(rulesets) {
+  return `rulesets:\n${rulesets
+    .filter((x) => x)
+    .map((ruleset) => `  - ${ruleset}\n`)
+    .join("")}`;
+}