chore: merge Fix/742 migrate doctest to jest (#749)

* Remove QuickSelect doctest

There are more Jest test cases already.

* Remove AverageMedian doctest

Already migrated to jest

* Migrate doctest for BinaryExponentiationRecursive.js

(also remove inline "main" test method)

* Migrate doctest for EulersTotient.js

(also remove inline "main" test method)

* Migrate doctest for PrimeFactors.js

(also remove inline "main" test method)

* Migrate doctest for BogoSort.js

Re-write prototype-polluting helper methods, too.

(also remove inline test driver code)

* Migrate doctest for BeadSort.js

(also remove inline test driver code)

* Migrate doctest for BucketSort.js

(also remove inline test driver code)

* Migrate doctest for CocktailShakerSort.js

(also remove inline test driver code)

* Migrate doctest for MergeSort.js

(also remove inline test driver code)

* Migrate doctest for QuickSort.js

(also remove inline test driver code)

* Migrate doctest for ReverseString.js

(also remove inline test driver code)

* Migrate doctest for ReverseString.js

* Migrate doctest for ValidateEmail.js

* Migrate doctest for ConwaysGameOfLife.js

(remove the animate code, too)

* Remove TernarySearch doctest

Already migrated to jest

* Migrate doctest for BubbleSort.js

(also remove inline test driver code)

* Remove doctest from CI and from dependencies

relates to #742
fixes #586

* Migrate doctest for RgbHsvConversion.js

* Add --fix option to "standard" npm script

* Migrate doctest for BreadthFirstSearch.js

(also remove inline test driver code)

* Migrate doctest for BreadthFirstShortestPath.js

(also remove inline test driver code)

* Migrate doctest for EulerMethod.js

(also remove inline test driver code)

Move manual test-code for plotting stuff in the browser in a distinct file, too. Those "*.manual-test.js" files are excluded from the UpdateDirectory.mjs script, as well.

* Migrate doctest for Mandelbrot.js

(also remove inline test driver code & moved manual drawing test into a *.manual-test.js)

* Migrate doctest for FloodFill.js

* Migrate doctest for KochSnowflake.js

(also move manual drawing test into a *.manual-test.js)

* Update npm lockfile

* Update README and COMMITTING with a few bits & bobs regarding testing & code quality

Graphs/BreadthFirstSearch.js

@@ -1,20 +1,13 @@
-/*
-Breadth-first search is an algorithm for traversing a graph. It's discovers all nodes reachable from the starting position by exploring all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.
-(description adapted from https://en.wikipedia.org/wiki/Breadth-first_search )
-(see also: https://www.koderdojo.com/blog/breadth-first-search-and-shortest-path-in-csharp-and-net-core )
-*/
-
-/*
-Doctests
-> Array.from(breadthFirstSearch(graph, "C"))
-[ 'C', 'D', 'A', 'B', 'E' ]
-> Array.from(breadthFirstSearch(graph, "A"))
-[ 'A', 'B', 'D', 'E' ]
-> Array.from(breadthFirstSearch(graph, "F"))
-[ 'F', 'G' ]
-*/
-
-function breadthFirstSearch (graph, startingNode) {
+/**
+ * Breadth-first search is an algorithm for traversing a graph.
+ *
+ * It discovers all nodes reachable from the starting position by exploring all of the neighbor nodes at the present
+ * depth prior to moving on to the nodes at the next depth level.
+ *
+ * (description adapted from https://en.wikipedia.org/wiki/Breadth-first_search)
+ * @see https://www.koderdojo.com/blog/breadth-first-search-and-shortest-path-in-csharp-and-net-core
+ */
+export function breadthFirstSearch (graph, startingNode) {
   // visited keeps track of all nodes visited
   const visited = new Set()
 
@@ -39,26 +32,3 @@ function breadthFirstSearch (graph, startingNode) {
 
   return visited
 }
-
-const graph = {
-  A: ['B', 'D'],
-  B: ['E'],
-  C: ['D'],
-  D: ['A'],
-  E: ['D'],
-  F: ['G'],
-  G: []
-}
-/*
-      A <-> B
-      ʌ     |
-      |     |
-      v     v
-C --> D <-- E
-
-F --> G
-*/
-
-console.log(breadthFirstSearch(graph, 'C'))
-console.log(breadthFirstSearch(graph, 'A'))
-console.log(breadthFirstSearch(graph, 'F'))

Graphs/BreadthFirstShortestPath.js

@@ -1,25 +1,13 @@
-/*
-Breadth-first approach can be applied to determine the shortest path between two nodes
-in an equi-weighted graph. It searches the target node among all neighbors of the
-starting node, then the process is repeated on the level of the neighbors of the
-neighbors and so on.
-(See also: https://en.wikipedia.org/wiki/Breadth-first_search )
-(see also: https://www.koderdojo.com/blog/breadth-first-search-and-shortest-path-in-csharp-and-net-core )
-*/
-
-/*
-Doctests
-> breadthFirstShortestPath(graph, 'C', 'E')
-[ 'C', 'D', 'A', 'B', 'E' ]
-> breadthFirstShortestPath(graph, 'E', 'B')
-[ 'E', 'D', 'A', 'B' ]
-> breadthFirstShortestPath(graph, 'F', 'G')
-[ 'F', 'G' ]
-> breadthFirstShortestPath(graph, 'A', 'G')
-[]
-*/
-
-function breadthFirstShortestPath (graph, startNode, targetNode) {
+/**
+ * Breadth-first approach can be applied to determine the shortest path between two nodes in an equi-weighted graph.
+ *
+ * It searches the target node among all neighbors of the starting node, then the process is repeated on the level of
+ * the neighbors of the neighbors and so on.
+ *
+ * @see https://en.wikipedia.org/wiki/Breadth-first_search
+ * @see https://www.koderdojo.com/blog/breadth-first-search-and-shortest-path-in-csharp-and-net-core
+ */
+export function breadthFirstShortestPath (graph, startNode, targetNode) {
   // check if startNode & targetNode are identical
   if (startNode === targetNode) {
     return [startNode]
@@ -62,27 +50,3 @@ function breadthFirstShortestPath (graph, startNode, targetNode) {
   // the target node was not reachable
   return []
 }
-
-const graph = {
-  A: ['B', 'D'],
-  B: ['E'],
-  C: ['D'],
-  D: ['A'],
-  E: ['D'],
-  F: ['G'],
-  G: []
-}
-/*
-      A <-> B
-      ʌ     |
-      |     |
-      v     v
-C --> D <-- E
-
-F --> G
-*/
-
-console.log(breadthFirstShortestPath(graph, 'C', 'E'))
-console.log(breadthFirstShortestPath(graph, 'E', 'B'))
-console.log(breadthFirstShortestPath(graph, 'F', 'G'))
-console.log(breadthFirstShortestPath(graph, 'A', 'G'))

Graphs/test/BreadthFirstSearch.test.js

@@ -0,0 +1,28 @@
+import { breadthFirstSearch } from '../BreadthFirstSearch'
+
+describe('BreadthFirstSearch', () => {
+  const graph = {
+    A: ['B', 'D'],
+    B: ['E'],
+    C: ['D'],
+    D: ['A'],
+    E: ['D'],
+    F: ['G'],
+    G: []
+  }
+  /*
+        A <-> B
+        ʌ     |
+        |     |
+        v     v
+  C --> D <-- E
+
+  F --> G
+  */
+
+  it('should return the visited nodes', () => {
+    expect(Array.from(breadthFirstSearch(graph, 'C'))).toEqual(['C', 'D', 'A', 'B', 'E'])
+    expect(Array.from(breadthFirstSearch(graph, 'A'))).toEqual(['A', 'B', 'D', 'E'])
+    expect(Array.from(breadthFirstSearch(graph, 'F'))).toEqual(['F', 'G'])
+  })
+})

Graphs/test/BreadthFirstShortestPath.test.js

@@ -0,0 +1,29 @@
+import { breadthFirstShortestPath } from '../BreadthFirstShortestPath'
+
+describe('BreadthFirstShortestPath', () => {
+  const graph = {
+    A: ['B', 'D'],
+    B: ['E'],
+    C: ['D'],
+    D: ['A'],
+    E: ['D'],
+    F: ['G'],
+    G: []
+  }
+  /*
+        A <-> B
+        ʌ     |
+        |     |
+        v     v
+  C --> D <-- E
+
+  F --> G
+  */
+
+  it('should return the visited nodes', () => {
+    expect(breadthFirstShortestPath(graph, 'C', 'E')).toEqual(['C', 'D', 'A', 'B', 'E'])
+    expect(breadthFirstShortestPath(graph, 'E', 'B')).toEqual(['E', 'D', 'A', 'B'])
+    expect(breadthFirstShortestPath(graph, 'F', 'G')).toEqual(['F', 'G'])
+    expect(breadthFirstShortestPath(graph, 'A', 'G')).toEqual([])
+  })
+})