refactor: small changes

Author: TheAlexLichter

src/dtmf.js

@@ -35,15 +35,18 @@ const includesKey = i => ([key]) => i.includes(key)
 
 const getLookup = mode => mode === 'include' ? LOOKUP : getSumOrDiffLookup(mode)
 
-const getSumOrDiffLookup = mode => Object.entries(LOOKUP)
-  .map(([colFrequency, rowObject]) =>
-    Object.entries(rowObject).reduce((acc, cellObject) => mergeObjects(acc, getLookupObject(mode, colFrequency, cellObject)), {}))
-  .reduce(mergeObjects, {})
+const getSumOrDiffLookup = mode => {
+  const getLookupObjectForMode = getLookupObject(mode)
+  return Object.entries(LOOKUP)
+    .map(([colFrequency, rowObject]) => Object.entries(rowObject)
+      .reduce((acc, cellObject) => mergeObjects(acc, getLookupObjectForMode(colFrequency, cellObject)), {}))
+    .reduce(mergeObjects, {})
+}
 
-const getLookupObject = (mode, colFrequency, [rowFrequency, character]) => {
+const getLookupObject = mode => (colFrequency, [rowFrequency, character]) => {
   [rowFrequency, colFrequency] = toNumber(rowFrequency, colFrequency)
 
-  const lookupKey = mode === 'sum' ? rowFrequency + colFrequency : rowFrequency - colFrequency
+  const lookupKey = mode === MODES.sum ? rowFrequency + colFrequency : rowFrequency - colFrequency
   return { [lookupKey]: character }
 }
 
@@ -52,19 +55,21 @@ const encode = (input, options = {}) => {
 
   checkMode(options)
 
+  const encodeResultWithOptions = encodeResult(options)
+
   return [...input].map(i => {
     const result = Object.entries(LOOKUP).map(([key, freqOb]) => {
       const foundFreq = Object.entries(freqOb).find(([, v]) => v === i)
 
-      return foundFreq ? encodeResult([key, foundFreq[0]], options) : false
+      return foundFreq ? encodeResultWithOptions([key, foundFreq[0]]) : false
     }).find(Boolean)
 
     return !result ? throwOrSilent(options, 'Invalid input') : result
   }).join(options.separator)
 }
 
-const encodeResult = (frequencies, { mode, invertedOutput, connector }) => {
-  // If output should be inverted, reverse array
+const encodeResult = ({ mode, invertedOutput, connector }) => frequencies => {
+  // If output should be inverted, reverse array (mutates array)
   if (invertedOutput) {
     frequencies.reverse()
   }
@@ -81,12 +86,12 @@ const encodeResult = (frequencies, { mode, invertedOutput, connector }) => {
 }
 
 const checkMode = ({ mode }) => {
-  if (!TYPES.includes(mode)) {
+  if (!Object.values(MODES).includes(mode)) {
     throw new Error('Unknown mode')
   }
 }
 
-const TYPES = ['include', 'sum', 'diff']
+const MODES = { include: 'include', sum: 'sum', diff: 'diff' }
 
 const DEFAULT_OPTIONS = {
   mode: 'include',

src/fractionatedMorse.js

@@ -5,14 +5,15 @@ export const decode = (input, options = {}) => {
   options = { ...DEFAULT_OPTIONS, ...options }
   const morseOptions = { ...DEFAULT_MORSE_OPTION, ...{ failOnUnknownCharacter: options.failOnUnknownCharacter } }
 
-  let morseCode = [...input].map(c => {
-    const decodedCharacterIndex = options.keyAlphabet.indexOf(c)
-    if (decodedCharacterIndex !== -1) {
-      return ENCODED_ALPHABET[decodedCharacterIndex]
-    }
-
-    return throwOrSilent(options, `Undecodable character ${c}`)
-  })
+  let morseCode = [...input]
+    .map(c => {
+      const decodedCharacterIndex = options.keyAlphabet.indexOf(c)
+      if (decodedCharacterIndex !== -1) {
+        return ENCODED_ALPHABET[decodedCharacterIndex]
+      }
+
+      return throwOrSilent(options, `Undecodable character ${c}`)
+    })
     .join('')
 
     // Remove padding if needed
@@ -38,7 +39,8 @@ export const encode = (input, options = {}) => {
       }
 
       return throwOrSilent(options, `Unencodable character ${c}`)
-    }).join('')
+    })
+    .join('')
 }
 
 const morseCodeFromInput = (input, morseOptions) => {

src/helpers/rotateAndMultiply.js

@@ -18,7 +18,7 @@ const isAllowed = (characterType, allowedTypes) => {
 }
 
 const modifyCharacter = (c, options) => {
-  const asciiOfset = ROTATE_AND_MULTIPLY_ASCII[options.type]
+  const asciiOffset = ROTATE_AND_MULTIPLY_ASCII[options.type]
   const parsedCharacter = parseInt(c, 36) - (options.type === ROTATE_AND_MULTIPLY_TYPES.NUMBER ? 0 : 10)
   const mod = options.type === ROTATE_AND_MULTIPLY_TYPES.NUMBER ? 10 : 26
   const multiplicationKey = options.decode ? modInverse(options.keys[0], mod) : options.keys[0]
@@ -32,7 +32,7 @@ const modifyCharacter = (c, options) => {
     transformedCode += mod
   }
 
-  return String.fromCharCode(asciiOfset + (transformedCode % mod))
+  return String.fromCharCode(asciiOffset + (transformedCode % mod))
 }
 
 const DEFAULT_ROTATE_AND_MULTIPLY_OPTIONS = {
@@ -43,9 +43,10 @@ const DEFAULT_ROTATE_AND_MULTIPLY_OPTIONS = {
   decode: false
 }
 
-const getType = c => (c >= 'a' && c <= 'z') ? ROTATE_AND_MULTIPLY_TYPES.LOWERCASE : (c >= 'A' && c <= 'Z')
-  ? ROTATE_AND_MULTIPLY_TYPES.UPPERCASE : (c >= '0' && c <= '9')
-    ? ROTATE_AND_MULTIPLY_TYPES.NUMBER : ROTATE_AND_MULTIPLY_TYPES.OTHER
+const getType = c => (c >= 'a' && c <= 'z')
+  ? ROTATE_AND_MULTIPLY_TYPES.LOWERCASE : (c >= 'A' && c <= 'Z')
+    ? ROTATE_AND_MULTIPLY_TYPES.UPPERCASE : (c >= '0' && c <= '9')
+      ? ROTATE_AND_MULTIPLY_TYPES.NUMBER : ROTATE_AND_MULTIPLY_TYPES.OTHER
 
 export const ROTATE_AND_MULTIPLY_TYPES = {
   UPPERCASE: 1,

src/manchester.js

@@ -5,7 +5,7 @@ const decode = (input, options = {}) => {
 
   if (input.match(/[^01]/g)) {
     throwOrSilent(options, 'Invalid Input')
-    input = [...input].filter(c => '01'.includes(c)).join('')
+    input = [...input].filter(c => /[01]/.test(c)).join('')
   }
 
   if (input.length % 2) {

src/multiTap.js

@@ -28,33 +28,30 @@ export const decode = (input, options = {}) => {
     if (options.failOnUnknownCharacter) {
       throw Error(`Undecodable characters`)
     }
-
-    input.replace(invalidInputRegex)
   }
 
   if (!input.length) {
     return ''
   }
 
-  const capturedInput = options.exponentForm ? input.match(exponentFormRegex) : input.match(normalFormRegex)
+  const capturedInput = input.match(options.exponentForm ? exponentFormRegex : normalFormRegex)
 
-  return capturedInput.map(expr => {
-    expr = expr.replace(/ /g, '')
+  return capturedInput.map(expression => {
+    expression = expression.replace(/ /g, '')
     /*
      * Retrieve the letter from the lookup object.
      * In exponent form use the number as key and get the letter on the exponent index
      * In "normal form" use the number as key as well, but determine the latter based on the length of the expression
      * Subtract one because array indices start at 0
      */
-    const cellIdentifier = (options.exponentForm ? expr[2] : expr.length) - 1
-    return alphabet[expr[0]][cellIdentifier]
+    const cellIdentifier = (options.exponentForm ? expression[2] : expression.length) - 1
+    return alphabet[expression[0]][cellIdentifier]
   }).join('')
 }
 
-const alphabetWithSpaceKey = customMapping =>
-  customMapping && typeof customMapping === 'object'
-    ? mergeObjects(ALPHABET, customMapping)
-    : ALPHABET
+const alphabetWithSpaceKey = customMapping => customMapping && typeof customMapping === 'object'
+  ? mergeObjects(ALPHABET, customMapping)
+  : ALPHABET
 
 const DEFAULT_OPTIONS = {
   customMapping: {

src/pollux.js

@@ -1,4 +1,3 @@
-/* eslint-disable no-unused-vars */
 import morse from './morse'
 import { randomInRange } from './helpers'
 

src/polybius.js

@@ -44,7 +44,8 @@ const decode = (input, options = {}) => {
   const grid = prepareGridString(options)
   let squareSize = options.withNumbers ? 6 : 5
 
-  return input.split(' ')
+  return input
+    .split(' ')
     .map(sequence => {
       if (!sequence.match(/\d{2}/)) {
         return errorExpression(sequence, options)
@@ -65,9 +66,10 @@ const DEFAULT_OPTIONS = {
   omitUnknownCharacter: true
 }
 
-const prepareGridString = options =>
-  [...options.key.toUpperCase(), ...getAlphabet(options)]
-    .reduce((acc, letter) => !acc.includes(letter) ? acc.concat(letter) : acc)
+const prepareGridString = options => [
+  ...options.key.toUpperCase(),
+  ...getAlphabet(options)
+].reduce((acc, letter) => !acc.includes(letter) ? acc.concat(letter) : acc)
 
 const getAlphabet = options => {
   const [substitute, toReplace] = [...options.equalLetters]

test/multiTap.test.js

@@ -85,6 +85,6 @@ describe('decoding', () => {
   })
 
   test('with invalid characters and silent fail', () => {
-    expect(multiTap.decode('$2', silentFailOptions)).toBe('A')
+    expect(multiTap.decode('$€2%^&', silentFailOptions)).toBe('A')
   })
 })