diff --git a/ext/zstdruby/common.h b/ext/zstdruby/common.h index aeadc7f..70e792e 100644 --- a/ext/zstdruby/common.h +++ b/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); diff --git a/ext/zstdruby/streaming_compress.c b/ext/zstdruby/streaming_compress.c index af01a3a..8614d47 100644 --- a/ext/zstdruby/streaming_compress.c +++ b/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); diff --git a/ext/zstdruby/zstdruby.c b/ext/zstdruby/zstdruby.c index fd95d9a..e63b95c 100644 --- a/ext/zstdruby/zstdruby.c +++ b/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); diff --git a/lib/zstd-ruby/version.rb b/lib/zstd-ruby/version.rb index c588151..94cd93d 100644 --- a/lib/zstd-ruby/version.rb +++ b/lib/zstd-ruby/version.rb @@ -1,3 +1,3 @@ module Zstd - VERSION = "1.5.7.0" + VERSION = "2.0.0-preview1" end diff --git a/spec/zstd-ruby-using-dict_spec.rb b/spec/zstd-ruby-using-dict_spec.rb index b946567..34226ee 100644 --- a/spec/zstd-ruby-using-dict_spec.rb +++ b/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 diff --git a/spec/zstd-ruby_spec.rb b/spec/zstd-ruby_spec.rb index 69954b9..15cc2c7 100644 --- a/spec/zstd-ruby_spec.rb +++ b/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