test: parsing non RFC uuid values

.eslintrc.json

@@ -13,6 +13,7 @@
   },
   "parser": "babel-eslint",
   "rules": {
-    "no-var": ["error"]
+    "no-var": ["error"],
+    "curly": ["error", "all"]
   }
 }

src/index.js

@@ -2,3 +2,6 @@ export { default as v1 } from './v1.js';
 export { default as v3 } from './v3.js';
 export { default as v4 } from './v4.js';
 export { default as v5 } from './v5.js';
+export { default as version } from './version.js';
+export { default as validate } from './validate.js';
+export { default as uuidRegex } from './regex.js';

src/regex.js

@@ -0,0 +1,3 @@
+const uuidRegex = /^([0-9a-f]{8}-[0-9a-f]{4}-[1345][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})|((00000000-0000-0000-0000-000000000000))$/i;
+
+export default uuidRegex;

src/uuid-bin.js

@@ -39,8 +39,13 @@ switch (version) {
     assert(name != null, 'v3 name not specified');
     assert(namespace != null, 'v3 namespace not specified');
 
-    if (namespace === 'URL') namespace = v3.URL;
-    if (namespace === 'DNS') namespace = v3.DNS;
+    if (namespace === 'URL') {
+      namespace = v3.URL;
+    }
+
+    if (namespace === 'DNS') {
+      namespace = v3.DNS;
+    }
 
     console.log(v3(name, namespace));
     break;
@@ -53,11 +58,17 @@ switch (version) {
   case 'v5': {
     const name = args.shift();
     let namespace = args.shift();
+
     assert(name != null, 'v5 name not specified');
     assert(namespace != null, 'v5 namespace not specified');
 
-    if (namespace === 'URL') namespace = v5.URL;
-    if (namespace === 'DNS') namespace = v5.DNS;
+    if (namespace === 'URL') {
+      namespace = v5.URL;
+    }
+
+    if (namespace === 'DNS') {
+      namespace = v5.DNS;
+    }
 
     console.log(v5(name, namespace));
     break;

src/v35.js

@@ -1,12 +1,27 @@
 import bytesToUuid from './bytesToUuid.js';
+import validate from './validate.js';
+
+// Int32 to 4 bytes https://stackoverflow.com/a/12965194/3684944
+function numberToBytes(num, bytes, offset) {
+  for (let i = 0; i < 4; ++i) {
+    const byte = num & 0xff;
+    // Fill the 4 bytes right-to-left.
+    bytes[offset + 3 - i] = byte;
+    num = (num - byte) / 256;
+  }
+}
 
 function uuidToBytes(uuid) {
-  // Note: We assume we're being passed a valid uuid string
-  const bytes = [];
+  if (!validate(uuid)) {
+    return [];
+  }
+
+  const bytes = new Array(16);
 
-  uuid.replace(/[a-fA-F0-9]{2}/g, function (hex) {
-    bytes.push(parseInt(hex, 16));
-  });
+  numberToBytes(parseInt(uuid.slice(0, 8), 16), bytes, 0);
+  numberToBytes(parseInt(uuid.slice(9, 13) + uuid.slice(14, 18), 16), bytes, 4);
+  numberToBytes(parseInt(uuid.slice(19, 23) + uuid.slice(24, 28), 16), bytes, 8);
+  numberToBytes(parseInt(uuid.slice(28), 16), bytes, 12);
 
   return bytes;
 }
@@ -28,10 +43,13 @@ export const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
 
 export default function (name, version, hashfunc) {
   function generateUUID(value, namespace, buf, offset) {
-    const off = (buf && offset) || 0;
+    if (typeof value === 'string') {
+      value = stringToBytes(value);
+    }
 
-    if (typeof value === 'string') value = stringToBytes(value);
-    if (typeof namespace === 'string') namespace = uuidToBytes(namespace);
+    if (typeof namespace === 'string') {
+      namespace = uuidToBytes(namespace);
+    }
 
     if (!Array.isArray(value)) {
       throw TypeError('value must be an array of bytes');
@@ -47,12 +65,16 @@ export default function (name, version, hashfunc) {
     bytes[8] = (bytes[8] & 0x3f) | 0x80;
 
     if (buf) {
-      for (let idx = 0; idx < 16; ++idx) {
-        buf[off + idx] = bytes[idx];
+      offset = offset || 0;
+
+      for (let i = 0; i < 16; ++i) {
+        buf[offset + i] = bytes[i];
       }
+
+      return buf;
     }
 
-    return buf || bytesToUuid(bytes);
+    return bytesToUuid(bytes);
   }
 
   // Function#name is not settable on some platforms (#270)

src/v4.js

@@ -12,10 +12,10 @@ function v4(options, buf, offset) {
 
   // Copy bytes to buffer, if provided
   if (buf) {
-    const start = offset || 0;
+    offset = offset || 0;
 
     for (let i = 0; i < 16; ++i) {
-      buf[start + i] = rnds[i];
+      buf[offset + i] = rnds[i];
     }
 
     return buf;

src/validate.js

@@ -0,0 +1,7 @@
+import uuidRegex from './regex.js';
+
+function validate(uuid) {
+  return uuidRegex.test(uuid);
+}
+
+export default validate;

src/version.js

@@ -0,0 +1,11 @@
+import validate from './validate.js';
+
+function version(uuid) {
+  if (validate(uuid)) {
+    return parseInt(uuid.substr(14, 1), 16);
+  }
+
+  return -1;
+}
+
+export default version;

test/unit/v35.test.js

@@ -32,7 +32,9 @@ describe('v5', () => {
   ];
 
   function hashToHex(hash) {
-    if (hash instanceof Buffer) hash = Array.from(hash);
+    if (hash instanceof Buffer) {
+      hash = Array.from(hash);
+    }
     return hash
       .map(function (b) {
         return b.toString(16).padStart(2, '0');
@@ -108,6 +110,19 @@ describe('v5', () => {
     assert.ok(v3('hello.example.com', '00000000-0000-0000-0000-000000000000'));
   });
 
+  test('v3 parsing non RFC uuid values', () => {
+    assert.throws(() => {
+      v3('hello.example.com', '00000000000000000000000000000000');
+    });
+
+    assert.throws(() => {
+      v3(
+        'hello.example.com',
+        '=Y00a-f*v00b*-00c-00d#-p00f\b-00g-00h-####00i^^^-00j*1*2*3&-L00k-\n00l-/00m-----00n-fg000-00p-00r+',
+      );
+    });
+  });
+
   test('v3 namespace buffer validation', () => {
     assert.throws(() => {
       v3('hello.example.com', new Array(15));
@@ -204,6 +219,19 @@ describe('v5', () => {
     assert.ok(v5('hello.example.com', '00000000-0000-0000-0000-000000000000'));
   });
 
+  test('v5 parsing non RFC uuid values', () => {
+    assert.throws(() => {
+      v5('hello.example.com', '00000000000000000000000000000000');
+    });
+
+    assert.throws(() => {
+      v5(
+        'hello.example.com',
+        '=Y00a-f*v00b*-00c-00d#-p00f\b-00g-00h-####00i^^^-00j*1*2*3&-L00k-\n00l-/00m-----00n-fg000-00p-00r+',
+      );
+    });
+  });
+
   test('v5 namespace buffer validation', () => {
     assert.throws(() => {
       v5('hello.example.com', new Array(15));

test/unit/version.test.js

@@ -0,0 +1,18 @@
+import assert from 'assert';
+import version from '../../src/version.js';
+
+describe('version', () => {
+  test('check uuid version', () => {
+    assert.strictEqual(version('00000000-0000-0000-0000-000000000000'), 0);
+
+    assert.strictEqual(version('d9428888-122b-11e1-b85c-61cd3cbb3210'), 1);
+
+    assert.strictEqual(version('109156be-c4fb-41ea-b1b4-efe1671c5836'), 4);
+
+    assert.strictEqual(version('a981a0c2-68b1-35dc-bcfc-296e52ab01ec'), 3);
+
+    assert.strictEqual(version('90123e1c-7512-523e-bb28-76fab9f2f73d'), 5);
+
+    assert.strictEqual(version('invalid uuid string'), -1);
+  });
+});