digest-murmurhash 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f158d21ca468ee7cccb9c39ba6fc57660850edd
-  data.tar.gz: 82730d511f8136b2ff960c0d2d99a62c9a78c339
+  metadata.gz: 635a6c34802609c512789d68c9ebe571df48cc01
+  data.tar.gz: 1a1884fb59d6a9ccfca3c5da969e688589c093f0
 SHA512:
-  metadata.gz: 4494bc8ee54eb5bc525c9c8d5a8f275c299b73350fd0f6fcb638e7272fb546cab8d5bd5867cab5f388845ddc2eeec11302c8d982ea1e0e5bb33cc2b50b127d28
-  data.tar.gz: 20cc99086cc26e5ba616a9d179aa11121f88704a8effb6a417dd3cc58032b8c0fb89a21818c1bf790bfd7dde3b94a0477cd67d74d0fe860c882e339ddfd3c1b8
+  metadata.gz: 2633494b6b099a2149deeb3c39af1eb81e80435156bc459b4aee9498ca5209f41ac5a400713b6ae6c762935c5a1d964bc408e63a6e21e0634778d4a78c63f329
+  data.tar.gz: 9c61561046045532d0c8fe863059625cb532d051ea978f16fc63b0bd7fada9fded44900d91642695253d50fd94344c9444d35d5e6715b2956c2078713bcd9fd2

data/README.md

@@ -2,26 +2,39 @@
 
 [![Build Status](https://travis-ci.org/ksss/digest-murmurhash.png?branch=master)](https://travis-ci.org/ksss/digest-murmurhash)
 
-Digest::MurmurHash is a class of use algorithm MurmurHash(MurmurHash1 32-bit) desiged by Austin Appleby.
+**MurmurHash** is a algorithm desiged by Austin Appleby.
 
-Digest::MurmurHash compliance Digest API of Ruby.
+**Digest::MurmurHash1** use algorithm MurmurHash1(32-bit).
 
-## Usage
+**Digest::MurmurHash2** use algorithm MurmurHash2(32-bit).
+
+(**Digest::MurmurHash** exist to write only version number)
 
-All interface compliance Digest::Base.
+All classes compliance Digest API of Ruby.
+
+## Usage
 
-You can use same interface built in Digest::XXX classes.
+You can use same interface built-in Digest::XXX classes.
 
 ```ruby
 require 'digest/murmurhash'
 
-p Digest::MurmurHash.hexdigest('murmurhash') #=> 'c709abd5'
-p Digest::MurmurHash.file("./LICENSE.txt").hexdigest #=> '712e9641'
+# MurmurHash1 can use like same than Digest::XXX.
+
+p Digest::MurmurHash1.hexdigest('murmurhash') #=> 'c709abd5'
+p Digest::MurmurHash1.file("./LICENSE.txt").hexdigest #=> '712e9641'
+
+# and MurmurHash2 too. but return another value because using another algorithm.
+
+p Digest::MurmurHash2.hexdigest('murmurhash') #=> '33f67c7e'
+p Digest::MurmurHash2.file("./LICENSE.txt").hexdigest #=> '78678326'
 ```
 
 ## Class tree
 
-Digest::MurmurHash < Digest::Base < Digest::Instance < Digest::Class < Object < Kernel < BasicObject
+**Digest::MurmurHash1** < Digest::StringBuffer
+
+**Digest::MurmurHash2** < Digest::StringBuffer
 
 ## Installation
 

data/Rakefile

@@ -14,7 +14,7 @@ require 'rake/extensiontask'
 spec = Bundler::GemHelper.gemspec
 Rake::ExtensionTask.new('murmurhash', spec) do |ext|
   ext.ext_dir = 'ext/digest/murmurhash'
-  ext.lib_dir = 'lib/digest'
+  ext.lib_dir = 'lib/digest/murmurhash'
 end
 
 

data/digest-murmurhash.gemspec

@@ -1,16 +1,15 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-# require 'digest/murmurhash/version'
+require 'digest/murmurhash/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "digest-murmurhash"
-  # FIXME replace Digest::MurmurHash::VERSION but raise NameError
-  spec.version       = "0.1.0"
+  spec.version       = Digest::MurmurHash::VERSION
   spec.author        = "ksss"
   spec.email         = "co000ri@gmail.com"
-  spec.description   = %q{Digest::MurmurHash is a class of use algorithm MurmurHash(MurmurHash1 32-bit) desiged by Austin Appleby.}
-  spec.summary       = %q{Digest::MurmurHash is a class of use algorithm MurmurHash(MurmurHash1 32-bit) desiged by Austin Appleby.}
+  spec.description   = %q{Digest::MurmurHash1 is a class of use algorithm MurmurHash1(32-bit) desiged by Austin Appleby.}
+  spec.summary       = %q{Digest::MurmurHash1 is a class of use algorithm MurmurHash1(32-bit) desiged by Austin Appleby.}
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -23,5 +22,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", ['~> 2.11']
-  spec.add_development_dependency "rake-compiler", ["~> 0.8.3"]
+  spec.add_development_dependency "rake-compiler", ["~> 0.9.2"]
+  spec.add_development_dependency "digest-stringbuffer", ["~> 0.0.2"]
 end

data/ext/digest/murmurhash/extconf.rb

@@ -4,4 +4,4 @@ have_header('ruby/digest.h')
 
 $preload = %w[digest]
 
-create_makefile('digest/murmurhash')
+create_makefile('digest/murmurhash/murmurhash')

data/ext/digest/murmurhash/init.c

@@ -0,0 +1,34 @@
+#include "murmurhash.h"
+#include "murmurhash1.h"
+#include "murmurhash2.h"
+#include "murmurhash2a.h"
+
+void
+Init_murmurhash(void)
+{
+	VALUE mDigest, cDigest_StringBuffer;
+	VALUE cDigest_MurmurHash1, cDigest_MurmurHash2, cDigest_MurmurHash2A;
+
+	/* Digest::MurmurHash is require that Digest::StringBuffer */
+	rb_require("digest/stringbuffer");
+	mDigest = rb_path2class("Digest");
+	cDigest_StringBuffer = rb_path2class("Digest::StringBuffer");
+
+	/* class Digest::MurmurHash1 < Digest::StringBuffer */
+	cDigest_MurmurHash1 = rb_define_class_under(mDigest, "MurmurHash1", cDigest_StringBuffer);
+	rb_define_private_method(cDigest_MurmurHash1, "finish", murmur1_finish, 0);
+	rb_define_method(cDigest_MurmurHash1, "to_i", murmur1_to_i, 0);
+	rb_define_singleton_method(cDigest_MurmurHash1, "rawdigest", murmur1_s_rawdigest, -1);
+
+	/* class Digest::MurmurHash2 < Digest::StringBuffer */
+	cDigest_MurmurHash2 = rb_define_class_under(mDigest, "MurmurHash2", cDigest_StringBuffer);
+	rb_define_private_method(cDigest_MurmurHash2, "finish", murmur2_finish, 0);
+	rb_define_method(cDigest_MurmurHash2, "to_i", murmur2_to_i, 0);
+	rb_define_singleton_method(cDigest_MurmurHash2, "rawdigest", murmur2_s_rawdigest, -1);
+
+	/* class Digest::MurmurHash2A < Digest::StringBuffer */
+	cDigest_MurmurHash2A = rb_define_class_under(mDigest, "MurmurHash2A", cDigest_StringBuffer);
+	rb_define_private_method(cDigest_MurmurHash2A, "finish", murmur2a_finish, 0);
+	rb_define_method(cDigest_MurmurHash2A, "to_i", murmur2a_to_i, 0);
+	rb_define_singleton_method(cDigest_MurmurHash2A, "rawdigest", murmur2a_s_rawdigest, -1);
+}

data/ext/digest/murmurhash/murmurhash.h

@@ -0,0 +1,23 @@
+#ifndef MURMURHASH_INCLUDED
+#  define MURMURHASH_INCLUDED
+
+#include "ruby.h"
+
+#define MURMURHASH_MAGIC 0x5bd1e995
+
+/* should be same type structure to digest/stringbuffer */
+typedef struct {
+	char* buffer;
+	char* p;
+	size_t memsize;
+} buffer_t;
+
+#define MURMURHASH(self, name) \
+	buffer_t* name; \
+	Data_Get_Struct(self, buffer_t, name); \
+	if (name == NULL) { \
+		rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be.'"); \
+	}
+
+#endif /* ifndef MURMURHASH_INCLUDED */
+

data/ext/digest/murmurhash/murmurhash1.c

@@ -0,0 +1,86 @@
+/*
+ * MurmurHash1 (C) Austin Appleby
+ */
+
+#include "murmurhash1.h"
+
+static inline size_t
+murmur1(uint32_t h, const uint8_t r)
+{
+	const uint32_t m = MURMURHASH_MAGIC;
+	h *= m;
+	h ^= h >> r;
+	return h;
+}
+
+static uint32_t
+murmur_hash_process1(const char *data, uint32_t length)
+{
+	const uint32_t m = MURMURHASH_MAGIC;
+	const uint8_t r = 16;
+	uint32_t h;
+
+	h = length * m;
+
+	while (4 <= length) {
+		h += *(uint32_t*)data;
+		h = murmur1(h, r);
+		data += 4;
+		length -= 4;
+	}
+
+	switch (length) {
+	case 3:
+		h += data[2] << 16;
+	case 2:
+		h += data[1] << 8;
+	case 1:
+		h += data[0];
+		h = murmur1(h, r);
+	}
+
+	h = murmur1(h, 10);
+	h = murmur1(h, 17);
+
+	return h;
+}
+
+VALUE
+murmur1_finish(VALUE self)
+{
+	uint32_t h;
+	uint8_t digest[4];
+	MURMURHASH(self, ptr);
+
+	h = murmur_hash_process1(ptr->buffer, ptr->p - ptr->buffer);
+
+	digest[0] = h >> 24;
+	digest[1] = h >> 16;
+	digest[2] = h >> 8;
+	digest[3] = h;
+
+	return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur1_to_i(VALUE self)
+{
+	MURMURHASH(self, ptr);
+	return UINT2NUM(murmur_hash_process1(ptr->buffer, ptr->p - ptr->buffer));
+}
+
+VALUE
+murmur1_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE str;
+
+	if (argc < 1)
+		rb_raise(rb_eArgError, "no data given");
+
+	str = *argv++;
+	argc--;
+
+	StringValue(str);
+
+	return UINT2NUM(murmur_hash_process1(RSTRING_PTR(str), RSTRING_LEN(str)));
+}

data/ext/digest/murmurhash/murmurhash1.h

@@ -0,0 +1,11 @@
+#ifndef MURMURHASH1_INCLUDED
+#  define MURMURHASH1_INCLUDED
+
+#include "murmurhash.h"
+
+VALUE murmur1_finish(VALUE self);
+VALUE murmur1_to_i(VALUE self);
+VALUE murmur1_s_rawdigest(int argc, VALUE *argv, VALUE klass);
+
+#endif /* ifndef MURMURHASH1_INCLUDED */
+

data/ext/digest/murmurhash/murmurhash2.c

@@ -0,0 +1,90 @@
+/*
+ * MurmurHash2 (C) Austin Appleby
+ */
+
+#include "murmurhash2.h"
+
+static inline size_t
+murmur2(uint32_t h, uint32_t k, const uint8_t r)
+{
+	const uint32_t m = MURMURHASH_MAGIC;
+	k *= m;
+	k ^= k >> r;
+	k *= m;
+
+	h *= m;
+	h ^= k;
+	return h;
+}
+
+static uint32_t
+murmur_hash_process2(const char *data, uint32_t length)
+{
+	const uint32_t m = MURMURHASH_MAGIC;
+	const uint8_t r = 24;
+	uint32_t h, k;
+
+	h = length * m;
+
+	while (4 <= length) {
+		k = *(uint32_t*)data;
+		h = murmur2(h, k, r);
+		data += 4;
+		length -= 4;
+	}
+
+	switch (length) {
+	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;
+
+	return h;
+}
+
+VALUE
+murmur2_finish(VALUE self)
+{
+	uint32_t h;
+	uint8_t digest[4];
+	MURMURHASH(self, ptr);
+
+	h = murmur_hash_process2(ptr->buffer, ptr->p - ptr->buffer);
+
+	digest[0] = h >> 24;
+	digest[1] = h >> 16;
+	digest[2] = h >> 8;
+	digest[3] = h;
+
+	return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur2_to_i(VALUE self)
+{
+	MURMURHASH(self, ptr);
+	return UINT2NUM(murmur_hash_process2(ptr->buffer, ptr->p - ptr->buffer));
+}
+
+VALUE
+murmur2_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE str;
+	volatile VALUE obj;
+
+	if (argc < 1)
+		rb_raise(rb_eArgError, "no data given");
+
+	str = *argv++;
+	argc--;
+
+	StringValue(str);
+
+	return UINT2NUM(murmur_hash_process2(RSTRING_PTR(str), RSTRING_LEN(str)));
+}
+

data/ext/digest/murmurhash/murmurhash2.h

@@ -0,0 +1,11 @@
+#ifndef MURMURHASH2_INCLUDED
+#  define MURMURHASH2_INCLUDED
+
+#include "murmurhash.h"
+
+VALUE murmur2_finish(VALUE self);
+VALUE murmur2_to_i(VALUE self);
+VALUE murmur2_s_rawdigest(int argc, VALUE *argv, VALUE klass);
+
+#endif /* ifndef MURMURHASH2_INCLUDED */
+

data/ext/digest/murmurhash/murmurhash2a.c

@@ -0,0 +1,84 @@
+/*
+ * MurmurHash2A (C) Austin Appleby
+ */
+
+#include "murmurhash2a.h"
+
+#define mmix(h,k) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; }
+
+static uint32_t
+murmur_hash_process2a(const void *key, uint32_t length)
+{
+	const uint32_t m = MURMURHASH_MAGIC;
+	const uint8_t r = 24;
+	uint32_t h, k, t, l;
+	const unsigned char *data = (const unsigned char *) key;
+
+	l = length;
+	h = 0 ^ length;
+
+	while (4 <= length) {
+		k = *(uint32_t*)data;
+		mmix(h,k);
+		data += 4;
+		length -= 4;
+	}
+
+	t = 0;
+	switch (length) {
+	case 3: t ^= data[2] << 16;
+	case 2: t ^= data[1] << 8;
+	case 1: t ^= data[0];
+	}
+
+	mmix(h,t);
+	mmix(h,l);
+
+	h ^= h >> 13;
+	h *= m;
+	h ^= h >> 15;
+
+	return h;
+}
+
+VALUE
+murmur2a_finish(VALUE self)
+{
+	uint32_t h;
+	uint8_t digest[4];
+	MURMURHASH(self, ptr);
+
+	h = murmur_hash_process2a(ptr->buffer, ptr->p - ptr->buffer);
+
+	digest[0] = h >> 24;
+	digest[1] = h >> 16;
+	digest[2] = h >> 8;
+	digest[3] = h;
+
+	return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur2a_to_i(VALUE self)
+{
+	MURMURHASH(self, ptr);
+	return UINT2NUM(murmur_hash_process2a(ptr->buffer, ptr->p - ptr->buffer));
+}
+
+VALUE
+murmur2a_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE str;
+	volatile VALUE obj;
+
+	if (argc < 1)
+		rb_raise(rb_eArgError, "no data given");
+
+	str = *argv++;
+	argc--;
+
+	StringValue(str);
+
+	return UINT2NUM(murmur_hash_process2a(RSTRING_PTR(str), RSTRING_LEN(str)));
+}
+

data/ext/digest/murmurhash/murmurhash2a.h

@@ -0,0 +1,11 @@
+#ifndef MURMURHASH2A_INCLUDED
+#  define MURMURHASH2A_INCLUDED
+
+#include "murmurhash.h"
+
+VALUE murmur2a_finish(VALUE self);
+VALUE murmur2a_to_i(VALUE self);
+VALUE murmur2a_s_rawdigest(int argc, VALUE *argv, VALUE klass);
+
+#endif /* ifndef MURMURHASH2A_INCLUDED */
+

data/lib/digest/murmurhash.rb

@@ -0,0 +1,6 @@
+begin
+  require "digest/murmurhash/#{RUBY_VERSION[/\d+.\d+/]}/murmurhash"
+rescue LoadError
+  require "digest/murmurhash/murmurhash"
+end
+require "digest/murmurhash/version"

data/lib/digest/murmurhash/version.rb

@@ -1,5 +1,5 @@
 module Digest
   class MurmurHash
-    VERSION = "0.1.0"
+    VERSION = "0.2.1"
   end
 end

data/spec/bench.rb

@@ -3,9 +3,24 @@
 lib = File.expand_path('../../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
+require 'digest/stringbuffer'
 require 'digest/murmurhash'
 require 'benchmark'
 
+class Prime37 < Digest::StringBuffer
+  def initialize
+    @prime = 37
+  end
+
+  def finish
+    result = 0
+    buffer.unpack("C*").each do |c|
+      result += (c * @prime)
+    end
+    [result & 0xffffffff].pack("N")
+  end
+end
+
 class Integer
   def to_32
     self & 0xffffffff
@@ -44,30 +59,82 @@ def murmur_hash str
   h = (h * m).to_32
   h ^= h >> 17
 
-  h.to_32
+  h
 end
 
+@rands = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".split(//)
 def rand_str
   rand = "";
-  File.open("/dev/urandom").read(20).each_byte{|x| rand << sprintf("%02x",x)}
+  20.times {
+    rand << @rands[rand(62)]
+  }
   rand
 end
 
-s = rand_str
-p [murmur_hash(s)].pack("N")
-p Digest::MurmurHash.digest(s)
+n = 100000
+times_enum = n.times
+
+a = Array.new(n, 0)
+n.times do |i|
+  a[i] = rand_str
+end
+
+c = Struct.new "Cases",
+               :name,
+               :func
+cases = [
+  c.new("pureRuby", proc{|x| murmur_hash x }),
+  c.new("Prime37", proc{|x| Prime37.digest x }),
+  c.new("MurmurHash1", proc{|x| Digest::MurmurHash1.rawdigest x }),
+  c.new("MurmurHash2", proc{|x| Digest::MurmurHash2.rawdigest x }),
+  c.new("MurmurHash2A", proc{|x| Digest::MurmurHash2A.rawdigest x }),
+]
+
+reals = {}
+confrict = {}
+confricts = {}
 
+puts "### condition"
+puts
+puts "    RUBY_VERSION = #{RUBY_VERSION}"
+puts "    count = #{n}"
+puts
+puts "### benchmark"
+puts
+puts "```"
 Benchmark.bm do |x|
-  n = 10000
-  a = []
-  n.times { |i|
-   a[i] = rand_str
-  }
+  cases.each do |c|
+    z = x.report c.name do
+      times_enum.each do |i|
+        c.func.call(a[i])
+      end
+    end
+
+    confrict.clear
+    times_enum.each do |i|
+      rethash = c.func.call(a[i])
+      if confrict[rethash].nil?
+        confrict[rethash] = 0
+      else 
+        confrict[rethash] += 1
+      end
+    end
+    reals[c.name] = z.real
+    confricts[c.name] = confrict.count{|hash, count| 0 < count}
+  end
+end
+puts "```"
+
+puts
+puts "### real second rate (pureRuby/)"
+puts
+reals.each do |name, real|
+  puts "    " + (reals["pureRuby"] / real).to_s + "/" + name
+end
 
-  x.report {n.times{ |i|
-    [murmur_hash(a[i])].pack("N")
-  }}
-  x.report {n.times{ |i|
-    Digest::MurmurHash.digest(a[i])
-  }}
+puts
+puts "### confrict count (/#{n})"
+puts
+confricts.each do |name, count|
+  puts "    #{name}: #{count}"
 end

data/spec/digest_spec.rb

@@ -1,60 +1,82 @@
 require 'spec_helper'
 
-describe Digest::MurmurHash do
-  let :murmur do
-    Digest::MurmurHash.new
+describe "Digest::MurmurHash1 and 2" do
+  let :all do
+    [MurmurHash1, MurmurHash2, MurmurHash2A]
   end
 
   it "initialize" do
-    expect(Digest::MurmurHash.new).to be_a_kind_of(Digest::Base)
+    expect(MurmurHash1.new).to be_a_kind_of(Digest::StringBuffer)
+    expect(MurmurHash2.new).to be_a_kind_of(Digest::StringBuffer)
+    expect(MurmurHash2A.new).to be_a_kind_of(Digest::StringBuffer)
+  end
+
+  it "digest" do
+    expect(MurmurHash1.digest("a" * 1024)).to eq("\xa1\x52\x2e\x5f".force_encoding("ASCII-8BIT"))
+    expect(MurmurHash2.digest("a" * 1024)).to eq("\xd0\x0c\x31\x2f".force_encoding("ASCII-8BIT"))
+    expect(MurmurHash2A.digest("a" * 1024)).to eq("\xd5\x2d\xb1\x67".force_encoding("ASCII-8BIT"))
   end
 
   it "hexdigest" do
-    expect(Digest::MurmurHash.hexdigest("a" * 1024)).to eq("a1522e5f")
+    expect(MurmurHash1.hexdigest("a" * 1024)).to eq("a1522e5f")
+    expect(MurmurHash2.hexdigest("a" * 1024)).to eq("d00c312f")
+    expect(MurmurHash2A.hexdigest("a" * 1024)).to eq("d52db167")
   end
 
-  it "update and reset and hexdigest" do
-    murmur.update("m")
-    murmur.update("u")
-    murmur.update("r")
-    murmur.update("m")
-    murmur.update("u")
-    murmur.update("r")
-    murmur.update("hash")
-    expect(murmur.hexdigest).to eq("c709abd5");
-    expect(murmur.hexdigest).to eq("c709abd5");
-    expect(murmur.hexdigest!).to eq("c709abd5");
-    expect(murmur.hexdigest).to eq("00000000");
+  it "rawdigest" do
+    expect(MurmurHash1.rawdigest("a" * 1024)).to eq(0xa1522e5f)
+    expect(MurmurHash2.rawdigest("a" * 1024)).to eq(0xd00c312f)
+    expect(MurmurHash2A.rawdigest("a" * 1024)).to eq(0xd52db167)
   end
 
-  it "dup" do
-    murmur1 = Digest::MurmurHash.new
-    murmur2 = Digest::MurmurHash.new
-    murmur1.update("murmur")
-    murmur2 = murmur1.dup
-    murmur2.update("hash")
-    expect(murmur2.hexdigest).to eq("c709abd5")
+  it "update and reset and hexdigest" do
+    {
+      MurmurHash1 => "c709abd5",
+      MurmurHash2 => "33f67c7e",
+      MurmurHash2A => "df25554b",
+    }.each do |c, should|
+      murmur = c.new
+      murmur.update("m").update("u").update("r")
+      murmur << "m" << "u" << "r"
+      murmur << "hash"
+      expect(murmur.hexdigest).to eq(should);
+      expect(murmur.hexdigest).to eq(should);
+      expect(murmur.hexdigest!).to eq(should);
+      expect(murmur.hexdigest).to eq("00000000");
+    end
   end
 
   it "==" do
-    ["", "murmur", "murmurhash" * 1024].each do |str|
-      murmur1 = Digest::MurmurHash.new
-      murmur2 = Digest::MurmurHash.new
-      expect(murmur1.update(str) == murmur2.update(str)).to be_true
+    all.each do |c|
+      ["", "murmur", "murmurhash" * 1024].each do |str|
+        murmur1 = c.new
+        murmur2 = c.new
+        expect(murmur1.update(str) == murmur2.update(str)).to be_true
+      end
     end
   end
 
-  it "length" do
-    expect(murmur.length).to eq(4);
+  it "dup" do
+    all.each do |c|
+      murmur1 = c.new
+      murmur2 = c.new
+      10.times {
+        murmur1 = murmur1.update("murmurhash" * 100).dup
+      }
+      murmur2.update(("murmurhash" * 100) * 10)
+      expect(murmur1 == murmur2).to be_true
+    end
   end
 
-  it "block_length" do
-    # MurmurHash don't use block.
-    # Therefore `block_length` return chunk size for calculate MurmurHash (equal 4) 
-    expect(murmur.block_length).to eq(4);
+  it "length" do
+    expect(MurmurHash1.new.length).to eq(4);
+    expect(MurmurHash2.new.length).to eq(4);
+    expect(MurmurHash2A.new.length).to eq(4);
   end
 
   it "to_i" do
-    expect(murmur.update("murmurhash").to_i).to eq(0xc709abd5);
+    expect(MurmurHash1.new.update("murmurhash").to_i).to eq(0xc709abd5);
+    expect(MurmurHash2.new.update("murmurhash").to_i).to eq(0x33f67c7e);
+    expect(MurmurHash2A.new.update("murmurhash").to_i).to eq(0xdf25554b);
   end
 end

data/spec/exception_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe MurmurHash do
+  let :all do
+    [MurmurHash1, MurmurHash2, MurmurHash2A]
+  end
+
+  it "update nil" do
+    all.each do |c|
+      murmur = c.new
+      expect{ murmur.update }.to raise_error(ArgumentError)
+    end
+  end
+
+  it "rawdigest no arguments" do
+    all.each do |c|
+      expect{ c.rawdigest }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/mem_spec.rb

@@ -1,12 +1,18 @@
 require 'spec_helper'
 
-describe Digest::MurmurHash do
+describe MurmurHash do
   it "gc safe" do
-    murmur = Digest::MurmurHash.new
-    GC.start
-    murmur.update("murmur")
-    GC.start
-    expect(murmur.update("hash").to_s).to eq("c709abd5");
+    {
+      MurmurHash1 => "c709abd5",
+      MurmurHash2 => "33f67c7e",
+      MurmurHash2A => "df25554b",
+    }.each do |c, should|
+      murmur = c.new
+      GC.start
+      murmur.update("murmur")
+      GC.start
+      expect(murmur.update("hash").to_s).to eq(should);
+    end
   end
 end
 

data/spec/spec_helper.rb

@@ -1 +1,2 @@
 require 'digest/murmurhash'
+include Digest

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: digest-murmurhash
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-02 00:00:00.000000000 Z
+date: 2013-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,16 +58,30 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.9.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.3
-description: Digest::MurmurHash is a class of use algorithm MurmurHash(MurmurHash1
-  32-bit) desiged by Austin Appleby.
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: digest-stringbuffer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+description: Digest::MurmurHash1 is a class of use algorithm MurmurHash1(32-bit) desiged
+  by Austin Appleby.
 email: co000ri@gmail.com
 executables: []
 extensions:
@@ -82,10 +96,19 @@ files:
 - Rakefile
 - digest-murmurhash.gemspec
 - ext/digest/murmurhash/extconf.rb
-- ext/digest/murmurhash/murmurhash.c
+- ext/digest/murmurhash/init.c
+- ext/digest/murmurhash/murmurhash.h
+- ext/digest/murmurhash/murmurhash1.c
+- ext/digest/murmurhash/murmurhash1.h
+- ext/digest/murmurhash/murmurhash2.c
+- ext/digest/murmurhash/murmurhash2.h
+- ext/digest/murmurhash/murmurhash2a.c
+- ext/digest/murmurhash/murmurhash2a.h
+- lib/digest/murmurhash.rb
 - lib/digest/murmurhash/version.rb
 - spec/bench.rb
 - spec/digest_spec.rb
+- spec/exception_spec.rb
 - spec/mem_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -108,13 +131,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.6
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
-summary: Digest::MurmurHash is a class of use algorithm MurmurHash(MurmurHash1 32-bit)
-  desiged by Austin Appleby.
+summary: Digest::MurmurHash1 is a class of use algorithm MurmurHash1(32-bit) desiged
+  by Austin Appleby.
 test_files:
 - spec/bench.rb
 - spec/digest_spec.rb
+- spec/exception_spec.rb
 - spec/mem_spec.rb
 - spec/spec_helper.rb

data/ext/digest/murmurhash/murmurhash.c

@@ -1,209 +0,0 @@
-#include "ruby.h"
-#ifdef HAVE_RUBY_DIGEST_H
-  #include "ruby/digest.h"
-#else
-  #include "digest.h"
-#endif
-
-#define MURMURHASH_DIGEST_LENGTH 4
-#define MURMURHASH_BLOCK_LENGTH 4
-
-
-ID id_concat;
-
-typedef struct {
-	char* data;
-	char* p;
-	size_t memsize;
-} murmur_t;
-
-#define MURMURHASH(self, name) \
-	murmur_t* name; \
-	Data_Get_Struct(self, murmur_t, name); \
-	if (name == NULL) { \
-		rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be.'"); \
-	}
-
-static void
-murmur_init(murmur_t* ptr)
-{
-	ptr->data = (char*) malloc(sizeof(char) * 64);
-	ptr->p = ptr->data;
-	ptr->memsize = 64;
-}
-
-static void
-murmur_mark(murmur_t* ptr)
-{
-}
-
-static void
-murmur_free(murmur_t* ptr)
-{
-	free(ptr->data);
-}
-
-static VALUE
-murmur_alloc(VALUE self)
-{
-	murmur_t* ptr = ALLOC(murmur_t);
-	murmur_init(ptr);
-	return Data_Wrap_Struct(self, murmur_mark, murmur_free, ptr);
-}
-
-static VALUE
-murmur_initialize_copy(VALUE copy, VALUE origin)
-{
-	murmur_t *ptr_copy, *ptr_origin;
-	size_t data_len;
-
-	if (copy == origin) return copy;
-
-	rb_check_frozen(copy);
-
-	Data_Get_Struct(copy, murmur_t, ptr_copy);
-	Data_Get_Struct(origin, murmur_t, ptr_origin);
-
-	data_len = ptr_origin->p - ptr_origin->data;
-	ptr_copy->data = (char*) malloc(sizeof(char) * ptr_origin->memsize);
-	memcpy(ptr_copy->data, ptr_origin->data, data_len);
-	ptr_copy->p = ptr_copy->data + data_len;
-	ptr_copy->memsize = ptr_origin->memsize;
-
-	return copy;
-}
-
-static VALUE
-murmur_reset(VALUE self)
-{
-	MURMURHASH(self, ptr);
-	ptr->p = ptr->data;
-	return self;
-}
-
-static VALUE
-murmur_update(VALUE self, VALUE str)
-{
-	size_t data_len, str_len, require, newsize;
-	const char* str_p;
-	MURMURHASH(self, ptr);
-
-	StringValue(str);
-	str_p = RSTRING_PTR(str);
-	str_len = RSTRING_LEN(str);
-	data_len = (ptr->p - ptr->data);
-	require = data_len + str_len;
-	if (ptr->memsize < require) {
-		newsize = ptr->memsize;
-		while (newsize < require) {
-			newsize *= 2;
-		}
-		ptr->data = realloc(ptr->data, sizeof(char) * newsize);
-		ptr->p = ptr->data + data_len;
-		ptr->memsize = newsize;
-	}
-	memcpy(ptr->p, str_p, str_len);
-	ptr->p += str_len;
-
-	return self;
-}
-
-static uint32_t
-murmur_hash_process(murmur_t* ptr)
-{
-	const uint32_t m = 0x5bd1e995;
-	const uint8_t r = 16;
-	uint32_t length, h;
-	const char* p;
-
-	p = ptr->data;
-	length = ptr->p - ptr->data;
-	h = length * m;
-
-	while (4 <= length) {
-		h += *(uint32_t*)p;
-		h *= m;
-		h ^= h >> r;
-		p += 4;
-		length -= 4;
-	}
-
-	switch (length) {
-		case 3:
-			h += p[2] << 16;
-		case 2:
-			h += p[1] << 8;
-		case 1:
-			h += p[0];
-			h *= m;
-			h ^= h >> r;
-	}
-
-	h *= m;
-	h ^= h >> 10;
-	h *= m;
-	h ^= h >> 17;
-
-	return h;
-}
-
-static VALUE
-murmur_finish(VALUE self)
-{
-	uint32_t h;
-	uint8_t digest[MURMURHASH_DIGEST_LENGTH];
-	MURMURHASH(self, ptr);
-
-	h = murmur_hash_process(ptr);
-
-	digest[0] = (h >> 24);
-	digest[1] = (h >> 16);
-	digest[2] = (h >> 8);
-	digest[3] = (h);
-
-	return rb_str_new((const char*) digest, 4);
-}
-
-static VALUE
-murmur_digest_length(VALUE self)
-{
-	return INT2NUM(MURMURHASH_DIGEST_LENGTH);
-}
-
-static VALUE
-murmur_block_length(VALUE self)
-{
-	return INT2NUM(MURMURHASH_BLOCK_LENGTH);
-}
-
-static VALUE
-murmur_to_i(VALUE self)
-{
-	MURMURHASH(self, ptr);
-	return UINT2NUM(murmur_hash_process(ptr));
-}
-
-void
-Init_murmurhash()
-{
-	VALUE mDigest, cDigest_Base, cDigest_MurmurHash;
-
-	id_concat = rb_intern("concat");
-
-	rb_require("digest");
-
-	mDigest = rb_path2class("Digest");
-	cDigest_Base = rb_path2class("Digest::Base");
-
-	cDigest_MurmurHash = rb_define_class_under(mDigest, "MurmurHash", cDigest_Base);
-
-	rb_define_alloc_func(cDigest_MurmurHash, murmur_alloc);
-	rb_define_method(cDigest_MurmurHash, "initialize_copy", murmur_initialize_copy, 1);
-	rb_define_method(cDigest_MurmurHash, "reset", murmur_reset, 0);
-	rb_define_method(cDigest_MurmurHash, "update", murmur_update, 1);
-	rb_define_private_method(cDigest_MurmurHash, "finish", murmur_finish, 0);
-	rb_define_method(cDigest_MurmurHash, "digest_length", murmur_digest_length, 0);
-	rb_define_method(cDigest_MurmurHash, "block_length", murmur_block_length, 0);
-
-	rb_define_method(cDigest_MurmurHash, "to_i", murmur_to_i, 0);
-}