zstd-ruby 1.5.2.0 → 1.5.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c33df57662a35d3eae35eb7b82afecf5e91191152edcef555b88aab4b803a3a
-  data.tar.gz: e3d5d34ff446b9a280bcb4e0fc103b4f6cb3312c37756145a578a05bfc237672
+  metadata.gz: 70096397fcb0ba88b1332602dc743a979e6417bc07aa25270b2fa3e637922291
+  data.tar.gz: e3e2f2ddf2d2d01514e7128b01792e10d9b48cbc08f61a25e0cd9ddf3e91430e
 SHA512:
-  metadata.gz: 3f0f2cab5053a1bd6ffc3af753aae2ba2d61c20623738e8c4214a9b67dedd6a76df1fdec888b1fe21fbc3334457d8fe4ed03c9ff17dcfbe19f55022846291ea3
-  data.tar.gz: 59ee08ebad25d6c1f21d3b611f7352db6b4cb219a047fe0d9782c9eaae17aa6972bc70e4818c91289e8f7c03cab0dea9db7ac06ce372295c718fa0dae5046c94
+  metadata.gz: fd02829550fef9d56add09f13c1bee7a5171830e6f7f08e728ef4140e922657b1c70df79e4dd4b56b1bf77cddedbcea4830405561d6cb027bbbce928ff5d7152
+  data.tar.gz: aa56ea5cbc0b9d6e6268691ad656d71f38afde239d9833f07c4ae02a6ab1e1ee2b81e92e5489db3e993774938e58d8fb884c8d882ba4126de15588164ceeff25

data/.gitignore

@@ -17,3 +17,5 @@ vendor/
 
 # rspec failure tracking
 .rspec_status
+
+.ruby-version

data/README.md

@@ -34,20 +34,73 @@ Or install it yourself as:
 require 'zstd-ruby'
 ```
 
-### compression
+### Simple Compression
 
 ```ruby
 compressed_data = Zstd.compress(data)
 compressed_data = Zstd.compress(data, complession_level) # default compression_level is 0
 ```
 
+### Streaming Compression
+```
+stream = Zstd::StreamingCompress.new
+stream << "abc" << "def"
+res = stream.flush
+stream << "ghi"
+res << stream.finish
+```
+
+or
+
+```
+stream = Zstd::StreamingCompress.new
+res = stream.compress("abc")
+res << stream.flush
+res << stream.compress("def")
+res << stream.finish
+```
 
-### decompression
+### Simple Decompression
 
 ```ruby
 data = Zstd.decompress(compressed_data)
 ```
 
+### Streaming Decompression
+```
+cstr = "" # Compressed data
+stream = Zstd::StreamingDecompress.new
+result = ''
+result << stream.decompress(cstr[0, 10])
+result << stream.decompress(cstr[10..-1])
+```
+
+
+## JRuby
+This gem does not support JRuby.
+
+Please consider using https://github.com/luben/zstd-jni.
+
+Sample code is below.
+
+```
+require 'java'
+require_relative './zstd-jni-1.5.2-3.jar'
+
+str = "testtest"
+compressed = com.github.luben.zstd.Zstd.compress(str.to_java_bytes)
+puts com.github.luben.zstd.Zstd.decompress(compressed, str.length)
+```
+
+```
+% ls
+test.rb              zstd-jni-1.5.2-3.jar
+% ruby -v
+jruby 9.3.2.0 (2.6.8) 2021-12-01 0b8223f905 OpenJDK 64-Bit Server VM 11.0.12+0 on 11.0.12+0 +jit [darwin-x86_64]
+% ruby test.rb
+testtest
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -17,6 +17,12 @@ task :default => [:clobber, :compile, :spec]
 
 desc 'Sync zstd libs dirs to ext/zstdruby/libzstd'
 task :zstd_update do
-  FileUtils.rm_r('ext/zstdruby/libzstd')
-  FileUtils.cp_r('zstd/lib', 'ext/zstdruby/libzstd')
+  FileUtils.rm_r("ext/zstdruby/libzstd")
+  FileUtils.mkdir_p("ext/zstdruby/libzstd")
+  ["common", "compress", "decompress", "dictBuilder"].each do |dir|
+    FileUtils.cp_r("zstd/lib/#{dir}", "ext/zstdruby/libzstd/#{dir}")
+  end
+  FileUtils.cp_r('zstd/lib/zdict.h', 'ext/zstdruby/libzstd')
+  FileUtils.cp_r('zstd/lib/zstd.h', 'ext/zstdruby/libzstd')
+  FileUtils.cp_r('zstd/lib/zstd_errors.h', 'ext/zstdruby/libzstd')
 end

data/ext/zstdruby/{zstdruby.h → common.h}

@@ -2,5 +2,7 @@
 #define ZSTD_RUBY_H 1
 
 #include "ruby.h"
+#include "./libzstd/zstd.h"
+
 
 #endif /* ZSTD_RUBY_H */

data/ext/zstdruby/main.c

@@ -0,0 +1,14 @@
+#include <common.h>
+VALUE rb_mZstd;
+void zstd_ruby_init(void);
+void zstd_ruby_streaming_compress_init(void);
+void zstd_ruby_streaming_decompress_init(void);
+
+void
+Init_zstdruby(void)
+{
+  rb_mZstd = rb_define_module("Zstd");
+  zstd_ruby_init();
+  zstd_ruby_streaming_compress_init();
+  zstd_ruby_streaming_decompress_init();
+}

data/ext/zstdruby/streaming_compress.c

@@ -0,0 +1,185 @@
+#include <common.h>
+#include <streaming_compress.h>
+
+struct streaming_compress_t {
+  ZSTD_CCtx* ctx;
+  VALUE buf;
+  size_t buf_size;
+};
+
+static void
+streaming_compress_mark(void *p)
+{
+  struct streaming_compress_t *sc = p;
+  // rb_gc_mark((VALUE)sc->ctx);
+  rb_gc_mark(sc->buf);
+  rb_gc_mark(sc->buf_size);
+}
+
+static void
+streaming_compress_free(void *p)
+{
+  struct streaming_compress_t *sc = p;
+  ZSTD_CCtx* ctx = sc->ctx;
+  if (ctx != NULL) {
+    ZSTD_freeCCtx(ctx);
+  }
+  xfree(sc);
+}
+
+static size_t
+streaming_compress_memsize(const void *p)
+{
+    return sizeof(struct streaming_compress_t);
+}
+
+static const rb_data_type_t streaming_compress_type = {
+    "streaming_compress",
+    { streaming_compress_mark, streaming_compress_free, streaming_compress_memsize, },
+     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE
+rb_streaming_compress_allocate(VALUE klass)
+{
+  struct streaming_compress_t* sc;
+  VALUE obj = TypedData_Make_Struct(klass, struct streaming_compress_t, &streaming_compress_type, sc);
+  sc->ctx = NULL;
+  sc->buf = Qnil;
+  sc->buf_size = 0;
+  return obj;
+}
+
+static VALUE
+rb_streaming_compress_initialize(int argc, VALUE *argv, VALUE obj)
+{
+  VALUE compression_level_value;
+  rb_scan_args(argc, argv, "01", &compression_level_value);
+
+  int compression_level;
+  if (NIL_P(compression_level_value)) {
+    compression_level = 0; // The default. See ZSTD_CLEVEL_DEFAULT in zstd_compress.c
+  } else {
+    compression_level = NUM2INT(compression_level_value);
+  }
+
+  struct streaming_compress_t* sc;
+  TypedData_Get_Struct(obj, struct streaming_compress_t, &streaming_compress_type, sc);
+  size_t const buffOutSize = ZSTD_CStreamOutSize();
+
+  ZSTD_CCtx* ctx = ZSTD_createCCtx();
+  if (ctx == NULL) {
+    rb_raise(rb_eRuntimeError, "%s", "ZSTD_createCCtx error");
+  }
+  ZSTD_CCtx_setParameter(ctx, ZSTD_c_compressionLevel, compression_level);
+  sc->ctx = ctx;
+  sc->buf = rb_str_new(NULL, buffOutSize);
+  sc->buf_size = buffOutSize;
+
+  return obj;
+}
+
+#define FIXNUMARG(val, ifnil) \
+    (NIL_P((val)) ? (ifnil) \
+    : (FIX2INT((val))))
+#define ARG_CONTINUE(val)     FIXNUMARG((val), ZSTD_e_continue)
+
+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 {
+    ZSTD_outBuffer output = { (void*)output_data, sc->buf_size, 0 };
+
+    size_t const ret = ZSTD_compressStream2(sc->ctx, &output, &input, endOp);
+    if (ZSTD_isError(ret)) {
+      rb_raise(rb_eRuntimeError, "flush error error code: %s", ZSTD_getErrorName(ret));
+    }
+    rb_str_cat(result, output.dst, output.pos);
+  } while (ret > 0);
+  return result;
+}
+
+static VALUE
+rb_streaming_compress_compress(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_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) {
+    ZSTD_outBuffer output = { (void*)output_data, sc->buf_size, 0 };
+    size_t const ret = ZSTD_compressStream2(sc->ctx, &output, &input, ZSTD_e_continue);
+    if (ZSTD_isError(ret)) {
+      rb_raise(rb_eRuntimeError, "compress error error code: %s", ZSTD_getErrorName(ret));
+    }
+    rb_str_cat(result, output.dst, output.pos);
+  }
+  return result;
+}
+
+static VALUE
+rb_streaming_compress_addstr(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_compress_t* sc;
+  TypedData_Get_Struct(obj, struct streaming_compress_t, &streaming_compress_type, sc);
+  const char* output_data = RSTRING_PTR(sc->buf);
+
+  while (input.pos < input.size) {
+    ZSTD_outBuffer output = { (void*)output_data, sc->buf_size, 0 };
+    size_t const result = ZSTD_compressStream2(sc->ctx, &output, &input, ZSTD_e_continue);
+    if (ZSTD_isError(result)) {
+      rb_raise(rb_eRuntimeError, "compress error error code: %s", ZSTD_getErrorName(result));
+    }
+  }
+  return obj;
+}
+
+static VALUE
+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;
+}
+
+static VALUE
+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;
+}
+
+extern VALUE rb_mZstd, cStreamingCompress;
+void
+zstd_ruby_streaming_compress_init(void)
+{
+  VALUE cStreamingCompress = rb_define_class_under(rb_mZstd, "StreamingCompress", rb_cObject);
+  rb_define_alloc_func(cStreamingCompress, rb_streaming_compress_allocate);
+  rb_define_method(cStreamingCompress, "initialize", rb_streaming_compress_initialize, -1);
+  rb_define_method(cStreamingCompress, "compress", rb_streaming_compress_compress, 1);
+  rb_define_method(cStreamingCompress, "<<", rb_streaming_compress_addstr, 1);
+  rb_define_method(cStreamingCompress, "flush", rb_streaming_compress_flush, 0);
+  rb_define_method(cStreamingCompress, "finish", rb_streaming_compress_finish, 0);
+
+  rb_define_const(cStreamingCompress, "CONTINUE", INT2FIX(ZSTD_e_continue));
+  rb_define_const(cStreamingCompress, "FLUSH", INT2FIX(ZSTD_e_flush));
+  rb_define_const(cStreamingCompress, "END", INT2FIX(ZSTD_e_end));
+}
+

data/ext/zstdruby/streaming_compress.h

@@ -0,0 +1,5 @@
+#if !defined(STREAMING_COMPRESS_H)
+#define STREAMING_COMPRESS_H
+
+
+#endif // STREAMING_COMPRESS_H

data/ext/zstdruby/streaming_decompress.c

@@ -0,0 +1,125 @@
+#include <common.h>
+
+struct streaming_decompress_t {
+  ZSTD_DCtx* ctx;
+  VALUE buf;
+  size_t buf_size;
+};
+
+static void
+streaming_decompress_mark(void *p)
+{
+  struct streaming_decompress_t *sd = p;
+  // rb_gc_mark((VALUE)sd->ctx);
+  rb_gc_mark(sd->buf);
+  rb_gc_mark(sd->buf_size);
+}
+
+static void
+streaming_decompress_free(void *p)
+{
+  struct streaming_decompress_t *sd = p;
+  ZSTD_DCtx* ctx = sd->ctx;
+  if (ctx != NULL) {
+    ZSTD_freeDCtx(ctx);
+  }
+  xfree(sd);
+}
+
+static size_t
+streaming_decompress_memsize(const void *p)
+{
+    return sizeof(struct streaming_decompress_t);
+}
+
+static const rb_data_type_t streaming_decompress_type = {
+    "streaming_decompress",
+    { streaming_decompress_mark, streaming_decompress_free, streaming_decompress_memsize, },
+     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE
+rb_streaming_decompress_allocate(VALUE klass)
+{
+  struct streaming_decompress_t* sd;
+  VALUE obj = TypedData_Make_Struct(klass, struct streaming_decompress_t, &streaming_decompress_type, sd);
+  sd->ctx = NULL;
+  sd->buf = Qnil;
+  sd->buf_size = 0;
+  return obj;
+}
+
+static VALUE
+rb_streaming_decompress_initialize(VALUE obj)
+{
+  struct streaming_decompress_t* sd;
+  TypedData_Get_Struct(obj, struct streaming_decompress_t, &streaming_decompress_type, sd);
+  size_t const buffOutSize = ZSTD_DStreamOutSize();
+
+  ZSTD_DCtx* ctx = ZSTD_createDCtx();
+  if (ctx == NULL) {
+    rb_raise(rb_eRuntimeError, "%s", "ZSTD_createDCtx error");
+  }
+  sd->ctx = ctx;
+  sd->buf = rb_str_new(NULL, buffOutSize);
+  sd->buf_size = buffOutSize;
+
+  return obj;
+}
+
+static VALUE
+rb_streaming_decompress_decompress(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);
+  while (input.pos < input.size) {
+    ZSTD_outBuffer output = { (void*)output_data, sd->buf_size, 0 };
+    size_t const ret = ZSTD_decompressStream(sd->ctx, &output, &input);
+    if (ZSTD_isError(ret)) {
+      rb_raise(rb_eRuntimeError, "compress error error code: %s", ZSTD_getErrorName(ret));
+    }
+    rb_str_cat(result, output.dst, output.pos);
+  }
+  return result;
+}
+
+static VALUE
+rb_streaming_decompress_addstr(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);
+
+  while (input.pos < input.size) {
+    ZSTD_outBuffer output = { (void*)output_data, sd->buf_size, 0 };
+    size_t const result = ZSTD_decompressStream(sd->ctx, &output, &input);
+    if (ZSTD_isError(result)) {
+      rb_raise(rb_eRuntimeError, "compress error error code: %s", ZSTD_getErrorName(result));
+    }
+  }
+  return obj;
+}
+
+extern VALUE rb_mZstd, cStreamingDecompress;
+void
+zstd_ruby_streaming_decompress_init(void)
+{
+  VALUE cStreamingDecompress = rb_define_class_under(rb_mZstd, "StreamingDecompress", rb_cObject);
+  rb_define_alloc_func(cStreamingDecompress, rb_streaming_decompress_allocate);
+  rb_define_method(cStreamingDecompress, "initialize", rb_streaming_decompress_initialize, 0);
+  rb_define_method(cStreamingDecompress, "decompress", rb_streaming_decompress_decompress, 1);
+  rb_define_method(cStreamingDecompress, "<<", rb_streaming_decompress_addstr, 1);
+}
+

data/ext/zstdruby/zstdruby.c

@@ -1,5 +1,6 @@
-#include "zstdruby.h"
-#include "./libzstd/zstd.h"
+#include <common.h>
+
+extern VALUE rb_mZstd;
 
 static VALUE zstdVersion(VALUE self)
 {
@@ -104,12 +105,9 @@ static VALUE decompress(VALUE self, VALUE input)
   return output;
 }
 
-VALUE rb_mZstd;
-
 void
-Init_zstdruby(void)
+zstd_ruby_init(void)
 {
-  rb_mZstd = rb_define_module("Zstd");
   rb_define_module_function(rb_mZstd, "zstd_version", zstdVersion, 0);
   rb_define_module_function(rb_mZstd, "compress", compress, -1);
   rb_define_module_function(rb_mZstd, "decompress", decompress, 1);

data/lib/zstd-ruby/version.rb

@@ -1,3 +1,3 @@
 module Zstd
-  VERSION = "1.5.2.0"
+  VERSION = "1.5.2.1"
 end

data/zstd-ruby.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   #end
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features|benchmarks|zstd)/})
+    f.match(%r{^(test|spec|features|benchmarks|zstd|.github)/})
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zstd-ruby
 version: !ruby/object:Gem::Version
-  version: 1.5.2.0
+  version: 1.5.2.1
 platform: ruby
 authors:
 - SpringMT
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-13 00:00:00.000000000 Z
+date: 2022-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,8 +75,6 @@ extensions:
 - ext/zstdruby/extconf.rb
 extra_rdoc_files: []
 files:
-- ".github/dependabot.yml"
-- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".gitmodules"
 - ".rspec"
@@ -87,11 +85,8 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- ext/zstdruby/common.h
 - ext/zstdruby/extconf.rb
-- ext/zstdruby/libzstd/.gitignore
-- ext/zstdruby/libzstd/BUCK
-- ext/zstdruby/libzstd/Makefile
-- ext/zstdruby/libzstd/README.md
 - ext/zstdruby/libzstd/common/bitstream.h
 - ext/zstdruby/libzstd/common/compiler.h
 - ext/zstdruby/libzstd/common/cpu.h
@@ -150,44 +145,20 @@ files:
 - ext/zstdruby/libzstd/decompress/zstd_decompress_block.c
 - ext/zstdruby/libzstd/decompress/zstd_decompress_block.h
 - ext/zstdruby/libzstd/decompress/zstd_decompress_internal.h
-- ext/zstdruby/libzstd/deprecated/zbuff.h
-- ext/zstdruby/libzstd/deprecated/zbuff_common.c
-- ext/zstdruby/libzstd/deprecated/zbuff_compress.c
-- ext/zstdruby/libzstd/deprecated/zbuff_decompress.c
 - ext/zstdruby/libzstd/dictBuilder/cover.c
 - ext/zstdruby/libzstd/dictBuilder/cover.h
 - ext/zstdruby/libzstd/dictBuilder/divsufsort.c
 - ext/zstdruby/libzstd/dictBuilder/divsufsort.h
 - ext/zstdruby/libzstd/dictBuilder/fastcover.c
 - ext/zstdruby/libzstd/dictBuilder/zdict.c
-- ext/zstdruby/libzstd/dll/example/Makefile
-- ext/zstdruby/libzstd/dll/example/README.md
-- ext/zstdruby/libzstd/dll/example/build_package.bat
-- ext/zstdruby/libzstd/dll/example/fullbench-dll.sln
-- ext/zstdruby/libzstd/dll/example/fullbench-dll.vcxproj
-- ext/zstdruby/libzstd/legacy/zstd_legacy.h
-- ext/zstdruby/libzstd/legacy/zstd_v01.c
-- ext/zstdruby/libzstd/legacy/zstd_v01.h
-- ext/zstdruby/libzstd/legacy/zstd_v02.c
-- ext/zstdruby/libzstd/legacy/zstd_v02.h
-- ext/zstdruby/libzstd/legacy/zstd_v03.c
-- ext/zstdruby/libzstd/legacy/zstd_v03.h
-- ext/zstdruby/libzstd/legacy/zstd_v04.c
-- ext/zstdruby/libzstd/legacy/zstd_v04.h
-- ext/zstdruby/libzstd/legacy/zstd_v05.c
-- ext/zstdruby/libzstd/legacy/zstd_v05.h
-- ext/zstdruby/libzstd/legacy/zstd_v06.c
-- ext/zstdruby/libzstd/legacy/zstd_v06.h
-- ext/zstdruby/libzstd/legacy/zstd_v07.c
-- ext/zstdruby/libzstd/legacy/zstd_v07.h
-- ext/zstdruby/libzstd/libzstd.mk
-- ext/zstdruby/libzstd/libzstd.pc.in
-- ext/zstdruby/libzstd/module.modulemap
 - ext/zstdruby/libzstd/zdict.h
 - ext/zstdruby/libzstd/zstd.h
 - ext/zstdruby/libzstd/zstd_errors.h
+- ext/zstdruby/main.c
+- ext/zstdruby/streaming_compress.c
+- ext/zstdruby/streaming_compress.h
+- ext/zstdruby/streaming_decompress.c
 - ext/zstdruby/zstdruby.c
-- ext/zstdruby/zstdruby.h
 - lib/zstd-ruby.rb
 - lib/zstd-ruby/version.rb
 - zstd-ruby.gemspec

data/.github/dependabot.yml

@@ -1,8 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: bundler
-  directory: "/"
-  schedule:
-    interval: weekly
-    time: "20:00"
-  open-pull-requests-limit: 10

data/.github/workflows/ruby.yml

@@ -1,35 +0,0 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
-# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
-
-name: Ruby
-
-on: [push, pull_request]
-
-jobs:
-  test:
-
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        ruby-version: ['2.6', '2.7', '3.0', '3.1']
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Ruby
-    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
-    # change this to (see https://github.com/ruby/setup-ruby#versioning):
-    # uses: ruby/setup-ruby@v1
-      uses: ruby/setup-ruby@168d6a54b412713c0ed60998a78093a270ca8d84
-      with:
-        ruby-version: ${{ matrix.ruby-version }}
-        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-    - name: Install dependencies
-      run: bundle install
-    - name: Compile
-      run: bundle exec rake compile
-    - name: Run tests
-      run: bundle exec rspec

data/ext/zstdruby/libzstd/.gitignore

@@ -1,3 +0,0 @@
-# make install artefact
-libzstd.pc
-libzstd-nomt