zstd-ruby 1.5.7.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50ffda13ae5c1470be924476eb600af7695a2e76f0764666f8f4a90b07b35428
-  data.tar.gz: e28d50be732039fc58762c02870e3ecf227b5843d647fce6a5cebac91dbf8487
+  metadata.gz: 91a2e54ff93b0c602d6b2d064f6f8c615a59f0ef963c20b24e4db6d17643163e
+  data.tar.gz: cbeb4c7c21187336a284cb714765fb80b02b982c6b4fafa60784d8f7950fe528
 SHA512:
-  metadata.gz: 71433e488936220118f3b4611594f8eaac68c3544816e890c412fa76f531e450f44d62d4b03d900e95b47e25d37f35b73c41baeb8275917adc1013172763fc11
-  data.tar.gz: 6e1f7a19a7fb75633b790d3d3a5c2c20bc520a6f2ed03f17941f186f7c9e5e2a00dfa7398fc428cfd665a935f5ed516115d81a826439bfa3d304119ae1f5cc79
+  metadata.gz: 70190b1a1233782dc440e5ef913f4a83b6bc936ea96d744f5a44b3dbceb41f8a1ef9c3264746eb251356b95c13c5503b2b2567076bc45c28d628ee278b9c2522
+  data.tar.gz: 600bc166bef41126b93a0e78190bbf6b5698259797e166ee4d787a113d6c4e27e7c6c927135e54b33a7e4cc25a74b2df4cb19413f74618892191863cc4c9b4fb

data/README.md

@@ -12,6 +12,20 @@ Fork from https://github.com/jarredholman/ruby-zstd.
 ## Zstd version
 [v1.5.7](https://github.com/facebook/zstd/tree/v1.5.7)
 
+## Versioning Policy
+
+Starting from v2.0.0, this gem follows Semantic Versioning.
+
+- **Major version** (X.0.0): Breaking changes to the API
+- **Minor version** (X.Y.0): New features, including Zstd library version updates
+- **Patch version** (X.Y.Z): Bug fixes and other backward-compatible changes
+
+### Zstd Library Updates
+
+Updates to the underlying Zstd library version will be released as **minor version** updates, as they may introduce new features or performance improvements while maintaining backward compatibility.
+
+**Note**: Versions prior to v2.0.0 followed the Zstd library versioning scheme with an additional patch number (e.g., 1.5.6.2). This approach has been replaced with semantic versioning to provide clearer expectations for API stability.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -155,6 +169,20 @@ result << stream.decompress(cstr[10..-1])
 
 DDict can also be specified to `dict:`.
 
+#### Streaming Decompression with Position Tracking
+
+If you need to know how much of the input data was consumed during decompression, you can use the `decompress_with_pos` method:
+
+```ruby
+cstr = "" # Compressed data
+stream = Zstd::StreamingDecompress.new
+result, consumed_bytes = stream.decompress_with_pos(cstr[0, 10])
+# result contains the decompressed data
+# consumed_bytes contains the number of bytes from input that were processed
+```
+
+This is particularly useful when processing streaming data where you need to track the exact position in the input stream.
+
 ### Skippable frame
 
 ```ruby

data/ext/zstdruby/common.h

@@ -18,7 +18,7 @@ static int convert_compression_level(VALUE compression_level_value)
   return NUM2INT(compression_level_value);
 }
 
-static void set_compress_params(ZSTD_CCtx* const ctx, VALUE level_from_args, VALUE kwargs)
+static void set_compress_params(ZSTD_CCtx* const ctx, VALUE kwargs)
 {
   ID kwargs_keys[2];
   kwargs_keys[0] = rb_intern("level");
@@ -29,9 +29,6 @@ static void set_compress_params(ZSTD_CCtx* const ctx, VALUE level_from_args, VAL
   int compression_level = ZSTD_CLEVEL_DEFAULT;
   if (kwargs_values[0] != Qundef && kwargs_values[0] != Qnil) {
     compression_level = convert_compression_level(kwargs_values[0]);
-  } else if (!NIL_P(level_from_args)) {
-    rb_warn("`level` in args is deprecated; use keyword args `level:` instead.");
-    compression_level = convert_compression_level(level_from_args);
   }
   ZSTD_CCtx_setParameter(ctx, ZSTD_c_compressionLevel, compression_level);
 

data/ext/zstdruby/exports.txt

@@ -0,0 +1 @@
+_Init_zstdruby 

data/ext/zstdruby/extconf.rb

@@ -2,9 +2,14 @@ require "mkmf"
 
 have_func('rb_gc_mark_movable')
 
-$CFLAGS = '-I. -O3 -std=c99 -DZSTD_STATIC_LINKING_ONLY -DZSTD_MULTITHREAD -pthread -DDEBUGLEVEL=0'
+$CFLAGS = '-I. -O3 -std=c99 -DZSTD_STATIC_LINKING_ONLY -DZSTD_MULTITHREAD -pthread -DDEBUGLEVEL=0 -fvisibility=hidden -DZSTDLIB_VISIBLE=\'__attribute__((visibility("hidden")))\' -DZSTDLIB_HIDDEN=\'__attribute__((visibility("hidden")))\''
 $CPPFLAGS += " -fdeclspec" if CONFIG['CXX'] =~ /clang/
 
+# macOS specific: Use exported_symbols_list to control symbol visibility
+if RUBY_PLATFORM =~ /darwin/
+  $LDFLAGS += " -exported_symbols_list #{File.expand_path('exports.txt', __dir__)}"
+end
+
 Dir.chdir File.expand_path('..', __FILE__) do
   $srcs = Dir['**/*.c', '**/*.S']
 

data/ext/zstdruby/main.c

@@ -8,7 +8,7 @@ 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

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,91 @@ 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);
-
-  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);
+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_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");
-  }
-
-  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);
-
-  if (ZSTD_isError(compressed_size)) {
-    ZSTD_freeCDict(cdict);
-    ZSTD_freeCCtx(ctx);
-    rb_raise(rb_eRuntimeError, "%s: %s", "compress failed", ZSTD_getErrorName(compressed_size));
-  }
-
-  rb_str_resize(output, compressed_size);
-  ZSTD_freeCDict(cdict);
-  ZSTD_freeCCtx(ctx);
-  return output;
-}
-
-
-static VALUE decompress_buffered(ZSTD_DCtx* dctx, const char* input_data, size_t input_size)
-{
-  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();
-    VALUE output_string = rb_str_new(NULL, output.size);
-    output.dst = RSTRING_PTR(output_string);
+  ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only);
+  set_decompress_params(dctx, kwargs);
 
-    size_t ret = zstd_stream_decompress(dctx, &output, &input, false);
+  for (;;) {
+    ZSTD_outBuffer o = (ZSTD_outBuffer){ buf, cap, 0 };
+    size_t ret = ZSTD_decompressStream(dctx, &o, &in);
     if (ZSTD_isError(ret)) {
-      ZSTD_freeDCtx(dctx);
-      rb_raise(rb_eRuntimeError, "%s: %s", "ZSTD_decompressStream failed", ZSTD_getErrorName(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;
     }
-    rb_str_cat(result, output.dst, output.pos);
   }
-  ZSTD_freeDCtx(dctx);
-  return result;
+  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;
-  VALUE kwargs;
+  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);
-  ZSTD_DCtx* const dctx = ZSTD_createDCtx();
-  if (dctx == NULL) {
-    rb_raise(rb_eRuntimeError, "%s", "ZSTD_createDCtx failed");
-  }
-  set_decompress_params(dctx, kwargs);
-
-  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);
-  }
-
-  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);
-  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_decompress_using_dict(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);
+  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;
+    }
 
-  StringValue(input_value);
-  char* input_data = RSTRING_PTR(input_value);
-  size_t input_size = RSTRING_LEN(input_value);
+    if (magic == ZSTD_MAGIC) {
+      ZSTD_DCtx *dctx = ZSTD_createDCtx();
+      if (!dctx) {
+        xfree(in);
+        rb_raise(rb_eRuntimeError, "ZSTD_createDCtx failed");
+      }
 
-  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");
-  }
+      VALUE out = decode_one_frame(dctx, in + off, in_size - off, kwargs);
 
-  ZSTD_DCtx* const ctx = ZSTD_createDCtx();
-  if (ctx == NULL) {
-    ZSTD_freeDDict(ddict);
-    rb_raise(rb_eRuntimeError, "%s", "ZSTD_createDCtx failed");
-  }
+      ZSTD_freeDCtx(dctx);
+      xfree(in);
+      RB_GC_GUARD(input_value);
+      return out;
+    }
 
-  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);
+    off += 1;
   }
 
-  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;
+  xfree(in);
+  RB_GC_GUARD(input_value);
+  rb_raise(rb_eRuntimeError, "not a zstd frame (magic not found)");
 }
 
 static void free_cdict(void *dict)
@@ -284,9 +215,7 @@ 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);

data/lib/zstd-ruby/version.rb

@@ -1,3 +1,3 @@
 module Zstd
-  VERSION = "1.5.7.0"
+  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.7.0
+  version: 2.0.1
 platform: ruby
 authors:
 - SpringMT
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-06 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
@@ -187,7 +187,6 @@ homepage: https://github.com/SpringMT/zstd-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -202,8 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Ruby binding for zstd(Zstandard - Fast real-time compression algorithm)
 test_files: []