feat: else and else if

Author: Mikadows

src/code-quality/complexity/CyclomaticComplexity.ts

@@ -15,6 +15,7 @@ export class CyclomaticComplexity {
     let cyclomaticComplexity = -1;
 
     tokenizedCode.forEach((token) => {
+      // console.log(`token: ${token}`);
       switch (token) {
         case CodeTokens.FOR:
           cyclomaticComplexity += 1;
@@ -25,6 +26,12 @@ export class CyclomaticComplexity {
         case CodeTokens.IF:
           cyclomaticComplexity += 1;
           break;
+        case CodeTokens.ELSEIF:
+          cyclomaticComplexity += 1;
+          break;
+        case CodeTokens.ELSE:
+          cyclomaticComplexity += 1;
+          break;
         case CodeTokens.CASE:
           cyclomaticComplexity += 1;
           break;
@@ -37,6 +44,7 @@ export class CyclomaticComplexity {
         default:
           break;
       }
+      // console.log(`cyclo: ${cyclomaticComplexity}`);
     });
 
     return cyclomaticComplexity;

src/code-quality/tokenizer/CodeTokenizer.ts

@@ -59,31 +59,36 @@ export class CodeTokenizer {
         ) {
           tokenizedCode.push(CodeTokens.WHILE);
           // If line
-        } else if (
-          trimmedLine.startsWith(languageIdentifier.ifIdentifier()) &&
-          trimmedLine.endsWith(languageIdentifier.endLoopAndCondIdentifier())
-        ) {
+        } else if (languageIdentifier.isIfBlock(trimmedLine)) {
           tokenizedCode.push(CodeTokens.IF);
-          const andOccurrences = CodeTokenizer.numberTokenPresentInLine(
-            languageIdentifier.andIdentifier(),
+          tokenizedCode = CodeTokenizer.getAndOrTokens(
             trimmedLine,
-          );
-          tokenizedCode = CodeTokenizer.pushTokensInTab(
+            languageIdentifier,
             tokenizedCode,
-            CodeTokens.AND,
-            andOccurrences,
           );
 
-          const orOccurrences = CodeTokenizer.numberTokenPresentInLine(
-            languageIdentifier.orIdentifier(),
+          // Else if line
+        } else if (
+          CodeTokenizer.numberTokenPresentInLine(
+            languageIdentifier.elseIfIdentifier(),
             trimmedLine,
-          );
-          tokenizedCode = CodeTokenizer.pushTokensInTab(
+          ) > 0
+        ) {
+          tokenizedCode.push(CodeTokens.ELSEIF);
+          tokenizedCode = CodeTokenizer.getAndOrTokens(
+            trimmedLine,
+            languageIdentifier,
             tokenizedCode,
-            CodeTokens.OR,
-            orOccurrences,
           );
 
+          // Else line
+        } else if (
+          CodeTokenizer.numberTokenPresentInLine(
+            languageIdentifier.elseIdentifier(),
+            trimmedLine,
+          ) > 0
+        ) {
+          tokenizedCode.push(CodeTokens.ELSE);
           // Case line
         } else if (
           trimmedLine.startsWith(languageIdentifier.caseIdentifier()) &&
@@ -102,10 +107,39 @@ export class CodeTokenizer {
           tokenizedCode.push(CodeTokens.LINE);
         }
 
-      console.log(trimmedLine);
+      // console.log(trimmedLine);
     });
 
-    console.log(tokenizedCode);
+    // console.log(tokenizedCode);
+
+    return tokenizedCode;
+  }
+
+  private static getAndOrTokens(
+    line: string,
+    languageIdentifier: CommonLangIdentifiers,
+    tokens: CodeTokens[],
+  ): CodeTokens[] {
+    let tokenizedCode = tokens;
+    const andOccurrences = CodeTokenizer.numberTokenPresentInLine(
+      languageIdentifier.andIdentifier(),
+      line,
+    );
+    tokenizedCode = CodeTokenizer.pushTokensInTab(
+      tokenizedCode,
+      CodeTokens.AND,
+      andOccurrences,
+    );
+
+    const orOccurrences = CodeTokenizer.numberTokenPresentInLine(
+      languageIdentifier.orIdentifier(),
+      line,
+    );
+    tokenizedCode = CodeTokenizer.pushTokensInTab(
+      tokenizedCode,
+      CodeTokens.OR,
+      orOccurrences,
+    );
 
     return tokenizedCode;
   }

src/code-quality/tokenizer/CodeTokens.ts

@@ -7,6 +7,8 @@ export enum CodeTokens {
   WHILE = 'WHILE',
   // conditions
   IF = 'IF',
+  ELSE = 'ELSE',
+  ELSEIF = 'ELSEIF',
   CASE = 'CASE',
   OR = 'OR',
   AND = 'AND',

src/code-quality/tokenizer/identifiers/CommonLangIdentifiers.ts

@@ -35,10 +35,32 @@ export class CommonLangIdentifiers {
     return '//';
   }
 
+  elseIdentifier(): string {
+    return 'else';
+  }
+
+  elseIfIdentifier(): string {
+    return 'else if';
+  }
+
   isFunction(line: string): boolean {
     return (
       line.startsWith(this.functionIdentifier()) &&
       line.endsWith(this.endLoopAndCondIdentifier())
     );
   }
+
+  isIfBlock(line: string): boolean {
+    return (
+      line.startsWith(this.ifIdentifier()) &&
+      line.endsWith(this.endLoopAndCondIdentifier())
+    );
+  }
+
+  isElseBlock(line: string): boolean {
+    return (
+      line.startsWith(this.elseIdentifier()) &&
+      line.endsWith(this.endLoopAndCondIdentifier())
+    );
+  }
 }

src/code-quality/tokenizer/identifiers/CppIdentifiers.ts

@@ -8,7 +8,15 @@ export class CppIdentifiers extends CommonLangIdentifiers {
         line.startsWith('int') ||
         line.startsWith('float') ||
         line.startsWith('double')) &&
-      line.endsWith('{')
+      (line.endsWith('{') || line.endsWith(')')) &&
+      line.split('=').length <= 1
+    );
+  }
+
+  isIfBlock(line: string): boolean {
+    return (
+      super.isIfBlock(line) ||
+      (line.split('if').length >= 2 && line.endsWith(')'))
     );
   }
 }

src/code-quality/tokenizer/identifiers/PythonIdentifiers.ts

@@ -16,4 +16,12 @@ export class PythonIdentifiers extends CommonLangIdentifiers {
   endLoopAndCondIdentifier(): string {
     return ':';
   }
+
+  elseIdentifier(): string {
+    return 'else';
+  }
+
+  elseIfIdentifier(): string {
+    return 'elif';
+  }
 }

src/submissions/submissions.service.ts

@@ -62,13 +62,13 @@ export class SubmissionsService {
       submission.benchmark,
       insertSubmissionDTO.language,
     );
-    // submission.self = submission;
     const tokenizedCode = this.codeTokenizer.tokenize(
       submission.code,
       submission.language,
     );
     submission.cyclomaticComplexity =
       this.cyclomaticComplexity.compute(tokenizedCode);
+    // console.log(cycloComp);
 
     return submission.save();
   }