murmur_redux 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f86efa1d0a92c333ab5119703d1be96f108cd342
-  data.tar.gz: c775a8a518c9d285a4919ef30843fc9b69116e7d
+  metadata.gz: 925117d747be38f53fff1621f2b2a5c50ff81843
+  data.tar.gz: 2f56e116c367da28c0d039fcfb43ce6a082ce84b
 SHA512:
-  metadata.gz: 5da0aff8b1c40090d1d96144c53cf50347c3307753db3849c78f1a05b2498ab5bb86723e79a15b1b4f31cb6cbb05490c49ac88f160200795eb75f51fdc5a7199
-  data.tar.gz: 603bcefa464c6e311839c8365443ca2c13a29414c7c79c3515b892318980fc6bc2b098b8f3c79f76ae5b894f0599974d3162bbffdefb46379ad8aa4614ea5c5e
+  metadata.gz: af1fffda69050fd8a3d9290622c6a1fa2024fd0d0097e273ca9409aebbfb116f48f11e1bd45295098aad07ee850f1c0598e062ec28f2c8e3502eca65eff24d1c
+  data.tar.gz: 6acbb6e828d76d3f2bdef8dd9b25180d32145426c2d2d009af4ca8ab25f31d67437290aad20a9f2dfcf8996ed4313fe3a1f8ade0cbe74791dbbd72a2fd0933be

data/.gitignore

@@ -1,4 +1,5 @@
 *.gem
 *.swp
 *.lock
+*.so
 tmp/*

data/Gemfile

@@ -3,6 +3,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
+  gem 'rake-compiler'
   gem 'rspec'
   gem 'guard-rspec'
 end

data/README.md

@@ -1,10 +1,8 @@
-# Search redux
+# Murmur redux
 
 A simpler wrapper around [murmurhash3](https://github.com/funny-falcon/murmurhash3-ruby) gem with a nicer API.
 
-## Requirements
-
-Murmur redux requires at least Ruby >= 1.9.2
+It defaults to `MurmurHash3_x86_128` which is a nice combination of low latency and with good collision resistence.
 
 ## Installation
 
@@ -19,12 +17,33 @@ gem 'murmur_redux'
 By default it uses MurmurHash3_x86_128 which is a nice combination of low latency and with good collision resistence.
 
 ```ruby
-class MyClass
-  hex_string = MurmurRedux::Hash.digest('test')
-end
+hex_string = MurmurRedux::Hash.digest('test')
+
+# => '9de1bd74cc287dac824dbdf93182129a'
 ```
 
-## License (MIT)
+### FAQ
+
+##### What is MurmurHash ?
+
+From its Wikipedia page[0] :
+
+>MurmurHash is a non-cryptographic hash function suitable for general hash-based lookup. It was created by Austin Appleby in 2008, and exists in a number of variants, all of which have been released into the public domain. When compared to other popular hash functions, MurmurHash performed well in a random distribution of regular keys.
+
+##### How fast is it ?
+
+Is one of the fastest hashing algorithms with with good to great collision resistence[1].
+
+- [0] - [wiki article](http://en.wikipedia.org/wiki/MurmurHash)
+- [1] - [performance](http://programmers.stackexchange.com/questions/49550/which-hashing-algorithm-is-best-for-uniqueness-and-speed)
+
+### Credits
+
+- [MurmurHash3](https://code.google.com/p/smhasher/wiki/MurmurHash3)
+- [murmurhash3-ruby gem](https://github.com/funny-falcon/murmurhash3-ruby)
+- [Byte Friendly article on MurmurHash 3](http://tech.tulentsev.com/2012/10/ruby-gem-for-murmurhash-3)
+
+### License (MIT)
 
 Copyright (c) 2013 Marian Posaceanu
 

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new 'murmur_native' do |ext|
+  ext.lib_dir = 'lib/murmur_redux'
+end

data/ext/murmur_native/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('murmur_native')

data/ext/murmur_native/murmur_native.c

@@ -0,0 +1,467 @@
+#include <ruby.h>
+/*-----------------------------------------------------------------------------
+ * MurmurHash3 was written by Austin Appleby, and is placed in the public
+ * domain. The author hereby disclaims copyright to this source code.
+
+ * Note - The x86 and x64 versions do _not_ produce the same results, as the
+ * algorithms are optimized for their respective platforms. You can still
+ * compile and run any of them on any platform, but your performance with the
+ * non-native version will be less than optimal.
+ */
+
+typedef unsigned char uint8_t;
+typedef unsigned int uint32_t;
+#ifndef HAVE_STDINT_H
+#if SIZEOF_LONG == 8
+typedef unsigned long uint64_t;
+#else
+typedef unsigned long long uint64_t;
+#endif
+#endif
+
+/*-----------------------------------------------------------------------------
+ * Platform-specific functions and macros
+ */
+
+#ifdef __GNUC__
+#define FORCE_INLINE __attribute__((always_inline))
+#elif defined(_MSC_VER)
+#define FORCE_INLINE  __forceinline
+#else
+#define FORCE_INLINE
+#endif
+
+#if defined(_MSC_VER)
+
+#define ROTL32(x,y)  _rotl(x,y)
+#define ROTL64(x,y)  _rotl64(x,y)
+
+#define BIG_CONSTANT(x) (x)
+
+#else
+
+static inline FORCE_INLINE uint32_t
+rotl32 ( uint32_t x, int8_t r )
+{
+  return (x << r) | (x >> (32 - r));
+}
+
+static inline FORCE_INLINE uint64_t
+rotl64 ( uint64_t x, int8_t r )
+{
+  return (x << r) | (x >> (64 - r));
+}
+
+#define	ROTL32(x,y)	rotl32(x,y)
+#define ROTL64(x,y)	rotl64(x,y)
+
+#define BIG_CONSTANT(x) (x##LLU)
+#endif
+
+/* end platform specific */
+
+/* Block read - if your platform needs to do endian-swapping or can only
+ * handle aligned reads, do the conversion here */
+#ifdef WORDS_BIGENDIAN
+#define GCC_VERSION_SINCE(major, minor, patchlevel) \
+   (defined(__GNUC__) && !defined(__INTEL_COMPILER) && \
+    ((__GNUC__ > (major)) ||  \
+     (__GNUC__ == (major) && __GNUC_MINOR__ > (minor)) || \
+     (__GNUC__ == (major) && __GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ >= (patchlevel))))
+#if GCC_VERSION_SINCE(4,3,0)
+# define swap32(x) __builtin_bswap32(x)
+# define swap64(x) __builtin_bswap64(x)
+#endif
+
+#ifndef swap32
+# define swap32(x)	((((x)&0xFF)<<24)	\
+			|(((x)>>24)&0xFF)	\
+			|(((x)&0x0000FF00)<<8)	\
+			|(((x)&0x00FF0000)>>8)	)
+#endif
+
+#ifndef swap64
+# ifdef HAVE_INT64_T
+static inline FORCE_INLINE uint64_t
+swap64(uint64_t x) {
+    x = (x>>32) | (x << 32);
+    x = ((x & BIG_CONSTANT(0xFFFF0000FFFF0000)) >> 16) |
+        ((x & BIG_CONSTANT(0x0000FFFF0000FFFF)) << 16);
+    return ((x & BIG_CONSTANT(0xFF00FF00FF00FF00)) >> 8) |
+           ((x & BIG_CONSTANT(0x00FF00FF00FF00FF)) << 8);
+}
+# endif
+
+#endif
+static inline FORCE_INLINE uint32_t
+getblock32(const uint32_t * p, int i)
+{
+    return swap32(p[i]);
+}
+
+static inline FORCE_INLINE uint64_t
+getblock64(const uint64_t * p, int i)
+{
+    return swap64(p[i]);
+}
+#else
+#define getblock32(p, i) (p[i])
+#define getblock64(p, i) (p[i])
+#endif
+
+/* Finalization mix - force all bits of a hash block to avalanche */
+
+static inline FORCE_INLINE uint32_t
+fmix32 ( uint32_t h )
+{
+  h ^= h >> 16;
+  h *= 0x85ebca6b;
+  h ^= h >> 13;
+  h *= 0xc2b2ae35;
+  h ^= h >> 16;
+
+  return h;
+}
+
+static inline FORCE_INLINE uint64_t
+fmix64 ( uint64_t k )
+{
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xff51afd7ed558ccd);
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
+  k ^= k >> 33;
+
+  return k;
+}
+
+static inline FORCE_INLINE uint32_t
+mmix32(uint32_t k1)
+{
+    k1 *= 0xcc9e2d51;
+    k1 = ROTL32(k1, 15);
+    return k1 * 0x1b873593;
+}
+
+static uint32_t
+MurmurHash3_x86_32 ( const void * key, long len, uint32_t seed)
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = (int)(len / 4);
+  int i;
+
+  uint32_t h1 = seed;
+  uint32_t k1 = 0;
+
+
+  /* body */
+
+  const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);
+
+  for(i = -nblocks; i; i++)
+  {
+    h1 ^= mmix32(getblock32(blocks, i));
+    h1 = ROTL32(h1,13);
+    h1 = h1*5+0xe6546b64;
+  }
+
+  /* tail */
+
+  data += nblocks*4;
+
+  switch(len & 3)
+  {
+  case 3: k1 ^= data[2] << 16;
+  case 2: k1 ^= data[1] << 8;
+  case 1: k1 ^= data[0];
+          h1 ^= mmix32(k1);
+  };
+
+  /* finalization */
+
+  h1 ^= len;
+
+  h1 = fmix32(h1);
+
+  return h1;
+}
+
+#define C1_128 BIG_CONSTANT(0x87c37b91114253d5)
+#define C2_128 BIG_CONSTANT(0x4cf5ad432745937f)
+
+static inline FORCE_INLINE uint64_t
+mmix128_1(uint64_t k1)
+{
+    k1 *= C1_128;
+    k1 = ROTL64(k1, 31);
+    return k1 * C2_128;
+}
+
+static inline FORCE_INLINE uint64_t
+mmix128_2(uint64_t k2)
+{
+    k2 *= C2_128;
+    k2 = ROTL64(k2, 33);
+    return k2 * C1_128;
+}
+
+static void MurmurHash3_x64_128 ( const void * key, const long len,
+                           const uint32_t seed, void * out )
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = (int)(len / 16);
+  int i;
+
+  uint64_t h1 = seed;
+  uint64_t h2 = seed;
+  uint64_t k1 = 0, k2 = 0;
+
+  /* body */
+
+  const uint64_t * blocks = (const uint64_t *)(data);
+
+  for(i = 0; i < nblocks; i++)
+  {
+    k1 = getblock64(blocks, i*2+0);
+    k2 = getblock64(blocks, i*2+1);
+
+    h1 ^= mmix128_1(k1);
+    h1 = ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729;
+
+    h2 ^= mmix128_2(k2);
+    h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
+  }
+
+  /* tail */
+
+  data += nblocks*16;
+  k1 = k2 = 0;
+
+  switch(len & 15)
+  {
+  case 15: k2 ^= (uint64_t)(data[14]) << 48;
+  case 14: k2 ^= (uint64_t)(data[13]) << 40;
+  case 13: k2 ^= (uint64_t)(data[12]) << 32;
+  case 12: k2 ^= (uint64_t)(data[11]) << 24;
+  case 11: k2 ^= (uint64_t)(data[10]) << 16;
+  case 10: k2 ^= (uint64_t)(data[ 9]) << 8;
+  case  9: k2 ^= (uint64_t)(data[ 8]) << 0;
+           h2 ^= mmix128_2(k2);
+
+  case  8: k1 ^= (uint64_t)(data[ 7]) << 56;
+  case  7: k1 ^= (uint64_t)(data[ 6]) << 48;
+  case  6: k1 ^= (uint64_t)(data[ 5]) << 40;
+  case  5: k1 ^= (uint64_t)(data[ 4]) << 32;
+  case  4: k1 ^= (uint64_t)(data[ 3]) << 24;
+  case  3: k1 ^= (uint64_t)(data[ 2]) << 16;
+  case  2: k1 ^= (uint64_t)(data[ 1]) << 8;
+  case  1: k1 ^= (uint64_t)(data[ 0]) << 0;
+           h1 ^= mmix128_1(k1);
+  };
+
+  /* finalization */
+
+  h1 ^= len; h2 ^= len;
+
+  h1 += h2;
+  h2 += h1;
+
+  h1 = fmix64(h1);
+  h2 = fmix64(h2);
+
+  h1 += h2;
+  h2 += h1;
+
+  ((uint64_t*)out)[0] = h1;
+  ((uint64_t*)out)[1] = h2;
+}
+
+/* end of MurmurHash3 algorithm */
+
+static VALUE
+rb_fmix32(VALUE self, VALUE integer)
+{
+    uint32_t _int = NUM2UINT(integer);
+    return UINT2NUM(fmix32(_int));
+}
+
+static VALUE
+rb_fmix64(VALUE self, VALUE integer)
+{
+#if SIZEOF_LONG == 8
+    uint64_t _int = NUM2ULONG(integer);
+    return ULONG2NUM(fmix64(_int));
+#else
+    uint64_t _int = NUM2ULL(integer);
+    return ULL2NUM(fmix64(_int));
+#endif
+}
+
+static VALUE
+rb_murmur3_32_str_hash(int argc, VALUE* argv, VALUE self)
+{
+    VALUE rstr;
+    uint32_t result;
+
+    if (argc == 0 || argc > 2) {
+	rb_raise(rb_eArgError, "accept 1 or 2 arguments: (string[, seed])");
+    }
+    rstr = argv[0];
+    StringValue(rstr);
+
+    result = MurmurHash3_x86_32(RSTRING_PTR(rstr), RSTRING_LEN(rstr), argc == 1 ? 0 : NUM2UINT(argv[1]));
+
+    return UINT2NUM(result);
+}
+
+static VALUE
+rb_murmur3_32_int32_hash(int argc, VALUE* argv, VALUE self)
+{
+    /* VALUE rint; */
+    uint32_t _int;
+    uint32_t result;
+
+    if (argc == 0 || argc > 2) {
+	rb_raise(rb_eArgError, "accept 1 or 2 arguments: (int32[, seed])");
+    }
+    _int = NUM2UINT(argv[0]);
+
+    result = MurmurHash3_x86_32(&_int, 4, argc == 1 ? 0 : NUM2UINT(argv[1]));
+
+    return UINT2NUM(result);
+}
+
+static VALUE
+rb_murmur3_32_int64_hash(int argc, VALUE* argv, VALUE self)
+{
+    /* VALUE rint; */
+    uint64_t _int;
+    uint32_t result;
+
+    if (argc == 0 || argc > 2) {
+	rb_raise(rb_eArgError, "accept 1 or 2 arguments: (int64[, seed])");
+    }
+#if SIZEOF_LONG == 8
+    _int = NUM2ULONG(argv[0]);
+#else
+    _int = NUM2ULL(argv[0]);
+#endif
+
+    result = MurmurHash3_x86_32(&_int, 8, argc == 1 ? 0 : NUM2UINT(argv[1]));
+
+    return UINT2NUM(result);
+}
+
+#define PREPARE_128_BIT()         \
+    VALUE rstr, rseed, ar_result; \
+    uint32_t result[4];           \
+
+#define SWAP_128_BIT() do {    \
+        uint32_t tmp;          \
+        tmp = result[0];       \
+        result[0] = result[1]; \
+        result[1] = tmp;       \
+        tmp = result[2];       \
+        result[2] = result[3]; \
+        result[3] = tmp;       \
+} while (0)
+
+#define RETURN_128_BIT()       \
+    ar_result = rb_ary_new2(4);      \
+    rb_ary_push(ar_result, UINT2NUM(result[0])); \
+    rb_ary_push(ar_result, UINT2NUM(result[1])); \
+    rb_ary_push(ar_result, UINT2NUM(result[2])); \
+    rb_ary_push(ar_result, UINT2NUM(result[3])); \
+    return ar_result
+
+static VALUE
+rb_murmur3_128_str_hash(int argc, VALUE* argv, VALUE self)
+{
+    VALUE rstr, ar_result;
+    uint32_t result[4];
+
+    if (argc == 0 || argc > 2) {
+	rb_raise(rb_eArgError, "accept 1 or 2 arguments: (string[, seed])");
+    }
+    rstr = argv[0];
+    StringValue(rstr);
+
+    MurmurHash3_x64_128(RSTRING_PTR(rstr), RSTRING_LEN(rstr), argc == 1 ? 0 : NUM2UINT(argv[1]), result);
+#if WORDS_BIGENDIAN
+    SWAP_128_BIT();
+#endif
+    RETURN_128_BIT();
+}
+
+static VALUE
+rb_murmur3_128_int32_hash(int argc, VALUE* argv, VALUE self)
+{
+    VALUE ar_result;
+    uint32_t result[4], _int;
+
+    if (argc == 0 || argc > 2) {
+	rb_raise(rb_eArgError, "accept 1 or 2 arguments: (int32[, seed])");
+    }
+    _int = NUM2UINT(argv[0]);
+    MurmurHash3_x64_128(&_int, 4, argc == 1 ? 0 : NUM2UINT(argv[1]), result);
+#if WORDS_BIGENDIAN
+    SWAP_128_BIT();
+#endif
+    RETURN_128_BIT();
+}
+
+static VALUE
+rb_murmur3_128_int64_hash(int argc, VALUE* argv, VALUE self)
+{
+    VALUE ar_result;
+    uint32_t result[4];
+    uint64_t _int;
+
+    if (argc == 0 || argc > 2) {
+	rb_raise(rb_eArgError, "accept 1 or 2 arguments: (int64[, seed])");
+    }
+#if SIZEOF_LONG == 8
+    _int = NUM2ULONG(argv[0]);
+#else
+    _int = NUM2ULL(argv[0]);
+#endif
+    MurmurHash3_x64_128(&_int, 8, argc == 1 ? 0 : NUM2UINT(argv[1]), result);
+#if WORDS_BIGENDIAN
+    SWAP_128_BIT();
+#endif
+    RETURN_128_BIT();
+}
+
+void
+Init_murmur_native() {
+    VALUE singleton;
+    VALUE mod_murmur = rb_define_module("MurmurRedux");
+    VALUE mod_murmur32 = rb_define_module_under(mod_murmur, "Native32");
+    VALUE mod_murmur128 = rb_define_module_under(mod_murmur, "Native128");
+
+    rb_define_method(mod_murmur32, "murmur3_32_fmix", rb_fmix32, 1);
+    rb_define_method(mod_murmur32, "murmur3_32_str_hash", rb_murmur3_32_str_hash, -1);
+    rb_define_method(mod_murmur32, "murmur3_32_int32_hash", rb_murmur3_32_int32_hash, -1);
+    rb_define_method(mod_murmur32, "murmur3_32_int64_hash", rb_murmur3_32_int64_hash, -1);
+
+    rb_extend_object(mod_murmur32, mod_murmur32);
+    singleton = rb_singleton_class(mod_murmur32);
+    rb_define_alias(singleton, "fmix", "murmur3_32_fmix");
+    rb_define_alias(singleton, "str_hash", "murmur3_32_str_hash");
+    rb_define_alias(singleton, "int32_hash", "murmur3_32_int32_hash");
+    rb_define_alias(singleton, "int64_hash", "murmur3_32_int64_hash");
+
+
+    rb_define_method(mod_murmur128, "murmur3_128_fmix", rb_fmix64, 1);
+    rb_define_method(mod_murmur128, "murmur3_128_str_hash", rb_murmur3_128_str_hash, -1);
+    rb_define_method(mod_murmur128, "murmur3_128_int32_hash", rb_murmur3_128_int32_hash, -1);
+    rb_define_method(mod_murmur128, "murmur3_128_int64_hash", rb_murmur3_128_int64_hash, -1);
+
+    rb_extend_object(mod_murmur128, mod_murmur128);
+    singleton = rb_singleton_class(mod_murmur128);
+    rb_define_alias(singleton, "fmix", "murmur3_128_fmix");
+    rb_define_alias(singleton, "str_hash", "murmur3_128_str_hash");
+    rb_define_alias(singleton, "int32_hash", "murmur3_128_int32_hash");
+    rb_define_alias(singleton, "int64_hash", "murmur3_128_int64_hash");
+
+}

data/lib/murmur_redux/hash.rb

@@ -2,14 +2,14 @@ module MurmurRedux
   class Hash
     class << self
       def digest(string)
-        ints = MurmurHash3::V128.str_hash(string)
+        ints = MurmurRedux::V128.str_hash(string)
 
-        gen_hex_string(ints)
+        generate_hex_string(ints)
       end
 
       private
 
-      def gen_hex_string(ints)
+      def generate_hex_string(ints)
         ints.pack('L*').unpack('H*').first
       end
     end

data/lib/murmur_redux/version.rb

@@ -1,3 +1,3 @@
 module MurmurRedux
-  VERSION = '0.0.1' unless defined? MurmurRedux::VERSION
+  VERSION = '1.0.0' unless defined? MurmurRedux::VERSION
 end

data/lib/murmur_redux.rb

@@ -1,6 +1,9 @@
-require 'murmurhash3'
+module MurmurRedux
+  require 'murmur_redux/murmur_native'
+  V32  = Native32
+  V128 = Native128
+end
 
 require 'murmur_redux/version'
 require 'murmur_redux/errors'
 require 'murmur_redux/hash'
-

data/murmur_redux.gemspec

@@ -1,20 +1,21 @@
-$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'rake'
 require 'murmur_redux/version'
 
-Gem::Specification.new do |s|
-  s.name          = 'murmur_redux'
-  s.version       = MurmurRedux::VERSION
-  s.platform      = Gem::Platform::RUBY
-  s.summary       = 'A simple wrapper around murmurhash3 gem with a nicer API.'
-  s.description   = 'A simple wrapper around murmurhash3 gem with a nicer API : MurmurRedux::Hash.digest(string)'
-  s.author        = 'Marian Posaceanu'
-  s.email         = 'contact@marianposaceanu.com'
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.require_paths = ['lib']
-  s.homepage      = 'https://github.com/dakull/murmur_redux'
+Gem::Specification.new do |gem|
+  gem.name          = 'murmur_redux'
+  gem.version       = MurmurRedux::VERSION
+  gem.platform      = Gem::Platform::RUBY
+  gem.summary       = 'A simple wrapper around murmurhash3 C extension.'
+  gem.description   = 'A simple wrapper around murmurhash3 C extension originally based on https://github.com/funny-falcon/murmurhash3-ruby'
+  gem.author        = 'Marian Posaceanu'
+  gem.email         = 'contact@marianposaceanu.com'
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ['lib', 'ext']
+  gem.homepage      = 'https://github.com/dakull/murmur_redux'
+  gem.extensions    = FileList["ext/**/extconf.rb"]
+  gem.license       = 'MIT'
 
-  s.required_ruby_version = '>= 1.9.2'
-
-  s.add_dependency('murmurhash3', '~> 0.1.3')
+  gem.required_ruby_version = '>= 1.9.2'
 end

data/spec/murmur_native_spec.rb

@@ -0,0 +1,55 @@
+shared_examples_128 = proc do
+  it 'should make correct hash for string' do
+    murmur.str_hash('asdfqwer', 0).should eq([0xd6d7d367, 0xcb41f064, 0x8973cd72, 0xc345e72e])
+    murmur.str_hash('asdfqwerzxcvyui', 0).should eq([0x007b2172f, 0x64ecae1b, 0x1813b5a5, 0x9c674ee6])
+    murmur.str_hash('asdfqwerzxcvyuio', 0).should eq([0xf508df57, 0xbb38f3fd, 0xf48c9d98, 0xb65c36cd])
+    murmur.str_hash('asdfqwerzxcvyuio!', 0).should eq([0x8a011755, 0xb13d463f, 0x8386d32a, 0x0df8884c])
+  end
+
+  it 'should make correct hash for 32bit integer' do
+    murmur.int32_hash(1717859169).should eq([0x20b48108, 0x10369ceb, 0x3ad523cc, 0xdacb587f])
+    murmur.int32_hash(1717859169).should eq(murmur.str_hash('asdf'))
+  end
+
+  it 'should make correct hash for 64bit integer' do
+    murmur.int64_hash(0x12345678).should eq(murmur.str_hash("\x78\x56\x34\x12\x00\x00\x00\x00"))
+    murmur.int64_hash(0x1234567812345678).should eq(murmur.str_hash("\x78\x56\x34\x12\x78\x56\x34\x12"))
+  end
+
+  it 'should make correct fmix for 64bit integer' do
+    murmur.fmix(1717859169).should eq(0xbefb9076a3712207)
+    murmur.fmix(12345678912345678).should eq(0x197ef59146f5221c)
+  end
+end
+
+shared_examples_32 = proc do
+  it 'should make correct hash for string' do
+    murmur.str_hash('asdfqwer', 0).should eq(0xa46b5209)
+    murmur.str_hash('asdfqwerty', 0).should eq(0xa3cfe04b)
+    murmur.str_hash('asd', 0).should eq(0x14570c6f)
+  end
+
+  it 'should make correct hash for 32bit integer' do
+    murmur.int32_hash(1717859169).should eq(0x1b20e026)
+    murmur.int32_hash(1717859169).should eq(murmur.str_hash('asdf'))
+  end
+
+  it 'should make correct hash for 64bit integer' do
+    murmur.int64_hash(0x12345678).should eq(murmur.str_hash("\x78\x56\x34\x12\x00\x00\x00\x00"))
+    murmur.int64_hash(0x1234567812345678).should eq(murmur.str_hash("\x78\x56\x34\x12\x78\x56\x34\x12"))
+  end
+
+  it 'should make correct fmix for 32bit integer' do
+    murmur.fmix(1717859169).should eq(0x17561734)
+  end
+end
+
+describe "Native 32" do
+  let(:murmur) { MurmurRedux::Native32 }
+  class_exec &shared_examples_32
+end
+
+describe "Native 128" do
+  let(:murmur) { MurmurRedux::Native128 }
+  class_exec &shared_examples_128
+end

data/spec/murmur_redux/hash_spec.rb

@@ -6,6 +6,6 @@ describe MurmurRedux::Hash do
   it 'digests an argument supplied string into a hexadecimal representation' do
     digested_string = MurmurRedux::Hash.digest(string_to_digest)
 
-    expect(digested_string).should eq('df65d6d2d12d51f164c5f3a85066322c')
+    expect(digested_string).to eq('df65d6d2d12d51f164c5f3a85066322c')
   end
 end

metadata

@@ -1,33 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: murmur_redux
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Marian Posaceanu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-08 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: murmurhash3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.1.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.1.3
-description: 'A simple wrapper around murmurhash3 gem with a nicer API : MurmurRedux::Hash.digest(string)'
+date: 2013-09-21 00:00:00.000000000 Z
+dependencies: []
+description: A simple wrapper around murmurhash3 C extension originally based on https://github.com/funny-falcon/murmurhash3-ruby
 email: contact@marianposaceanu.com
 executables: []
-extensions: []
+extensions:
+- ext/murmur_native/extconf.rb
 extra_rdoc_files: []
 files:
 - .gitignore
@@ -37,20 +24,26 @@ files:
 - Gemfile
 - Guardfile
 - README.md
+- Rakefile
+- ext/murmur_native/extconf.rb
+- ext/murmur_native/murmur_native.c
 - lib/murmur_redux.rb
 - lib/murmur_redux/errors.rb
 - lib/murmur_redux/hash.rb
 - lib/murmur_redux/version.rb
 - murmur_redux.gemspec
+- spec/murmur_native_spec.rb
 - spec/murmur_redux/hash_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/dakull/murmur_redux
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
+- ext
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
@@ -63,8 +56,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
-summary: A simple wrapper around murmurhash3 gem with a nicer API.
+summary: A simple wrapper around murmurhash3 C extension.
 test_files: []