brotli 0.2.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab7474a5a27fb0167098bc9838f8e57bc78082d596c5e38a7c86764fdf62bf13
-  data.tar.gz: 5a0b4d731bfd0fdbdd19a2cec36973cfc04460237acf58ac03dda51e8da82fe1
+  metadata.gz: 97953895465e26d5937e5959f86954aa58de2d2221301bc64ff639e682565605
+  data.tar.gz: 4f26bccb546a19c743eea5b0fd9207f8e623bfd73f05e08f3dae275b76c51482
 SHA512:
-  metadata.gz: ae940a4cb85d44b0ad84a01fde9e8aaf285366dfcbccca4ba68619966005e1f003046de298b5d69098a4d3fcfd2a020ef49fa6eb5a3a0c790f59cd3060138bb6
-  data.tar.gz: 92b9e926ad5b98f4afc7522c0b7a1a7490f32ed474d0881643f09ae8747ada70f25aa77360dc4707c369c6e58bfa747fc0eca7efb8cc05ee2f752e802202b017
+  metadata.gz: b5e79aee2804a948da509247c56b1f79e9248927ec6430319b1d2b6202973ed41bca1ceba215f8d4954ad98a52637a91e49bfa316af4ab3d35fcb779f0e94aa3
+  data.tar.gz: 46d42e9297f79aef7481b068e43da47c60d45b0f781a0ceb1fc7626cdb9c59bc306feaab0b05321cba17e23256e492814f340725db8fb21dc9e4c84198507bf5

data/.github/workflows/main.yml

@@ -0,0 +1,37 @@
+name: Ruby
+
+on: [pull_request]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.7, 3.1, 3.2, 3.3]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Run the default task
+      run: |
+        bundle exec rake clobber
+        bundle exec rake compile -- --enable-vendor
+        bundle exec rake test
+        bundle exec rake build
+        gem install --no-document "$(ls pkg/brotli-*.gem)"
+        cat <<EOF | ruby
+        require "brotli"
+        if Brotli.inflate(Brotli.deflate(File.read("README.md"))) == File.read("README.md")
+          puts "OK"
+          exit 0
+        else
+          puts "NG"
+          exit 0
+        end
+        EOF

data/.github/workflows/publish.yml

@@ -0,0 +1,24 @@
+name: Publish Gem
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    if: github.repository == 'miyucy/brotli'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ruby
+        bundler-cache: true
+    - uses: rubygems/release-gem@v1

data/.gitmodules

@@ -1,3 +1,3 @@
 [submodule "vendor/brotli"]
 	path = vendor/brotli
-	url = git://github.com/google/brotli.git
+	url = https://github.com/google/brotli.git

data/Gemfile

@@ -1,7 +1,10 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in brotli.gemspec
 gemspec
 
-gem 'travis'
-gem 'yard'
+gem "rake", "~> 13.0"
+gem "rake-compiler"
+gem "test-unit", "~> 3.0"
+gem "test-unit-rr"
+gem "rantly"

data/README.md

@@ -1,4 +1,4 @@
-# Brotli [![](https://travis-ci.org/miyucy/brotli.svg)](https://travis-ci.org/miyucy/brotli)
+# Brotli
 
 Brotli is a Ruby implementation of the Brotli generic-purpose lossless
 compression algorithm that compresses data using a combination of a modern
@@ -31,7 +31,7 @@ compressed = Brotli.deflate(string)
 decompressed = Brotli.inflate(compressed)
 ```
 
-See spec/brotli_spec.rb
+See test/brotli_test.rb
 
 ## Development
 

data/Rakefile

@@ -1,18 +1,25 @@
+require "bundler/setup"
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require "rake/clean"
+require "rake/testtask"
 require "rake/extensiontask"
-require "yard"
 
-RSpec::Core::RakeTask.new(:spec)
+CLEAN.include("ext/brotli/common")
+CLEAN.include("ext/brotli/dec")
+CLEAN.include("ext/brotli/enc")
+CLEAN.include("ext/brotli/include")
 
-task :default => [:compile, :spec]
-
-task :build => :compile
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.warning = true
+  t.verbose = true
+end
 
 Rake::ExtensionTask.new("brotli") do |ext|
   ext.lib_dir = "lib/brotli"
 end
 
-YARD::Rake::YardocTask.new do |t|
-  t.options = ["--no-progress", "--output-dir", "docs"]
-end
+task :build => :compile
+task :test => :compile
+task :default => :test

data/brotli.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'brotli/version'
+require "brotli/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "brotli"
@@ -9,25 +9,19 @@ Gem::Specification.new do |spec|
   spec.authors       = ["miyucy"]
   spec.email         = ["fistfvck@gmail.com"]
 
-  spec.summary       = %q{Brotli compressor/decompressor}
-  spec.description   = %q{Brotli compressor/decompressor}
+  spec.summary       = "Brotli compressor/decompressor"
+  spec.description   = "Brotli compressor/decompressor"
   spec.homepage      = "https://github.com/miyucy/brotli"
   spec.license       = "MIT"
 
-  spec.test_files    = `git ls-files -z -- spec`.split("\x0")
+  spec.test_files    = `git ls-files -z -- test`.split("\x0")
   spec.files         = `git ls-files -z`.split("\x0")
   spec.files        -= spec.test_files
-  spec.files        -= ['vendor/brotli']
-  spec.files        += Dir['vendor/brotli/c/{common,enc,dec,include}/**/*']
-  spec.files        += ['vendor/brotli/LICENSE']
+  spec.files        -= ["vendor/brotli"]
+  spec.files        += Dir["vendor/brotli/c/{common,enc,dec,include}/**/*"]
+  spec.files        += ["vendor/brotli/LICENSE"]
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.extensions    = ["ext/brotli/extconf.rb"]
-
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rake-compiler"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "rantly"
 end

data/ext/brotli/brotli.c

@@ -2,20 +2,19 @@
 
 #define CSTR2SYM(x) ID2SYM(rb_intern(x))
 
-static VALUE rb_mBrotli;
 static VALUE rb_eBrotli;
 
-static void*
+static inline void*
 brotli_alloc(void* opaque, size_t size)
 {
-    return malloc(size);
+    return ruby_xmalloc(size);
 }
 
-static void
+static inline void
 brotli_free(void* opaque, void* address)
 {
     if (address) {
-        free(address);
+        ruby_xfree(address);
     }
 }
 
@@ -138,11 +137,10 @@ brotli_deflate_set_mode(BrotliEncoderState* s, VALUE value)
 static void
 brotli_deflate_set_quality(BrotliEncoderState* s, VALUE value)
 {
-    uint32_t param;
     if (NIL_P(value)) {
         return;
     } else {
-        param = NUM2INT(value);
+        int32_t param = NUM2INT(value);
         if (0 <= param && param <= 11) {
             BrotliEncoderSetParameter(s, BROTLI_PARAM_QUALITY, param);
         } else {
@@ -154,11 +152,10 @@ brotli_deflate_set_quality(BrotliEncoderState* s, VALUE value)
 static void
 brotli_deflate_set_lgwin(BrotliEncoderState* s, VALUE value)
 {
-    uint32_t param;
     if (NIL_P(value)) {
         return;
     } else {
-        param = NUM2INT(value);
+        int32_t param = NUM2INT(value);
         if (10 <= param && param <= 24) {
             BrotliEncoderSetParameter(s, BROTLI_PARAM_LGWIN, param);
         } else {
@@ -170,11 +167,10 @@ brotli_deflate_set_lgwin(BrotliEncoderState* s, VALUE value)
 static void
 brotli_deflate_set_lgblock(BrotliEncoderState* s, VALUE value)
 {
-    uint32_t param;
     if (NIL_P(value)) {
         return;
     } else {
-        param = NUM2INT(value);
+        int32_t param = NUM2INT(value);
         if ((param == 0) || (16 <= param && param <= 24)) {
             BrotliEncoderSetParameter(s, BROTLI_PARAM_LGBLOCK, param);
         } else {
@@ -187,6 +183,7 @@ static BrotliEncoderState*
 brotli_deflate_parse_options(BrotliEncoderState* s, VALUE opts)
 {
     if (!NIL_P(opts)) {
+        Check_Type(opts, T_HASH);
         brotli_deflate_set_mode(s, rb_hash_aref(opts, CSTR2SYM("mode")));
         brotli_deflate_set_quality(s, rb_hash_aref(opts, CSTR2SYM("quality")));
         brotli_deflate_set_lgwin(s, rb_hash_aref(opts, CSTR2SYM("lgwin")));
@@ -241,26 +238,6 @@ brotli_deflate_no_gvl(void *arg)
     return arg;
 }
 
-/*
- * call-seq:
- *     Brotli.deflate(str, opts=nil) -> String
- * @param [String] str
- *   string
- * @param [Hash] opts
- *   options
- * @option opts [Symbol] :mode
- *   Deflate mode
- *   * :generic
- *   * :text
- *   * :font
- * @option opts [Integer] :quality
- *   quality 0-11
- * @option opts [Integer] :lgwin
- *   lgwin 10-24
- * @option opts [Integer] :lgblock
- *   lgblock 16-24 or 0
- * @return [String] Deflated string
- */
 static VALUE
 brotli_deflate(int argc, VALUE *argv, VALUE self)
 {
@@ -268,6 +245,10 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
     brotli_deflate_args_t args;
 
     rb_scan_args(argc, argv, "11", &str, &opts);
+    if (NIL_P(str)) {
+        rb_raise(rb_eArgError, "input should not be nil");
+        return Qnil;
+    }
     StringValue(str);
 
     args.str = (uint8_t*)RSTRING_PTR(str);
@@ -293,6 +274,185 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
     return value;
 }
 
+/*******************************************************************************
+ * version
+ ******************************************************************************/
+
+static VALUE brotli_version(VALUE klass) {
+    uint32_t ver = BrotliEncoderVersion();
+    char version[255];
+    snprintf(version, sizeof(version), "%u.%u.%u", ver >> 24, (ver >> 12) & 0xFFF, ver & 0xFFF);
+    return rb_str_new2(version);
+}
+
+/*******************************************************************************
+ * Writer
+ ******************************************************************************/
+
+static ID id_write, id_flush, id_close;
+
+struct brotli {
+    VALUE io;
+    BrotliEncoderState* state;
+};
+
+static void br_mark(void *p)
+{
+    struct brotli *br = p;
+    rb_gc_mark(br->io);
+}
+
+static void br_free(void *p)
+{
+    struct brotli* br = p;
+    BrotliEncoderDestroyInstance(br->state);
+    br->state = NULL;
+    br->io = Qnil;
+    ruby_xfree(br);
+}
+
+static size_t br_memsize(const void *p)
+{
+    return sizeof(struct brotli);
+}
+
+static const rb_data_type_t brotli_data_type = {
+    "brotli",
+    { br_mark, br_free, br_memsize },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+typedef struct {
+    BrotliEncoderState* state;
+    BrotliEncoderOperation op;
+    size_t available_in;
+    const uint8_t* next_in;
+} brotli_encoder_args_t;
+
+static void* compress_no_gvl(void *ptr) {
+    brotli_encoder_args_t *args = ptr;
+    size_t zero = 0;
+    if (!BrotliEncoderCompressStream(args->state, args->op,
+                                     &args->available_in, &args->next_in,
+                                     &zero, NULL, NULL)) {
+        rb_raise(rb_eBrotli, "BrotliEncoderCompressStream failed");
+    }
+    return NULL;
+}
+
+static size_t push_output(struct brotli *br) {
+    size_t len = 0;
+    if (BrotliEncoderHasMoreOutput(br->state)) {
+        const uint8_t* out = BrotliEncoderTakeOutput(br->state, &len);
+        if (len > 0) {
+            rb_funcall(br->io, id_write, 1, rb_str_new((const char*)out, len));
+        }
+    }
+    return len;
+}
+
+static VALUE rb_writer_alloc(VALUE klass) {
+    struct brotli *br;
+    VALUE obj = TypedData_Make_Struct(klass, struct brotli, &brotli_data_type, br);
+    br->io = Qnil;
+    br->state = BrotliEncoderCreateInstance(brotli_alloc, brotli_free, NULL);
+    if (!br->state) {
+        rb_raise(rb_eNoMemError, "BrotliEncoderCreateInstance failed");
+        return Qnil;
+    }
+    return obj;
+}
+
+static VALUE rb_writer_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE io = Qnil;
+    VALUE opts = Qnil;
+    rb_scan_args(argc, argv, "11", &io, &opts);
+    if (NIL_P(io)) {
+        rb_raise(rb_eArgError, "io should not be nil");
+        return Qnil;
+    }
+
+    struct brotli *br;
+    TypedData_Get_Struct(self, struct brotli, &brotli_data_type, br);
+    brotli_deflate_parse_options(br->state, opts);
+    br->io = io;
+    return self;
+}
+
+static VALUE rb_writer_write(VALUE self, VALUE buf) {
+    struct brotli* br;
+    TypedData_Get_Struct(self, struct brotli, &brotli_data_type, br);
+    StringValue(buf);
+
+    const size_t total = (size_t)RSTRING_LEN(buf);
+
+    brotli_encoder_args_t args = {
+        .state = br->state,
+        .op = BROTLI_OPERATION_PROCESS,
+        .available_in = total,
+        .next_in = (uint8_t*)RSTRING_PTR(buf)
+    };
+
+    while (args.available_in > 0) {
+        rb_thread_call_without_gvl(compress_no_gvl, (void*)&args, NULL, NULL);
+        push_output(br);
+    }
+
+    return SIZET2NUM(total);
+}
+
+static VALUE rb_writer_finish(VALUE self) {
+    struct brotli* br;
+    TypedData_Get_Struct(self, struct brotli, &brotli_data_type, br);
+
+    brotli_encoder_args_t args = {
+        .state = br->state,
+        .op = BROTLI_OPERATION_FINISH,
+        .available_in = 0,
+        .next_in = NULL
+    };
+
+    while (!BrotliEncoderIsFinished(br->state)) {
+        rb_thread_call_without_gvl(compress_no_gvl, (void*)&args, NULL, NULL);
+        push_output(br);
+    }
+    return br->io;
+}
+
+static VALUE rb_writer_flush(VALUE self) {
+    struct brotli *br;
+    TypedData_Get_Struct(self, struct brotli, &brotli_data_type, br);
+
+    brotli_encoder_args_t args = {
+        .state = br->state,
+        .op = BROTLI_OPERATION_FLUSH,
+        .available_in = 0,
+        .next_in = NULL
+    };
+
+    do  {
+        rb_thread_call_without_gvl(compress_no_gvl, (void*)&args, NULL, NULL);
+        push_output(br);
+    } while (BrotliEncoderHasMoreOutput(br->state));
+
+    if (rb_respond_to(br->io, id_flush)) {
+        rb_funcall(br->io, id_flush, 0);
+    }
+    return self;
+}
+
+static VALUE rb_writer_close(VALUE self) {
+    struct brotli* br;
+    TypedData_Get_Struct(self, struct brotli, &brotli_data_type, br);
+
+    rb_writer_finish(self);
+
+    if (rb_respond_to(br->io, id_close)) {
+        rb_funcall(br->io, id_close, 0);
+    }
+    return br->io;
+}
+
 /*******************************************************************************
  * entry
  ******************************************************************************/
@@ -300,8 +460,27 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
 void
 Init_brotli(void)
 {
+#if HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+#endif
+
+    VALUE rb_mBrotli;
+    VALUE rb_Writer;
     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);
+    // 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);
 }

data/ext/brotli/buffer.c

@@ -34,13 +34,7 @@ static
 buffer_t*
 expand_buffer(buffer_t* const buffer, const size_t need) {
     size_t size = need * buffer->expand_ratio / 100;
-    uint8_t* ptr = malloc(size);
-    if (ptr == NULL) {
-        return NULL;
-    }
-    memcpy(ptr, buffer->ptr, buffer->size);
-    free(buffer->ptr);
-    buffer->ptr = ptr;
+    buffer->ptr = realloc(buffer->ptr, size);
     buffer->size = size;
     buffer->expand_count += 1;
     return buffer;

data/ext/brotli/buffer.h

@@ -5,7 +5,7 @@
 #include <string.h>
 
 typedef struct {
-    uint8_t* ptr;
+    char* ptr;
     size_t size;
     size_t used;
     size_t expand_ratio;

data/ext/brotli/extconf.rb

@@ -1,6 +1,6 @@
-require 'mkmf'
-require 'fileutils'
-require 'rbconfig'
+require "mkmf"
+require "fileutils"
+require "rbconfig"
 
 dir_config("brotli")
 
@@ -13,36 +13,44 @@ have_dev_pkg = [
   pkg_config("libbrotlienc")
 ].all? { |e| e }
 
-$CPPFLAGS << ' -DOS_MACOSX' if RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-unless have_dev_pkg
-  $INCFLAGS << ' -I$(srcdir)/enc -I$(srcdir)/dec -I$(srcdir)/common -I$(srcdir)/include'
+if enable_config("vendor")
+  have_dev_pkg = false
+  Logging::message "Use vendor brotli\n"
 end
 
-create_makefile('brotli/brotli')
+$CPPFLAGS << " -DOS_MACOSX" if RbConfig::CONFIG["host_os"] =~ /darwin|mac os/
+$INCFLAGS << " -I$(srcdir)/enc -I$(srcdir)/dec -I$(srcdir)/common -I$(srcdir)/include" unless have_dev_pkg
+
+create_makefile("brotli/brotli")
 
 unless have_dev_pkg
-  __DIR__ = File.expand_path(File.dirname __FILE__)
+  __DIR__ = File.expand_path(File.dirname(__FILE__))
 
   %w[enc dec common include].each do |dirname|
+    FileUtils.rm_rf dirname
     FileUtils.mkdir_p dirname
-    FileUtils.cp_r File.expand_path(File.join(__DIR__, '..', '..', 'vendor', 'brotli', 'c', dirname), __DIR__), __DIR__, verbose: true
+    FileUtils.cp_r(
+      File.expand_path(File.join(__DIR__, "..", "..", "vendor", "brotli", "c", dirname), __DIR__),
+      __DIR__,
+      verbose: true
+    )
   end
 
   srcs = []
   objs = []
-  Dir[File.expand_path(File.join('{enc,dec,common,include}', '**', '*.c'), __DIR__)].sort.each do |file|
-    file[__DIR__ + File::SEPARATOR] = ''
+  Dir[File.expand_path(File.join("{enc,dec,common,include}", "**", "*.c"), __DIR__)].sort.each do |file|
+    file[__DIR__ + File::SEPARATOR] = ""
     srcs << file
-    objs << file.sub(/\.c\z/, '.' + RbConfig::CONFIG['OBJEXT'])
+    objs << file.sub(/\.c\z/, "." + RbConfig::CONFIG["OBJEXT"])
   end
 
-  File.open('Makefile', 'r+') do |f|
-    obj_ext = RbConfig::CONFIG['OBJEXT']
-    src = 'ORIG_SRCS = brotli.c buffer.c'
+  File.open("Makefile", "r+") do |f|
+    obj_ext = RbConfig::CONFIG["OBJEXT"]
+    src = "ORIG_SRCS = brotli.c buffer.c"
     obj = "OBJS = brotli.#{obj_ext} buffer.#{obj_ext}"
     txt = f.read
-            .sub(/^ORIG_SRCS = .*$/, src + ' ' + srcs.join(' '))
-            .sub(/^OBJS = .*$/, obj + ' ' + objs.join(' '))
+           .sub(/^ORIG_SRCS = .*$/, "#{src} #{srcs.join(" ")}")
+           .sub(/^OBJS = .*$/, "#{obj} #{objs.join(" ")}")
     f.rewind
     f.write txt
   end

data/lib/brotli/version.rb

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