Remove deprecated methods for v2

- Remove deprecated positional argument for compression level
  - Update C extension methods to only accept keyword arguments
  - Remove deprecation warnings related to positional arguments
- Remove deprecated compress_using_dict method entirely
- Update tests to reflect the API changes
  - Remove tests for positional compression level arguments
  - Remove all tests for compress_using_dict method

These changes prepare the codebase for v2 release by removing previously deprecated functionality.

Author: SpringMT

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);
 

ext/zstdruby/streaming_compress.c

@@ -71,8 +71,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,7 +81,7 @@ 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);

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,51 +39,6 @@ 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);
-
-  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 };
@@ -142,59 +96,6 @@ static VALUE rb_decompress(int argc, VALUE *argv, VALUE self)
   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);
-
-  StringValue(input_value);
-  char* input_data = RSTRING_PTR(input_value);
-  size_t input_size = RSTRING_LEN(input_value);
-
-  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);
-  }
-
-  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 void free_cdict(void *dict)
 {
   ZSTD_freeCDict(dict);
@@ -284,9 +185,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);

spec/zstd-ruby-using-dict_spec.rb

@@ -88,49 +88,4 @@
     end
   end
 
-  describe 'compress_using_dict' do
-    let(:user_json) do
-      File.read("#{__dir__}/user_springmt.json")
-    end
-    let(:dictionary) do
-      File.read("#{__dir__}/dictionary")
-    end
-
-    it 'should work' do
-      compressed_using_dict = Zstd.compress_using_dict(user_json, dictionary)
-      compressed = Zstd.compress(user_json)
-      expect(compressed_using_dict.length).to be < compressed.length
-      expect(user_json).to eq(Zstd.decompress_using_dict(compressed_using_dict, dictionary))
-    end
-
-    it 'should work with simple string' do
-      compressed_using_dict = Zstd.compress_using_dict("abc", dictionary)
-      expect("abc").to eq(Zstd.decompress_using_dict(compressed_using_dict, dictionary))
-    end
-
-    it 'should work with blank input' do
-      compressed_using_dict = Zstd.compress_using_dict("", dictionary)
-      expect("").to eq(Zstd.decompress_using_dict(compressed_using_dict, dictionary))
-    end
-
-    it 'should work with blank dictionary' do
-      compressed_using_dict = Zstd.compress_using_dict(user_json, "")
-      expect(user_json).to eq(Zstd.decompress_using_dict(compressed_using_dict, ""))
-      expect(user_json).to eq(Zstd.decompress(compressed_using_dict))
-    end
-
-    it 'should support compression levels' do
-      compressed_using_dict    = Zstd.compress_using_dict(user_json, dictionary)
-      compressed_using_dict_10 = Zstd.compress_using_dict(user_json, dictionary, 10)
-      expect(compressed_using_dict_10.length).to be < compressed_using_dict.length
-      expect(user_json).to eq(Zstd.decompress_using_dict(compressed_using_dict_10, dictionary))
-    end
-
-    it 'should support compression levels with blank dictionary' do
-      compressed_using_dict_10 = Zstd.compress_using_dict(user_json, "", 10)
-      expect(user_json).to eq(Zstd.decompress_using_dict(compressed_using_dict_10, ""))
-      expect(user_json).to eq(Zstd.decompress(compressed_using_dict_10))
-    end
-  end
-
 end

spec/zstd-ruby_spec.rb

@@ -24,20 +24,13 @@
       expect(compressed).to_not eq(user_json)
     end
 
-    it 'should support compression levels' do
-      compressed = Zstd.compress(user_json, 1)
-      expect(compressed).to be_a(String)
-      expect(compressed).to_not eq(user_json)
-    end
-
     it 'should support compression keyward args levels' do
       compressed = Zstd.compress(user_json, level: 1)
-      compressed_with_arg = Zstd.compress(user_json, 1)
       compressed_default = Zstd.compress(user_json)
       expect(compressed).to be_a(String)
       expect(compressed).to_not eq(user_json)
-      expect(compressed).to eq(compressed_with_arg)
-      expect(compressed_default.length).to be < compressed_with_arg.length
+      expect(compressed).to_not eq(compressed_default)
+      expect(compressed_default.length).to be < compressed.length
     end
 
     it 'should compress large bytes' do