test: parsing non RFC uuid values

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}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})|((00000000-0000-0000-0000-000000000000))$/i;
+
+export default uuidRegex;

src/v35.js

@@ -1,12 +1,29 @@
 import bytesToUuid from './bytesToUuid.js';
+import validate from './validate.js';
+
+// Int32 to 4 bytes
+function numberToBytes(num, bytes) {
+  const offset = bytes.length;
+  bytes.push(0, 0, 0, 0);
+
+  for (let i = 0; i < 4; ++i) {
+    const byte = num & 0xff;
+    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 = [];
 
-  uuid.replace(/[a-fA-F0-9]{2}/g, function (hex) {
-    bytes.push(parseInt(hex, 16));
-  });
+  if (!validate(uuid)) {
+    return bytes;
+  }
+
+  numberToBytes(parseInt(uuid.slice(0, 8), 16), bytes);
+  numberToBytes(parseInt(uuid.slice(9, 13) + uuid.slice(14, 18), 16), bytes);
+  numberToBytes(parseInt(uuid.slice(19, 23) + uuid.slice(24, 28), 16), bytes);
+  numberToBytes(parseInt(uuid.slice(28), 16), bytes);
 
   return bytes;
 }
@@ -28,8 +45,6 @@ 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 namespace === 'string') namespace = uuidToBytes(namespace);
 
@@ -47,12 +62,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/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

@@ -109,26 +109,24 @@ describe('v5', () => {
   });
 
   test('v3 parsing non RFC uuid values', () => {
-    assert.strictEqual(
+    assert.throws(() => {
       v3(
         'hello.example.com',
         // equal '00000000-0000-0000-0000-000000000000'
         '00000000000000000000000000000000',
-      ),
-      '8ccfd135-fc23-3a10-a477-5a4f02f92cf9',
-    );
+      );
+    });
 
     // During parsing only two hex chars in a row are taken into account
     // The remaining characters are ignored.
 
-    assert.strictEqual(
+    assert.throws(() => {
       v3(
         'hello.example.com',
         // equal '00000000-0000-0000-0000-000000000000'
         '=Y00a-f*v00b*-00c-00d#-p00f\b-00g-00h-####00i^^^-00j*1*2*3&-L00k-\n00l-/00m-----00n-fg000-00p-00r+',
-      ),
-      '8ccfd135-fc23-3a10-a477-5a4f02f92cf9',
-    );
+      );
+    });
   });
 
   test('v3 namespace buffer validation', () => {
@@ -228,26 +226,24 @@ describe('v5', () => {
   });
 
   test('v5 parsing non RFC uuid values', () => {
-    assert.strictEqual(
+    assert.throws(() => {
       v5(
         'hello.example.com',
         // equal '00000000-0000-0000-0000-000000000000'
         '00000000000000000000000000000000',
-      ),
-      '9aefd4c8-16b3-555b-9731-72b19be683e4',
-    );
+      );
+    });
 
     // During parsing only two hex chars in a row are taken into account
     // The remaining characters are ignored.
 
-    assert.strictEqual(
+    assert.throws(() => {
       v5(
         'hello.example.com',
         // equal '00000000-0000-0000-0000-000000000000'
         '=Y00a-f*v00b*-00c-00d#-p00f\b-00g-00h-####00i^^^-00j*1*2*3&-L00k-\n00l-/00m-----00n-fg000-00p-00r+',
-      ),
-      '9aefd4c8-16b3-555b-9731-72b19be683e4',
-    );
+      );
+    });
   });
 
   test('v5 namespace buffer validation', () => {

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);
+  });
+});