Merge pull request #3 from codiga/feat/rule-command

ruleset-add command

Author: dastrong-codiga

DEVELOPMENT.md

@@ -12,6 +12,10 @@
 
   ```bash
   npm link
+
+  # if you have the NPM package installed
+  # you'll need to force this link
+  npm link --force
   ```
 
 - You're all set now, open help to see a list of commands

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
+    }
+  }
+`;

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@codiga/cli",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "A Codiga CLI used to integrate Codiga easily in your projects",
   "homepage": "https://github.com/codiga/codiga-cli",
   "repository": {

package.json

@@ -0,0 +1,138 @@
+import { writeFile } from "fs/promises";
+import { isTestMode } from "../tests/test-utils";
+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/addRuleset.js

@@ -1,7 +1,7 @@
 import {
   executeGitCommand,
   findClosestSha,
-  getRootDirectory,
+  getGitDirectoryRequired,
 } from "../utils/git";
 import {
   getRulesetsFromCodigaFile,
@@ -34,6 +34,18 @@ function getChangedFilePaths(remoteSHA, localSHA) {
     remoteSHA,
     localSHA,
   ]);
+  if (!diff) {
+    printEmptyLine();
+    printFailure(
+      `We were unable to get the difference between ${remoteSHA} and ${localSHA}`
+    );
+    printSuggestion(
+      " ↳ Please review your SHAs above and contact support, if needed:",
+      "https://app.codiga.io/support"
+    );
+    printEmptyLine();
+    process.exit(1);
+  }
   return diff.split("\n").filter((s) => s);
 }
 
@@ -90,8 +102,17 @@ export function checkSHAs(remoteShaArg, localShaArg) {
  * @param {string} localSHA
  */
 export async function checkPush(remoteShaArg, localShaArg) {
+  if (!remoteShaArg || !localShaArg) {
+    printFailure("You need to pass in both remote and local SHA values");
+    printSuggestion(
+      " ↳ Refer to our documentation for more info:",
+      "https://doc.codiga.io/docs/cli/#analysis-and-report-issues-between-two-commits"
+    );
+    process.exit(1);
+  }
+
   // ensure that there's a git directory to continue
-  getRootDirectory();
+  getGitDirectoryRequired();
 
   // check and verify the SHA args
   const { remoteSha, localSha } = checkSHAs(remoteShaArg, localShaArg);

src/checkPush.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();

src/cli.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/add-ruleset.test.js

@@ -4,11 +4,15 @@ import { executeCommand } from "./test-utils";
 describe("codiga git-push-hook", () => {
   test("check for same SHAs", async () => {
     // run the command
-    await executeCommand([ACTION_GIT_PUSH_HOOK, "1234", "1234"]).then(
-      (output) => {
-        expect(output).toMatch(/Remote and local SHA are the same/);
-      }
-    );
+    await executeCommand([
+      ACTION_GIT_PUSH_HOOK,
+      "--remote-sha",
+      "1234",
+      "--local-sha",
+      "1234",
+    ]).then((output) => {
+      expect(output).toMatch(/Remote and local SHA are the same/);
+    });
   });
 
   test("check for closest SHA", async () => {

tests/check-push.test.js

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