brotli 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 28b044ea8f0192f41b544f72eea2855d490f2722
-  data.tar.gz: 6face28127a2acde37dd8a72a203d277f72f78a9
+SHA256:
+  metadata.gz: 410f0b599c6bf42f90cb7fa83c6710304ad0fb018b1f4b5560bfadadaef165d9
+  data.tar.gz: 03fbcca525c9705b99935ab2ea4db0bb80e4c6a960d3010450a173c5b305eb43
 SHA512:
-  metadata.gz: 12b573800edcd717571dff187a05cb9b71d8e6d33c64a8c9c358b3b6e332152b80035c66e050ae83846d02378abf63a3df778afd3af04ca17dc6ea3cd124f80f
-  data.tar.gz: 1932d518c3345ab655a52bc75a0066304eb88ad1207d830a94ad6d97148cedb4094859691730329e34ad442bb4c089c1c1a51d430eb2c12ad20177633b5360ad
+  metadata.gz: fe26f6b7a9a2f3a0bf0ab5d1e79ff89ff8dc2a763e3b8beb073feb365f6ae222dcf277672bbbe2ac7aeaa71f2b024edd6ce49a6a7254452897fdbfef61f422a5
+  data.tar.gz: c1952c3b820fa2ec0b5a1e1567acfe831fcc1a6131f07e12acf3b26595c3bda90c89182abfcc57730febe5311906632ea8c19a21e16e866a5e620a8b85cfa2d4

data/.github/workflows/main.yml

@@ -0,0 +1,34 @@
+name: Ruby
+
+on: [pull_request]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.5, 2.6, 2.7, 3.0]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+      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 test 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,34 @@
+name: Publish Gem
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.7]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Run release task
+      run: |
+        mkdir -p ~/.gem
+        cat << EOF > ~/.gem/credentials
+        ---
+        :github: Bearer ${{secrets.GITHUB_TOKEN}}
+        :rubygems_api_key: ${{secrets.RUBYGEMS_API_KEY}}
+        EOF
+        chmod 600 ~/.gem/credentials
+        bundle exec rake release[remote]
+        rm -f ~/.gem/credentials

data/Gemfile

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

data/Rakefile

@@ -1,13 +1,25 @@
+require "bundler/setup"
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => [:compile, :spec]
+require "rake/clean"
+require "rake/testtask"
 require "rake/extensiontask"
 
-task :build => :compile
+CLEAN.include("ext/brotli/common")
+CLEAN.include("ext/brotli/dec")
+CLEAN.include("ext/brotli/enc")
+CLEAN.include("ext/brotli/include")
+
+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
+
+task :build => :compile
+task :test => :compile
+task :default => :test

data/bin/before_install.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+set -ev
+gem update --system || gem update --system '2.7.8'
+if [ "$(gem --version | cut -b 1)" = 3 ]; then
+  echo "gem: -N" >> ~/.gemrc
+else
+  echo "gem: --no-ri --no-rdoc" >> ~/.gemrc
+fi
+gem install bundler || gem install bundler -v '< 2'

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", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
-  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 {
@@ -248,6 +244,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);
@@ -273,6 +273,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
  ******************************************************************************/
@@ -280,8 +459,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);
 }