Java hashcode functions for Nodejs

Author: akhilbojedla

index.js

@@ -0,0 +1,33 @@
+let long = require('long');
+
+exports.jHashCode = function(stringToBeHashed) {
+    let hash = 0, i, chr;
+    if (stringToBeHashed.length === 0) return hash;
+    for (i = 0; i < stringToBeHashed.length; i++) {
+        chr = stringToBeHashed.charCodeAt(i);
+        hash = ((hash << 5) - hash) + chr;
+        hash |= 0;
+    }
+    return hash
+}
+
+exports.jUUIDHashCode = function(uuidToBeHashed) {
+
+    if (!uuidToBeHashed.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i)) {
+        throw TypeError("Invalid UUID string");
+    }
+
+    let uuidSplits = uuidToBeHashed.split("-");
+    let msb = long.fromString(uuidSplits[0], false, 16).and(0xffffffff);
+    msb = msb.shiftLeft(16);
+    msb = msb.or(long.fromString(uuidSplits[1], false, 16).and(0xffff));
+    msb = msb.shiftLeft(16);
+    msb = msb.or(long.fromString(uuidSplits[2], false, 16).and(0xffff));
+
+    let lsb = long.fromString(uuidSplits[3], false, 16).and(0xffff);
+    lsb = lsb.shiftLeft(48);
+    lsb = lsb.or(long.fromString(uuidSplits[4], false, 16).and(0xffffffffffff));
+
+    let hilo = msb.xor(lsb);
+    return hilo.shiftRight(32).toInt() ^ hilo.toInt();
+}

package-lock.json

@@ -0,0 +1,29 @@
+{
+  "name": "jhash",
+  "version": "1.0.0",
+  "description": "Java hashcode functions for Nodejs",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bytecodehq/jhash.git"
+  },
+  "keywords": [
+    "java",
+    "string-hashcode",
+    "hashcode",
+    "uuid",
+    "uuid-hashcode"
+  ],
+  "author": "Akhil Bojedla",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/bytecodehq/jhash/issues"
+  },
+  "homepage": "https://github.com/bytecodehq/jhash#readme",
+  "dependencies": {
+    "long": "^5.2.0"
+  }
+}

package.json

@@ -0,0 +1,73 @@
+const { jHashCode, jUUIDHashCode } = require(".");
+
+test_jHashCode = function () {
+    const testCases = [
+        {
+            "input": "java",
+            "hashCode": 3254818
+        },
+        {
+            "input": "javascript",
+            "hashCode": 188995949
+        },
+        {
+            "input": "ecmascript",
+            "hashCode": -948769283
+        }
+    ]
+
+    testCases.forEach((testCase) => {
+        if (jHashCode(testCase["input"]) !== testCase["hashCode"]) {
+            throw EvalError("jHashCode generated hascode not consistent with Java hashcode")
+        }
+    });
+}
+
+test_jHashCode_returns_0_on_empty_string = function () {
+    if (jHashCode("") !== 0) {
+        throw EvalError("jHashCode generated hascode not consistent with Java hashcode");
+    }
+}
+
+test_jUUIDHashCode = function() {
+    const testCases = [
+        {
+            "input": "90903f27-e36e-4e6f-996a-124c58365b43",
+            "hashCode": -1297991609
+        },
+        {
+            "input": "20adfcb5-d0e7-4157-a94e-fcb749f25168",
+            "hashCode": 284561469
+        },
+        {
+            "input": "737de8e7-9ae9-4208-95c3-9514309c5032",
+            "hashCode": 1288400841
+        }
+    ];
+
+    testCases.forEach((testCase) => {
+        if (jUUIDHashCode(testCase["input"]) !== testCase["hashCode"]) {
+            throw EvalError("jUUIDHashCode generated hascode not consistent with Java UUID hashcode")
+        }
+    });
+}
+
+test_jUUIDHashCode_throws_TypError_on_non_UUID = function() {
+    let exceptionThrown = false;
+    try {
+        jUUIDHashCode("foo")
+    } catch (error) {
+        if (error instanceof TypeError) {
+            exceptionThrown = true;
+        }
+    }
+
+    if (!exceptionThrown) {
+        throw EvalError("jUUIDHashCode did not throw TypeError on non UUID string")
+    }
+}
+
+test_jHashCode();
+test_jHashCode_returns_0_on_empty_string();
+test_jUUIDHashCode();
+test_jUUIDHashCode_throws_TypError_on_non_UUID();