up: eslint fixes, prettier integration and LF EOL

Author: ashokdey

.editorconfig

@@ -3,7 +3,6 @@ root = true
 [*]
 indent_style = space
 indent_size = 2
-
 end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true

.eslintrc.json

@@ -1,7 +1,19 @@
 {
+  "env": {
+    "node": true,
+    "jest": true
+  },
   "extends": ["airbnb", "prettier"],
   "plugins": ["prettier"],
   "rules": {
-    "prettier/prettier": ["error"]
+    "prettier/prettier": ["error"],
+    "no-underscore-dangle": "off",
+    "no-param-reassign": "off",
+    "no-console": "warn",
+    "consistent-return": "warn",
+    "max-classes-per-file": "off",
+    "no-bitwise": "warn",
+    "no-restricted-syntax": "warn",
+    "no-continue": "warn"
   }
 }

.gitattributes

@@ -0,0 +1 @@
+* text eol=crlf

.prettierrc.js

@@ -5,4 +5,5 @@ module.exports = {
   printWidth: 120,
   tabWidth: 2,
   arrowParens: 'always',
+  endOfLine: 'lf',
 };

src/_Algorithms_/lru-cache/LRUCache.test.js

@@ -28,21 +28,21 @@ describe('Algorithms: LRU Cache', () => {
         lruCache.set('key1', 'value1');
         lruCache.set('key2', 'value2');
 
-        expect(lruCache.list.head.next.data['key']).toEqual('key2');
-        expect(lruCache.list.head.next.data['value']).toEqual('value2');
+        expect(lruCache.list.head.next.data.key).toEqual('key2');
+        expect(lruCache.list.head.next.data.value).toEqual('value2');
 
         // The least recently used key is moved at the beginning of the list
         lruCache.get('key1');
-        expect(lruCache.list.head.next.data['key']).toEqual('key1');
-        expect(lruCache.list.head.next.data['value']).toEqual('value1');
+        expect(lruCache.list.head.next.data.key).toEqual('key1');
+        expect(lruCache.list.head.next.data.value).toEqual('value1');
       });
     });
 
     describe('set(key, value)', () => {
       it('Should append each <key:value> pair to the beginning of list', () => {
         lruCache.set('foo', 'bar');
-        expect(lruCache.list.head.next.data['key']).toEqual('foo');
-        expect(lruCache.list.head.next.data['value']).toEqual('bar');
+        expect(lruCache.list.head.next.data.key).toEqual('foo');
+        expect(lruCache.list.head.next.data.value).toEqual('bar');
       });
 
       it('Should update value if key already exists', () => {
@@ -59,14 +59,14 @@ describe('Algorithms: LRU Cache', () => {
         lruCache.set('key1', 'value1');
 
         expect(lruCache.list.length()).toEqual(lruCache.size);
-        expect(lruCache.list.head.next.data['key']).toEqual('key1');
-        expect(lruCache.list.head.next.data['value']).toEqual('value1');
-        expect(lruCache.list.head.next.next.data['key']).toEqual('key2');
-        expect(lruCache.list.head.next.next.data['value']).toEqual('value2');
-        expect(lruCache.list.head.next.next.next.data['key']).toEqual('key3');
-        expect(lruCache.list.head.next.next.next.data['value']).toEqual('value3');
-        expect(lruCache.list.head.next.next.next.next.data['key']).toEqual('key4');
-        expect(lruCache.list.head.next.next.next.next.data['value']).toEqual('value4');
+        expect(lruCache.list.head.next.data.key).toEqual('key1');
+        expect(lruCache.list.head.next.data.value).toEqual('value1');
+        expect(lruCache.list.head.next.next.data.key).toEqual('key2');
+        expect(lruCache.list.head.next.next.data.value).toEqual('value2');
+        expect(lruCache.list.head.next.next.next.data.key).toEqual('key3');
+        expect(lruCache.list.head.next.next.next.data.value).toEqual('value3');
+        expect(lruCache.list.head.next.next.next.next.data.key).toEqual('key4');
+        expect(lruCache.list.head.next.next.next.next.data.value).toEqual('value4');
       });
     });
   });

src/_Algorithms_/path-finder/a-star/index.js

@@ -10,7 +10,7 @@ function AStar(s, e, row, col, inputGrid) {
   const start = s;
   const end = e;
 
-  function cell() {
+  function Cell() {
     this.cellValue = null;
     this.parent_i = -1;
     this.parent_j = -1;
@@ -19,7 +19,7 @@ function AStar(s, e, row, col, inputGrid) {
     this.f = Number.MAX_SAFE_INTEGER;
   }
 
-  function pair(i, j, f) {
+  function Pair(i, j, f) {
     this.i = i;
     this.j = j;
     this.f = f;
@@ -30,15 +30,13 @@ function AStar(s, e, row, col, inputGrid) {
   for (let i = 0; i < Row; i += 1) {
     grid[i] = [];
     for (let j = 0; j < Col; j += 1) {
-      grid[i][j] = new cell();
+      grid[i][j] = new Cell();
       grid[i][j].cellValue = inputGrid[i][j];
     }
   }
 
   const isValid = (i, j) => i >= 0 && j >= 0 && i < Row && j < Col;
-
   const isDestination = (i, j) => end.i === i && end.j === j;
-
   const isBlocked = (i, j) => grid[i][j].cellValue === 0;
 
   const euclideanDistance = (i, j) =>
@@ -64,7 +62,7 @@ function AStar(s, e, row, col, inputGrid) {
     }
     path.push([i, j]);
 
-    for (let i = 0; i < path.length; i += 1) {
+    for (let z = 0; z < path.length; z += 1) {
       console.log(path[i]);
     }
   };
@@ -101,7 +99,7 @@ function AStar(s, e, row, col, inputGrid) {
       grid[i][j].h = h;
       grid[i][j].f = g + h;
 
-      const item = new pair(i, j, f);
+      const item = new Pair(i, j, f);
       // can be improved by using Min-Heap DataStructure
       if (!openList.length) {
         openList.push(item);
@@ -123,8 +121,8 @@ function AStar(s, e, row, col, inputGrid) {
       return false;
     }
 
-    let i = start.i;
-    let j = start.j;
+    let { i } = start;
+    let { j } = start;
     const openList = [];
     const openListMap = new Map();
     const closedListMap = new Map();
@@ -135,7 +133,7 @@ function AStar(s, e, row, col, inputGrid) {
     grid[i][j].g = 0;
     grid[i][j].f = 0;
 
-    openList.push(new pair(i, j, 0.0));
+    openList.push(new Pair(i, j, 0.0));
 
     openListMap[[i, j]] = 0;
 

src/_Classics_/caeser_cipher/index.js

@@ -18,44 +18,52 @@ function caesarCipher(str, num) {
   const alphabetsMap = new Map();
 
   for (const index in alphabets) {
-    alphabetsMap[alphabets[index]] = index;
+    if (index) {
+      alphabetsMap[alphabets[index]] = index;
+    }
   }
 
-  for (let index in lowerCaseString) {
-    // get the current character
-    const currentCharacter = lowerCaseString[index];
+  for (const index in lowerCaseString) {
+    if (index) {
+      // get the current character
+      const currentCharacter = lowerCaseString[index];
 
-    // if character is space, add it to the result and continue to next
-    if (currentCharacter === ' ') {
-      result += currentCharacter;
-      continue;
-    }
+      // if character is space, add it to the result and continue to next
+      if (currentCharacter === ' ') {
+        result += currentCharacter;
+        continue;
+      }
 
-    // determine the new index
-    /**
-     * const currentIndex = alphabets.indexOf(currentCharacter);
-     *
-     * With indexOf complexity will be O(n*26)
-     * With Map complexity will be O(n).
-     */
-    const currentIndex = Number(alphabetsMap[currentCharacter]);
-    let newIndex = currentIndex + num;
-
-    // if the index passes 25, restart from 0
-    if (newIndex > totalAlphabets - 1) {
-      newIndex -= totalAlphabets;
-    }
+      // determine the new index
+      /**
+       * const currentIndex = alphabets.indexOf(currentCharacter);
+       *
+       * With indexOf complexity will be O(n*26)
+       * With Map complexity will be O(n).
+       */
+      const currentIndex = Number(alphabetsMap[currentCharacter]);
+      let newIndex = currentIndex + num;
 
-    if (newIndex < 0) {
-      newIndex = totalAlphabets + newIndex;
-    }
+      // if the index passes 25, restart from 0
+      if (newIndex > totalAlphabets - 1) {
+        newIndex -= totalAlphabets;
+      }
+
+      if (newIndex < 0) {
+        newIndex = totalAlphabets + newIndex;
+      }
 
-    // check if the character in original string was upper case
-    if (str[index] === str[index].toUpperCase()) {
-      result += alphabets[newIndex].toUpperCase();
-    } else {
-      result += alphabets[newIndex];
+      // check if the character in original string was upper case
+      if (str[index] === str[index].toUpperCase()) {
+        result += alphabets[newIndex].toUpperCase();
+      } else {
+        result += alphabets[newIndex];
+      }
     }
   }
   return result;
 }
+
+module.exports = {
+  caesarCipher,
+};

src/_Classics_/fibonacci/index.js

@@ -1,10 +1,11 @@
-//The Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21
+// The Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21
 // the algorithm has time complexity of O(n^2), very bad!
 function fibonacci(position) {
   // if position is 1 or 2, the number in fibonacci sequence will be 1
   if (position === 1 || position === 0) {
     return position;
-  } else if (position < 0) {
+  }
+  if (position < 0) {
     throw new Error('Invalid Position');
   }
 
@@ -27,15 +28,16 @@ function fibonacciMemoized(index, cache) {
 
   if (cache[index]) {
     return cache[index];
+  }
+  if (index === 1 || index === 0) {
+    return index;
+  }
+  if (index < 0) {
+    throw new Error('Invalid Position');
   } else {
-    if (index === 1 || index === 0) {
-      return index;
-    } else if (index < 0) {
-      throw new Error('Invalid Position');
-    } else {
-      cache[index] = fibonacciMemoized(index - 1, cache) + fibonacciMemoized(index - 2, cache);
-    }
+    cache[index] = fibonacciMemoized(index - 1, cache) + fibonacciMemoized(index - 2, cache);
   }
+
   return cache[index];
 }
 
@@ -47,7 +49,8 @@ function fibonacciTabular(n) {
   const table = [0, 1];
   if (n === 1 || n === 0) {
     return n;
-  } else if (n < 0) {
+  }
+  if (n < 0) {
     throw new Error('Invalid Position');
   }
   for (let i = 2; i <= n; i += 1) {
@@ -63,3 +66,9 @@ function fibonacciTabular(n) {
 // console.log('--');
 // console.log(`Fib memo - ${fibonacciMemoized(number)}`);
 // console.log(`Fib table - ${fibonacciTabular(number)}`);
+
+module.exports = {
+  fibonacci,
+  fibonacciMemoized,
+  fibonacciTabular,
+};

src/_DataStructures_/LinkedList/reverse-linked-list/reverse-linked-list.test.js

@@ -18,7 +18,7 @@ describe('Reverse a LinkedList', () => {
   });
 
   it('Should return `5`->`4`->`3`->`2`->`1` for the given list', () => {
-    let reversedList = reverseLinkedList(list);
+    const reversedList = reverseLinkedList(list);
     expect(reversedList.data).toEqual('5');
     expect(reversedList.next.data).toEqual('4');
     expect(reversedList.next.next.data).toEqual('3');
@@ -29,7 +29,7 @@ describe('Reverse a LinkedList', () => {
   it('Should return `3`->`2`->`1` after deleting 2 last nodes of the list', () => {
     list.removeFromEnd();
     list.removeFromEnd();
-    let reversedList2 = reverseLinkedList(list);
+    const reversedList2 = reverseLinkedList(list);
     expect(reversedList2.data).toEqual('3');
     expect(reversedList2.next.data).toEqual('2');
     expect(reversedList2.next.next.data).toEqual('1');

src/_DataStructures_/Stack/balanced-parenthesis/index.js

@@ -13,34 +13,35 @@ Output: false
 const Stack = require('../index');
 
 function checkBalancedParenthesis(expression) {
-  let s = new Stack();
-  for (let i = 0; i < expression.length; i++) {
+  const s = new Stack();
+  for (let i = 0; i < expression.length; i += 1) {
     const char = expression[i];
     if (char === '{' || char === '(' || char === '[') {
-      //If current character is a starting bracket (‘(‘ or ‘{‘ or ‘[‘) then push it to stack
+      // If current character is a starting bracket (‘(‘ or ‘{‘ or ‘[‘) then push it to stack
       s.push(char);
     } else {
       if (s.isEmpty()) {
-        //when we have only right parenthesis or brackets in expresion
+        // when we have only right parenthesis or brackets in expresion
         return false;
-      } else if (
+      }
+      if (
         (char === '}' && s.peek() !== '{') ||
         (char === ')' && s.peek() !== '(') ||
         (char === ']' && s.peek() !== '[')
       ) {
         return false;
       }
-      //If the current character is a closing bracket (‘)’ or ‘}’ or ‘]’) then pop it from stack
+      // If the current character is a closing bracket (‘)’ or ‘}’ or ‘]’) then pop it from stack
       s.pop();
     }
   }
   if (s.isEmpty()) {
-    //expression has balanced parenthesis
+    // expression has balanced parenthesis
     return true;
-  } else {
-    return false;
   }
+  return false;
 }
 
-console.log(checkBalancedParenthesis('{()}[]')); //true
-console.log(checkBalancedParenthesis('{()}}')); //false
+module.exports = {
+  checkBalancedParenthesis,
+};