Remove overloaded functions

dingosky · dingosky · commit 37d45f716555 · 2017-07-26T21:40:47.000-07:00
Remove use of parameter types and flags to achieve “overload” function names
diff --git a/README.md b/README.md
@@ -202,20 +202,20 @@ Now let's suppose we need to ensure the names of a handful of items are unique.
 
   ```js
   bits = entropy.bits(30, 100000)
-  string = entropy.string(bits, entropy.charSet16, false)
+  string = entropy.string(bits, entropy.charSet16)
   ```
 
   > String: dbf40a6
 
 Using 4 characters:
 
   ```js
-  string = entropy.string(bits, entropy.charSet4, false)
+  string = entropy.string(bits, entropy.charSet4)
   ```
 
   > String: CGCCGTAGGATAT
 
-Okay, we probably wouldn't use 4 characters (and what's up with those characters?), but you get the idea. The [Efficiency](#Efficiency) explains the 3rd argument of `false`.
+Okay, we probably wouldn't use 4 characters (and what's up with those characters?), but you get the idea.
 
 Suppose we have a more extreme need. We want less than a 1 in a trillion chance that 10 billion base 32 strings repeat. Let's see, our risk (trillion) is 10 to the 12th and our total (10 billion) is 10 to the 10th, so:
 
@@ -372,11 +372,11 @@ Compare that to the `entropy-string` scheme. For the example above, slicing off
   
 But there is an even bigger issue with the previous code from a security perspective. `Math.random` *is not a cryptographically strong random number generator*. **_Do not_** use `Math.random` to create strings used for security purposes! This highlights an important point. Strings are only capable of carrying information (entropy); it's the random bytes that actually provide the entropy itself. `entropy-string` automatically generates the necessary bytes needed to create cryptographically strong random strings using the `crypto` library.
 
-However, if you don't need cryptographically strong random strings, you can request `entropy-string` use `Math.random` rather than the `crypto` library by passing in a 3rd argument of `false`:
+However, if you don't need cryptographically strong random strings, you can request `entropy-string` use `Math.random` rather than the `crypto` library by using `entropy.stringRandom`:
 
   ```js
   const entropy = require('entropy-string')
-  let string = entropy.string(80, entropy.charSet32, false)
+  let string = entropy.stringRandom(80, entropy.charSet32)
   ```
   
   > fdRp9Q3rTMF7TdFN
diff --git a/dist/lib/charSet.js b/dist/lib/charSet.js
@@ -63,17 +63,6 @@ var CharSet = function () {
   return CharSet;
 }();
 
-var charSet64 = new CharSet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", _ndx64);
-var charSet32 = new CharSet("2346789bdfghjmnpqrtBDFGHJLMNPQRT", _ndx32);
-var charSet16 = new CharSet("0123456789abcdef", _ndx16);
-var charSet8 = new CharSet("01234567", _ndx8);
-var charSet4 = new CharSet("ATCG", _ndx4);
-var charSet2 = new CharSet("01", _ndx2);
-
-var isValid = function isValid(charSet) {
-  return charSet instanceof CharSet;
-};
-
 var _ndx64 = function _ndx64(chunk, slice, bytes) {
   return _ndxGen(chunk, slice, bytes, 6);
 };
@@ -119,6 +108,17 @@ var _ndxGen = function _ndxGen(chunk, slice, bytes, bitsPerSlice) {
   return ndx;
 };
 
+var charSet64 = new CharSet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", _ndx64);
+var charSet32 = new CharSet("2346789bdfghjmnpqrtBDFGHJLMNPQRT", _ndx32);
+var charSet16 = new CharSet("0123456789abcdef", _ndx16);
+var charSet8 = new CharSet("01234567", _ndx8);
+var charSet4 = new CharSet("ATCG", _ndx4);
+var charSet2 = new CharSet("01", _ndx2);
+
+var isValid = function isValid(charSet) {
+  return charSet instanceof CharSet;
+};
+
 exports.default = {
   charSet64: charSet64,
   charSet32: charSet32,
diff --git a/dist/lib/entropy.js b/dist/lib/entropy.js
@@ -75,14 +75,11 @@ var bitsWithPowers = function bitsWithPowers(tPower, rPower) {
 };
 
 var string = function string(entropy, charSet) {
-  var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-
-  if (!(opt === null || opt instanceof Uint8Array || typeof opt == 'boolean')) {
-    throw new Error('Optional 3rd argument must be either an Uint8Array or a boolean');
-  }
+  return stringWithBytes(entropy, charSet, _cryptoBytes(entropy, charSet));
+};
 
-  var bytes = opt instanceof Uint8Array ? opt : opt === false ? _randomBytes(entropy, charSet) : _cryptoBytes(entropy, charSet);
-  return stringWithBytes(entropy, charSet, bytes);
+var stringRandom = function stringRandom(entropy, charSet) {
+  return stringWithBytes(entropy, charSet, _randomBytes(entropy, charSet));
 };
 
 var stringWithBytes = function stringWithBytes(entropy, charSet, bytes) {
@@ -166,9 +163,8 @@ exports.default = {
   bitsWithRiskPower: bitsWithRiskPower,
   bitsWithPowers: bitsWithPowers,
   string: string,
+  stringRandom: stringRandom,
   stringWithBytes: stringWithBytes,
-  randomString: string,
-  randomStringWithBytes: stringWithBytes,
   bytesNeeded: bytesNeeded,
 
   charSet64: _charSet2.default.charSet64,
diff --git a/example.js b/example.js
@@ -20,7 +20,7 @@ print('\nBase 32 character string with a 1 in a trillion chance of a repeat in 1
 bits = entropy.bitsWithPowers(7, 12)
 print('  ' + entropy.string(bits, entropy.charSet32))
 
-print('\nAs above, but with "my" characters"')
+print('\nAs above, but with "my" base 8 characters')
 entropy.charSet8.use('dingosky')
 print('  ' + entropy.string(bits, entropy.charSet8))
 
diff --git a/lib/entropy.js b/lib/entropy.js
@@ -52,14 +52,12 @@ const bitsWithPowers = (tPower, rPower) => {
   return N
 }
 
-const string = (entropy, charSet, opt = null) => {
-  if ( !( (opt === null) || (opt instanceof Uint8Array) || (typeof opt == 'boolean') ) ) {
-    throw new Error('Optional 3rd argument must be either an Uint8Array or a boolean')
-  }
-  
-  let bytes = (opt instanceof Uint8Array) ? opt :
-      (opt === false) ? _randomBytes(entropy, charSet) : _cryptoBytes(entropy, charSet)
-  return stringWithBytes(entropy, charSet, bytes)
+const string = (entropy, charSet) => {
+  return stringWithBytes(entropy, charSet, _cryptoBytes(entropy, charSet))
+}
+
+const stringRandom = (entropy, charSet) => {
+  return stringWithBytes(entropy, charSet, _randomBytes(entropy, charSet))
 }
 
 const stringWithBytes = (entropy, charSet, bytes) => {
@@ -135,9 +133,8 @@ export default {
   bitsWithRiskPower     : bitsWithRiskPower,
   bitsWithPowers        : bitsWithPowers,
   string                : string,
+  stringRandom          : stringRandom,
   stringWithBytes       : stringWithBytes,
-  randomString          : string,
-  randomStringWithBytes : stringWithBytes,
   bytesNeeded           : bytesNeeded,
 
   charSet64: CharSet.charSet64,
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "entropy-string",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Efficiently generate cryptographically strong random strings of specified entropy from various character sets.",
   "main": "entropy-string.js",
   "directories": {
diff --git a/test/entropy.js b/test/entropy.js
@@ -454,7 +454,7 @@ test('Custom 64 chars', t => {
   try {
     charSet.use('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ9876543210_-')
     let bytes = new Uint8Array([0x9d, 0x99, 0x4e, 0xa5, 0xd2, 0x3f, 0x8c, 0x86, 0x80])
-    let string = entropy.string(72, charSet, bytes)
+    let string = entropy.stringWithBytes(72, charSet, bytes)
                                                
     t.is(string, 'NzLoPDi-JiAa')
   }
@@ -472,7 +472,7 @@ test('Custom 32 chars', t => {
   try {
     charSet.use('2346789BDFGHJMNPQRTbdfghjlmnpqrt')
     let bytes = new Uint8Array([0xd2, 0xe3, 0xe9, 0xda, 0x19, 0x97, 0x52])
-    let string = entropy.string(55, charSet, bytes)
+    let string = entropy.stringWithBytes(55, charSet, bytes)
     t.is(string, 'mHRrbgQlTqF')
   }
   catch(error) {
@@ -488,7 +488,7 @@ test('Custom 16 chars', t => {
   let charSet = entropy.charSet16
   try {
     charSet.use('0123456789ABCDEF')
-    let string = entropy.string(20, charSet, new Uint8Array([0xc7, 0xc9, 0x00]))
+    let string = entropy.stringWithBytes(20, charSet, new Uint8Array([0xc7, 0xc9, 0x00]))
     t.is(string, 'C7C90')
   }
   catch(error) {
@@ -504,7 +504,7 @@ test('Custom 8 chars', t => {
   let charSet = entropy.charSet8
   try {
     charSet.use('abcdefgh')
-    let string = entropy.string(30, charSet, new Uint8Array([0xc7, 0xc9, 0x07, 0xc9]))
+    let string = entropy.stringWithBytes(30, charSet, new Uint8Array([0xc7, 0xc9, 0x07, 0xc9]))
     t.is(string, 'gbheeeahgc')
   }
   catch(error) {
@@ -520,7 +520,7 @@ test('Custom 4 chars', t => {
   let charSet = entropy.charSet4
   try {
     charSet.use('atcg')
-    let string = entropy.string(16, charSet, new Uint8Array([0x20, 0xf1]))
+    let string = entropy.stringWithBytes(16, charSet, new Uint8Array([0x20, 0xf1]))
     t.is(string, 'acaaggat')
   }
   catch(error) {
@@ -536,7 +536,7 @@ test('Custom 2 chars', t => {
   let charSet = entropy.charSet2
   try {
     charSet.use('HT')
-    let string = entropy.string(16, charSet, new Uint8Array([0xe3, 0xe9]))
+    let string = entropy.stringWithBytes(16, charSet, new Uint8Array([0xe3, 0xe9]))
     t.is(string, 'TTTHHHTTTTTHTHHT')
   }
   catch(error) {
@@ -575,16 +575,15 @@ test('No crypto', t => {
 })
 
 const entropyString = (bits, charSet, arr) => {
-  let bytes = Buffer.from(arr)
-  return entropy.string(bits, charSet, bytes)
+  return entropy.stringWithBytes(bits, charSet, Buffer.from(arr))
 }
 
 const entropyStringLength = (bits, charSet) => {
   return entropy.string(bits, charSet).length
 }
 
 const entropyStringLengthNoCrypto = (bits, charSet) => {
-  return entropy.string(bits, charSet, false).length
+  return entropy.stringRandom(bits, charSet).length
 }
 
 const bitsStringLength = (total, risk, charSet) => {

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "entropy-string",`
`3`		`- "version": "1.3.1",`
	`3`	`+ "version": "1.4.0",`
`4`	`4`	`"description": "Efficiently generate cryptographically strong random strings of specified entropy from various character sets.",`
`5`	`5`	`"main": "entropy-string.js",`
`6`	`6`	`"directories": {`