xxhash 0.4.0 → 0.6.0

data/ext/xxhash/xxhash.c

@@ -1,17 +1,96 @@
 #include "xxhash.h"
 
+VALUE xxhash_xxh32_file(VALUE mod, VALUE filename, VALUE seed)
+{
+  StringValue(filename);
+
+  XXH32_state_t* state = XXH32_createState();
+  if (state == NULL) {
+    rb_raise(rb_eRuntimeError, "%s", "Cannot create state, out of memory");
+  }
+
+  XXH32_reset(state, NUM2INT(seed));
+
+  char buffer[16384];
+  size_t count;
+  FILE *fp = fopen(RSTRING_PTR(filename), "rb");
+  if (fp == NULL) {
+    XXH32_freeState(state);
+    VALUE error = INT2FIX(errno);
+    rb_exc_raise(rb_class_new_instance(1, &error, rb_eSystemCallError));
+  }
+
+  while ((count = fread(buffer, 1, sizeof(buffer), fp)) != 0) {
+    XXH32_update(state, buffer, count);
+  }
+  fclose(fp);
+
+  XXH32_hash_t result = XXH32_digest(state);
+
+  XXH32_freeState(state);
+  return ULL2NUM(result);
+}
+
+VALUE xxhash_xxh64_file(VALUE mod, VALUE filename, VALUE seed)
+{
+  StringValue(filename);
+
+  XXH64_state_t* state = XXH64_createState();
+  if (state == NULL) {
+    rb_raise(rb_eRuntimeError, "%s", "Cannot create state, out of memory");
+  }
+
+  XXH64_reset(state, NUM2INT(seed));
+
+  char buffer[16384];
+  size_t count;
+  FILE *fp = fopen(RSTRING_PTR(filename), "rb");
+  if (fp == NULL) {
+    XXH64_freeState(state);
+    VALUE error = INT2FIX(errno);
+    rb_exc_raise(rb_class_new_instance(1, &error, rb_eSystemCallError));
+  }
+
+  while ((count = fread(buffer, 1, sizeof(buffer), fp)) != 0) {
+    XXH64_update(state, buffer, count);
+  }
+  fclose(fp);
+
+  XXH64_hash_t result = XXH64_digest(state);
+
+  XXH64_freeState(state);
+  return ULL2NUM(result);
+}
+
 VALUE xxhash_xxh32(VALUE mod, VALUE input, VALUE seed)
 {
   return ULL2NUM(XXH32(StringValuePtr(input), (size_t)RSTRING_LEN(input), (unsigned int)NUM2ULL(seed)));
 }
 
-void xxhash32_streaming_hash_free(xxhash_xxh32_t* storage)
+static void xxhash32_streaming_hash_free(void *ptr)
 {
+  xxhash_xxh32_t* storage = (xxhash_xxh32_t*)ptr;
   // Digest frees the memory.
   XXH32_freeState(storage->state);
   xfree(storage);
 }
 
+static size_t xxhash32_streaming_hash_memsize(const void *ptr)
+{
+  // Ideally we'd include sizeof(XXH32_state_t) too, but the type is opaque.
+  return sizeof(xxhash_xxh32_t);
+}
+
+static const rb_data_type_t xxhash_xxh32_type = {
+    .wrap_struct_name = "xxhash/xxhash32_streaming_hash",
+    .function = {
+        .dmark = NULL,
+        .dfree = xxhash32_streaming_hash_free,
+        .dsize = xxhash32_streaming_hash_memsize,
+    },
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 VALUE xxhash32_streaming_hash_new(VALUE klass, VALUE seed)
 {
   XXH_errorcode code;
@@ -24,14 +103,14 @@ VALUE xxhash32_streaming_hash_new(VALUE klass, VALUE seed)
     rb_raise(rb_eRuntimeError, "Error during reset.");
     return Qnil;
   }
-  return Data_Wrap_Struct(klass, 0, xxhash32_streaming_hash_free, storage);
+  return TypedData_Wrap_Struct(klass, &xxhash_xxh32_type, storage);
 }
 
 VALUE xxhash32_streaming_hash_reset(VALUE self)
 {
   XXH_errorcode code;
   xxhash_xxh32_t* storage;
-  Data_Get_Struct(self, xxhash_xxh32_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh32_t, &xxhash_xxh32_type, storage);
 
   code = XXH32_reset(storage->state, storage->seed);
   if(code != XXH_OK) {
@@ -45,7 +124,7 @@ VALUE xxhash32_streaming_hash_update(VALUE self, VALUE data)
 {
   XXH_errorcode code;
   xxhash_xxh32_t* storage;
-  Data_Get_Struct(self, xxhash_xxh32_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh32_t, &xxhash_xxh32_type, storage);
 
   code = XXH32_update(storage->state, StringValuePtr(data), (size_t)RSTRING_LEN(data));
   if(code != XXH_OK) {
@@ -57,7 +136,7 @@ VALUE xxhash32_streaming_hash_update(VALUE self, VALUE data)
 VALUE xxhash32_streaming_hash_digest(VALUE self)
 {
   xxhash_xxh32_t* storage;
-  Data_Get_Struct(self, xxhash_xxh32_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh32_t, &xxhash_xxh32_type, storage);
 
   // Do not free memory now.
   return ULL2NUM(XXH32_digest(storage->state));
@@ -68,13 +147,30 @@ VALUE xxhash_xxh64(VALUE mod, VALUE input, VALUE seed)
   return ULL2NUM(XXH64(StringValuePtr(input), (size_t)RSTRING_LEN(input), (unsigned int)NUM2ULL(seed)));
 }
 
-void xxhash64_streaming_hash_free(xxhash_xxh64_t* storage)
+static void xxhash64_streaming_hash_free(void *ptr)
 {
+  xxhash_xxh64_t* storage = (xxhash_xxh64_t*)ptr;
   // Digest frees the memory.
   XXH64_freeState(storage->state);
   xfree(storage);
 }
 
+static size_t xxhash64_streaming_hash_memsize(const void *ptr)
+{
+  // Ideally we'd include sizeof(XXH64_state_t) too, but the type is opaque.
+  return sizeof(xxhash_xxh64_t);
+}
+
+static const rb_data_type_t xxhash_xxh64_type = {
+    .wrap_struct_name = "xxhash/xxhash64_streaming_hash",
+    .function = {
+        .dmark = NULL,
+        .dfree = xxhash64_streaming_hash_free,
+        .dsize = xxhash64_streaming_hash_memsize,
+    },
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 VALUE xxhash64_streaming_hash_new(VALUE klass, VALUE seed)
 {
   XXH_errorcode code;
@@ -88,14 +184,14 @@ VALUE xxhash64_streaming_hash_new(VALUE klass, VALUE seed)
     rb_raise(rb_eRuntimeError, "Error during reset.");
     return Qnil;
   }
-  return Data_Wrap_Struct(klass, 0, xxhash64_streaming_hash_free, storage);
+  return TypedData_Wrap_Struct(klass, &xxhash_xxh64_type, storage);
 }
 
 VALUE xxhash64_streaming_hash_reset(VALUE self)
 {
   XXH_errorcode code;
   xxhash_xxh64_t* storage;
-  Data_Get_Struct(self, xxhash_xxh64_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh64_t, &xxhash_xxh64_type, storage);
 
   code = XXH64_reset(storage->state, storage->seed);
   if(code != XXH_OK) {
@@ -108,7 +204,7 @@ VALUE xxhash64_streaming_hash_update(VALUE self, VALUE data)
 {
   XXH_errorcode code;
   xxhash_xxh64_t* storage;
-  Data_Get_Struct(self, xxhash_xxh64_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh64_t, &xxhash_xxh64_type, storage);
 
   code = XXH64_update(storage->state, StringValuePtr(data), (size_t)RSTRING_LEN(data));
   if(code != XXH_OK) {
@@ -120,7 +216,7 @@ VALUE xxhash64_streaming_hash_update(VALUE self, VALUE data)
 VALUE xxhash64_streaming_hash_digest(VALUE self)
 {
   xxhash_xxh64_t* storage;
-  Data_Get_Struct(self, xxhash_xxh64_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh64_t, &xxhash_xxh64_type, storage);
 
   // Do not free memory now.
   return ULL2NUM(XXH64_digest(storage->state));
@@ -129,6 +225,10 @@ VALUE xxhash64_streaming_hash_digest(VALUE self)
 
 void Init_xxhash(void)
 {
+  #ifdef HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+  #endif
+
   VALUE cStreamingHash;
   VALUE cStreamingHash64;
   VALUE mXXhash;
@@ -138,9 +238,12 @@ void Init_xxhash(void)
   mInternal = rb_define_module_under(mXXhash, "XXhashInternal");
 
   rb_define_singleton_method(mInternal, "xxh32", (ruby_method*) &xxhash_xxh32, 2);
+  rb_define_singleton_method(mInternal, "xxh32_file", (ruby_method*) &xxhash_xxh32_file, 2);
   rb_define_singleton_method(mInternal, "xxh64", (ruby_method*) &xxhash_xxh64, 2);
+  rb_define_singleton_method(mInternal, "xxh64_file", (ruby_method*) &xxhash_xxh64_file, 2);
 
   cStreamingHash = rb_define_class_under(mInternal, "StreamingHash32", rb_cObject);
+  rb_undef_alloc_func(cStreamingHash);
 
   rb_define_singleton_method(cStreamingHash, "new", (ruby_method*) &xxhash32_streaming_hash_new, 1);
   rb_define_method(cStreamingHash, "update", (ruby_method*) &xxhash32_streaming_hash_update, 1);
@@ -148,6 +251,7 @@ void Init_xxhash(void)
   rb_define_method(cStreamingHash, "reset", (ruby_method*) &xxhash32_streaming_hash_reset, 0);
 
   cStreamingHash64 = rb_define_class_under(mInternal, "StreamingHash64", rb_cObject);
+  rb_undef_alloc_func(cStreamingHash64);
 
   rb_define_singleton_method(cStreamingHash64, "new", (ruby_method*) &xxhash64_streaming_hash_new, 1);
   rb_define_method(cStreamingHash64, "update", (ruby_method*) &xxhash64_streaming_hash_update, 1);

data/ext/xxhash/xxhash.h

@@ -1,4 +1,5 @@
 #include <stdlib.h>
+#include <errno.h>
 #include <ruby.h>
 #include "libxxhash.h"
 
@@ -17,13 +18,13 @@ typedef struct {
 typedef VALUE (ruby_method)();
 
 VALUE xxhash_xxh32(VALUE mod, VALUE input, VALUE seed);
-void xxhash32_streaming_hash_free(xxhash_xxh32_t* state);
+VALUE xxhash_xxh32_file(VALUE mod, VALUE filename, VALUE seed);
 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(xxhash_xxh64_t* state);
+VALUE xxhash_xxh64_file(VALUE mod, VALUE filename, VALUE seed);
 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);

data/lib/xxhash/version.rb

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

data/lib/xxhash.rb

@@ -11,6 +11,14 @@ module XXhash
     XXhashInternal.xxh64(input.to_s, seed.to_i)
   end
 
+  def self.xxh32_file(filename, seed = 0)
+    XXhashInternal.xxh32_file(filename.to_s, seed.to_i)
+  end
+
+  def self.xxh64_file(filename, seed = 0)
+    XXhashInternal.xxh64_file(filename.to_s, seed.to_i)
+  end
+
   def self.xxh32_stream(io, seed = 0, chunk_size = 32)
     seed = seed.to_i
     chunk_size = chunk_size.to_i

data/test/xxhash_test.rb

@@ -2,19 +2,50 @@ require_relative 'test_helper'
 require 'stringio'
 
 describe XXhash do
+  it 'is marked as ractor-safe' do
+    skip("Ractorrs are not supported in this version of ruby(#{RUBY_VERSION})") unless defined?(Ractor)
+
+    ractor = Ractor.new do
+      Ractor.yield XXhash.xxh32(Ractor.receive)
+    end
+
+    ractor.send('test')
+    assert_equal ractor.take, XXhash.xxh32('test')
+  end
+
   it 'returns 32-bit hash' do
     assert_equal 2758658570, XXhash.xxh32('test', 123)
   end
 
+  it 'returns 32-bit hash from a file' do
+    assert_equal XXhash.xxh32(File.read(__FILE__)), XXhash.xxh32_file(__FILE__)
+    assert_equal XXhash.xxh32(File.read(__FILE__), 123), XXhash.xxh32_file(__FILE__, 123)
+  end
+
   it 'returns 64-bit hash' do
     assert_equal 3134990500624303823, XXhash.xxh64('test', 123)
   end
 
+  it 'returns 64-bit hash from a file' do
+    assert_equal XXhash.xxh64(File.read(__FILE__)), XXhash.xxh64_file(__FILE__)
+    assert_equal XXhash.xxh64(File.read(__FILE__), 123), XXhash.xxh64_file(__FILE__, 123)
+  end
+
   it 'uses 0 (default value) if seed is not specified' do
     assert_equal 1042293711, XXhash.xxh32('test')
     assert_equal 5754696928334414137, XXhash.xxh64('test')
   end
 
+  it 'raises an Errno exception for invalid file' do
+    assert_raises Errno::ENOENT do
+      XXhash.xxh32_file('nonexistent-file')
+    end
+
+    assert_raises Errno::ENOENT do
+      XXhash.xxh64_file('nonexistent-file')
+    end
+  end
+
   describe 'XXhashInternal::StreamingHash32' do
 
     it 'rises ArgumentError if first argument is not IO object' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xxhash
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Vasiliy Ermolovich
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-12-11 00:00:00.000000000 Z
+date: 2024-12-19 00:00:00.000000000 Z
 dependencies: []
 description: Ruby wrapper for xxHash lib
 email:
@@ -18,8 +18,8 @@ extensions:
 - ext/xxhash/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
-- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -39,7 +39,7 @@ homepage: http://github.com/nashby/xxhash
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -54,9 +54,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: Ruby wrapper for xxHash lib
 test_files:

data/.travis.yml

@@ -1,9 +0,0 @@
-language: ruby
-before_install:
-  - gem install bundler
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1
-  - 2.2
-script: "bundle exec rake test"