digest-murmurhash 0.3.0 → 1.0.0

data/ext/digest/murmurhash/murmurhash64a.h

@@ -4,10 +4,7 @@
 #include "murmurhash.h"
 
 VALUE murmur64a_finish(VALUE self);
-VALUE murmur64a_to_i(VALUE self);
 VALUE murmur64a_s_digest(int argc, VALUE *argv, VALUE klass);
-VALUE murmur64a_s_hexdigest(int argc, VALUE *argv, VALUE klass);
 VALUE murmur64a_s_rawdigest(int argc, VALUE *argv, VALUE klass);
 
 #endif /* ifndef MURMURHASH64A_INCLUDED */
-

data/ext/digest/murmurhash/murmurhash64b.c

@@ -7,87 +7,75 @@
 uint64_t
 murmur_hash_process64b(const char * key, uint32_t len, uint64_t seed)
 {
-	const uint32_t m = MURMURHASH_MAGIC;
-	const int r = 24;
-
-	uint32_t h1 = (uint32_t)(seed) ^ len;
-	uint32_t h2 = (uint32_t)(seed >> 32);
-
-	const uint32_t * data = (const uint32_t *)key;
-
-	while(len >= 8) {
-		uint32_t k1 = *data++;
-		k1 *= m; k1 ^= k1 >> r; k1 *= m;
-		h1 *= m; h1 ^= k1;
-		len -= 4;
-
-		uint32_t k2 = *data++;
-		k2 *= m; k2 ^= k2 >> r; k2 *= m;
-		h2 *= m; h2 ^= k2;
-		len -= 4;
-	}
-
-	if(len >= 4) {
-		uint32_t k1 = *data++;
-		k1 *= m; k1 ^= k1 >> r; k1 *= m;
-		h1 *= m; h1 ^= k1;
-		len -= 4;
-	}
-
-	switch(len) {
-	case 3: h2 ^= ((unsigned char*)data)[2] << 16;
-	case 2: h2 ^= ((unsigned char*)data)[1] << 8;
-	case 1: h2 ^= ((unsigned char*)data)[0];
-			h2 *= m;
-	};
-
-	h1 ^= h2 >> 18; h1 *= m;
-	h2 ^= h1 >> 22; h2 *= m;
-	h1 ^= h2 >> 17; h1 *= m;
-	h2 ^= h1 >> 19; h2 *= m;
-
-	uint64_t h = h1;
-
-	h = (h << 32) | h2;
-
-	return h;
-} 
+  const uint32_t m = MURMURHASH_MAGIC;
+  const int r = 24;
+
+  uint32_t h1 = (uint32_t)(seed) ^ len;
+  uint32_t h2 = (uint32_t)(seed >> 32);
+
+  const uint32_t * data = (const uint32_t *)key;
+
+  while(len >= 8) {
+    uint32_t k1 = *data++;
+    k1 *= m; k1 ^= k1 >> r; k1 *= m;
+    h1 *= m; h1 ^= k1;
+    len -= 4;
+
+    uint32_t k2 = *data++;
+    k2 *= m; k2 ^= k2 >> r; k2 *= m;
+    h2 *= m; h2 ^= k2;
+    len -= 4;
+  }
+
+  if(len >= 4) {
+    uint32_t k1 = *data++;
+    k1 *= m; k1 ^= k1 >> r; k1 *= m;
+    h1 *= m; h1 ^= k1;
+    len -= 4;
+  }
+
+  switch(len) {
+    case 3: h2 ^= ((unsigned char*)data)[2] << 16;
+    case 2: h2 ^= ((unsigned char*)data)[1] << 8;
+    case 1: h2 ^= ((unsigned char*)data)[0];
+            h2 *= m;
+  };
+
+  h1 ^= h2 >> 18; h1 *= m;
+  h2 ^= h1 >> 22; h2 *= m;
+  h1 ^= h2 >> 17; h1 *= m;
+  h2 ^= h1 >> 19; h2 *= m;
+
+  uint64_t h = h1;
+
+  h = (h << 32) | h2;
+
+  return h;
+}
 
 VALUE
 murmur64b_finish(VALUE self)
 {
-	uint8_t digest[8];
-	uint64_t h;
-
-	h = _murmur_finish64(self, murmur_hash_process64b);
-	ASSINE_BY_ENDIAN_64(digest, h);
-	return rb_str_new((const char*) digest, 8);
-}
+  uint8_t digest[8];
+  uint64_t h;
 
-VALUE
-murmur64b_to_i(VALUE self)
-{
-	return ULL2NUM(_murmur_finish64(self, murmur_hash_process64b));
+  h = _murmur_finish64(self, murmur_hash_process64b);
+  assign_by_endian_64(digest, h);
+  return rb_str_new((const char*) digest, 8);
 }
 
 VALUE
 murmur64b_s_digest(int argc, VALUE *argv, VALUE klass)
 {
-	uint8_t digest[8];
-	uint64_t h;
-	h = _murmur_s_digest64(argc, argv, klass, murmur_hash_process64b);
-	ASSINE_BY_ENDIAN_64(digest, h);
-	return rb_str_new((const char*) digest, 8);
-}
-
-VALUE
-murmur64b_s_hexdigest(int argc, VALUE *argv, VALUE klass)
-{
-	return hexencode_str_new(murmur64b_s_digest(argc, argv, klass));
+  uint8_t digest[8];
+  uint64_t h;
+  h = _murmur_s_digest64(argc, argv, klass, murmur_hash_process64b);
+  assign_by_endian_64(digest, h);
+  return rb_str_new((const char*) digest, 8);
 }
 
 VALUE
 murmur64b_s_rawdigest(int argc, VALUE *argv, VALUE klass)
 {
-	return ULL2NUM(_murmur_s_digest64(argc, argv, klass, murmur_hash_process64b));
+  return ULL2NUM(_murmur_s_digest64(argc, argv, klass, murmur_hash_process64b));
 }

data/ext/digest/murmurhash/murmurhash64b.h

@@ -4,9 +4,7 @@
 #include "murmurhash.h"
 
 VALUE murmur64b_finish(VALUE self);
-VALUE murmur64b_to_i(VALUE self);
 VALUE murmur64b_s_digest(int argc, VALUE *argv, VALUE klass);
-VALUE murmur64b_s_hexdigest(int argc, VALUE *argv, VALUE klass);
 VALUE murmur64b_s_rawdigest(int argc, VALUE *argv, VALUE klass);
 
 #endif /* ifndef MURMURHASH64B_INCLUDED */

data/ext/digest/murmurhash/murmurhash_aligned2.c

@@ -7,81 +7,69 @@
 uint32_t
 murmur_hash_process_aligned2(const char * key, uint32_t len, uint32_t seed)
 {
-	const uint32_t m = 0x5bd1e995;
-	const int r = 24;
+  const uint32_t m = 0x5bd1e995;
+  const int r = 24;
 
-	uint32_t h = seed ^ len;
+  uint32_t h = seed ^ len;
 
-	const unsigned char * data = (const unsigned char *)key;
+  const unsigned char * data = (const unsigned char *)key;
 
-	while(len >= 4) {
-		uint32_t k;
+  while(len >= 4) {
+    uint32_t k;
 
-		k  = data[0];
-		k |= data[1] << 8;
-		k |= data[2] << 16;
-		k |= data[3] << 24;
+    k  = data[0];
+    k |= data[1] << 8;
+    k |= data[2] << 16;
+    k |= data[3] << 24;
 
-		k *= m; 
-		k ^= k >> r; 
-		k *= m;
+    k *= m; 
+    k ^= k >> r; 
+    k *= m;
 
-		h *= m;
-		h ^= k;
+    h *= m;
+    h ^= k;
 
-		data += 4;
-		len -= 4;
-	}
+    data += 4;
+    len -= 4;
+  }
 
-	switch(len) {
-	case 3: h ^= data[2] << 16;
-	case 2: h ^= data[1] << 8;
-	case 1: h ^= data[0];
-			h *= m;
-	};
+  switch(len) {
+    case 3: h ^= data[2] << 16;
+    case 2: h ^= data[1] << 8;
+    case 1: h ^= data[0];
+            h *= m;
+  };
 
-	h ^= h >> 13;
-	h *= m;
-	h ^= h >> 15;
+  h ^= h >> 13;
+  h *= m;
+  h ^= h >> 15;
 
-	return h;
+  return h;
 }
 
 VALUE
 murmur_aligned2_finish(VALUE self)
 {
-	uint8_t digest[4];
-	uint32_t h;
+  uint8_t digest[4];
+  uint32_t h;
 
-	h = _murmur_finish32(self, murmur_hash_process_aligned2);
-	ASSINE_BY_ENDIAN_32(digest, h);
-	return rb_str_new((const char*) digest, 4);
-}
-
-VALUE
-murmur_aligned2_to_i(VALUE self)
-{
-	return ULL2NUM(_murmur_finish32(self, murmur_hash_process_aligned2));
+  h = _murmur_finish32(self, murmur_hash_process_aligned2);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur_aligned2_s_digest(int argc, VALUE *argv, VALUE klass)
 {
-	uint8_t digest[4];
-	uint64_t h;
-	h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process_aligned2);
-	ASSINE_BY_ENDIAN_32(digest, h);
-	return rb_str_new((const char*) digest, 4);
-}
-
-VALUE
-murmur_aligned2_s_hexdigest(int argc, VALUE *argv, VALUE klass)
-{
-	return hexencode_str_new(murmur_aligned2_s_digest(argc, argv, klass));
+  uint8_t digest[4];
+  uint64_t h;
+  h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process_aligned2);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur_aligned2_s_rawdigest(int argc, VALUE *argv, VALUE klass)
 {
-	return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process_aligned2));
+  return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process_aligned2));
 }

data/ext/digest/murmurhash/murmurhash_aligned2.h

@@ -4,9 +4,7 @@
 #include "murmurhash.h"
 
 VALUE murmur_aligned2_finish(VALUE self);
-VALUE murmur_aligned2_to_i(VALUE self);
 VALUE murmur_aligned2_s_digest(int argc, VALUE *argv, VALUE klass);
-VALUE murmur_aligned2_s_hexdigest(int argc, VALUE *argv, VALUE klass);
 VALUE murmur_aligned2_s_rawdigest(int argc, VALUE *argv, VALUE klass);
 
 #endif /* ifndef MURMURHASH_ALIGNED2_INCLUDED */

data/ext/digest/murmurhash/murmurhash_neutral2.c

@@ -7,81 +7,69 @@
 uint32_t
 murmur_hash_process_neutral2(const char * key, uint32_t len, uint32_t seed)
 {
-	const uint32_t m = 0x5bd1e995;
-	const int r = 24;
+  const uint32_t m = 0x5bd1e995;
+  const int r = 24;
 
-	uint32_t h = seed ^ len;
+  uint32_t h = seed ^ len;
 
-	const unsigned char * data = (const unsigned char *)key;
+  const unsigned char * data = (const unsigned char *)key;
 
-	while(len >= 4) {
-		uint32_t k;
+  while(len >= 4) {
+    uint32_t k;
 
-		k  = data[0];
-		k |= data[1] << 8;
-		k |= data[2] << 16;
-		k |= data[3] << 24;
+    k  = data[0];
+    k |= data[1] << 8;
+    k |= data[2] << 16;
+    k |= data[3] << 24;
 
-		k *= m; 
-		k ^= k >> r; 
-		k *= m;
+    k *= m; 
+    k ^= k >> r; 
+    k *= m;
 
-		h *= m;
-		h ^= k;
+    h *= m;
+    h ^= k;
 
-		data += 4;
-		len -= 4;
-	}
+    data += 4;
+    len -= 4;
+  }
 
-	switch(len) {
-	case 3: h ^= data[2] << 16;
-	case 2: h ^= data[1] << 8;
-	case 1: h ^= data[0];
-			h *= m;
-	};
+  switch(len) {
+    case 3: h ^= data[2] << 16;
+    case 2: h ^= data[1] << 8;
+    case 1: h ^= data[0];
+            h *= m;
+  };
 
-	h ^= h >> 13;
-	h *= m;
-	h ^= h >> 15;
+  h ^= h >> 13;
+  h *= m;
+  h ^= h >> 15;
 
-	return h;
+  return h;
 }
 
 VALUE
 murmur_neutral2_finish(VALUE self)
 {
-	uint8_t digest[4];
-	uint32_t h;
+  uint8_t digest[4];
+  uint32_t h;
 
-	h = _murmur_finish32(self, murmur_hash_process_neutral2);
-	ASSINE_BY_ENDIAN_32(digest, h);
-	return rb_str_new((const char*) digest, 4);
-}
-
-VALUE
-murmur_neutral2_to_i(VALUE self)
-{
-	return ULL2NUM(_murmur_finish32(self, murmur_hash_process_neutral2));
+  h = _murmur_finish32(self, murmur_hash_process_neutral2);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur_neutral2_s_digest(int argc, VALUE *argv, VALUE klass)
 {
-	uint8_t digest[4];
-	uint64_t h;
-	h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process_neutral2);
-	ASSINE_BY_ENDIAN_32(digest, h);
-	return rb_str_new((const char*) digest, 4);
-}
-
-VALUE
-murmur_neutral2_s_hexdigest(int argc, VALUE *argv, VALUE klass)
-{
-	return hexencode_str_new(murmur_neutral2_s_digest(argc, argv, klass));
+  uint8_t digest[4];
+  uint64_t h;
+  h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process_neutral2);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur_neutral2_s_rawdigest(int argc, VALUE *argv, VALUE klass)
 {
-	return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process_neutral2));
+  return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process_neutral2));
 }

data/ext/digest/murmurhash/murmurhash_neutral2.h

@@ -4,9 +4,7 @@
 #include "murmurhash.h"
 
 VALUE murmur_neutral2_finish(VALUE self);
-VALUE murmur_neutral2_to_i(VALUE self);
 VALUE murmur_neutral2_s_digest(int argc, VALUE *argv, VALUE klass);
-VALUE murmur_neutral2_s_hexdigest(int argc, VALUE *argv, VALUE klass);
 VALUE murmur_neutral2_s_rawdigest(int argc, VALUE *argv, VALUE klass);
 
 #endif /* ifndef MURMURHASH_NEUTRAL2_INCLUDED */

data/lib/digest/murmurhash.rb

@@ -1,7 +1,73 @@
-require "digest/stringbuffer"
-begin
-  require "digest/murmurhash/#{RUBY_VERSION[/\d+.\d+/]}/murmurhash"
-rescue LoadError
-  require "digest/murmurhash/murmurhash"
+require "digest/simple"
+
+module Digest
+  class MurmurHash < Simple
+    def initialize
+      @seed = self.class::DEFAULT_SEED
+      super
+    end
+
+    def seed
+      @seed
+    end
+
+    def seed=(s)
+      fail ArgumentError, "seed string should #{digest_length * 16} bit chars" if s.bytesize != digest_length
+      @seed = s
+    end
+
+    module Size32
+      DEFAULT_SEED = "\x00\x00\x00\x00".encode('ASCII-8BIT')
+
+      def digest_length
+        4
+      end
+
+      def to_i
+        finish.unpack("I")[0]
+      end
+    end
+
+    module Size64
+      DEFAULT_SEED = "\x00\x00\x00\x00\x00\x00\x00\x00".encode('ASCII-8BIT')
+
+      def digest_length
+        8
+      end
+
+      def to_i
+        finish.unpack("L")[0]
+      end
+    end
+  end
+
+  class MurmurHash1 < MurmurHash
+    include Size32
+  end
+
+  class MurmurHash2 < MurmurHash
+    include Size32
+  end
+
+  class MurmurHash2A < MurmurHash
+    include Size32
+  end
+
+  class MurmurHash64A < MurmurHash
+    include Size64
+  end
+
+  class MurmurHash64B < MurmurHash
+    include Size64
+  end
+
+  class MurmurHashAligned2 < MurmurHash
+    include Size32
+  end
+
+  class MurmurHashNeutral2 < MurmurHash
+    include Size32
+  end
 end
-require "digest/murmurhash/version"
+
+require "digest/murmurhash/murmurhash"