xxhash 0.3.0 → 0.4.0

data/ext/xxhash/xxhash.h

@@ -1,18 +1,31 @@
+#include <stdlib.h>
 #include <ruby.h>
 #include "libxxhash.h"
 
+typedef struct {
+  XXH32_state_t* state;
+  unsigned int seed;
+} xxhash_xxh32_t;
+
+typedef struct {
+  XXH64_state_t* state;
+  unsigned int seed;
+} xxhash_xxh64_t;
+
 // Use this typedef to make the compiler happy when
 // calling rb_define_method()
 typedef VALUE (ruby_method)();
 
 VALUE xxhash_xxh32(VALUE mod, VALUE input, VALUE seed);
-void xxhash32_streaming_hash_free(XXH32_state_t* state);
+void xxhash32_streaming_hash_free(xxhash_xxh32_t* state);
 VALUE xxhash32_streaming_hash_new(VALUE klass, VALUE seed);
 VALUE xxhash32_streaming_hash_update(VALUE self, VALUE data);
+VALUE xxhash32_streaming_hash_reset(VALUE self);
 VALUE xxhash32_streaming_hash_digest(VALUE self);
 VALUE xxhash_xxh64(VALUE mod, VALUE input, VALUE seed);
-void xxhash64_streaming_hash_free(XXH64_state_t* state);
+void xxhash64_streaming_hash_free(xxhash_xxh64_t* state);
 VALUE xxhash64_streaming_hash_new(VALUE klass, VALUE seed);
 VALUE xxhash64_streaming_hash_update(VALUE self, VALUE data);
+VALUE xxhash64_streaming_hash_reset(VALUE self);
 VALUE xxhash64_streaming_hash_digest(VALUE self);
 void Init_xxhash(void);

data/lib/xxhash.rb

@@ -1,36 +1,96 @@
 require 'xxhash/version'
 require 'xxhash/xxhash'
+require 'digest'
 
 module XXhash
   def self.xxh32(input, seed = 0)
-    XXhashInternal.xxh32(input, seed)
+    XXhashInternal.xxh32(input.to_s, seed.to_i)
   end
 
   def self.xxh64(input, seed = 0)
-    XXhashInternal.xxh64(input, seed)
+    XXhashInternal.xxh64(input.to_s, seed.to_i)
   end
 
   def self.xxh32_stream(io, seed = 0, chunk_size = 32)
-    raise ArgumentError, 'first argument should be IO' if !io.is_a?(IO) && !io.is_a?(StringIO)
+    seed = seed.to_i
+    chunk_size = chunk_size.to_i
+    raise ArgumentError, 'first argument should be IO' if !io.respond_to?(:read)
 
     hash = XXhashInternal::StreamingHash32.new(seed)
 
     while chunk = io.read(chunk_size)
-      hash.update(chunk)
+      hash.update(chunk.to_s)
     end
 
     hash.digest
   end
 
   def self.xxh64_stream(io, seed = 0, chunk_size = 32)
-    raise ArgumentError, 'first argument should be IO' if !io.is_a?(IO) && !io.is_a?(StringIO)
+    seed = seed.to_i
+    chunk_size = chunk_size.to_i
+    raise ArgumentError, 'first argument should be IO' if !io.respond_to?(:read)
 
     hash = XXhashInternal::StreamingHash64.new(seed)
 
     while chunk = io.read(chunk_size)
-      hash.update(chunk)
+      hash.update(chunk.to_s)
     end
 
     hash.digest
   end
+
+end
+
+module Digest
+  class XXHash < Digest::Class
+    attr_reader :digest_length
+
+    def initialize(bitlen, seed = 0)
+      bitlen = bitlen.to_i
+      seed = seed.to_i
+      @hash = case bitlen
+      when 32
+        XXhash::XXhashInternal::StreamingHash32.new(seed)
+      when 64
+        XXhash::XXhashInternal::StreamingHash64.new(seed)
+      else
+        raise ArgumentError, "Unsupported bit length: %s" % bitlen.inspect
+      end
+
+      @digest_length = bitlen
+    end
+
+    def update(chunk)
+      @hash.update(chunk.to_s)
+    end
+
+    def digest(val = nil)
+      @hash.update(val) if val
+
+      @hash.digest
+    end
+
+    def digest!(val = nil)
+      result = digest(val)
+      @hash.reset
+
+      result
+    end
+
+    def reset
+      @hash.reset
+    end
+  end
+
+  class XXHash32 < Digest::XXHash
+    def initialize(seed = 0)
+      super(32, seed.to_i)
+    end
+  end
+
+  class XXHash64 < Digest::XXHash
+    def initialize(seed = 0)
+      super(64, seed.to_i)
+    end
+  end
 end

data/lib/xxhash/version.rb

@@ -1,3 +1,3 @@
 module XXhash
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/test/xxhash_test.rb

@@ -15,7 +15,7 @@ describe XXhash do
     assert_equal 5754696928334414137, XXhash.xxh64('test')
   end
 
-  describe 'StreamingHash32' do
+  describe 'XXhashInternal::StreamingHash32' do
 
     it 'rises ArgumentError if first argument is not IO object' do
       assert_raises(ArgumentError) do
@@ -34,7 +34,7 @@ describe XXhash do
     end
   end
 
-  describe 'StreamingHash64' do
+  describe 'XXhashInternal::StreamingHash64' do
     it 'rises ArgumentError if first argument is not IO object' do
       assert_raises(ArgumentError) do
         XXhash.xxh64_stream('test', 123)
@@ -50,5 +50,81 @@ describe XXhash do
       h2 = XXhash.xxh64_stream(File.open(__FILE__), 123)
       assert_equal h1, h2
     end
+
+    it 'exception (not segfault) on nil' do
+      begin
+        XXhash.xxh64(nil)
+        fail
+      rescue
+      end
+    end
   end
+
+  def use_external_hash hash, io, chunk_size=1024
+    while chunk=io.read(chunk_size)
+      hash.update(chunk)
+    end
+    hash.digest
+  end
+
+  describe 'Digest::XXhash32' do
+
+    it 'returns the hash for streamed strings' do
+      StringIO.open('test') do |io|
+        xxhash = Digest::XXHash32.new(123)
+        result = use_external_hash xxhash, io
+        assert_equal 2758658570, result
+      end
+    end
+
+    it 'returns the hash for streamed files' do
+      h1 = XXhash.xxh32(File.read(__FILE__), 123)
+      xxhash = Digest::XXHash32.new(123)
+      result = use_external_hash xxhash, File.open(__FILE__)
+      assert_equal h1, result
+    end
+
+    it 'returns correct hash after a reset' do
+      h1 = XXhash.xxh32(File.read(__FILE__), 123)
+      xxhash = Digest::XXHash32.new(123)
+      assert_equal 2758658570, xxhash.digest('test')
+      xxhash.reset
+      result = use_external_hash xxhash, File.open(__FILE__)
+      assert_equal h1, result
+    end
+
+    it 'exception (not segfault) on nil' do
+      begin
+        XXhash.xxh32(nil)
+      rescue
+      end
+    end
+  end
+
+  describe 'Digest::XXhash64' do
+    it 'returns the hash for streamed strings' do
+      StringIO.open('test') do |io|
+        xxhash = Digest::XXHash64.new(123)
+        result = use_external_hash xxhash, io
+        assert_equal 3134990500624303823, result
+      end
+    end
+
+    it 'returns the hash for streamed files' do
+      h1 = XXhash.xxh64(File.read(__FILE__), 123)
+      xxhash = Digest::XXHash64.new(123)
+      result = use_external_hash xxhash, File.open(__FILE__)
+      assert_equal h1, result
+    end
+
+    it 'returns correct hash after reset' do
+      h1 = XXhash.xxh64(File.read(__FILE__), 123)
+      xxhash = Digest::XXHash64.new(123)
+      assert_equal 3134990500624303823, xxhash.digest('test')
+      xxhash.reset
+      result = use_external_hash xxhash, File.open(__FILE__)
+      assert_equal h1, result
+    end
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xxhash
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Vasiliy Ermolovich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-18 00:00:00.000000000 Z
+date: 2016-12-11 00:00:00.000000000 Z
 dependencies: []
 description: Ruby wrapper for xxHash lib
 email:
@@ -55,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby wrapper for xxHash lib