brotli 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97953895465e26d5937e5959f86954aa58de2d2221301bc64ff639e682565605
-  data.tar.gz: 4f26bccb546a19c743eea5b0fd9207f8e623bfd73f05e08f3dae275b76c51482
+  metadata.gz: c3722424560d3f3491399e46108213ae088a809ca502fe2c9f8a83d5c9383434
+  data.tar.gz: 4584239a0597b0c2e5cf47ba0d6c8a96e0198cc8af7c7b217f8bf1312bab56d8
 SHA512:
-  metadata.gz: b5e79aee2804a948da509247c56b1f79e9248927ec6430319b1d2b6202973ed41bca1ceba215f8d4954ad98a52637a91e49bfa316af4ab3d35fcb779f0e94aa3
-  data.tar.gz: 46d42e9297f79aef7481b068e43da47c60d45b0f781a0ceb1fc7626cdb9c59bc306feaab0b05321cba17e23256e492814f340725db8fb21dc9e4c84198507bf5
+  metadata.gz: ca8b9c2bfae436c8b19d657948e0a2f2a3137d05ef9af070f2de4625ffcbe9cb7dd2e6eb011c8e475ea16a74ac5825b9dc074ab95b809e68ce722a06ce72798d
+  data.tar.gz: b5864a5aeb5630e8ad9b491621d89aa4c12f65131a261e49b0499d35cd5b32d43288ddbccb10cfe2ab7201d140e1ae311a0cbb1328cc0a010fad4ad775db8f2d

data/.github/workflows/main.yml

@@ -7,7 +7,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [2.7, 3.1, 3.2, 3.3]
+        ruby: [3.1, 3.2, 3.3, 3.4]
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4

data/Dockerfile

@@ -0,0 +1,38 @@
+ARG GCC_VERSION=14
+FROM gcc:${GCC_VERSION}
+
+ARG USE_SYSTEM_BROTLI=true
+
+# Install Ruby and development dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    libbrotli-dev \
+    pkg-config \
+    ruby \
+    ruby-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Verify GCC version
+RUN gcc --version
+
+# Set working directory
+WORKDIR /app
+
+# Copy source code
+COPY . .
+
+# Install bundler and dependencies
+RUN gem install bundler
+RUN bundle install
+
+# Build and test
+RUN if [ "${USE_SYSTEM_BROTLI}" = "true" ]; then \
+        echo "Building with system Brotli" && \
+        bundle exec rake compile; \
+    else \
+        echo "Building with vendor Brotli" && \
+        bundle exec rake compile -- --enable-vendor; \
+    fi
+RUN bundle exec rake test
+
+CMD ["bash"]

data/README.md

@@ -25,13 +25,62 @@ Or install it yourself as:
 
 ## Usage
 
+### Basic Compression/Decompression
+
 ```ruby
 require 'brotli'
 compressed = Brotli.deflate(string)
 decompressed = Brotli.inflate(compressed)
 ```
 
-See test/brotli_test.rb
+### Custom Dictionary Support
+
+Brotli supports using custom dictionaries to improve compression ratio when you have repetitive data patterns:
+
+```ruby
+# Using a dictionary that contains common patterns in your data
+dictionary = "common patterns in my data"
+data = "This text contains common patterns in my data multiple times"
+
+# Compress with dictionary
+compressed = Brotli.deflate(data, dictionary: dictionary)
+
+# Decompress with the same dictionary
+decompressed = Brotli.inflate(compressed, dictionary: dictionary)
+```
+
+### Compression Options
+
+```ruby
+# Combine dictionary with other compression options
+compressed = Brotli.deflate(data,
+  dictionary: dictionary,
+  quality: 11,        # 0-11, higher = better compression but slower
+  mode: :text,        # :generic (default), :text, or :font
+  lgwin: 22,          # window size (10-24)
+  lgblock: 0          # block size (0 or 16-24)
+)
+```
+
+### Streaming Compression with Writer
+
+```ruby
+# Basic usage
+File.open('output.br', 'wb') do |file|
+  writer = Brotli::Writer.new(file)
+  writer.write(data)
+  writer.close
+end
+
+# With dictionary
+File.open('output.br', 'wb') do |file|
+  writer = Brotli::Writer.new(file, dictionary: dictionary)
+  writer.write(data)
+  writer.close
+end
+```
+
+See test/brotli_test.rb for more examples.
 
 ## Development
 

data/Rakefile

@@ -23,3 +23,20 @@ end
 task :build => :compile
 task :test => :compile
 task :default => :test
+
+task :docker do
+  gcc_versions = ["14", "15"]
+  brotli_configs = [true, false]
+  gcc_versions.product(brotli_configs).each do |gcc_version, use_system_brotli|
+    command = "docker build "\
+              "--progress=plain "\
+              "--build-arg GCC_VERSION=#{gcc_version} "\
+              "--build-arg USE_SYSTEM_BROTLI=#{use_system_brotli} "\
+              "-t brotli:#{gcc_version}#{use_system_brotli ? "-use_system_brotli" : ""} ."
+    puts "Running: #{command}"
+    system command
+    unless $?.exited?
+      raise "Docker build failed for GCC version #{gcc_version} with use_system_brotli=#{use_system_brotli}"
+    end
+  end
+end

data/ext/brotli/brotli.c

@@ -28,6 +28,8 @@ typedef struct {
     BrotliDecoderState* s;
     buffer_t* buffer;
     BrotliDecoderResult r;
+    uint8_t* dict;
+    size_t dict_len;
 } brotli_inflate_args_t;
 
 static void*
@@ -44,6 +46,14 @@ brotli_inflate_no_gvl(void *arg)
     buffer_t*       buffer = args->buffer;
     BrotliDecoderState*  s = args->s;
 
+#ifdef HAVE_BROTLIDECODERATTACHDICTIONARY
+    /* Attach dictionary if provided */
+    if (args->dict && args->dict_len > 0) {
+        BrotliDecoderAttachDictionary(s, BROTLI_SHARED_DICTIONARY_RAW,
+                                      args->dict_len, args->dict);
+    }
+#endif
+
     for (;;) {
         r = BrotliDecoderDecompressStream(s,
                                           &available_in, &next_in,
@@ -68,14 +78,28 @@ brotli_inflate_no_gvl(void *arg)
     return arg;
 }
 
+static ID id_read;
+
 static VALUE
-brotli_inflate(VALUE self, VALUE str)
+brotli_inflate(int argc, VALUE *argv, VALUE self)
 {
-    VALUE value = Qnil;
+    VALUE str = Qnil, opts = Qnil, value = Qnil, dict = Qnil;
     brotli_inflate_args_t args;
 
+    rb_scan_args(argc, argv, "11", &str, &opts);
+
+    if (rb_respond_to(str, id_read)) {
+      str = rb_funcall(str, id_read, 0, 0);
+    }
+
     StringValue(str);
 
+    /* Extract dictionary from options if provided */
+    if (!NIL_P(opts)) {
+        Check_Type(opts, T_HASH);
+        dict = rb_hash_aref(opts, CSTR2SYM("dictionary"));
+    }
+
     args.str = (uint8_t*)RSTRING_PTR(str);
     args.len = (size_t)RSTRING_LEN(str);
     args.buffer = create_buffer(BUFSIZ);
@@ -84,6 +108,20 @@ brotli_inflate(VALUE self, VALUE str)
                                          NULL);
     args.r = BROTLI_DECODER_RESULT_ERROR;
 
+    /* Set dictionary parameters */
+    if (!NIL_P(dict)) {
+#ifdef HAVE_BROTLIDECODERATTACHDICTIONARY
+        StringValue(dict);
+        args.dict = (uint8_t*)RSTRING_PTR(dict);
+        args.dict_len = (size_t)RSTRING_LEN(dict);
+#else
+        rb_raise(rb_eBrotli, "Dictionary support not available in this build");
+#endif
+    } else {
+        args.dict = NULL;
+        args.dict_len = 0;
+    }
+
 #ifdef HAVE_RUBY_THREAD_H
     rb_thread_call_without_gvl(brotli_inflate_no_gvl, (void *)&args, NULL, NULL);
 #else
@@ -199,6 +237,8 @@ typedef struct {
     BrotliEncoderState* s;
     buffer_t* buffer;
     BROTLI_BOOL finished;
+    uint8_t *dict;
+    size_t dict_len;
 } brotli_deflate_args_t;
 
 static void*
@@ -215,6 +255,19 @@ brotli_deflate_no_gvl(void *arg)
     buffer_t*       buffer = args->buffer;
     BrotliEncoderState*  s = args->s;
 
+#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
+    /* Attach dictionary if provided */
+    if (args->dict && args->dict_len > 0) {
+        BrotliEncoderPreparedDictionary* dict = BrotliEncoderPrepareDictionary(
+            BROTLI_SHARED_DICTIONARY_RAW, args->dict_len, args->dict,
+            BROTLI_MAX_QUALITY, brotli_alloc, brotli_free, NULL);
+        if (dict) {
+            BrotliEncoderAttachPreparedDictionary(s, dict);
+            /* Note: dict is owned by encoder after attach, no need to free */
+        }
+    }
+#endif
+
     for (;;) {
         r = BrotliEncoderCompressStream(s,
                                         BROTLI_OPERATION_FINISH,
@@ -241,7 +294,7 @@ brotli_deflate_no_gvl(void *arg)
 static VALUE
 brotli_deflate(int argc, VALUE *argv, VALUE self)
 {
-    VALUE str = Qnil, opts = Qnil, value = Qnil;
+    VALUE str = Qnil, opts = Qnil, value = Qnil, dict = Qnil;
     brotli_deflate_args_t args;
 
     rb_scan_args(argc, argv, "11", &str, &opts);
@@ -251,14 +304,35 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
     }
     StringValue(str);
 
+    /* Extract dictionary from options if provided */
+    if (!NIL_P(opts)) {
+        Check_Type(opts, T_HASH);
+        dict = rb_hash_aref(opts, CSTR2SYM("dictionary"));
+    }
+
     args.str = (uint8_t*)RSTRING_PTR(str);
     args.len = (size_t)RSTRING_LEN(str);
     args.s = brotli_deflate_parse_options(
         BrotliEncoderCreateInstance(brotli_alloc, brotli_free, NULL),
         opts);
-    args.buffer = create_buffer(BUFSIZ);
+    size_t max_compressed_size = BrotliEncoderMaxCompressedSize(args.len);
+    args.buffer = create_buffer(max_compressed_size);
     args.finished = BROTLI_FALSE;
 
+    /* Set dictionary parameters */
+    if (!NIL_P(dict)) {
+#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
+        StringValue(dict);
+        args.dict = (uint8_t*)RSTRING_PTR(dict);
+        args.dict_len = (size_t)RSTRING_LEN(dict);
+#else
+        rb_raise(rb_eBrotli, "Dictionary support not available in this build");
+#endif
+    } else {
+        args.dict = NULL;
+        args.dict_len = 0;
+    }
+
 #ifdef HAVE_RUBY_THREAD_H
     rb_thread_call_without_gvl(brotli_deflate_no_gvl, (void *)&args, NULL, NULL);
 #else
@@ -366,6 +440,7 @@ static VALUE rb_writer_alloc(VALUE klass) {
 static VALUE rb_writer_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE io = Qnil;
     VALUE opts = Qnil;
+    VALUE dict = Qnil;
     rb_scan_args(argc, argv, "11", &io, &opts);
     if (NIL_P(io)) {
         rb_raise(rb_eArgError, "io should not be nil");
@@ -376,6 +451,41 @@ static VALUE rb_writer_initialize(int argc, VALUE* argv, VALUE self) {
     TypedData_Get_Struct(self, struct brotli, &brotli_data_type, br);
     brotli_deflate_parse_options(br->state, opts);
     br->io = io;
+
+#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
+    /* Extract and attach dictionary if provided */
+    if (!NIL_P(opts)) {
+        Check_Type(opts, T_HASH);
+        dict = rb_hash_aref(opts, CSTR2SYM("dictionary"));
+        if (!NIL_P(dict)) {
+            StringValue(dict);
+            BrotliEncoderPreparedDictionary* prepared_dict = BrotliEncoderPrepareDictionary(
+                BROTLI_SHARED_DICTIONARY_RAW,
+                (size_t)RSTRING_LEN(dict),
+                (uint8_t*)RSTRING_PTR(dict),
+                BROTLI_MAX_QUALITY,
+                brotli_alloc,
+                brotli_free,
+                NULL);
+            if (prepared_dict) {
+                BrotliEncoderAttachPreparedDictionary(br->state, prepared_dict);
+                /* Note: dict is owned by encoder after attach, no need to free */
+            } else {
+                rb_raise(rb_eBrotli, "Failed to prepare dictionary for compression");
+            }
+        }
+    }
+#else
+    /* Check if dictionary is requested but not supported */
+    if (!NIL_P(opts)) {
+        Check_Type(opts, T_HASH);
+        dict = rb_hash_aref(opts, CSTR2SYM("dictionary"));
+        if (!NIL_P(dict)) {
+            rb_raise(rb_eBrotli, "Dictionary support not available in this build");
+        }
+    }
+#endif
+
     return self;
 }
 
@@ -469,18 +579,19 @@ Init_brotli(void)
     rb_mBrotli = rb_define_module("Brotli");
     rb_eBrotli = rb_define_class_under(rb_mBrotli, "Error", rb_eStandardError);
     rb_global_variable(&rb_eBrotli);
-    rb_define_singleton_method(rb_mBrotli, "deflate", RUBY_METHOD_FUNC(brotli_deflate), -1);
-    rb_define_singleton_method(rb_mBrotli, "inflate", RUBY_METHOD_FUNC(brotli_inflate), 1);
-    rb_define_singleton_method(rb_mBrotli, "version", RUBY_METHOD_FUNC(brotli_version), 0);
+    rb_define_singleton_method(rb_mBrotli, "deflate", brotli_deflate, -1);
+    rb_define_singleton_method(rb_mBrotli, "inflate", brotli_inflate, -1);
+    rb_define_singleton_method(rb_mBrotli, "version", brotli_version, 0);
+    id_read = rb_intern("read");
     // Brotli::Writer
     id_write = rb_intern("write");
     id_flush = rb_intern("flush");
     id_close = rb_intern("close");
     rb_Writer = rb_define_class_under(rb_mBrotli, "Writer", rb_cObject);
     rb_define_alloc_func(rb_Writer, rb_writer_alloc);
-    rb_define_method(rb_Writer, "initialize", RUBY_METHOD_FUNC(rb_writer_initialize), -1);
-    rb_define_method(rb_Writer, "write", RUBY_METHOD_FUNC(rb_writer_write), 1);
-    rb_define_method(rb_Writer, "finish", RUBY_METHOD_FUNC(rb_writer_finish), 0);
-    rb_define_method(rb_Writer, "flush", RUBY_METHOD_FUNC(rb_writer_flush), 0);
-    rb_define_method(rb_Writer, "close", RUBY_METHOD_FUNC(rb_writer_close), 0);
+    rb_define_method(rb_Writer, "initialize", rb_writer_initialize, -1);
+    rb_define_method(rb_Writer, "write", rb_writer_write, 1);
+    rb_define_method(rb_Writer, "finish", rb_writer_finish, 0);
+    rb_define_method(rb_Writer, "flush", rb_writer_flush, 0);
+    rb_define_method(rb_Writer, "close", rb_writer_close, 0);
 }

data/ext/brotli/brotli.h

@@ -10,6 +10,9 @@
 
 #include "brotli/encode.h"
 #include "brotli/decode.h"
+#ifdef HAVE_BROTLI_SHARED_DICTIONARY_H
+#include "brotli/shared_dictionary.h"
+#endif
 #include "buffer.h"
 
 #endif /* BROTLI_H */

data/ext/brotli/buffer.c

@@ -1,9 +1,10 @@
 #include "buffer.h"
+#include "ruby/ruby.h"
 #define INITIAL (1024)
 
 buffer_t*
 create_buffer(const size_t initial) {
-    buffer_t *buffer = malloc(sizeof(buffer_t));
+    buffer_t *buffer = ruby_xmalloc(sizeof(buffer_t));
     if (buffer == NULL) {
         return NULL;
     }
@@ -12,7 +13,7 @@ create_buffer(const size_t initial) {
     buffer->expand_count = 0;
     buffer->expand_ratio = 130;
     buffer->size = (size_t) (initial > 0 ? initial : INITIAL);
-    buffer->ptr = malloc(buffer->size);
+    buffer->ptr = ruby_xmalloc(buffer->size);
     if (buffer->ptr == NULL) {
         delete_buffer(buffer);
         return NULL;
@@ -24,17 +25,17 @@ create_buffer(const size_t initial) {
 void
 delete_buffer(buffer_t* buffer) {
     if (buffer->ptr != NULL) {
-        free(buffer->ptr);
+        ruby_xfree(buffer->ptr);
         buffer->ptr = NULL;
     }
-    free(buffer);
+    ruby_xfree(buffer);
 }
 
 static
 buffer_t*
 expand_buffer(buffer_t* const buffer, const size_t need) {
     size_t size = need * buffer->expand_ratio / 100;
-    buffer->ptr = realloc(buffer->ptr, size);
+    buffer->ptr = ruby_xrealloc(buffer->ptr, size);
     buffer->size = size;
     buffer->expand_count += 1;
     return buffer;

data/ext/brotli/extconf.rb

@@ -13,9 +13,18 @@ have_dev_pkg = [
   pkg_config("libbrotlienc")
 ].all? { |e| e }
 
+have_header("brotli/shared_dictionary.h")
+have_func("BrotliEncoderPrepareDictionary", "brotli/encode.h")
+have_func("BrotliEncoderAttachPreparedDictionary", "brotli/encode.h")
+have_func("BrotliDecoderAttachDictionary", "brotli/decode.h")
+
 if enable_config("vendor")
   have_dev_pkg = false
   Logging::message "Use vendor brotli\n"
+  $defs << "-DHAVE_BROTLI_SHARED_DICTIONARY_H"
+  $defs << "-DHAVE_BROTLIENCODERPREPAREDICTIONARY"
+  $defs << "-DHAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY"
+  $defs << "-DHAVE_BROTLIDECODERATTACHDICTIONARY"
 end
 
 $CPPFLAGS << " -DOS_MACOSX" if RbConfig::CONFIG["host_os"] =~ /darwin|mac os/

data/lib/brotli/version.rb

@@ -1,3 +1,3 @@
 module Brotli
-  VERSION = '0.5.0'
+  VERSION = '0.7.0'
 end

data/test/brotli_test.rb

@@ -21,9 +21,10 @@ class BrotliTest < Test::Unit::TestCase
     end
   end
 
-  sub_test_case ".version" do
-    test "returns string" do
-      assert_equal "1.1.0", Brotli.version
+  test ".version" do
+    assert do
+      puts "Brotli version: #{Brotli.version}"
+      ["1.1.0", "1.0.9"].include? Brotli.version
     end
   end
 
@@ -77,6 +78,16 @@ class BrotliTest < Test::Unit::TestCase
       assert_equal testdata, Brotli.inflate(testdata2)
     end
 
+    test "works with StringIO" do
+      testdata3 = StringIO.new testdata2
+      assert_equal testdata, Brotli.inflate(testdata3)
+    end
+
+    test "works with File" do
+      f = File.open(File.expand_path(File.join("..", "vendor", "brotli", "tests", "testdata", "alice29.txt.compressed"), __dir__))
+      assert_equal testdata, Brotli.inflate(f)
+    end
+
     test "raise error when pass insufficient data" do
       assert_raise Brotli::Error do
         Brotli.inflate(testdata2[0, 64])
@@ -90,6 +101,71 @@ class BrotliTest < Test::Unit::TestCase
     end
   end
 
+  sub_test_case "dictionary support" do
+    def setup
+      omit "Dictionary tests are skipped" if Brotli.version < "1.1.0"
+    end
+
+    def dictionary_data
+      "The quick brown fox jumps over the lazy dog"
+    end
+
+    def repetitive_data
+      dictionary_data * 10
+    end
+
+    test "deflate with dictionary produces smaller output" do
+      compressed_no_dict = Brotli.deflate(repetitive_data)
+      compressed_with_dict = Brotli.deflate(repetitive_data, dictionary: dictionary_data)
+
+      assert compressed_with_dict.bytesize < compressed_no_dict.bytesize
+    end
+
+    test "inflate with matching dictionary works" do
+      compressed = Brotli.deflate(repetitive_data, dictionary: dictionary_data)
+      decompressed = Brotli.inflate(compressed, dictionary: dictionary_data)
+
+      assert_equal repetitive_data, decompressed
+    end
+
+    test "inflate without dictionary fails on dictionary-compressed data" do
+      compressed = Brotli.deflate(repetitive_data, dictionary: dictionary_data)
+
+      assert_raise Brotli::Error do
+        Brotli.inflate(compressed)
+      end
+    end
+
+    test "inflate with wrong dictionary fails" do
+      compressed = Brotli.deflate(repetitive_data, dictionary: dictionary_data)
+      wrong_dict = "A completely different dictionary"
+
+      assert_raise Brotli::Error do
+        Brotli.inflate(compressed, dictionary: wrong_dict)
+      end
+    end
+
+    test "deflate and inflate work with binary dictionary" do
+      binary_dict = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09" * 10
+      data = "Test data " * 100 + binary_dict
+
+      compressed = Brotli.deflate(data, dictionary: binary_dict)
+      decompressed = Brotli.inflate(compressed, dictionary: binary_dict)
+
+      assert_equal data, decompressed
+    end
+
+    test "deflate with dictionary and other options" do
+      compressed = Brotli.deflate(repetitive_data,
+                                 dictionary: dictionary_data,
+                                 quality: 11,
+                                 mode: :text)
+      decompressed = Brotli.inflate(compressed, dictionary: dictionary_data)
+
+      assert_equal repetitive_data, decompressed
+    end
+  end
+
   sub_test_case "Ractor safe" do
     test "able to invoke non-main ractor" do
       unless defined? ::Ractor

data/test/brotli_writer_test.rb

@@ -33,4 +33,61 @@ class BrotliWriterTest < Test::Unit::TestCase
       Brotli::Writer.new nil
     end
   end
+
+  test "works with dictionary" do
+    omit_if(Brotli.version < "1.1.0", "Dictionary tests are skipped")
+
+    dictionary = "The quick brown fox jumps over the lazy dog"
+    data = dictionary * 10
+
+    writer = Brotli::Writer.new @tempfile, dictionary: dictionary
+    assert_equal data.bytesize, writer.write(data)
+    assert_equal @tempfile, writer.close
+
+    @tempfile.open
+    compressed = @tempfile.read
+    decompressed = Brotli.inflate(compressed, dictionary: dictionary)
+    assert_equal data, decompressed
+  end
+
+  test "writer with dictionary produces smaller output" do
+    omit_if(Brotli.version < "1.1.0", "Dictionary tests are skipped")
+
+    dictionary = "The quick brown fox jumps over the lazy dog"
+    data = dictionary * 10
+
+    # Without dictionary
+    @tempfile.rewind
+    writer_no_dict = Brotli::Writer.new @tempfile
+    writer_no_dict.write(data)
+    writer_no_dict.close
+    size_no_dict = @tempfile.size
+
+    # With dictionary
+    tempfile2 = Tempfile.new
+    writer_with_dict = Brotli::Writer.new tempfile2, dictionary: dictionary
+    writer_with_dict.write(data)
+    writer_with_dict.close
+    size_with_dict = tempfile2.size
+
+    assert size_with_dict < size_no_dict
+
+    tempfile2.close!
+  end
+
+  test "writer with dictionary and other options" do
+    omit_if(Brotli.version < "1.1.0", "Dictionary tests are skipped")
+
+    dictionary = "compression dictionary"
+    data = "test data " * 100 + dictionary * 5
+
+    writer = Brotli::Writer.new @tempfile, dictionary: dictionary, quality: 11, mode: :text
+    writer.write(data)
+    writer.finish
+    writer.close
+
+    @tempfile.open
+    decompressed = Brotli.inflate(@tempfile.read, dictionary: dictionary)
+    assert_equal data, decompressed
+  end
 end

data/test/test_helper.rb

@@ -6,3 +6,4 @@ require "brotli"
 require "test-unit"
 require "test/unit/rr"
 require "rantly/testunit_extensions"
+require "stringio"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: brotli
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - miyucy
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-31 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Brotli compressor/decompressor
 email:
@@ -23,6 +22,7 @@ files:
 - ".gitignore"
 - ".gitmodules"
 - ".rspec"
+- Dockerfile
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -140,7 +140,6 @@ homepage: https://github.com/miyucy/brotli
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -155,8 +154,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.7
 specification_version: 4
 summary: Brotli compressor/decompressor
 test_files: