feat: Add Wolfenbuetteler code

Author: TheAlexLichter

README.md

@@ -53,6 +53,7 @@ console.log(rot('Hello world!'))
 - Manchester code
 - DTMF
 - Base64 (with unicode support!)
+- Wolfenbuetteler code
 
 ## Contributing
 

docs/ciphers/wolfenbuetteler.md

@@ -0,0 +1,67 @@
+# Wolfenbuetteler code
+
+> The Wolfenbuetteler code was invented in 1433. Thus, the cipher isn't overly complex.
+  It is a simple substitution of vocals by the letters M, K, D, T and H.
+
+## Cipher behavior information
+
+* Case sensitive? ✓❌ (not by default, but only uppercase can be enabled)
+* Deterministic? ✓
+* Alphabet: **All characters, even unicode**
+* Characters not in alphabet will be: N/A
+
+## Default options object
+
+```
+const options = {
+  onlyUppercase: false // Should the code transform only uppercase letters?
+}
+```
+
+## Usage
+
+### Encoding
+
+#### Default
+
+```
+import { wolfenbuetteler } from 'cipher-collection'
+
+
+console.log(wolfenbuetteler('EXAMPLE✓')) // KXMAPLK✓
+console.log(wolfenbuetteler('EXamPLE✓')) // KXmaPLK✓
+```
+
+#### Only uppercase
+
+```
+import { wolfenbuetteler } from 'cipher-collection'
+
+const onlyUpperCaseOptions = { onlyUpperCase: true }
+
+console.log(wolfenbuetteler('EXAMPLE✓', onlyUpperCaseOptions)) // KXMAPLK✓
+console.log(wolfenbuetteler('EXamPLE✓', onlyUpperCaseOptions)) // KXamPLK✓
+```
+
+### Decoding
+
+#### Default
+
+```
+import { wolfenbuetteler } from 'cipher-collection'
+
+
+console.log(wolfenbuetteler('KXMAPLK✓')) // EXAMPLE✓
+console.log(wolfenbuetteler('KXmaPLK✓')) // EXamPLE✓
+```
+
+#### Only uppercase
+
+```
+import { wolfenbuetteler } from 'cipher-collection'
+
+const onlyUpperCaseOptions = { onlyUpperCase: true }
+
+console.log(wolfenbuetteler('KXMAPLK✓', onlyUpperCaseOptions)) // EXAMPLE✓
+console.log(wolfenbuetteler('KXmaPLK✓', onlyUpperCaseOptions)) // EXmaPLE✓
+```

docs/index.md

@@ -15,4 +15,5 @@
 * [Manchester code](./ciphers/manchester.md)
 * [DTMF](./ciphers/dtmf.md)
 * [Base64](./ciphers/base64.md)
+* [Wolfenbuetteler code](./ciphers/wolfenbuetteler.md)
 

src/helpers.js

@@ -16,3 +16,22 @@ export const throwOrSilent = (options, errorMessage) => {
 }
 
 export const isBrowser = (() => typeof window === 'object')()
+
+export const substitute = (input, options = {}) => {
+  options = { ...DEFAULT_SUBSTITUTE_OPTIONS, ...options }
+
+  const mappingEntries = Object.entries(options.mapping)
+
+  return input.replace(/./g, x => {
+    const transformedEntries = options.caseSensitive ? mappingEntries : mappingEntries.map(([k, v]) => isLowerCase(x) ? [k.toLowerCase(), v.toLowerCase()] : [k.toUpperCase(), v.toUpperCase()])
+    const foundMapping = transformedEntries.find(([k, v]) => k === x || v === x)
+    return !foundMapping ? x : foundMapping[0] === x ? foundMapping[1] : foundMapping[0]
+  })
+}
+
+const isLowerCase = x => x.toLowerCase() === x
+
+const DEFAULT_SUBSTITUTE_OPTIONS = {
+  mapping: {},
+  caseSensitive: true
+}

src/index.js

@@ -5,6 +5,7 @@ import pollux from './pollux'
 import multiTap from './multiTap'
 import dtmf from './dtmf'
 import base64 from './base64'
+import wolfenbuetteler from './wolfenbuetteler'
 
 export default {
   rot,
@@ -13,5 +14,6 @@ export default {
   pollux,
   multiTap,
   dtmf,
-  base64
+  base64,
+  wolfenbuetteler
 }

src/wolfenbuetteler.js

@@ -0,0 +1,16 @@
+import { substitute } from './helpers'
+
+export default (input, options = {}) => substitute(input, retrieveOptions(options))
+
+const retrieveOptions = options => ({
+  mapping: MAPPING,
+  caseSensitive: options.onlyUpperCase
+})
+
+const MAPPING = {
+  'A': 'M',
+  'E': 'K',
+  'I': 'D',
+  'O': 'T',
+  'U': 'H'
+}

test/helpers.test.js

@@ -1,4 +1,4 @@
-import { randomInRange } from 'helpers'
+import { randomInRange, substitute } from 'helpers'
 
 describe('randomInRange', () => {
   test('returns random number in range', () => {
@@ -13,3 +13,29 @@ describe('randomInRange', () => {
     expect(() => { randomInRange(1, 0) }).toThrowError('Min cannot be larger than max')
   })
 })
+
+describe('substitute', () => {
+  const mappingOptions = { mapping: { 'A': 'M' } }
+  const mappingAndCaseInsensitiveOptions = { mapping: { 'A': 'M' }, caseSensitive: false }
+  test('default', () => {
+    expect(substitute('A')).toBe('A')
+  })
+
+  test('with custom mapping', () => {
+    expect(substitute('A', mappingOptions)).toBe('M')
+    expect(substitute('AMAMA', mappingOptions)).toBe('MAMAM')
+
+    expect(substitute('B', mappingOptions)).toBe('B')
+  })
+
+  test('case-insensitive', () => {
+    expect(substitute('Aa', { caseSensitive: false })).toBe('Aa')
+  })
+
+  test('case-insensitive with custom mapping', () => {
+    expect(substitute('Aa', mappingAndCaseInsensitiveOptions)).toBe('Mm')
+    expect(substitute('AMamA', mappingAndCaseInsensitiveOptions)).toBe('MAmaM')
+
+    expect(substitute('B', mappingAndCaseInsensitiveOptions)).toBe('B')
+  })
+})

test/wolfenbuetteler.test.js

@@ -0,0 +1,41 @@
+import wolfenbuetteler from 'wolfenbuetteler'
+
+const example = {
+  cleartext: 'EXAMPLE✓',
+  ciphertext: 'KXMAPLK✓'
+}
+const exampleMixed = {
+  cleartext: 'ExamPLE✓',
+  ciphertext: 'KxmaPLK✓'
+}
+
+const onlyUppercaseOutput = {
+  cleartext: 'ExmaPLE✓',
+  ciphertext: 'KxamPLK✓'
+}
+
+const onlyUppercase = { onlyUpperCase: true }
+
+describe('encoding', () => {
+  test('default', () => {
+    expect(wolfenbuetteler(example.cleartext)).toBe(example.ciphertext)
+    expect(wolfenbuetteler(exampleMixed.cleartext)).toBe(exampleMixed.ciphertext)
+  })
+
+  test('only uppercase', () => {
+    expect(wolfenbuetteler(example.cleartext, onlyUppercase)).toBe(example.ciphertext)
+    expect(wolfenbuetteler(exampleMixed.cleartext, onlyUppercase)).toBe(onlyUppercaseOutput.ciphertext)
+  })
+})
+
+describe('decoding', () => {
+  test('default', () => {
+    expect(wolfenbuetteler(example.ciphertext)).toBe(example.cleartext)
+    expect(wolfenbuetteler(exampleMixed.ciphertext)).toBe(exampleMixed.cleartext)
+  })
+
+  test('only uppercase', () => {
+    expect(wolfenbuetteler(example.ciphertext, onlyUppercase)).toBe(example.cleartext)
+    expect(wolfenbuetteler(exampleMixed.ciphertext, onlyUppercase)).toBe(onlyUppercaseOutput.cleartext)
+  })
+})