draft

some basic markdown parsing and tests

endosulfan.ts

@@ -0,0 +1,159 @@
+
+export let total_tests: number = 0;
+export let failed_tests: number = 0;
+export let passed_tests: number = 0;
+
+export function test_assert(condition: boolean, test_name: string): boolean {
+  total_tests++;
+  if (condition) {
+    passed_tests++;
+    console.log(`\x1B[32mTEST PASS\x1B[m ${test_name}`);
+    return true;
+  } else {
+    failed_tests++;
+    console.log(`\x1B[31mTEST FAIL\x1B[m ${test_name}`);
+    return false;
+  }
+}
+
+type Difference = {
+  start_index: number,
+  end_index: number,
+};
+
+//items will probably be strings or numbers,
+//but any object that is comparable after a JSON.stringify() should be fine
+export function test_assert_equal(first_item: any, second_item: any, test_name: string, silent?: boolean) {
+  if (typeof first_item !== typeof second_item) {
+    throw Error("Cannot compare two items of different types!");
+  }
+  //if the items are objects (including arrays)
+  if (typeof first_item === "object") {
+    first_item = JSON.stringify(first_item);
+    second_item = JSON.stringify(second_item);
+  }
+  let passed = test_assert(first_item === second_item, test_name);
+  if (!silent && !passed) {
+    //log info for debugging purposes
+    //log both items
+    console.log(`${test_name}:\n${first_item}\n${second_item}`);
+    //log differences (partially effective)
+    //don't log differences if not string
+    if (typeof first_item !== "string") return;
+    //get longest item
+    let longer = first_item.length > second_item.length ? first_item : second_item;
+    //get differrences, only kinda works
+    let differences: Difference[] = [];
+    let offset: number = 0;
+    let dispute_length: number = 0;
+    for (let i=0; i < longer.length; i++) {
+      if (first_item[i] === second_item[i-offset]) {
+        if (i === 9) {
+          console.log(offset)
+        }
+        continue;
+      } else {
+        if (dispute_length > 0) {
+          //last loop
+          if (i === longer.length-1) {
+            dispute_length++;
+            differences.push({
+              start_index: i-dispute_length,
+              end_index: i,
+            });
+            continue;
+          }
+          //see if dispute ends or continues (two characters must match)
+          for (let ii=0; ii < dispute_length; ii++) {
+            //change offset and add difference
+            if (first_item[i] === second_item[i-dispute_length-ii] && first_item[i+1] === second_item[i-dispute_length-ii+1]) {
+              differences.push({
+                start_index: i-dispute_length,
+                end_index: i-1,
+              });
+              offset = dispute_length-ii;
+              dispute_length = 0;
+              break;
+            } else if (first_item[i] === second_item[i-dispute_length+ii] && first_item[i+1] === second_item[i-dispute_length+ii+1]) {
+              differences.push({
+                start_index: i-dispute_length,
+                end_index: i-1,
+              });
+              offset = dispute_length+ii;
+              dispute_length = 0;
+              break;
+            }
+          }
+          if (dispute_length === 0) {
+            //dispute ends
+            continue;
+          }
+        }
+        dispute_length++;
+      }
+      /*
+      if (first_item[i] !== second_item[i]) {
+        if (first_item[i] === second_item[i-offset]) {
+          continue;
+        }
+        //add to differences
+        //if already existing difference, add to it
+        let current_diff = differences.findIndex((diff) => i === diff.end_index+1);
+        if (current_diff !== -1) {
+          differences[current_diff].end_index = i;
+        } else {
+          //create new difference
+          differences.push({
+            start_index: i,
+            end_index: i,
+          });
+        }
+        offset++;
+      }
+      */
+    }
+    //differences not really working right now, only log the first difference
+    differences = differences.length > 0 ? [differences[0]] : [];
+    for (let j=0; j < differences.length; j++) {
+      let diff: Difference = differences[j];
+      let start_i: number = diff.start_index;
+      let end_i: number = diff.end_index;
+      if (diff.start_index === diff.end_index) {
+        console.log(`Difference at index ${start_i}:`);
+        console.log(`${first_item.slice(start_i-2, start_i)}\x1B[30;44m${first_item[start_i]}\x1B[m${first_item.slice(start_i+1,start_i+3)}`);
+        console.log(`${second_item.slice(start_i-2, start_i)}\x1B[30;44m${second_item[start_i]}\x1B[m${second_item.slice(start_i+1,start_i+3)}`);
+      } else {
+        //multi character difference
+        console.log(`Difference at indexes ${start_i} to ${end_i}:`);
+        console.log(`${first_item.slice(start_i-2, start_i)}\x1B[30;44m${first_item.slice(start_i, end_i+1)}\x1B[m${first_item.slice(end_i+1,end_i+3)}`);
+        console.log(`${second_item.slice(start_i-2, start_i)}\x1B[30;44m${second_item.slice(start_i, end_i+1)}\x1B[m${second_item.slice(end_i+1,end_i+3)}`);
+      }
+    }
+  }
+}
+
+export type Warning = {
+  type: string,
+  message: string,
+  line_number?: number,
+};
+
+export type WarningFunction = (input: any) => Warning[];
+
+export function generate_warnings(input: any, warning_function: WarningFunction, ignore_types: string[]) {
+  let warnings: Warning[] = warning_function(input);
+  let ignore_count: number = 0;
+  for (let i=0; i < warnings.length; i++) {
+    let warning: Warning = warnings[i];
+    if (ignore_types.includes(warning.type)) {
+      ignore_count++;
+      continue;
+    }
+    if (warning.line_number) {
+      console.log(`\x1B[33mWarning at ${warning.line_number}:\x1B[m "${warning.message}" (type: ${warning.type})`);
+    } else {
+      console.log(`\x1B[33mWarning:\x1B[m "${warning.message} (type: ${warning.type})"`);
+    }
+  }
+  console.log(`\x1B[33m${warnings.length} warnings (${ignore_count} suppressed)\x1B[m`);
+}