brotli 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 439249d900d92fdfbdba0c607d03b1cc52be123ed909bf7971d6c8b89c8134de
-  data.tar.gz: 3ae1816fee964948daedfa0835f2098efd4526def10f855f6a3fcc415ad56ce1
+  metadata.gz: 6e39135e3c6e289c1b4f233d8e0bec31f1cfb6be48f63280b5a7609965b88459
+  data.tar.gz: 5f0bae9eb2e35baf822e7eff9e8432e24043893afe29c70506050d41c073bbaa
 SHA512:
-  metadata.gz: 330cc7d4176f2ede18d615c7c51862131182c5e3826d164b3cced606a490924d44ef349ab746677e8f62f547a87601ddc65c5f95197a7cc43f53e87f1a7f448d
-  data.tar.gz: 711194c375cd78bba734cb5ae4b89270ddcbaa8a457e3e45b055a6334a0a684d1f7351780c868a965c804cab306796949f5e915a60bbeb95f332b6900fea68a6
+  metadata.gz: 46ae27522c3cb015279531a8d6b91af3afcd40a0b61c552db76e7caa9562a547f8f4e2f09873f5e113314cbc0ffe811fcfdc9a0c02b84aa2df4ade1d005857e9
+  data.tar.gz: cc393196d928f8d761b83bf7f04415c7f1ddd1b2f113008063e9b99615004adf00af95171932d009efeeb0e6ad2f5edb3c26196610475b08a4e5db0d56e5e201

data/ext/brotli/brotli.c

@@ -101,13 +101,11 @@ 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,
@@ -133,6 +131,13 @@ brotli_inflate_no_gvl(void *arg)
     return arg;
 }
 
+static VALUE
+brotli_inflate_take_result(VALUE arg)
+{
+    brotli_inflate_args_t *args = (brotli_inflate_args_t *)arg;
+    return rb_str_new(args->buffer->ptr, args->buffer->used);
+}
+
 static VALUE
 brotli_inflate(int argc, VALUE *argv, VALUE self)
 {
@@ -141,7 +146,7 @@ brotli_inflate(int argc, VALUE *argv, VALUE self)
     VALUE value = Qnil;
     VALUE dict = Qnil;
     const char *error = NULL;
-    brotli_inflate_args_t args;
+    brotli_inflate_args_t args = {0};
 
     (void)self;
 
@@ -153,6 +158,9 @@ brotli_inflate(int argc, VALUE *argv, VALUE self)
 
     StringValue(str);
     dict = brotli_hash_lookup(opts, id_dictionary);
+    if (!NIL_P(dict)) {
+        StringValue(dict);
+    }
 
     args.str = (uint8_t*)RSTRING_PTR(str);
     args.len = (size_t)RSTRING_LEN(str);
@@ -161,28 +169,24 @@ brotli_inflate(int argc, VALUE *argv, VALUE self)
     args.r = BROTLI_DECODER_RESULT_ERROR;
 
     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, &args, NULL, NULL);
-#else
-    brotli_inflate_no_gvl(&args);
-#endif
     RB_GC_GUARD(str);
     RB_GC_GUARD(dict);
 
     if (args.r == BROTLI_DECODER_RESULT_SUCCESS) {
-        value = rb_str_new(args.buffer->ptr, args.buffer->used);
+        int state = 0;
+        value = rb_protect(brotli_inflate_take_result, (VALUE)&args, &state);
+        if (state) {
+            brotli_inflate_cleanup(&args);
+            rb_jump_tag(state);
+        }
     } else if (args.r == BROTLI_DECODER_RESULT_ERROR) {
         error = BrotliDecoderErrorString(BrotliDecoderGetErrorCode(args.s));
     } else if (args.r == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
@@ -204,11 +208,11 @@ brotli_inflate(int argc, VALUE *argv, VALUE self)
  * deflate
  ******************************************************************************/
 
-static void
+static const char *
 brotli_deflate_set_mode(BrotliEncoderState* s, VALUE value)
 {
     if (NIL_P(value)) {
-        return;
+        return NULL;
     }
 
     if (value == ID2SYM(id_generic)) {
@@ -218,68 +222,99 @@ brotli_deflate_set_mode(BrotliEncoderState* s, VALUE value)
     } else if (value == ID2SYM(id_font)) {
         BrotliEncoderSetParameter(s, BROTLI_PARAM_MODE, BROTLI_MODE_FONT);
     } else {
-        rb_raise(rb_eArgError, "invalid mode");
+        return "invalid mode";
     }
+
+    return NULL;
 }
 
-static void
+static const char *
 brotli_deflate_set_quality(BrotliEncoderState* s, VALUE value)
 {
-    int32_t param;
+    long param;
 
     if (NIL_P(value)) {
-        return;
+        return NULL;
+    }
+
+    if (!FIXNUM_P(value)) {
+        return "invalid quality value. Should be 0 to 11.";
     }
 
-    param = NUM2INT(value);
+    param = FIX2LONG(value);
     if (0 <= param && param <= 11) {
-        BrotliEncoderSetParameter(s, BROTLI_PARAM_QUALITY, param);
+        BrotliEncoderSetParameter(s, BROTLI_PARAM_QUALITY, (uint32_t)param);
     } else {
-        rb_raise(rb_eArgError, "invalid quality value. Should be 0 to 11.");
+        return "invalid quality value. Should be 0 to 11.";
     }
+
+    return NULL;
 }
 
-static void
+static const char *
 brotli_deflate_set_lgwin(BrotliEncoderState* s, VALUE value)
 {
-    int32_t param;
+    long param;
 
     if (NIL_P(value)) {
-        return;
+        return NULL;
     }
 
-    param = NUM2INT(value);
+    if (!FIXNUM_P(value)) {
+        return "invalid lgwin value. Should be 10 to 24.";
+    }
+
+    param = FIX2LONG(value);
     if (10 <= param && param <= 24) {
-        BrotliEncoderSetParameter(s, BROTLI_PARAM_LGWIN, param);
+        BrotliEncoderSetParameter(s, BROTLI_PARAM_LGWIN, (uint32_t)param);
     } else {
-        rb_raise(rb_eArgError, "invalid lgwin value. Should be 10 to 24.");
+        return "invalid lgwin value. Should be 10 to 24.";
     }
+
+    return NULL;
 }
 
-static void
+static const char *
 brotli_deflate_set_lgblock(BrotliEncoderState* s, VALUE value)
 {
-    int32_t param;
+    long param;
 
     if (NIL_P(value)) {
-        return;
+        return NULL;
+    }
+
+    if (!FIXNUM_P(value)) {
+        return "invalid lgblock value. Should be 0 or 16 to 24.";
     }
 
-    param = NUM2INT(value);
+    param = FIX2LONG(value);
     if (param == 0 || (16 <= param && param <= 24)) {
-        BrotliEncoderSetParameter(s, BROTLI_PARAM_LGBLOCK, param);
+        BrotliEncoderSetParameter(s, BROTLI_PARAM_LGBLOCK, (uint32_t)param);
     } else {
-        rb_raise(rb_eArgError, "invalid lgblock value. Should be 0 or 16 to 24.");
+        return "invalid lgblock value. Should be 0 or 16 to 24.";
     }
+
+    return NULL;
 }
 
-static void
+static const char *
 brotli_deflate_parse_options(BrotliEncoderState* s, VALUE opts)
 {
-    brotli_deflate_set_mode(s, brotli_hash_lookup(opts, id_mode));
-    brotli_deflate_set_quality(s, brotli_hash_lookup(opts, id_quality));
-    brotli_deflate_set_lgwin(s, brotli_hash_lookup(opts, id_lgwin));
-    brotli_deflate_set_lgblock(s, brotli_hash_lookup(opts, id_lgblock));
+    const char *err;
+
+    err = brotli_deflate_set_mode(s, brotli_hash_lookup(opts, id_mode));
+    if (err) {
+        return err;
+    }
+    err = brotli_deflate_set_quality(s, brotli_hash_lookup(opts, id_quality));
+    if (err) {
+        return err;
+    }
+    err = brotli_deflate_set_lgwin(s, brotli_hash_lookup(opts, id_lgwin));
+    if (err) {
+        return err;
+    }
+    return brotli_deflate_set_lgblock(s, brotli_hash_lookup(opts, id_lgblock));
 }
 
 typedef struct {
@@ -288,9 +323,7 @@ typedef struct {
     BrotliEncoderState* s;
     buffer_t* buffer;
     BROTLI_BOOL finished;
-#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
     BrotliEncoderPreparedDictionary* prepared_dict;
-#endif
 } brotli_deflate_args_t;
 
 static void
@@ -302,12 +335,10 @@ brotli_deflate_cleanup(brotli_deflate_args_t* args)
         BrotliEncoderDestroyInstance(args->s);
         args->s = NULL;
     }
-#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
     if (args->prepared_dict) {
         BrotliEncoderDestroyPreparedDictionary(args->prepared_dict);
         args->prepared_dict = NULL;
     }
-#endif
 }
 
 static void*
@@ -347,6 +378,13 @@ brotli_deflate_no_gvl(void *arg)
     return arg;
 }
 
+static VALUE
+brotli_deflate_take_result(VALUE arg)
+{
+    brotli_deflate_args_t *args = (brotli_deflate_args_t *)arg;
+    return rb_str_new(args->buffer->ptr, args->buffer->used);
+}
+
 static VALUE
 brotli_deflate(int argc, VALUE *argv, VALUE self)
 {
@@ -354,8 +392,9 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
     VALUE opts = Qnil;
     VALUE value = Qnil;
     VALUE dict = Qnil;
-    brotli_deflate_args_t args;
+    brotli_deflate_args_t args = {0};
     size_t max_compressed_size;
+    const char *err;
 
     (void)self;
 
@@ -365,21 +404,24 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
     }
     StringValue(str);
     dict = brotli_hash_lookup(opts, id_dictionary);
+    if (!NIL_P(dict)) {
+        StringValue(dict);
+    }
 
     args.str = (uint8_t*)RSTRING_PTR(str);
     args.len = (size_t)RSTRING_LEN(str);
     args.s = brotli_encoder_state_create();
-    brotli_deflate_parse_options(args.s, opts);
+    err = brotli_deflate_parse_options(args.s, opts);
+    if (err) {
+        brotli_deflate_cleanup(&args);
+        rb_raise(rb_eArgError, "%s", err);
+    }
     max_compressed_size = BrotliEncoderMaxCompressedSize(args.len);
     args.buffer = create_buffer(max_compressed_size);
     args.finished = BROTLI_FALSE;
 
-#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
     args.prepared_dict = NULL;
-#endif
     if (!NIL_P(dict)) {
-#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
-        StringValue(dict);
         args.prepared_dict = BrotliEncoderPrepareDictionary(
             BROTLI_SHARED_DICTIONARY_RAW,
             (size_t)RSTRING_LEN(dict),
@@ -396,21 +438,18 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
             brotli_deflate_cleanup(&args);
             rb_raise(rb_eBrotli, "Failed to attach dictionary for compression");
         }
-#else
-        brotli_deflate_cleanup(&args);
-        rb_raise(rb_eBrotli, "Dictionary support not available in this build");
-#endif
     }
 
-#ifdef HAVE_RUBY_THREAD_H
     rb_thread_call_without_gvl(brotli_deflate_no_gvl, &args, NULL, NULL);
-#else
-    brotli_deflate_no_gvl(&args);
-#endif
     RB_GC_GUARD(str);
     RB_GC_GUARD(dict);
     if (args.finished == BROTLI_TRUE) {
-        value = rb_str_new(args.buffer->ptr, args.buffer->used);
+        int state = 0;
+        value = rb_protect(brotli_deflate_take_result, (VALUE)&args, &state);
+        if (state) {
+            brotli_deflate_cleanup(&args);
+            rb_jump_tag(state);
+        }
     }
 
     brotli_deflate_cleanup(&args);
@@ -432,7 +471,7 @@ static VALUE brotli_version(VALUE klass) {
 
     (void)klass;
     snprintf(version, sizeof(version), "%u.%u.%u", ver >> 24, (ver >> 12) & 0xFFF, ver & 0xFFF);
-    return rb_str_new2(version);
+    return rb_str_new_cstr(version);
 }
 
 /*******************************************************************************
@@ -462,9 +501,7 @@ brotli_copy_string_data(VALUE string, size_t* len)
 
 typedef struct {
     BrotliEncoderState* state;
-#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
     BrotliEncoderPreparedDictionary* prepared_dict;
-#endif
     uint8_t* dict_data;
     size_t dict_len;
     BROTLI_BOOL finished;
@@ -523,21 +560,13 @@ static void* decompress_no_gvl(void *ptr) {
 static void
 brotli_encoder_step(brotli_encoder_args_t *args)
 {
-#ifdef HAVE_RUBY_THREAD_H
     rb_thread_call_without_gvl(compress_no_gvl, (void*)args, NULL, NULL);
-#else
-    compress_no_gvl((void*)args);
-#endif
 }
 
 static void
 brotli_decompressor_step(brotli_decoder_args_t *args)
 {
-#ifdef HAVE_RUBY_THREAD_H
     rb_thread_call_without_gvl(decompress_no_gvl, (void*)args, NULL, NULL);
-#else
-    decompress_no_gvl((void*)args);
-#endif
 }
 
 static void
@@ -547,12 +576,10 @@ brotli_encoder_destroy(brotli_encoder_t* encoder)
         BrotliEncoderDestroyInstance(encoder->state);
         encoder->state = NULL;
     }
-#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
     if (encoder->prepared_dict) {
         BrotliEncoderDestroyPreparedDictionary(encoder->prepared_dict);
         encoder->prepared_dict = NULL;
     }
-#endif
     brotli_free(NULL, encoder->dict_data);
     encoder->dict_data = NULL;
     encoder->dict_len = 0;
@@ -587,7 +614,6 @@ brotli_encoder_attach_dictionary(brotli_encoder_t* encoder, VALUE opts)
         return;
     }
 
-#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
     encoder->dict_data = brotli_copy_string_data(dict, &encoder->dict_len);
     encoder->prepared_dict = BrotliEncoderPrepareDictionary(
         BROTLI_SHARED_DICTIONARY_RAW,
@@ -613,9 +639,6 @@ brotli_encoder_attach_dictionary(brotli_encoder_t* encoder, VALUE opts)
         encoder->dict_len = 0;
         rb_raise(rb_eBrotli, "Failed to attach dictionary for compression");
     }
-#else
-    rb_raise(rb_eBrotli, "Dictionary support not available in this build");
-#endif
 }
 
 static VALUE
@@ -684,7 +707,7 @@ brotli_compressor_memsize(const void *p)
 static const rb_data_type_t brotli_compressor_data_type = {
     "brotli_compressor",
     { 0, brotli_compressor_free, brotli_compressor_memsize },
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static VALUE
@@ -693,9 +716,7 @@ rb_compressor_alloc(VALUE klass)
     brotli_compressor_t *br;
     VALUE obj = TypedData_Make_Struct(klass, brotli_compressor_t, &brotli_compressor_data_type, br);
     br->encoder.state = NULL;
-#if defined(HAVE_BROTLIENCODERPREPAREDICTIONARY) && defined(HAVE_BROTLIENCODERATTACHPREPAREDDICTIONARY)
     br->encoder.prepared_dict = NULL;
-#endif
     br->encoder.dict_data = NULL;
     br->encoder.dict_len = 0;
     br->encoder.finished = BROTLI_FALSE;
@@ -715,12 +736,16 @@ rb_compressor_initialize(int argc, VALUE* argv, VALUE self)
 {
     VALUE opts = Qnil;
     brotli_compressor_t *br;
+    const char *err;
 
     rb_scan_args(argc, argv, "01", &opts);
 
     TypedData_Get_Struct(self, brotli_compressor_t, &brotli_compressor_data_type, br);
     brotli_encoder_reset(&br->encoder);
-    brotli_deflate_parse_options(br->encoder.state, opts);
+    err = brotli_deflate_parse_options(br->encoder.state, opts);
+    if (err) {
+        rb_raise(rb_eArgError, "%s", err);
+    }
     brotli_encoder_attach_dictionary(&br->encoder, opts);
 
     return self;
@@ -896,7 +921,6 @@ brotli_decompressor_attach_dictionary(brotli_decompressor_t* br, VALUE opts)
         return;
     }
 
-#ifdef HAVE_BROTLIDECODERATTACHDICTIONARY
     br->dict_data = brotli_copy_string_data(dict, &br->dict_len);
     if (!BrotliDecoderAttachDictionary(br->state,
                                        BROTLI_SHARED_DICTIONARY_RAW,
@@ -907,9 +931,6 @@ brotli_decompressor_attach_dictionary(brotli_decompressor_t* br, VALUE opts)
         br->dict_len = 0;
         rb_raise(rb_eBrotli, "Failed to attach dictionary for decompression");
     }
-#else
-    rb_raise(rb_eBrotli, "Dictionary support not available in this build");
-#endif
 }
 
 static VALUE
@@ -1156,9 +1177,7 @@ rb_decompressor_unused_data(VALUE self)
 void
 Init_brotli(void)
 {
-#if HAVE_RB_EXT_RACTOR_SAFE
     rb_ext_ractor_safe(true);
-#endif
 
     VALUE rb_mBrotli;
     rb_mBrotli = rb_define_module("Brotli");

data/ext/brotli/brotli.h

@@ -3,16 +3,11 @@
 
 #include "ruby.h"
 
-// ruby/thread.h is ruby 2.x
-#ifdef HAVE_RUBY_THREAD_H
 #include "ruby/thread.h"
-#endif
 
 #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/extconf.rb

@@ -1,60 +1,131 @@
+# frozen_string_literal: true
+
 require "mkmf"
 require "fileutils"
 require "rbconfig"
+require "rubygems/version"
 
-dir_config("brotli")
-have_func("rb_gc_mark_movable")
+VENDORED_DIRS = %w[common dec enc include].freeze
+MINIMUM_BROTLI_VERSION = Gem::Version.new("1.2.0")
+BUILD_DIR = Dir.pwd
+VENDORED_SOURCE_DIR = File.expand_path("../../vendor/brotli/c", __dir__)
 
-# libbrotli-dev
-have_dev_pkg = [
-  have_header("brotli/decode.h"),
-  have_header("brotli/encode.h"),
-  pkg_config("libbrotlicommon"),
-  pkg_config("libbrotlidec"),
-  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"
+def generated_vendored_dirs
+  VENDORED_DIRS.map { |dirname| File.join(BUILD_DIR, dirname) }
 end
 
-$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
+def remove_generated_vendored_dirs
+  generated_vendored_dirs.each { |path| FileUtils.rm_rf(path) }
+end
 
-create_makefile("brotli/brotli")
+def copy_vendored_sources
+  sources = Dir[File.join(VENDORED_SOURCE_DIR, "{common,dec,enc,include}", "**", "*.{c,h}")].sort
 
-unless have_dev_pkg
-  ext_dir = __dir__
-  vendor_dir = File.expand_path("../../vendor/brotli/c", __dir__)
-  objext = RbConfig::CONFIG["OBJEXT"]
+  if sources.empty?
+    abort "ERROR: Vendored Brotli sources not found at #{VENDORED_SOURCE_DIR}.\n" \
+          "Install system libbrotli-dev >= #{MINIMUM_BROTLI_VERSION} or ensure vendor sources are present."
+  end
+
+  sources.each do |source|
+    relative_path = source.delete_prefix("#{VENDORED_SOURCE_DIR}/")
+    destination = File.join(BUILD_DIR, relative_path)
 
-  %w[enc dec common include].each do |dirname|
-    FileUtils.rm_rf dirname
-    FileUtils.mkdir_p dirname
-    FileUtils.cp_r(File.join(vendor_dir, dirname), ext_dir)
+    FileUtils.mkdir_p(File.dirname(destination))
+    FileUtils.cp(source, destination)
   end
+end
 
-  srcs = []
-  objs = []
-  Dir[File.expand_path(File.join("{enc,dec,common,include}", "**", "*.c"), ext_dir)].sort.each do |file|
-    file["#{ext_dir}#{File::SEPARATOR}"] = ""
-    srcs << file
-    objs << file.sub(/\.c\z/, ".#{objext}")
+def vendored_source_files
+  Dir[File.join(BUILD_DIR, "{common,dec,enc,include}", "**", "*.c")].sort.map do |path|
+    path.delete_prefix("#{BUILD_DIR}/")
   end
+end
+
+def add_vendored_sources_to_makefile
+  objext = RbConfig::CONFIG["OBJEXT"]
+  source_files = vendored_source_files
+  object_files = source_files.map { |path| path.sub(/\.c\z/, ".#{objext}") }
 
   makefile = File.read("Makefile")
   makefile = makefile
-             .sub(/^ORIG_SRCS = .*$/, "ORIG_SRCS = brotli.c buffer.c #{srcs.join(" ")}")
-             .sub(/^OBJS = .*$/, "OBJS = brotli.#{objext} buffer.#{objext} #{objs.join(" ")}")
+             .sub(/^ORIG_SRCS = .*$/, "ORIG_SRCS = brotli.c buffer.c #{source_files.join(" ")}")
+             .sub(/^OBJS = .*$/, "OBJS = brotli.#{objext} buffer.#{objext} #{object_files.join(" ")}")
   File.write("Makefile", makefile)
 end
+
+def mkmf_flags
+  {
+    cflags: $CFLAGS.dup,
+    cxxflags: $CXXFLAGS.dup,
+    cppflags: $CPPFLAGS.dup,
+    defs: $defs.dup,
+    incflags: $INCFLAGS.dup,
+    ldflags: $LDFLAGS.dup,
+    libs: $libs.dup,
+    local_libs: $LOCAL_LIBS.dup
+  }
+end
+
+def restore_mkmf_flags(flags)
+  $CFLAGS = flags[:cflags]
+  $CXXFLAGS = flags[:cxxflags]
+  $CPPFLAGS = flags[:cppflags]
+  $defs = flags[:defs]
+  $INCFLAGS = flags[:incflags]
+  $LDFLAGS = flags[:ldflags]
+  $libs = flags[:libs]
+  $LOCAL_LIBS = flags[:local_libs]
+end
+
+def system_brotli_version
+  version = pkg_config("libbrotlicommon", "modversion")
+  Gem::Version.new(version) if version
+rescue ArgumentError
+  nil
+end
+
+def system_brotli_available?
+  flags = mkmf_flags
+  version = system_brotli_version
+
+  unless version && version >= MINIMUM_BROTLI_VERSION
+    Logging.message(
+      "System Brotli version %s is too old; need >= %s\n",
+      version || "unknown",
+      MINIMUM_BROTLI_VERSION
+    )
+    restore_mkmf_flags(flags)
+    return false
+  end
+
+  available = pkg_config("libbrotlicommon") &&
+              pkg_config("libbrotlidec") &&
+              pkg_config("libbrotlienc") &&
+              have_header("brotli/decode.h") &&
+              have_header("brotli/encode.h") &&
+              have_header("brotli/shared_dictionary.h") &&
+              have_func("BrotliEncoderPrepareDictionary", "brotli/encode.h") &&
+              have_func("BrotliEncoderAttachPreparedDictionary", "brotli/encode.h") &&
+              have_func("BrotliDecoderAttachDictionary", "brotli/decode.h")
+
+  restore_mkmf_flags(flags) unless available
+  available
+end
+
+dir_config("brotli")
+have_func("rb_gc_mark_movable")
+
+$CPPFLAGS << " -DOS_MACOSX" if RbConfig::CONFIG["host_os"] =~ /darwin|mac os/
+
+remove_generated_vendored_dirs
+
+use_vendored_brotli = enable_config("vendor", false) || !system_brotli_available?
+
+if use_vendored_brotli
+  Logging.message "Using vendored Brotli sources\n"
+  copy_vendored_sources
+  $INCFLAGS << " -Ienc -Idec -Icommon -Iinclude"
+end
+
+create_makefile("brotli/brotli")
+add_vendored_sources_to_makefile if use_vendored_brotli

data/lib/brotli/version.rb

@@ -1,3 +1,3 @@
 module Brotli
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 end