@learnpack/learnpack 2.1.26 → 2.1.28

package/src/utils/audit.ts

@@ -1,12 +1,12 @@
-import { IAuditErrors } from "../models/audit";
-import { IConfigObj } from "../models/config";
-import { ICounter } from "../models/counter";
-import { IFindings } from "../models/findings";
-import { IExercise } from "../models/exercise-obj";
-import { IFrontmatter } from "../models/front-matter";
-import Console from "./console";
-import * as fs from "fs";
-import * as path from "path";
+import { IAuditErrors } from "../models/audit"
+import { IConfigObj } from "../models/config"
+import { ICounter } from "../models/counter"
+import { IFindings } from "../models/findings"
+import { IExercise } from "../models/exercise-obj"
+import { IFrontmatter } from "../models/front-matter"
+import Console from "./console"
+import * as fs from "fs"
+import * as path from "path"
 
 // eslint-disable-next-line
 const fetch = require("node-fetch");
@@ -19,39 +19,39 @@ const isUrl = async (
   errors: IAuditErrors[],
   counter: ICounter
 ) => {
-  const regexUrl = /(https?:\/\/[\w./-]+)/gm;
-  counter.links.total++;
+  const regexUrl = /(https?:\/\/[\w./-]+)/gm
+  counter.links.total++
   if (!regexUrl.test(url)) {
-    counter.links.error++;
+    counter.links.error++
     errors.push({
       exercise: undefined,
       msg: `The repository value of the configuration file is not a link: ${url}`,
-    });
-    return false;
+    })
+    return false
   }
 
-  const res = await fetch(url, { method: "HEAD" });
+  const res = await fetch(url, { method: "HEAD" })
   if (!res.ok) {
-    counter.links.error++;
+    counter.links.error++
     errors.push({
       exercise: undefined,
       msg: `The link of the repository is broken: ${url}`,
-    });
+    })
   }
 
-  return true;
-};
+  return true
+}
 
 const checkForEmptySpaces = (str: string) => {
-  const isEmpty = true;
+  const isEmpty = true
   for (const letter of str) {
     if (letter !== " ") {
-      return false;
+      return false
     }
   }
 
-  return isEmpty;
-};
+  return isEmpty
+}
 
 const checkLearnpackClean = (configObj: IConfigObj, errors: IAuditErrors[]) => {
   if (
@@ -67,9 +67,9 @@ const checkLearnpackClean = (configObj: IConfigObj, errors: IAuditErrors[]) => {
     errors.push({
       exercise: undefined,
       msg: "You have to run learnpack clean command",
-    });
+    })
   }
-};
+}
 
 const findInFile = (types: string[], content: string) => {
   const regex: any = {
@@ -79,13 +79,13 @@ const findInFile = (types: string[], content: string) => {
     markdownLinks: /(\s)+\[.*]\((https?:\/(\/[^)/]+)+\/?)\)/gm,
     url: /(https?:\/\/[\w./-]+)/gm,
     uploadcare: /https:\/\/ucarecdn.com\/(?:.*\/)*([\w./-]+)/gm,
-  };
+  }
 
-  const validTypes = Object.keys(regex);
+  const validTypes = Object.keys(regex)
   if (!Array.isArray(types)) 
-types = [types];
+types = [types]
 
-  const findings: IFindings = {};
+  const findings: IFindings = {}
   type findingsType =
     | "relativeImages"
     | "externalImages"
@@ -95,17 +95,17 @@ types = [types];
 
   for (const type of types) {
     if (!validTypes.includes(type)) 
-throw new Error("Invalid type: " + type);
+throw new Error("Invalid type: " + type)
     else 
-findings[type as findingsType] = {};
+findings[type as findingsType] = {}
   }
 
   for (const type of types) {
-    let m: RegExpExecArray;
+    let m: RegExpExecArray
     while ((m = regex[type].exec(content)) !== null) {
       // This is necessary to avoid infinite loops with zero-width matches
       if (m.index === regex.lastIndex) {
-        regex.lastIndex++;
+        regex.lastIndex++
       }
 
       // The result can be accessed through the `m`-variable.
@@ -116,12 +116,12 @@ findings[type as findingsType] = {};
         absUrl: m[1],
         mdUrl: m[2],
         relUrl: m[6],
-      };
+      }
     }
   }
 
-  return findings;
-};
+  return findings
+}
 
 // This function checks that each of the url's are working.
 const checkUrl = async (
@@ -134,40 +134,40 @@ const checkUrl = async (
   counter: ICounter | undefined
 ) => {
   if (!fs.existsSync(filePath)) 
-return false;
-  const content: string = fs.readFileSync(filePath).toString();
-  const isEmpty = checkForEmptySpaces(content);
+return false
+  const content: string = fs.readFileSync(filePath).toString()
+  const isEmpty = checkForEmptySpaces(content)
   if (isEmpty || !content)
     errors.push({
       exercise: exercise?.title!,
       msg: `This file (${fileName}) doesn't have any content inside.`,
-    });
+    })
 
-  const frontmatter: IFrontmatter = fm(content);
+  const frontmatter: IFrontmatter = fm(content)
   for (const attribute in frontmatter.attributes) {
     if (
       Object.prototype.hasOwnProperty.call(frontmatter.attributes, attribute) &&
       (attribute === "intro" || attribute === "tutorial")
     ) {
-      counter && counter.links.total++;
+      counter && counter.links.total++
       try {
         // eslint-disable-next-line
         let res = await fetch(frontmatter.attributes[attribute], {
           method: "HEAD",
-        });
+        })
         if (!res.ok) {
-          counter && counter.links.error++;
+          counter && counter.links.error++
           errors.push({
             exercise: exercise?.title!,
             msg: `This link is broken (${res.ok}): ${frontmatter.attributes[attribute]}`,
-          });
+          })
         }
       } catch {
-        counter && counter.links.error++;
+        counter && counter.links.error++
         errors.push({
           exercise: exercise?.title,
           msg: `This link is broken: ${frontmatter.attributes[attribute]}`,
-        });
+        })
       }
     }
   }
@@ -176,7 +176,7 @@ return false;
   const findings: IFindings = findInFile(
     ["relativeImages", "externalImages", "markdownLinks"],
     content
-  );
+  )
   type findingsType =
     | "relativeImages"
     | "externalImages"
@@ -185,25 +185,25 @@ return false;
     | "uploadcare";
   for (const finding in findings) {
     if (Object.prototype.hasOwnProperty.call(findings, finding)) {
-      const obj = findings[finding as findingsType];
+      const obj = findings[finding as findingsType]
       // Valdites all the relative path images.
       if (finding === "relativeImages" && Object.keys(obj!).length > 0) {
         for (const img in obj) {
           if (Object.prototype.hasOwnProperty.call(obj, img)) {
             // Validates if the image is in the assets folder.
-            counter && counter.images.total++;
+            counter && counter.images.total++
             const relativePath = path
               .relative(
                 exercise ? exercise.path.replace(/\\/gm, "/") : "./",
                 `${config!.config?.dirPath}/assets/${obj[img].relUrl}`
               )
-              .replace(/\\/gm, "/");
+              .replace(/\\/gm, "/")
             if (relativePath !== obj[img].absUrl.split("?").shift()) {
-              counter && counter.images.error++;
+              counter && counter.images.error++
               errors.push({
                 exercise: exercise?.title,
                 msg: `This relative path (${obj[img].relUrl}) is not pointing to the assets folder.`,
-              });
+              })
             }
 
             if (
@@ -211,11 +211,11 @@ return false;
                 `${config!.config?.dirPath}/assets/${obj[img].relUrl}`
               )
             ) {
-              counter && counter.images.error++;
+              counter && counter.images.error++
               errors.push({
                 exercise: exercise?.title,
                 msg: `The file ${obj[img].relUrl} doesn't exist in the assets folder.`,
-              });
+              })
             }
           }
         }
@@ -223,7 +223,7 @@ return false;
         // Valdites all the aboslute path images.
         for (const img in obj) {
           if (Object.prototype.hasOwnProperty.call(obj, img)) {
-            counter && counter.images.total++;
+            counter && counter.images.total++
             if (
               fs.existsSync(
                 `${config!.config?.dirPath}/assets${obj[img].mdUrl
@@ -236,57 +236,57 @@ return false;
                   exercise ? exercise.path.replace(/\\/gm, "/") : "./",
                   `${config!.config?.dirPath}/assets/${obj[img].mdUrl}`
                 )
-                .replace(/\\/gm, "/");
+                .replace(/\\/gm, "/")
               warnings.push({
                 exercise: exercise?.title,
                 msg: `On this exercise you have an image with an absolute path "${obj[img].absUrl}". We recommend you to replace it by the relative path: "${relativePath}".`,
-              });
+              })
             }
 
             try {
               // eslint-disable-next-line
               let res = await fetch(obj[img].absUrl, {
                 method: "HEAD",
-              });
+              })
               if (!res.ok) {
-                counter && counter.images.error++;
+                counter && counter.images.error++
                 errors.push({
                   exercise: exercise?.title,
                   msg: `This link is broken: ${obj[img].absUrl}`,
-                });
+                })
               }
             } catch {
-              counter && counter.images.error++;
+              counter && counter.images.error++
               errors.push({
                 exercise: exercise?.title,
                 msg: `This link is broken: ${obj[img].absUrl}`,
-              });
+              })
             }
           }
         }
       } else if (finding === "markdownLinks" && Object.keys(obj!).length > 0) {
         for (const link in obj) {
           if (Object.prototype.hasOwnProperty.call(obj, link)) {
-            counter && counter.links.total++;
+            counter && counter.links.total++
             if (!obj[link].mdUrl.includes("twitter")) {
               try {
                 // eslint-disable-next-line
                 let res = await fetch(obj[link].mdUrl, {
                   method: "HEAD",
-                });
+                })
                 if (res.status > 399 && res.status < 500) {
-                  counter && counter.links.error++;
+                  counter && counter.links.error++
                   errors.push({
                     exercise: exercise?.title,
                     msg: `This link is broken: ${obj[link].mdUrl}`,
-                  });
+                  })
                 }
               } catch {
-                counter && counter.links.error++;
+                counter && counter.links.error++
                 errors.push({
                   exercise: exercise?.title,
                   msg: `This link is broken: ${obj[link].mdUrl}`,
-                });
+                })
               }
             }
           }
@@ -295,37 +295,34 @@ return false;
     }
   }
 
-  return true;
-};
+  return true
+}
 
 // This function writes a given file with the given content.
 const writeFile = async (content: string, filePath: string) => {
   try {
-    await fs.promises.writeFile(filePath, content);
+    await fs.promises.writeFile(filePath, content)
   } catch (error) {
     if (error)
       Console.error(
         `We weren't able to write the file in this path "${filePath}".`,
         error
-      );
+      )
   }
-};
+}
 
 // This function checks if there are errors, and show them in the console at the end.
-const showErrors = (
-  errors: IAuditErrors[],
-  counter: ICounter | undefined
-) => {
+const showErrors = (errors: IAuditErrors[], counter: ICounter | undefined) => {
   return new Promise((resolve, reject) => {
     if (errors) {
       if (errors.length > 0) {
-        Console.log("Checking for errors...");
+        Console.log("Checking for errors...")
         for (const [i, error] of errors.entries())
           Console.error(
             `${i + 1}) ${error.msg} ${
               error.exercise ? `(Exercise: ${error.exercise})` : ""
             }`
-          );
+          )
         if (counter) {
           Console.error(
             ` We found ${errors.length} error${
@@ -335,53 +332,53 @@ const showErrors = (
             } link, ${counter.readmeFiles} README files and ${
               counter.exercises
             } exercises.`
-          );
+          )
         } else {
           Console.error(
             ` We found ${errors.length} error${
               errors.length > 1 ? "s" : ""
             } related with the project integrity.`
-          );
+          )
         }
 
-        process.exit(1);
+        process.exit(1)
       } else {
         if (counter) {
           Console.success(
             `We didn't find any errors in this repository among ${counter.images.total} images, ${counter.links.total} link, ${counter.readmeFiles} README files and ${counter.exercises} exercises.`
-          );
+          )
         } else {
-          Console.success(`We didn't find any errors in this repository.`);
+          Console.success(`We didn't find any errors in this repository.`)
         }
 
-        process.exit(0);
+        process.exit(0)
       }
     } else {
-      reject("Failed");
+      reject("Failed")
     }
-  });
-};
+  })
+}
 
 // This function checks if there are warnings, and show them in the console at the end.
 const showWarnings = (warnings: IAuditErrors[]) => {
   return new Promise((resolve, reject) => {
     if (warnings) {
       if (warnings.length > 0) {
-        Console.log("Checking for warnings...");
+        Console.log("Checking for warnings...")
         for (const [i, warning] of warnings.entries())
           Console.warning(
             `${i + 1}) ${warning.msg} ${
               warning.exercise ? `File: ${warning.exercise}` : ""
             }`
-          );
+          )
       }
 
-      resolve("SUCCESS");
+      resolve("SUCCESS")
     } else {
-      reject("Failed");
+      reject("Failed")
     }
-  });
-};
+  })
+}
 
 export default {
   isUrl,
@@ -392,4 +389,4 @@ export default {
   writeFile,
   showErrors,
   showWarnings,
-};
+}

package/src/utils/exercisesQueue.ts

@@ -1,11 +1,11 @@
-import { IConfig } from "../models/config";
-import { IExercise } from "../models/exercise-obj";
-import { ISocket } from "../models/socket";
+import { IConfig } from "../models/config"
+import { IExercise } from "../models/exercise-obj"
+import { ISocket } from "../models/socket"
 
 class Exercise {
-  exercise: IExercise;
+  exercise: IExercise
   constructor(exercise: IExercise) {
-    this.exercise = exercise;
+    this.exercise = exercise
   }
 
   test(sessionConfig: IConfig, config: IConfig, socket: ISocket) {
@@ -13,39 +13,39 @@ class Exercise {
       socket.log(
         "testing",
         `Testing exercise ${this.exercise.slug} using ${this.exercise.language} engine`
-      );
+      )
 
       sessionConfig.runHook("action", {
         action: "test",
         socket,
         configuration: config,
         exercise: this.exercise,
-      });
+      })
     } else {
-      socket.onTestingFinished({ result: "success" });
+      socket.onTestingFinished({ result: "success" })
     }
   }
 }
 
 class ExercisesQueue {
-  exercises: IExercise[];
+  exercises: IExercise[]
   constructor(exercises: any) {
     this.exercises = exercises.map((exercise: IExercise) => {
-      return new Exercise(exercise);
-    });
+      return new Exercise(exercise)
+    })
   }
 
   pop() {
-    return this.exercises.shift();
+    return this.exercises.shift()
   }
 
   isEmpty() {
-    return this.size() === 0;
+    return this.size() === 0
   }
 
   size() {
-    return this.exercises.length;
+    return this.exercises.length
   }
 }
 
-export default ExercisesQueue;
+export default ExercisesQueue