zstd-ruby 1.5.6.6 → 2.0.1

data/ext/zstdruby/libzstd/zstd_errors.h

@@ -15,10 +15,6 @@
 extern "C" {
 #endif
 
-/*===== dependency =====*/
-#include <stddef.h>   /* size_t */
-
-
 /* =====   ZSTDERRORLIB_API : control library symbols visibility   ===== */
 #ifndef ZSTDERRORLIB_VISIBLE
    /* Backwards compatibility with old macro name */
@@ -80,6 +76,7 @@ typedef enum {
   ZSTD_error_tableLog_tooLarge       = 44,
   ZSTD_error_maxSymbolValue_tooLarge = 46,
   ZSTD_error_maxSymbolValue_tooSmall = 48,
+  ZSTD_error_cannotProduce_uncompressedBlock = 49,
   ZSTD_error_stabilityCondition_notRespected = 50,
   ZSTD_error_stage_wrong       = 60,
   ZSTD_error_init_missing      = 62,
@@ -100,10 +97,6 @@ typedef enum {
   ZSTD_error_maxCode = 120  /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
 } ZSTD_ErrorCode;
 
-/*! ZSTD_getErrorCode() :
-    convert a `size_t` function result into a `ZSTD_ErrorCode` enum type,
-    which can be used to compare with enum list published above */
-ZSTDERRORLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult);
 ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);   /**< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument */
 
 

data/ext/zstdruby/main.c

@@ -1,12 +1,14 @@
 #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);
 void zstd_ruby_streaming_decompress_init(void);
 
-void
+RUBY_FUNC_EXPORTED void
 Init_zstdruby(void)
 {
 #ifdef HAVE_RB_EXT_RACTOR_SAFE
@@ -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/streaming_compress.c

@@ -4,6 +4,7 @@ struct streaming_compress_t {
   ZSTD_CCtx* ctx;
   VALUE buf;
   size_t buf_size;
+  VALUE pending;   /* accumulate compressed bytes produced by write() */
 };
 
 static void
@@ -12,8 +13,10 @@ streaming_compress_mark(void *p)
   struct streaming_compress_t *sc = p;
 #ifdef HAVE_RB_GC_MARK_MOVABLE
   rb_gc_mark_movable(sc->buf);
+  rb_gc_mark_movable(sc->pending);
 #else
   rb_gc_mark(sc->buf);
+  rb_gc_mark(sc->pending);
 #endif
 }
 
@@ -40,6 +43,7 @@ streaming_compress_compact(void *p)
 {
   struct streaming_compress_t *sc = p;
   sc->buf = rb_gc_location(sc->buf);
+  sc->pending = rb_gc_location(sc->pending);
 }
 #endif
 
@@ -64,6 +68,7 @@ rb_streaming_compress_allocate(VALUE klass)
   sc->ctx = NULL;
   sc->buf = Qnil;
   sc->buf_size = 0;
+  sc->pending = Qnil;
   return obj;
 }
 
@@ -71,8 +76,7 @@ static VALUE
 rb_streaming_compress_initialize(int argc, VALUE *argv, VALUE obj)
 {
   VALUE kwargs;
-  VALUE compression_level_value;
-  rb_scan_args(argc, argv, "01:", &compression_level_value, &kwargs);
+  rb_scan_args(argc, argv, "00:", &kwargs);
 
   struct streaming_compress_t* sc;
   TypedData_Get_Struct(obj, struct streaming_compress_t, &streaming_compress_type, sc);
@@ -82,11 +86,12 @@ rb_streaming_compress_initialize(int argc, VALUE *argv, VALUE obj)
   if (ctx == NULL) {
     rb_raise(rb_eRuntimeError, "%s", "ZSTD_createCCtx error");
   }
-  set_compress_params(ctx, compression_level_value, kwargs);
+  set_compress_params(ctx, kwargs);
 
   sc->ctx = ctx;
   sc->buf = rb_str_new(NULL, buffOutSize);
   sc->buf_size = buffOutSize;
+  sc->pending = rb_str_new(0, 0);
 
   return obj;
 }
@@ -100,13 +105,13 @@ static VALUE
 no_compress(struct streaming_compress_t* sc, ZSTD_EndDirective endOp)
 {
   ZSTD_inBuffer input = { NULL, 0, 0 };
-  const char* output_data = RSTRING_PTR(sc->buf);
   VALUE result = rb_str_new(0, 0);
   size_t ret;
   do {
+    const char* output_data = RSTRING_PTR(sc->buf);
     ZSTD_outBuffer output = { (void*)output_data, sc->buf_size, 0 };
 
-    size_t const ret = zstd_stream_compress(sc->ctx, &output, &input, endOp, false);
+    ret = zstd_stream_compress(sc->ctx, &output, &input, endOp, false);
     if (ZSTD_isError(ret)) {
       rb_raise(rb_eRuntimeError, "flush error error code: %s", ZSTD_getErrorName(ret));
     }
@@ -126,9 +131,9 @@ rb_streaming_compress_compress(VALUE obj, VALUE src)
   struct streaming_compress_t* sc;
   TypedData_Get_Struct(obj, struct streaming_compress_t, &streaming_compress_type, sc);
 
-  const char* output_data = RSTRING_PTR(sc->buf);
   VALUE result = rb_str_new(0, 0);
   while (input.pos < input.size) {
+    const char* output_data = RSTRING_PTR(sc->buf);
     ZSTD_outBuffer output = { (void*)output_data, sc->buf_size, 0 };
     size_t const ret = zstd_stream_compress(sc->ctx, &output, &input, ZSTD_e_continue, false);
     if (ZSTD_isError(ret)) {
@@ -143,10 +148,8 @@ static VALUE
 rb_streaming_compress_write(int argc, VALUE *argv, VALUE obj)
 {
   size_t total = 0;
-  VALUE result = rb_str_new(0, 0);
   struct streaming_compress_t* sc;
   TypedData_Get_Struct(obj, struct streaming_compress_t, &streaming_compress_type, sc);
-  const char* output_data = RSTRING_PTR(sc->buf);
 
   while (argc-- > 0) {
     VALUE str = *argv++;
@@ -156,14 +159,20 @@ rb_streaming_compress_write(int argc, VALUE *argv, VALUE obj)
     ZSTD_inBuffer input = { input_data, input_size, 0 };
 
     while (input.pos < input.size) {
+      const char* output_data = RSTRING_PTR(sc->buf);
       ZSTD_outBuffer output = { (void*)output_data, sc->buf_size, 0 };
       size_t const ret = zstd_stream_compress(sc->ctx, &output, &input, ZSTD_e_continue, false);
       if (ZSTD_isError(ret)) {
         rb_raise(rb_eRuntimeError, "compress error error code: %s", ZSTD_getErrorName(ret));
       }
-      total += RSTRING_LEN(str);
+      /* Directly append to the pending buffer */
+      if (output.pos > 0) {
+        rb_str_cat(sc->pending, output.dst, output.pos);
+      }
     }
+    total += RSTRING_LEN(str);
   }
+
   return SIZET2NUM(total);
 }
 
@@ -193,8 +202,11 @@ rb_streaming_compress_flush(VALUE obj)
 {
   struct streaming_compress_t* sc;
   TypedData_Get_Struct(obj, struct streaming_compress_t, &streaming_compress_type, sc);
-  VALUE result = no_compress(sc, ZSTD_e_flush);
-  return result;
+  VALUE drained = no_compress(sc, ZSTD_e_flush);
+  VALUE out = rb_str_dup(sc->pending);
+  rb_str_cat(out, RSTRING_PTR(drained), RSTRING_LEN(drained));
+  rb_str_resize(sc->pending, 0);
+  return out;
 }
 
 static VALUE
@@ -202,8 +214,11 @@ rb_streaming_compress_finish(VALUE obj)
 {
   struct streaming_compress_t* sc;
   TypedData_Get_Struct(obj, struct streaming_compress_t, &streaming_compress_type, sc);
-  VALUE result = no_compress(sc, ZSTD_e_end);
-  return result;
+  VALUE drained = no_compress(sc, ZSTD_e_end);
+  VALUE out = rb_str_dup(sc->pending);
+  rb_str_cat(out, RSTRING_PTR(drained), RSTRING_LEN(drained));
+  rb_str_resize(sc->pending, 0);
+  return out;
 }
 
 extern VALUE rb_mZstd, cStreamingCompress;

data/ext/zstdruby/streaming_decompress.c

@@ -100,19 +100,47 @@ rb_streaming_decompress_decompress(VALUE obj, VALUE src)
 
   struct streaming_decompress_t* sd;
   TypedData_Get_Struct(obj, struct streaming_decompress_t, &streaming_decompress_type, sd);
-  const char* output_data = RSTRING_PTR(sd->buf);
   VALUE result = rb_str_new(0, 0);
+
   while (input.pos < input.size) {
+    const char* output_data = RSTRING_PTR(sd->buf);
     ZSTD_outBuffer output = { (void*)output_data, sd->buf_size, 0 };
     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));
     }
-    rb_str_cat(result, output.dst, output.pos);
+    if (output.pos > 0) {
+        rb_str_cat(result, output.dst, output.pos);
+    }
+    if (ret == 0 && output.pos == 0) {
+        break;
+    }
   }
   return result;
 }
 
+static VALUE
+rb_streaming_decompress_decompress_with_pos(VALUE obj, VALUE src)
+{
+  StringValue(src);
+  const char* input_data = RSTRING_PTR(src);
+  size_t input_size = RSTRING_LEN(src);
+  ZSTD_inBuffer input = { input_data, input_size, 0 };
+
+  struct streaming_decompress_t* sd;
+  TypedData_Get_Struct(obj, struct streaming_decompress_t, &streaming_decompress_type, sd);
+  const char* output_data = RSTRING_PTR(sd->buf);
+  VALUE result = rb_str_new(0, 0);
+  ZSTD_outBuffer output = { (void*)output_data, sd->buf_size, 0 };
+  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));
+  }
+  rb_str_cat(result, output.dst, output.pos);
+  return rb_ary_new_from_args(2, result, ULONG2NUM(input.pos));
+}
+
 extern VALUE rb_mZstd, cStreamingDecompress;
 void
 zstd_ruby_streaming_decompress_init(void)
@@ -121,4 +149,5 @@ zstd_ruby_streaming_decompress_init(void)
   rb_define_alloc_func(cStreamingDecompress, rb_streaming_decompress_allocate);
   rb_define_method(cStreamingDecompress, "initialize", rb_streaming_decompress_initialize, -1);
   rb_define_method(cStreamingDecompress, "decompress", rb_streaming_decompress_decompress, 1);
+  rb_define_method(cStreamingDecompress, "decompress_with_pos", rb_streaming_decompress_decompress_with_pos, 1);
 }

data/ext/zstdruby/zstdruby.c

@@ -11,16 +11,15 @@ static VALUE zstdVersion(VALUE self)
 static VALUE rb_compress(int argc, VALUE *argv, VALUE self)
 {
   VALUE input_value;
-  VALUE compression_level_value;
   VALUE kwargs;
-  rb_scan_args(argc, argv, "11:", &input_value, &compression_level_value, &kwargs);
+  rb_scan_args(argc, argv, "10:", &input_value, &kwargs);
 
   ZSTD_CCtx* const ctx = ZSTD_createCCtx();
   if (ctx == NULL) {
     rb_raise(rb_eRuntimeError, "%s", "ZSTD_createCCtx error");
   }
 
-  set_compress_params(ctx, compression_level_value, kwargs);
+  set_compress_params(ctx, kwargs);
 
   StringValue(input_value);
   char* input_data = RSTRING_PTR(input_value);
@@ -40,159 +39,175 @@ static VALUE rb_compress(int argc, VALUE *argv, VALUE self)
   return output;
 }
 
-static VALUE rb_compress_using_dict(int argc, VALUE *argv, VALUE self)
-{
-  rb_warn("Zstd.compress_using_dict is deprecated; use Zstd.compress with `dict:` instead.");
-  VALUE input_value;
-  VALUE dict;
-  VALUE compression_level_value;
-  rb_scan_args(argc, argv, "21", &input_value, &dict, &compression_level_value);
-  int compression_level = convert_compression_level(compression_level_value);
+static VALUE decode_one_frame(ZSTD_DCtx* dctx, const unsigned char* src, size_t size, VALUE kwargs) {
+  VALUE out = rb_str_buf_new(0);
+  size_t cap = ZSTD_DStreamOutSize();
+  char *buf = ALLOC_N(char, cap);
+  ZSTD_inBuffer in = (ZSTD_inBuffer){ src, size, 0 };
 
+  ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only);
+  set_decompress_params(dctx, kwargs);
+
+  for (;;) {
+    ZSTD_outBuffer o = (ZSTD_outBuffer){ buf, cap, 0 };
+    size_t ret = ZSTD_decompressStream(dctx, &o, &in);
+    if (ZSTD_isError(ret)) {
+      xfree(buf);
+      rb_raise(rb_eRuntimeError, "ZSTD_decompressStream failed: %s", ZSTD_getErrorName(ret));
+    }
+    if (o.pos) {
+      rb_str_cat(out, buf, o.pos);
+    }
+    if (ret == 0) {
+      break;
+    }
+  }
+  xfree(buf);
+  return out;
+}
+
+static VALUE decompress_buffered(ZSTD_DCtx* dctx, const char* data, size_t len) {
+  return decode_one_frame(dctx, (const unsigned char*)data, len, Qnil);
+}
+
+static VALUE rb_decompress(int argc, VALUE *argv, VALUE self)
+{
+  VALUE input_value, kwargs;
+  rb_scan_args(argc, argv, "10:", &input_value, &kwargs);
   StringValue(input_value);
-  char* input_data = RSTRING_PTR(input_value);
-  size_t input_size = RSTRING_LEN(input_value);
-  size_t max_compressed_size = ZSTD_compressBound(input_size);
 
-  char* dict_buffer = RSTRING_PTR(dict);
-  size_t dict_size = RSTRING_LEN(dict);
+  size_t in_size = RSTRING_LEN(input_value);
+  const unsigned char *in_r = (const unsigned char *)RSTRING_PTR(input_value);
+  unsigned char *in = ALLOC_N(unsigned char, in_size);
+  memcpy(in, in_r, in_size);
+
+  size_t off = 0;
+  const uint32_t ZSTD_MAGIC = 0xFD2FB528U;
+  const uint32_t SKIP_LO    = 0x184D2A50U; /* ...5F */
+
+  while (off + 4 <= in_size) {
+    uint32_t magic = (uint32_t)in[off]
+                   | ((uint32_t)in[off+1] << 8)
+                   | ((uint32_t)in[off+2] << 16)
+                   | ((uint32_t)in[off+3] << 24);
+
+    if ((magic & 0xFFFFFFF0U) == (SKIP_LO & 0xFFFFFFF0U)) {
+      if (off + 8 > in_size) break;
+      uint32_t skipLen = (uint32_t)in[off+4]
+                       | ((uint32_t)in[off+5] << 8)
+                       | ((uint32_t)in[off+6] << 16)
+                       | ((uint32_t)in[off+7] << 24);
+      size_t adv = (size_t)8 + (size_t)skipLen;
+      if (off + adv > in_size) break;
+      off += adv;
+      continue;
+    }
 
-  ZSTD_CDict* const cdict = ZSTD_createCDict(dict_buffer, dict_size, compression_level);
-  if (cdict == NULL) {
-    rb_raise(rb_eRuntimeError, "%s", "ZSTD_createCDict failed");
-  }
-  ZSTD_CCtx* const ctx = ZSTD_createCCtx();
-  if (ctx == NULL) {
-    ZSTD_freeCDict(cdict);
-    rb_raise(rb_eRuntimeError, "%s", "ZSTD_createCCtx failed");
-  }
+    if (magic == ZSTD_MAGIC) {
+      ZSTD_DCtx *dctx = ZSTD_createDCtx();
+      if (!dctx) {
+        xfree(in);
+        rb_raise(rb_eRuntimeError, "ZSTD_createDCtx failed");
+      }
 
-  VALUE output = rb_str_new(NULL, max_compressed_size);
-  char* output_data = RSTRING_PTR(output);
-  size_t const compressed_size = ZSTD_compress_usingCDict(ctx, (void*)output_data, max_compressed_size,
-                                             (void*)input_data, input_size, cdict);
+      VALUE out = decode_one_frame(dctx, in + off, in_size - off, kwargs);
 
-  if (ZSTD_isError(compressed_size)) {
-    ZSTD_freeCDict(cdict);
-    ZSTD_freeCCtx(ctx);
-    rb_raise(rb_eRuntimeError, "%s: %s", "compress failed", ZSTD_getErrorName(compressed_size));
+      ZSTD_freeDCtx(dctx);
+      xfree(in);
+      RB_GC_GUARD(input_value);
+      return out;
+    }
+
+    off += 1;
   }
 
-  rb_str_resize(output, compressed_size);
-  ZSTD_freeCDict(cdict);
-  ZSTD_freeCCtx(ctx);
-  return output;
+  xfree(in);
+  RB_GC_GUARD(input_value);
+  rb_raise(rb_eRuntimeError, "not a zstd frame (magic not found)");
 }
 
-
-static VALUE decompress_buffered(ZSTD_DCtx* dctx, const char* input_data, size_t input_size)
+static void free_cdict(void *dict)
 {
-  ZSTD_inBuffer input = { input_data, input_size, 0 };
-  VALUE result = rb_str_new(0, 0);
+  ZSTD_freeCDict(dict);
+}
 
-  while (input.pos < input.size) {
-    ZSTD_outBuffer output = { NULL, 0, 0 };
-    output.size += ZSTD_DStreamOutSize();
-    VALUE output_string = rb_str_new(NULL, output.size);
-    output.dst = RSTRING_PTR(output_string);
+static size_t sizeof_cdict(const void *dict)
+{
+  return ZSTD_sizeof_CDict(dict);
+}
 
-    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);
-  }
-  ZSTD_freeDCtx(dctx);
-  return result;
+static void free_ddict(void *dict)
+{
+  ZSTD_freeDDict(dict);
 }
 
-static VALUE rb_decompress(int argc, VALUE *argv, VALUE self)
+static size_t sizeof_ddict(const void *dict)
 {
-  VALUE input_value;
-  VALUE kwargs;
-  rb_scan_args(argc, argv, "10:", &input_value, &kwargs);
-  StringValue(input_value);
-  char* input_data = RSTRING_PTR(input_value);
-  size_t input_size = RSTRING_LEN(input_value);
-  ZSTD_DCtx* const dctx = ZSTD_createDCtx();
-  if (dctx == NULL) {
-    rb_raise(rb_eRuntimeError, "%s", "ZSTD_createDCtx failed");
-  }
-  set_decompress_params(dctx, kwargs);
+  return ZSTD_sizeof_DDict(dict);
+}
 
-  unsigned long long const uncompressed_size = ZSTD_getFrameContentSize(input_data, input_size);
-  if (uncompressed_size == ZSTD_CONTENTSIZE_ERROR) {
-    rb_raise(rb_eRuntimeError, "%s: %s", "not compressed by zstd", ZSTD_getErrorName(uncompressed_size));
-  }
-  // ZSTD_decompressStream may be called multiple times when ZSTD_CONTENTSIZE_UNKNOWN, causing slowness.
-  // Therefore, we will not standardize on ZSTD_decompressStream
-  if (uncompressed_size == ZSTD_CONTENTSIZE_UNKNOWN) {
-    return decompress_buffered(dctx, input_data, input_size);
-  }
+static const rb_data_type_t cdict_type = {
+  "Zstd::CDict",
+  {0, free_cdict, sizeof_cdict,},
+  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
 
-  VALUE output = rb_str_new(NULL, uncompressed_size);
-  char* output_data = RSTRING_PTR(output);
+static const rb_data_type_t ddict_type = {
+  "Zstd::DDict",
+  {0, free_ddict, sizeof_ddict,},
+  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
 
-  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));
-  }
-  ZSTD_freeDCtx(dctx);
-  return output;
+static VALUE rb_cdict_alloc(VALUE self)
+{
+  ZSTD_CDict* cdict = NULL;
+  return TypedData_Wrap_Struct(self, &cdict_type, cdict);
 }
 
-static VALUE rb_decompress_using_dict(int argc, VALUE *argv, VALUE self)
+static VALUE rb_cdict_initialize(int argc, VALUE *argv, VALUE self)
 {
-  rb_warn("Zstd.decompress_using_dict is deprecated; use Zstd.decompress with `dict:` instead.");
-  VALUE input_value;
   VALUE dict;
-  rb_scan_args(argc, argv, "20", &input_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(input_value);
-  char* input_data = RSTRING_PTR(input_value);
-  size_t input_size = RSTRING_LEN(input_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");
   }
-  unsigned const expected_dict_id = ZSTD_getDictID_fromDDict(ddict);
-  unsigned const actual_dict_id = ZSTD_getDictID_fromFrame(input_data, input_size);
-  if (expected_dict_id != actual_dict_id) {
-    ZSTD_freeDDict(ddict);
-    rb_raise(rb_eRuntimeError, "DictID mismatch");
-  }
 
-  ZSTD_DCtx* const ctx = ZSTD_createDCtx();
-  if (ctx == NULL) {
-    ZSTD_freeDDict(ddict);
-    rb_raise(rb_eRuntimeError, "%s", "ZSTD_createDCtx failed");
-  }
-
-  unsigned long long const uncompressed_size = ZSTD_getFrameContentSize(input_data, input_size);
-  if (uncompressed_size == ZSTD_CONTENTSIZE_ERROR) {
-    ZSTD_freeDDict(ddict);
-    ZSTD_freeDCtx(ctx);
-    rb_raise(rb_eRuntimeError, "%s: %s", "not compressed by zstd", ZSTD_getErrorName(uncompressed_size));
-  }
-  if (uncompressed_size == ZSTD_CONTENTSIZE_UNKNOWN) {
-    return decompress_buffered(ctx, input_data, input_size);
-  }
+  DATA_PTR(self) = ddict;
+  return self;
+}
 
-  VALUE output = rb_str_new(NULL, uncompressed_size);
-  char* output_data = RSTRING_PTR(output);
-  size_t const decompress_size = ZSTD_decompress_usingDDict(ctx, output_data, uncompressed_size, input_data, input_size, ddict);
-  if (ZSTD_isError(decompress_size)) {
-    ZSTD_freeDDict(ddict);
-    ZSTD_freeDCtx(ctx);
-    rb_raise(rb_eRuntimeError, "%s: %s", "decompress error", ZSTD_getErrorName(decompress_size));
-  }
-  ZSTD_freeDDict(ddict);
-  ZSTD_freeDCtx(ctx);
-  return output;
+static VALUE rb_prohibit_copy(VALUE self, VALUE obj)
+{
+  rb_raise(rb_eRuntimeError, "CDict cannot be duplicated");
 }
 
 void
@@ -200,7 +215,13 @@ zstd_ruby_init(void)
 {
   rb_define_module_function(rb_mZstd, "zstd_version", zstdVersion, 0);
   rb_define_module_function(rb_mZstd, "compress", rb_compress, -1);
-  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.6"
+  VERSION = "2.0.1"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: zstd-ruby
 version: !ruby/object:Gem::Version
-  version: 1.5.6.6
+  version: 2.0.1
 platform: ruby
 authors:
 - SpringMT
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-23 00:00:00.000000000 Z
+date: 2025-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,6 +99,7 @@ files:
 - bin/console
 - bin/setup
 - ext/zstdruby/common.h
+- ext/zstdruby/exports.txt
 - ext/zstdruby/extconf.rb
 - ext/zstdruby/libzstd/common/allocations.h
 - ext/zstdruby/libzstd/common/bits.h
@@ -151,6 +151,8 @@ files:
 - ext/zstdruby/libzstd/compress/zstd_ldm_geartab.h
 - ext/zstdruby/libzstd/compress/zstd_opt.c
 - ext/zstdruby/libzstd/compress/zstd_opt.h
+- ext/zstdruby/libzstd/compress/zstd_preSplit.c
+- ext/zstdruby/libzstd/compress/zstd_preSplit.h
 - ext/zstdruby/libzstd/compress/zstdmt_compress.c
 - ext/zstdruby/libzstd/compress/zstdmt_compress.h
 - ext/zstdruby/libzstd/decompress/huf_decompress.c
@@ -185,7 +187,6 @@ homepage: https://github.com/SpringMT/zstd-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -200,8 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Ruby binding for zstd(Zstandard - Fast real-time compression algorithm)
 test_files: []