Fix/742 migrate doctest to jest

.github/workflows/UpdateDirectory.mjs

@@ -76,7 +76,13 @@ function pathsToMarkdown (filePaths) {
 }
 
 // get paths of all .js files - excluding node_modules, the .github folder, tests and config stuff
-globby(['**/*.js', '!(node_modules|.github)/**/*', '!**/*.test.js', '!babel.config.js'])
+globby([
+  '**/*.js',
+  '!(node_modules|.github)/**/*',
+  '!**/*.test.js',
+  '!**/*.manual-test.js',
+  '!babel.config.js'
+])
   // create markdown content
   .then(pathsToMarkdown)
   // write markdown to file

.github/workflows/ci.yml

@@ -15,9 +15,7 @@ jobs:
       run: npm ci
 
     - name: 🧪 Run tests
-      run: |
-        npm run doctest || true # TODO: Add all doctests
-        npm test
+      run: npm test
 
     - name: 💄 Code style
       run: npm run style

CONTRIBUTING.md

@@ -2,33 +2,39 @@
 
 ## Before contributing
 
-Welcome to [TheAlgorithms/Javascript](https://github.com/TheAlgorithms/Javascript)! Before sending your pull requests, make sure that you **read the whole guidelines**. If you have any doubt on the contributing guide, please feel free to [state it clearly in an issue](https://github.com/TheAlgorithms/Javascript/issues/new)
+Welcome to [TheAlgorithms/Javascript](https://github.com/TheAlgorithms/Javascript)! Before sending your pull requests,
+make sure that you **read the whole guidelines**. If you have any doubt on the contributing guide, please feel free to
+[state it clearly in an issue](https://github.com/TheAlgorithms/Javascript/issues/new).
 
 ## Contributing
 
 ### Contributor
 
-We are very happy that you consider implementing algorithms and data structures for others! This repository is referenced and used by learners from around the globe. Being one of our contributors, you agree and confirm that:
+We are very happy that you consider implementing algorithms and data structures for others! This repository is
+referenced and used by learners from around the globe. Being one of our contributors, you agree and confirm that:
 
-- You did your work - plagiarism is not allowed.
-  - Any plagiarized work will not be merged.
-- Your work will be distributed under [GNU License](LICENSE) once your pull request is merged
-- Your submitted work must fulfill our styles and standards
+* You did your work - plagiarism is not allowed.
+    * Any plagiarized work will not be merged.
+* Your work will be distributed under [GNU License](LICENSE) once your pull request is merged.
+* Your submitted work must fulfill our styles and standards.
 
-**New implementation** is welcome! For example, new solutions to a problem, different representations of a graph data structure or algorithm designs with different complexity.
+**New implementation** is welcome! For example, new solutions to a problem, different representations of a graph data
+structure or algorithm designs with different complexity.
 
 **Improving comments** and **writing proper tests** are also highly welcome.
 
 ### Contribution
 
-We appreciate any contribution, from fixing grammar mistakes to implementing complex algorithms. Please read this section if you are contributing to your work.
+We appreciate any contribution, from fixing grammar mistakes to implementing complex algorithms. Please read this
+section if you are contributing to your work.
 
-
-If you submit a pull request that resolves an open issue, please help us to keep our issue list small by adding `fixes: #{$ISSUE_NO}` to your commit message. GitHub will use this tag to auto-close the issue if your PR is merged.
+If you submit a pull request that resolves an open issue, please help us to keep our issue list small by adding
+`fixes: #{$ISSUE_NO}` to your commit message. GitHub will use this tag to auto-close the issue if your PR is merged.
 
 #### What is an Algorithm?
 
 An Algorithm is one or more functions (or classes) that:
+
 * take one or more inputs,
 * perform some internal calculations or data manipulations,
 * return one or more outputs,
@@ -37,66 +43,97 @@ An Algorithm is one or more functions (or classes) that:
 Algorithms should be packaged in a way that would make it easy for readers to put them into larger programs.
 
 Algorithms should:
+
 * have intuitive class and function names that make their purpose clear to readers
 * use JavaScript naming conventions and intuitive variable names to ease comprehension
 * be flexible to take different input values
 * raise JavaScript exceptions (RangeError, etc.) on erroneous input values
 
-Algorithms in this repo should not be how-to examples for existing JavaScript packages.  Instead, they should perform internal calculations or manipulations to convert input values into different output values.  Those calculations or manipulations can use data types, classes, or functions of existing JavaScript packages but each algorithm in this repo should add unique value.
+Algorithms in this repo should not be how-to examples for existing JavaScript packages. Instead, they should perform
+internal calculations or manipulations to convert input values into different output values. Those calculations or
+manipulations can use data types, classes, or functions of existing JavaScript packages but each algorithm in this repo
+should add unique value.
 
 #### File Naming Convention
-  - filenames should use the UpperCamelCase (PascalCase) style.
-  - There should be no spaces in filenames.
- **Example:**`UserProfile.js` is allowed but `userprofile.js`,`Userprofile.js`,`user-Profile.js`,`userProfile.js` are not
+
+* filenames should use the UpperCamelCase (PascalCase) style.
+* There should be no spaces in filenames.
+* **Example:**`UserProfile.js` is allowed but `userprofile.js`,`Userprofile.js`,`user-Profile.js`,`userProfile.js` are
+  not.
 
 #### Testing
 
-Be confident that your code works. When was the last time you committed a code change, your build failed, and half of your app stopped working? Mine was last week. Writing tests for our Algorithms will help us ensure the implementations are air tight even after multiple fixes and code changes.
-We use a NPM package [doctest](https://www.npmjs.com/package/doctest) to add basic testing functionality to our code. Doctests are simple structured comments that evaluate a function and ensure a required result.
+Be confident that your code works. When was the last time you committed a code change, your build failed, and half of
+your app stopped working? Mine was last week. Writing tests for our Algorithms will help us ensure the implementations
+are air tight even after multiple fixes and code changes.
+
+We use [Jest](https://jestjs.io/) to run unit tests on our algorithms. It provides a very readable and expressive way to
+structure your test code.
 
-The implementation of doctest is quite simple. You can easily learn it [here](https://www.npmjs.com/package/doctest).
+It is advised that the algorithm file (module) does not contain any "live" code but rather just exports the function(s)
+needed to execute the algorithm. Your test code can import those function(s), call them with the appropriate parameters
+and inspect the outcome. Example: [RatInAMaze.test.js](Backtracking/tests/RatInAMaze.test.js).
 
-It is advised that you add the Doctests in a multiline comment just after the Algorithm description.
-For Code Structure reference see [this file](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/BubbleSort.js).
+Please refrain from using `console` in your implementation AND test code.
 
-You can run the doctest by using the command
+You can (and should!) run all tests locally before committing your changes:
+
+```shell
+npm test
 ```
-$ doctest MyFile.js  // if that fails, try: npx doctest MyFile.js
+
+If you want save some time and just run a specific test:
+
+```shell
+# this will run any test file where the filename matches "koch"
+npm test -- koch
 ```
 
+You can also start Jest in "watch" mode:
+
+```shell
+npm test -- --watchAll
+```
+
+This will run all tests and watch source and test files for changes. When a change is made, the tests will run again.
+
 #### Coding Style
 
-To maximize the readability and correctness of our code, we require that new submissions follow [JavaScript Standard Style](https://standardjs.com/)
-  - Command to  install JavaScript Standard Style
-    ```
-    $ npm install standard --save-dev
-    ```
-  - Usage
-    ```
-    $ standard MyFile.js  // if that fails, try: npx standard MyFile.js
-    ```
-
-- Use camelCase with the leading character as lowercase for identifier names (variables and functions)
-- Names start with a letter
-- follow code indentation
-  - Always use 2 spaces for indentation of code blocks
-    ```
-    function sumOfArray (arrayOfNumbers) {
-      let sum = 0
-      for (let i = 0; i < arrayOfNumbers.length; i++) {
-        sum += arrayOfNumbers[i]
-      }
-      return (sum)
-    }
-
-    ```
-- Avoid using global variables and avoid '=='
-- Please use 'let' over 'var'
-- Please use 'console.log()'
-- We strongly recommend the use of ECMAScript 6
-- Avoid importing external libraries for basic algorithms. Only use those libraries for complicated algorithms.
-- Most importantly,
-  - **Be consistent in the use of these guidelines when submitting.**
-  - Happy coding!
+To maximize the readability and correctness of our code, we require that new submissions follow the
+[JavaScript Standard Style](https://standardjs.com/).
+
+Before committing, please run
+
+```shell
+npm run style
+```
+
+in order to apply the coding style (where it can be done automatically). If an error is shown, please figure out what's
+wrong, fix it and run standard again.
+
+A few (but not all) of the things to keep in mind:
+
+* Use camelCase with the leading character as lowercase for identifier names (variables and functions)
+* Names start with a letter
+* Follow code indentation: Always use 2 spaces for indentation of code blocks
+```js
+function sumOfArray (arrayOfNumbers) {
+  let sum = 0
+  for (let i = 0; i < arrayOfNumbers.length; i++) {
+    sum += arrayOfNumbers[i]
+  }
+  return (sum)
+}
+```
+* 
+* Avoid using global variables and avoid `==`
+* Please use `let` over `var`
+* Please refrain from using `console.log` or any other console methods
+* **Absolutely** don't use `alert`
+* We strongly recommend the use of ECMAScript 6
+* Avoid importing external libraries for basic algorithms. Only use those libraries for complicated algorithms
+* Most importantly:
+    * **Be consistent in the use of these guidelines when submitting**
+    * Happy coding!
 
 Writer [@itsvinayak](https://github.com/itsvinayak), May 2020.

Cellular-Automata/ConwaysGameOfLife.js

@@ -8,17 +8,10 @@ The Game of Life is a cellular automaton devised by the British mathematician Jo
 (example adapted from https://github.com/TheAlgorithms/Python/blob/master/cellular_automata/conways_game_of_life.py )
 */
 
-/*
-*  Doctests
-*
-*  > newGeneration([[0, 1, 0], [0, 1, 0], [0, 1, 0]])
-*  [ [ 0, 0, 0 ], [ 1, 1, 1 ], [ 0, 0, 0 ] ]
-*/
-
-/*
-*  Generates the next generation for a given state of Conway's Game of Life.
-*/
-function newGeneration (cells) {
+/**
+ * Generates the next generation for a given state of Conway's Game of Life.
+ */
+export function newGeneration (cells) {
   const nextGeneration = []
   for (let i = 0; i < cells.length; i++) {
     const nextGenerationRow = []
@@ -46,45 +39,3 @@ function newGeneration (cells) {
   }
   return nextGeneration
 }
-
-/*
-*  utility function to display a series of generations in the console
-*/
-async function animate (cells, steps) {
-  /*
-  * utility function to print one frame
-  */
-  function printCells (cells) {
-    console.clear()
-    for (let i = 0; i < cells.length; i++) {
-      let line = ''
-      for (let j = 0; j < cells[i].length; j++) {
-        if (cells[i][j] === 1) line += '\u2022'
-        else line += ' '
-      }
-      console.log(line)
-    }
-  }
-
-  printCells(cells)
-
-  for (let i = 0; i < steps; i++) {
-    await new Promise(resolve => setTimeout(resolve, 250)) // sleep
-    cells = newGeneration(cells)
-    printCells(cells)
-  }
-}
-
-// Define glider example
-const glider = [
-  [0, 1, 0, 0, 0, 0, 0, 0],
-  [0, 0, 1, 0, 0, 0, 0, 0],
-  [1, 1, 1, 0, 0, 0, 0, 0],
-  [0, 0, 0, 0, 0, 0, 0, 0],
-  [0, 0, 0, 0, 0, 0, 0, 0],
-  [0, 0, 0, 0, 0, 0, 0, 0],
-  [0, 0, 0, 0, 0, 0, 0, 0],
-  [0, 0, 0, 0, 0, 0, 0, 0]
-]
-
-animate(glider, 16)

Cellular-Automata/ConwaysGameOfLife.test.js

@@ -0,0 +1,8 @@
+import { newGeneration } from './ConwaysGameOfLife'
+
+describe('newGeneration', () => {
+  it('should produce the next generation according to the rules', () => {
+    expect(newGeneration([[0, 1, 0], [0, 1, 0], [0, 1, 0]]))
+      .toEqual([[0, 0, 0], [1, 1, 1], [0, 0, 0]])
+  })
+})