zstd-ruby 1.5.6.4 → 1.5.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe4c394ffc4bcfd9e48c1baaa1dd91f8bf19f9bd65397218017c39145db14106
-  data.tar.gz: 5b87fa1c74eff20d0abe4b90260ac6fdb0db8fc65afd4a571bf0f7b10aa419b2
+  metadata.gz: 1fe1a5bcfa102673b36ea9a48096636faa76535095211998cddfe316775a3d78
+  data.tar.gz: e2a96d0d1d2bdda0bc3d34080df219aeaa8c5274a2dac7a838730fce54ebe4f6
 SHA512:
-  metadata.gz: ea1413beb577cc5c735f2a6514e99071bba67e40de2216d84b11afa77b653d36b026db573f06002797e4f258142b441331eaa4f9fb71e5426d1408ad4123bfeb
-  data.tar.gz: 58476bc0ce00c3d612e1aa460728a2255fbb9e289b132dc76106f539b535323d71ce5c0cda3adcded4cd8407066b332f79efff8fe41085e64e8bdee6ac14f563
+  metadata.gz: 6bdffd7e5b2d824fdf5ebad116ef4b965c4d4d2a77898df5a51623020db6fddf0e4562aa4d80de7f8978fa5f557ce85e56d19042667c379b3ac97c3a274a9d11
+  data.tar.gz: 639a3d64cf8a8fa36a10cf180560a4102516d4da21e3100c1cdd724732fb583449c828ac4eeef6f9bad89c2f22467f7adf80b083116121ccff8d356c58246966

data/README.md

@@ -127,6 +127,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

@@ -74,6 +74,37 @@ static size_t zstd_stream_compress(ZSTD_CCtx* const ctx, ZSTD_outBuffer* output,
 #endif
 }
 
+struct compress_params {
+  ZSTD_CCtx* ctx;
+  char* output_data;
+  size_t output_size;
+  char* input_data;
+  size_t input_size;
+  size_t ret;
+};
+
+static void* compress_wrapper(void* args)
+{
+    struct compress_params* params = args;
+    params->ret = ZSTD_compress2(params->ctx ,params->output_data, params->output_size, params->input_data, params->input_size);
+    return NULL;
+}
+
+static size_t zstd_compress(ZSTD_CCtx* const ctx, char* output_data, size_t output_size, char* input_data, size_t input_size, bool gvl)
+{
+#ifdef HAVE_RUBY_THREAD_H
+    if (gvl) {
+      return ZSTD_compress2(ctx , output_data, output_size, input_data, input_size);
+    } else {
+      struct compress_params params = { ctx, output_data, output_size, input_data, input_size };
+      rb_thread_call_without_gvl(compress_wrapper, &params, NULL, NULL);
+      return params.ret;
+    }
+#else
+    return ZSTD_compress2(ctx , output_data, output_size, input_data, input_size);
+#endif
+}
+
 static void set_decompress_params(ZSTD_DCtx* const dctx, VALUE kwargs)
 {
   ID kwargs_keys[1];
@@ -92,28 +123,28 @@ static void set_decompress_params(ZSTD_DCtx* const dctx, VALUE kwargs)
   }
 }
 
-struct decompress_params {
+struct stream_decompress_params {
   ZSTD_DCtx* dctx;
   ZSTD_outBuffer* output;
   ZSTD_inBuffer* input;
   size_t ret;
 };
 
-static void* decompress_wrapper(void* args)
+static void* stream_decompress_wrapper(void* args)
 {
-    struct decompress_params* params = args;
+    struct stream_decompress_params* params = args;
     params->ret = ZSTD_decompressStream(params->dctx, params->output, params->input);
     return NULL;
 }
 
-static size_t zstd_decompress(ZSTD_DCtx* const dctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input, bool gvl)
+static size_t zstd_stream_decompress(ZSTD_DCtx* const dctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input, bool gvl)
 {
 #ifdef HAVE_RUBY_THREAD_H
     if (gvl) {
       return ZSTD_decompressStream(dctx, output, input);
     } else {
-      struct decompress_params params = { dctx, output, input };
-      rb_thread_call_without_gvl(decompress_wrapper, &params, NULL, NULL);
+      struct stream_decompress_params params = { dctx, output, input };
+      rb_thread_call_without_gvl(stream_decompress_wrapper, &params, NULL, NULL);
       return params.ret;
     }
 #else
@@ -121,4 +152,35 @@ static size_t zstd_decompress(ZSTD_DCtx* const dctx, ZSTD_outBuffer* output, ZST
 #endif
 }
 
+struct decompress_params {
+  ZSTD_DCtx* dctx;
+  char* output_data;
+  size_t output_size;
+  char* input_data;
+  size_t input_size;
+  size_t ret;
+};
+
+static void* decompress_wrapper(void* args)
+{
+    struct decompress_params* params = args;
+    params->ret = ZSTD_decompressDCtx(params->dctx, params->output_data, params->output_size, params->input_data, params->input_size);
+    return NULL;
+}
+
+static size_t zstd_decompress(ZSTD_DCtx* const dctx, char* output_data, size_t output_size, char* input_data, size_t input_size, bool gvl)
+{
+#ifdef HAVE_RUBY_THREAD_H
+    if (gvl) {
+      return ZSTD_decompressDCtx(dctx, output_data, output_size, input_data, input_size);
+    } else {
+      struct decompress_params params = { dctx, output_data, output_size, input_data, input_size };
+      rb_thread_call_without_gvl(decompress_wrapper, &params, NULL, NULL);
+      return params.ret;
+    }
+#else
+    return ZSTD_decompressDCtx(dctx, output_data, output_size, input_data, input_size);
+#endif
+}
+
 #endif /* ZSTD_RUBY_H */

data/ext/zstdruby/streaming_decompress.c

@@ -104,7 +104,7 @@ rb_streaming_decompress_decompress(VALUE obj, VALUE src)
   VALUE result = rb_str_new(0, 0);
   while (input.pos < input.size) {
     ZSTD_outBuffer output = { (void*)output_data, sd->buf_size, 0 };
-    size_t const ret = zstd_decompress(sd->dctx, &output, &input, false);
+    size_t const ret = zstd_stream_decompress(sd->dctx, &output, &input, false);
     if (ZSTD_isError(ret)) {
       rb_raise(rb_eRuntimeError, "decompress error error code: %s", ZSTD_getErrorName(ret));
     }

data/ext/zstdruby/zstdruby.c

@@ -26,11 +26,11 @@ static VALUE rb_compress(int argc, VALUE *argv, VALUE self)
   char* input_data = RSTRING_PTR(input_value);
   size_t input_size = RSTRING_LEN(input_value);
 
-  size_t const max_compressed_size = ZSTD_compressBound(input_size);
+  size_t max_compressed_size = ZSTD_compressBound(input_size);
   VALUE output = rb_str_new(NULL, max_compressed_size);
-  const char* output_data = RSTRING_PTR(output);
+  char* output_data = RSTRING_PTR(output);
 
-  size_t const ret = ZSTD_compress2(ctx,(void*)output_data, max_compressed_size, (void*)input_data, input_size);
+  size_t const ret = zstd_compress(ctx, output_data, max_compressed_size, input_data, input_size, false);
   if (ZSTD_isError(ret)) {
     rb_raise(rb_eRuntimeError, "compress error error code: %s", ZSTD_getErrorName(ret));
   }
@@ -87,24 +87,24 @@ 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_decompress(dctx, &output, &input, true);
+    size_t ret = zstd_stream_decompress(dctx, &output, &input, false);
     if (ZSTD_isError(ret)) {
       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_decompressDCtx(dctx, output_data, uncompressed_size, input_data, input_size);
+  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));
   }

data/lib/zstd-ruby/version.rb

@@ -1,3 +1,3 @@
 module Zstd
-  VERSION = "1.5.6.4"
+  VERSION = "1.5.6.6"
 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.4
+  version: 1.5.6.6
 platform: ruby
 authors:
 - SpringMT
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-16 00:00:00.000000000 Z
+date: 2024-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler