zstd-ruby 1.5.6.5 → 1.5.6.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63e93f85ee472c512ed26f0e7da7fd352b143fab32dcf5e902772bc1f202c7b0
-  data.tar.gz: 681ea9a091527554620a032b003f578684a743ecba43c66dfb1682b1e15db794
+  metadata.gz: 9acf1d7797f3431d0df130388295910e47c9bdaf36df29e1f116a55b993c130d
+  data.tar.gz: c58e20e6f0c2d270a21481b8ac2ba1c427d8cc6b1c2e52305e5b7540fcda41bc
 SHA512:
-  metadata.gz: 4245143daaf4a8c905e7c82eec53c60fcf391f55e21fa1f39c9aca76cccefedc6c90a25a9c581255f6fc3ea909501eb83a219c461b1b24b1f2e6552c4281d16e
-  data.tar.gz: 6294213e536fd3117e6f2de7efdb58d9754344bc9d4aff83ec6943e0958dfe4e1cdae9316c6ca2a778e08f6573390fdf026f053677def60aa92abf8e5c98518f
+  metadata.gz: 9fad54c87b430ddbd437dd5e238b873c7572b2ed23e7b2a6409b817e1a823ab943bd49278c989abc1470a30c7fc8ad983fcf18a0b1dad84f8b99625fee2e6097
+  data.tar.gz: d8dd762266849d491ac971bd7eb764ea9bda42da6ef6fbd351bc91ab792e18009f1d52f8005734489776c049b4ef82bd25042020be8cb286c73f94af86b1a2c7

data/.gitignore

@@ -1,3 +1,4 @@
+.DS_Store
 /.bundle/
 /.yardoc
 /Gemfile.lock

data/README.md

@@ -49,6 +49,22 @@ compressed_data = Zstd.compress(data, level: complession_level) # default compre
 compressed_using_dict = Zstd.compress("", dict: File.read('dictionary_file'))
 ```
 
+#### Compression with CDict
+
+If you use the same dictionary repeatedly, you can speed up the setup by creating CDict in advance:
+
+```ruby
+cdict = Zstd::CDict.new(File.read('dictionary_file'))
+compressed_using_dict = Zstd.compress("", dict: cdict)
+```
+
+The compression_level can be specified on creating CDict.
+
+```ruby
+cdict = Zstd::CDict.new(File.read('dictionary_file'), 5)
+compressed_using_dict = Zstd.compress("", dict: cdict)
+```
+
 #### Streaming Compression
 ```ruby
 stream = Zstd::StreamingCompress.new
@@ -86,6 +102,16 @@ stream << "ghi"
 res << stream.finish
 ```
 
+#### Streaming Compression with CDict of level 5
+```ruby
+cdict = Zstd::CDict.new(File.read('dictionary_file', 5)
+stream = Zstd::StreamingCompress.new(dict: cdict)
+stream << "abc" << "def"
+res = stream.flush
+stream << "ghi"
+res << stream.finish
+```
+
 ### Decompression
 
 #### Simple Decompression
@@ -100,6 +126,15 @@ data = Zstd.decompress(compressed_data)
 Zstd.decompress(compressed_using_dict, dict: File.read('dictionary_file'))
 ```
 
+#### Decompression with DDict
+
+If you use the same dictionary repeatedly, you can speed up the setup by creating DDict in advance:
+
+```ruby
+ddict = Zstd::Ddict.new(File.read('dictionary_file'))
+data = Zstd.compress(compressed_using_dict, ddict)
+```
+
 #### Streaming Decompression
 ```ruby
 cstr = "" # Compressed data
@@ -118,6 +153,8 @@ result << stream.decompress(cstr[0, 10])
 result << stream.decompress(cstr[10..-1])
 ```
 
+DDict can also be specified to `dict:`.
+
 ### Skippable frame
 
 ```ruby
@@ -127,6 +164,45 @@ Zstd.read_skippable_frame(compressed_data_with_skippable_frame)
 # => "sample data"
 ```
 
+### Stream Writer and Reader Wrapper
+**EXPERIMENTAL**
+
+* These features are experimental and may be subject to API changes in future releases.
+* There may be performance and compatibility issues, so extensive testing is required before production use.
+* If you have any questions, encounter bugs, or have suggestions, please report them via [GitHub issues](https://github.com/SpringMT/zstd-ruby/issues).
+
+#### Zstd::StreamWriter
+
+```ruby
+require 'stringio'
+require 'zstd-ruby'
+
+io = StringIO.new
+stream = Zstd::StreamWriter.new(io)
+stream.write("abc")
+stream.finish
+
+io.rewind
+# Retrieve the compressed data
+compressed_data = io.read
+```
+
+#### Zstd::StreamReader
+
+```ruby
+require 'stringio'
+require 'zstd-ruby' # Add the appropriate require statement if necessary
+
+io = StringIO.new(compressed_data)
+reader = Zstd::StreamReader.new(io)
+
+# Read and output the decompressed data
+puts reader.read(10)  # 'abc'
+puts reader.read(10)  # 'def'
+puts reader.read(10)  # '' (end of data)
+```
+
+
 ## JRuby
 This gem does not support JRuby.
 

data/ext/zstdruby/common.h

@@ -1,13 +1,15 @@
 #ifndef ZSTD_RUBY_H
 #define ZSTD_RUBY_H 1
 
+#include <stdbool.h>
 #include <ruby.h>
 #ifdef HAVE_RUBY_THREAD_H
 #include <ruby/thread.h>
 #endif
-#include <stdbool.h>
 #include "./libzstd/zstd.h"
 
+extern VALUE rb_cCDict, rb_cDDict;
+
 static int convert_compression_level(VALUE compression_level_value)
 {
   if (NIL_P(compression_level_value)) {
@@ -34,12 +36,24 @@ static void set_compress_params(ZSTD_CCtx* const ctx, VALUE level_from_args, VAL
   ZSTD_CCtx_setParameter(ctx, ZSTD_c_compressionLevel, compression_level);
 
   if (kwargs_values[1] != Qundef && kwargs_values[1] != Qnil) {
-    char* dict_buffer = RSTRING_PTR(kwargs_values[1]);
-    size_t dict_size = RSTRING_LEN(kwargs_values[1]);
-    size_t load_dict_ret = ZSTD_CCtx_loadDictionary(ctx, dict_buffer, dict_size);
-    if (ZSTD_isError(load_dict_ret)) {
+    if (CLASS_OF(kwargs_values[1]) == rb_cCDict) {
+      ZSTD_CDict* cdict = DATA_PTR(kwargs_values[1]);
+      size_t ref_dict_ret = ZSTD_CCtx_refCDict(ctx, cdict);
+      if (ZSTD_isError(ref_dict_ret)) {
+        ZSTD_freeCCtx(ctx);
+        rb_raise(rb_eRuntimeError, "%s", "ZSTD_CCtx_refCDict failed");
+      }
+    } else if (TYPE(kwargs_values[1]) == T_STRING) {
+      char* dict_buffer = RSTRING_PTR(kwargs_values[1]);
+      size_t dict_size = RSTRING_LEN(kwargs_values[1]);
+      size_t load_dict_ret = ZSTD_CCtx_loadDictionary(ctx, dict_buffer, dict_size);
+      if (ZSTD_isError(load_dict_ret)) {
+        ZSTD_freeCCtx(ctx);
+        rb_raise(rb_eRuntimeError, "%s", "ZSTD_CCtx_loadDictionary failed");
+      }
+    } else {
       ZSTD_freeCCtx(ctx);
-      rb_raise(rb_eRuntimeError, "%s", "ZSTD_CCtx_loadDictionary failed");
+      rb_raise(rb_eArgError, "`dict:` must be a Zstd::CDict or a String");
     }
   }
 }
@@ -113,12 +127,24 @@ static void set_decompress_params(ZSTD_DCtx* const dctx, VALUE kwargs)
   rb_get_kwargs(kwargs, kwargs_keys, 0, 1, kwargs_values);
 
   if (kwargs_values[0] != Qundef && kwargs_values[0] != Qnil) {
-    char* dict_buffer = RSTRING_PTR(kwargs_values[0]);
-    size_t dict_size = RSTRING_LEN(kwargs_values[0]);
-    size_t load_dict_ret = ZSTD_DCtx_loadDictionary(dctx, dict_buffer, dict_size);
-    if (ZSTD_isError(load_dict_ret)) {
+    if (CLASS_OF(kwargs_values[0]) == rb_cDDict) {
+      ZSTD_DDict* ddict = DATA_PTR(kwargs_values[0]);
+      size_t ref_dict_ret = ZSTD_DCtx_refDDict(dctx, ddict);
+      if (ZSTD_isError(ref_dict_ret)) {
+        ZSTD_freeDCtx(dctx);
+        rb_raise(rb_eRuntimeError, "%s", "ZSTD_DCtx_refDDict failed");
+      }
+    } else if (TYPE(kwargs_values[0]) == T_STRING) {
+      char* dict_buffer = RSTRING_PTR(kwargs_values[0]);
+      size_t dict_size = RSTRING_LEN(kwargs_values[0]);
+      size_t load_dict_ret = ZSTD_DCtx_loadDictionary(dctx, dict_buffer, dict_size);
+      if (ZSTD_isError(load_dict_ret)) {
+        ZSTD_freeDCtx(dctx);
+        rb_raise(rb_eRuntimeError, "%s", "ZSTD_CCtx_loadDictionary failed");
+      }
+    } else {
       ZSTD_freeDCtx(dctx);
-      rb_raise(rb_eRuntimeError, "%s", "ZSTD_CCtx_loadDictionary failed");
+      rb_raise(rb_eArgError, "`dict:` must be a Zstd::DDict or a String");
     }
   }
 }

data/ext/zstdruby/main.c

@@ -1,6 +1,8 @@
 #include "common.h"
 
 VALUE rb_mZstd;
+VALUE rb_cCDict;
+VALUE rb_cDDict;
 void zstd_ruby_init(void);
 void zstd_ruby_skippable_frame_init(void);
 void zstd_ruby_streaming_compress_init(void);
@@ -14,6 +16,8 @@ Init_zstdruby(void)
 #endif
 
   rb_mZstd = rb_define_module("Zstd");
+  rb_cCDict = rb_define_class_under(rb_mZstd, "CDict", rb_cObject);
+  rb_cDDict = rb_define_class_under(rb_mZstd, "DDict", rb_cObject);
   zstd_ruby_init();
   zstd_ruby_skippable_frame_init();
   zstd_ruby_streaming_compress_init();

data/ext/zstdruby/zstdruby.c

@@ -87,13 +87,13 @@ static VALUE rb_compress_using_dict(int argc, VALUE *argv, VALUE self)
 
 static VALUE decompress_buffered(ZSTD_DCtx* dctx, const char* input_data, size_t input_size)
 {
-  VALUE output_string = rb_str_new(NULL, 0);
-  ZSTD_outBuffer output = { NULL, 0, 0 };
-
   ZSTD_inBuffer input = { input_data, input_size, 0 };
+  VALUE result = rb_str_new(0, 0);
+
   while (input.pos < input.size) {
+    ZSTD_outBuffer output = { NULL, 0, 0 };
     output.size += ZSTD_DStreamOutSize();
-    rb_str_resize(output_string, output.size);
+    VALUE output_string = rb_str_new(NULL, output.size);
     output.dst = RSTRING_PTR(output_string);
 
     size_t ret = zstd_stream_decompress(dctx, &output, &input, false);
@@ -101,10 +101,10 @@ static VALUE decompress_buffered(ZSTD_DCtx* dctx, const char* input_data, size_t
       ZSTD_freeDCtx(dctx);
       rb_raise(rb_eRuntimeError, "%s: %s", "ZSTD_decompressStream failed", ZSTD_getErrorName(ret));
     }
+    rb_str_cat(result, output.dst, output.pos);
   }
-  rb_str_resize(output_string, output.pos);
   ZSTD_freeDCtx(dctx);
-  return output_string;
+  return result;
 }
 
 static VALUE rb_decompress(int argc, VALUE *argv, VALUE self)
@@ -134,7 +134,7 @@ static VALUE rb_decompress(int argc, VALUE *argv, VALUE self)
   VALUE output = rb_str_new(NULL, uncompressed_size);
   char* output_data = RSTRING_PTR(output);
 
-  size_t const decompress_size =  zstd_decompress(dctx, output_data, uncompressed_size, input_data, input_size, false);
+  size_t const decompress_size = zstd_decompress(dctx, output_data, uncompressed_size, input_data, input_size, false);
   if (ZSTD_isError(decompress_size)) {
     rb_raise(rb_eRuntimeError, "%s: %s", "decompress error", ZSTD_getErrorName(decompress_size));
   }
@@ -195,6 +195,90 @@ static VALUE rb_decompress_using_dict(int argc, VALUE *argv, VALUE self)
   return output;
 }
 
+static void free_cdict(void *dict)
+{
+  ZSTD_freeCDict(dict);
+}
+
+static size_t sizeof_cdict(const void *dict)
+{
+  return ZSTD_sizeof_CDict(dict);
+}
+
+static void free_ddict(void *dict)
+{
+  ZSTD_freeDDict(dict);
+}
+
+static size_t sizeof_ddict(const void *dict)
+{
+  return ZSTD_sizeof_DDict(dict);
+}
+
+static const rb_data_type_t cdict_type = {
+  "Zstd::CDict",
+  {0, free_cdict, sizeof_cdict,},
+  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static const rb_data_type_t ddict_type = {
+  "Zstd::DDict",
+  {0, free_ddict, sizeof_ddict,},
+  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE rb_cdict_alloc(VALUE self)
+{
+  ZSTD_CDict* cdict = NULL;
+  return TypedData_Wrap_Struct(self, &cdict_type, cdict);
+}
+
+static VALUE rb_cdict_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE dict;
+  VALUE compression_level_value;
+  rb_scan_args(argc, argv, "11", &dict, &compression_level_value);
+  int compression_level = convert_compression_level(compression_level_value);
+
+  StringValue(dict);
+  char* dict_buffer = RSTRING_PTR(dict);
+  size_t dict_size = RSTRING_LEN(dict);
+
+  ZSTD_CDict* const cdict = ZSTD_createCDict(dict_buffer, dict_size, compression_level);
+  if (cdict == NULL) {
+    rb_raise(rb_eRuntimeError, "%s", "ZSTD_createCDict failed");
+  }
+
+  DATA_PTR(self) = cdict;
+  return self;
+}
+
+static VALUE rb_ddict_alloc(VALUE self)
+{
+  ZSTD_CDict* ddict = NULL;
+  return TypedData_Wrap_Struct(self, &ddict_type, ddict);
+}
+
+static VALUE rb_ddict_initialize(VALUE self, VALUE dict)
+{
+  StringValue(dict);
+  char* dict_buffer = RSTRING_PTR(dict);
+  size_t dict_size = RSTRING_LEN(dict);
+
+  ZSTD_DDict* const ddict = ZSTD_createDDict(dict_buffer, dict_size);
+  if (ddict == NULL) {
+    rb_raise(rb_eRuntimeError, "%s", "ZSTD_createDDict failed");
+  }
+
+  DATA_PTR(self) = ddict;
+  return self;
+}
+
+static VALUE rb_prohibit_copy(VALUE self, VALUE obj)
+{
+  rb_raise(rb_eRuntimeError, "CDict cannot be duplicated");
+}
+
 void
 zstd_ruby_init(void)
 {
@@ -203,4 +287,12 @@ zstd_ruby_init(void)
   rb_define_module_function(rb_mZstd, "compress_using_dict", rb_compress_using_dict, -1);
   rb_define_module_function(rb_mZstd, "decompress", rb_decompress, -1);
   rb_define_module_function(rb_mZstd, "decompress_using_dict", rb_decompress_using_dict, -1);
+
+  rb_define_alloc_func(rb_cCDict, rb_cdict_alloc);
+  rb_define_private_method(rb_cCDict, "initialize", rb_cdict_initialize, -1);
+  rb_define_method(rb_cCDict, "initialize_copy", rb_prohibit_copy, 1);
+
+  rb_define_alloc_func(rb_cDDict, rb_ddict_alloc);
+  rb_define_private_method(rb_cDDict, "initialize", rb_ddict_initialize, 1);
+  rb_define_method(rb_cDDict, "initialize_copy", rb_prohibit_copy, 1);
 }

data/lib/zstd-ruby/stream_writer.rb

@@ -3,7 +3,7 @@ module Zstd
   class StreamWriter
     def initialize(io, level: nil)
       @io = io
-      @stream = Zstd::StreamingCompress.new(level)
+      @stream = Zstd::StreamingCompress.new(level: level)
     end
 
     def write(*data)

data/lib/zstd-ruby/version.rb

@@ -1,3 +1,3 @@
 module Zstd
-  VERSION = "1.5.6.5"
+  VERSION = "1.5.6.7"
 end

data/lib/zstd-ruby.rb

@@ -1,5 +1,7 @@
 require "zstd-ruby/version"
 require "zstd-ruby/zstdruby"
+require "zstd-ruby/stream_writer"
+require "zstd-ruby/stream_reader"
 
 module Zstd
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zstd-ruby
 version: !ruby/object:Gem::Version
-  version: 1.5.6.5
+  version: 1.5.6.7
 platform: ruby
 authors:
 - SpringMT
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-26 00:00:00.000000000 Z
+date: 2025-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -200,7 +200,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Ruby binding for zstd(Zstandard - Fast real-time compression algorithm)