ruby-bzs 1.0.0

data/ext/bzs_ext/stream/decompressor.h

@@ -0,0 +1,31 @@
+// Ruby bindings for bzip2 library.
+// Copyright (c) 2022 AUTHORS, MIT License.
+
+#if !defined(BZS_EXT_STREAM_DECOMPRESSOR_H)
+#define BZS_EXT_STREAM_DECOMPRESSOR_H
+
+#include <bzlib.h>
+#include <stdbool.h>
+
+#include "bzs_ext/common.h"
+#include "ruby.h"
+
+typedef struct
+{
+  bz_stream*      stream_ptr;
+  bzs_ext_byte_t* destination_buffer;
+  size_t          destination_buffer_length;
+  bzs_ext_byte_t* remaining_destination_buffer;
+  size_t          remaining_destination_buffer_length;
+  bool            gvl;
+} bzs_ext_decompressor_t;
+
+VALUE bzs_ext_allocate_decompressor(VALUE klass);
+VALUE bzs_ext_initialize_decompressor(VALUE self, VALUE options);
+VALUE bzs_ext_decompress(VALUE self, VALUE source);
+VALUE bzs_ext_decompressor_read_result(VALUE self);
+VALUE bzs_ext_decompressor_close(VALUE self);
+
+void bzs_ext_decompressor_exports(VALUE root_module);
+
+#endif // BZS_EXT_STREAM_DECOMPRESSOR_H

data/ext/bzs_ext/string.c

@@ -0,0 +1,340 @@
+// Ruby bindings for bzip2 library.
+// Copyright (c) 2022 AUTHORS, MIT License.
+
+#include "bzs_ext/string.h"
+
+#include <bzlib.h>
+
+#include "bzs_ext/buffer.h"
+#include "bzs_ext/common.h"
+#include "bzs_ext/error.h"
+#include "bzs_ext/gvl.h"
+#include "bzs_ext/macro.h"
+#include "bzs_ext/option.h"
+#include "bzs_ext/utils.h"
+
+// -- buffer --
+
+static inline bzs_ext_result_t increase_destination_buffer(
+  VALUE   destination_value,
+  size_t  destination_length,
+  size_t* remaining_destination_buffer_length_ptr,
+  size_t  destination_buffer_length)
+{
+  if (*remaining_destination_buffer_length_ptr == destination_buffer_length) {
+    // We want to write more data at once, than buffer has.
+    return BZS_EXT_ERROR_NOT_ENOUGH_DESTINATION_BUFFER;
+  }
+
+  int exception;
+
+  BZS_EXT_RESIZE_STRING_BUFFER(destination_value, destination_length + destination_buffer_length, exception);
+  if (exception != 0) {
+    return BZS_EXT_ERROR_ALLOCATE_FAILED;
+  }
+
+  *remaining_destination_buffer_length_ptr = destination_buffer_length;
+
+  return 0;
+}
+
+// -- compress --
+
+typedef struct
+{
+  bz_stream*       stream_ptr;
+  int              stream_action;
+  bzs_ext_byte_t** remaining_source_ptr;
+  size_t*          remaining_source_length_ptr;
+  bzs_ext_byte_t*  remaining_destination_buffer;
+  size_t*          remaining_destination_buffer_length_ptr;
+  bzs_result_t     result;
+} compress_args_t;
+
+static inline void* compress_wrapper(void* data)
+{
+  compress_args_t* args = data;
+
+  args->stream_ptr->next_in   = (char*) *args->remaining_source_ptr;
+  args->stream_ptr->avail_in  = bzs_consume_size(*args->remaining_source_length_ptr);
+  args->stream_ptr->next_out  = (char*) args->remaining_destination_buffer;
+  args->stream_ptr->avail_out = bzs_consume_size(*args->remaining_destination_buffer_length_ptr);
+
+  args->result = BZ2_bzCompress(args->stream_ptr, args->stream_action);
+
+  *args->remaining_source_ptr                    = (bzs_ext_byte_t*) args->stream_ptr->next_in;
+  *args->remaining_source_length_ptr             = args->stream_ptr->avail_in;
+  *args->remaining_destination_buffer_length_ptr = args->stream_ptr->avail_out;
+
+  return NULL;
+}
+
+#define BUFFERED_COMPRESS(gvl, args, RUN_OK)                                                                     \
+  while (true) {                                                                                                 \
+    bzs_ext_byte_t* remaining_destination_buffer =                                                               \
+      (bzs_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;                                     \
+    size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;                       \
+                                                                                                                 \
+    args.remaining_destination_buffer            = remaining_destination_buffer;                                 \
+    args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;                         \
+                                                                                                                 \
+    BZS_EXT_GVL_WRAP(gvl, compress_wrapper, &args);                                                              \
+    if (args.result != RUN_OK && args.result != BZ_PARAM_ERROR && args.result != BZ_STREAM_END) {                \
+      return bzs_ext_get_error(args.result);                                                                     \
+    }                                                                                                            \
+                                                                                                                 \
+    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;        \
+                                                                                                                 \
+    if (args.result == BZ_STREAM_END) {                                                                          \
+      break;                                                                                                     \
+    }                                                                                                            \
+                                                                                                                 \
+    if (remaining_source_length != 0 || remaining_destination_buffer_length == 0) {                              \
+      ext_result = increase_destination_buffer(                                                                  \
+        destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length); \
+                                                                                                                 \
+      if (ext_result != 0) {                                                                                     \
+        return ext_result;                                                                                       \
+      }                                                                                                          \
+                                                                                                                 \
+      continue;                                                                                                  \
+    }                                                                                                            \
+                                                                                                                 \
+    break;                                                                                                       \
+  }
+
+static inline bzs_ext_result_t compress(
+  bz_stream*  stream_ptr,
+  const char* source,
+  size_t      source_length,
+  VALUE       destination_value,
+  size_t      destination_buffer_length,
+  bool        gvl)
+{
+  bzs_ext_result_t ext_result;
+  bzs_ext_byte_t*  remaining_source                    = (bzs_ext_byte_t*) source;
+  size_t           remaining_source_length             = source_length;
+  size_t           destination_length                  = 0;
+  size_t           remaining_destination_buffer_length = destination_buffer_length;
+
+  compress_args_t run_args = {
+    .stream_ptr                  = stream_ptr,
+    .stream_action               = BZ_RUN,
+    .remaining_source_ptr        = &remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
+  BUFFERED_COMPRESS(gvl, run_args, BZ_RUN_OK);
+
+  compress_args_t finish_args = {
+    .stream_ptr                  = stream_ptr,
+    .stream_action               = BZ_FINISH,
+    .remaining_source_ptr        = &remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
+  BUFFERED_COMPRESS(gvl, finish_args, BZ_FINISH_OK);
+
+  int exception;
+
+  BZS_EXT_RESIZE_STRING_BUFFER(destination_value, destination_length, exception);
+  if (exception != 0) {
+    return BZS_EXT_ERROR_ALLOCATE_FAILED;
+  }
+
+  return 0;
+}
+
+VALUE bzs_ext_compress_string(VALUE BZS_EXT_UNUSED(self), VALUE source_value, VALUE options)
+{
+  Check_Type(source_value, T_STRING);
+  Check_Type(options, T_HASH);
+  BZS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  BZS_EXT_GET_BOOL_OPTION(options, gvl);
+  BZS_EXT_RESOLVE_COMPRESSOR_OPTIONS(options);
+
+  bz_stream stream = {
+    .bzalloc = NULL,
+    .bzfree  = NULL,
+    .opaque  = NULL,
+  };
+
+  bzs_result_t result = BZ2_bzCompressInit(&stream, block_size, verbosity, work_factor);
+  if (result != BZ_OK) {
+    bzs_ext_raise_error(bzs_ext_get_error(result));
+  }
+
+  if (destination_buffer_length == 0) {
+    destination_buffer_length = BZS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR;
+  }
+
+  int exception;
+
+  BZS_EXT_CREATE_STRING_BUFFER(destination_value, destination_buffer_length, exception);
+  if (exception != 0) {
+    BZ2_bzCompressEnd(&stream);
+    bzs_ext_raise_error(BZS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  const char* source        = RSTRING_PTR(source_value);
+  size_t      source_length = RSTRING_LEN(source_value);
+
+  bzs_ext_result_t ext_result =
+    compress(&stream, source, source_length, destination_value, destination_buffer_length, gvl);
+
+  result = BZ2_bzCompressEnd(&stream);
+  if (result != BZ_OK) {
+    ext_result = bzs_ext_get_error(result);
+  }
+
+  if (ext_result != 0) {
+    bzs_ext_raise_error(ext_result);
+  }
+
+  return destination_value;
+}
+
+// -- decompress --
+
+typedef struct
+{
+  bz_stream*       stream_ptr;
+  bzs_ext_byte_t** remaining_source_ptr;
+  size_t*          remaining_source_length_ptr;
+  bzs_ext_byte_t*  remaining_destination_buffer;
+  size_t*          remaining_destination_buffer_length_ptr;
+  bzs_result_t     result;
+} decompress_args_t;
+
+static inline void* decompress_wrapper(void* data)
+{
+  decompress_args_t* args = data;
+
+  args->stream_ptr->next_in   = (char*) *args->remaining_source_ptr;
+  args->stream_ptr->avail_in  = bzs_consume_size(*args->remaining_source_length_ptr);
+  args->stream_ptr->next_out  = (char*) args->remaining_destination_buffer;
+  args->stream_ptr->avail_out = bzs_consume_size(*args->remaining_destination_buffer_length_ptr);
+
+  args->result = BZ2_bzDecompress(args->stream_ptr);
+
+  *args->remaining_source_ptr                    = (bzs_ext_byte_t*) args->stream_ptr->next_in;
+  *args->remaining_source_length_ptr             = args->stream_ptr->avail_in;
+  *args->remaining_destination_buffer_length_ptr = args->stream_ptr->avail_out;
+
+  return NULL;
+}
+
+static inline bzs_ext_result_t decompress(
+  bz_stream*  stream_ptr,
+  const char* source,
+  size_t      source_length,
+  VALUE       destination_value,
+  size_t      destination_buffer_length,
+  bool        gvl)
+{
+  bzs_ext_result_t ext_result;
+  bzs_ext_byte_t*  remaining_source                    = (bzs_ext_byte_t*) source;
+  size_t           remaining_source_length             = source_length;
+  size_t           destination_length                  = 0;
+  size_t           remaining_destination_buffer_length = destination_buffer_length;
+
+  decompress_args_t args = {
+    .stream_ptr                  = stream_ptr,
+    .remaining_source_ptr        = &remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
+
+  while (true) {
+    bzs_ext_byte_t* remaining_destination_buffer =
+      (bzs_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;
+    size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
+
+    args.remaining_destination_buffer            = remaining_destination_buffer;
+    args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;
+
+    BZS_EXT_GVL_WRAP(gvl, decompress_wrapper, &args);
+    if (args.result != BZ_OK && args.result != BZ_PARAM_ERROR && args.result != BZ_STREAM_END) {
+      return bzs_ext_get_error(args.result);
+    }
+
+    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;
+
+    if (args.result == BZ_STREAM_END) {
+      break;
+    }
+
+    if (remaining_source_length != 0 || remaining_destination_buffer_length == 0) {
+      ext_result = increase_destination_buffer(
+        destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length);
+
+      if (ext_result != 0) {
+        return ext_result;
+      }
+
+      continue;
+    }
+
+    break;
+  }
+
+  int exception;
+
+  BZS_EXT_RESIZE_STRING_BUFFER(destination_value, destination_length, exception);
+  if (exception != 0) {
+    return BZS_EXT_ERROR_ALLOCATE_FAILED;
+  }
+
+  return 0;
+}
+
+VALUE bzs_ext_decompress_string(VALUE BZS_EXT_UNUSED(self), VALUE source_value, VALUE options)
+{
+  Check_Type(source_value, T_STRING);
+  Check_Type(options, T_HASH);
+  BZS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  BZS_EXT_GET_BOOL_OPTION(options, gvl);
+  BZS_EXT_RESOLVE_DECOMPRESSOR_OPTIONS(options);
+
+  bz_stream stream = {
+    .bzalloc = NULL,
+    .bzfree  = NULL,
+    .opaque  = NULL,
+  };
+
+  bzs_result_t result = BZ2_bzDecompressInit(&stream, verbosity, small);
+  if (result != BZ_OK) {
+    bzs_ext_raise_error(bzs_ext_get_error(result));
+  }
+
+  if (destination_buffer_length == 0) {
+    destination_buffer_length = BZS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR;
+  }
+
+  int exception;
+
+  BZS_EXT_CREATE_STRING_BUFFER(destination_value, destination_buffer_length, exception);
+  if (exception != 0) {
+    BZ2_bzDecompressEnd(&stream);
+    bzs_ext_raise_error(BZS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  const char* source        = RSTRING_PTR(source_value);
+  size_t      source_length = RSTRING_LEN(source_value);
+
+  bzs_ext_result_t ext_result =
+    decompress(&stream, source, source_length, destination_value, destination_buffer_length, gvl);
+
+  result = BZ2_bzDecompressEnd(&stream);
+  if (result != BZ_OK) {
+    ext_result = bzs_ext_get_error(result);
+  }
+
+  if (ext_result != 0) {
+    bzs_ext_raise_error(ext_result);
+  }
+
+  return destination_value;
+}
+
+// -- exports --
+
+void bzs_ext_string_exports(VALUE root_module)
+{
+  rb_define_module_function(root_module, "_native_compress_string", RUBY_METHOD_FUNC(bzs_ext_compress_string), 2);
+  rb_define_module_function(root_module, "_native_decompress_string", RUBY_METHOD_FUNC(bzs_ext_decompress_string), 2);
+}

data/ext/bzs_ext/string.h

@@ -0,0 +1,14 @@
+// Ruby bindings for bzip2 library.
+// Copyright (c) 2022 AUTHORS, MIT License.
+
+#if !defined(BZS_EXT_STRING_H)
+#define BZS_EXT_STRING_H
+
+#include "ruby.h"
+
+VALUE bzs_ext_compress_string(VALUE self, VALUE source, VALUE options);
+VALUE bzs_ext_decompress_string(VALUE self, VALUE source, VALUE options);
+
+void bzs_ext_string_exports(VALUE root_module);
+
+#endif // BZS_EXT_STRING_H

data/ext/bzs_ext/utils.c

@@ -0,0 +1,15 @@
+// Ruby bindings for bzip2 library.
+// Copyright (c) 2022 AUTHORS, MIT License.
+
+#include "utils.h"
+
+#include <limits.h>
+
+unsigned int bzs_consume_size(size_t size)
+{
+  if (size > UINT_MAX) {
+    return UINT_MAX;
+  } else {
+    return (unsigned int) size;
+  }
+}

data/ext/bzs_ext/utils.h

@@ -0,0 +1,13 @@
+// Ruby bindings for bzip2 library.
+// Copyright (c) 2022 AUTHORS, MIT License.
+
+#if !defined(BZS_EXT_UTILS_H)
+#define BZS_EXT_UTILS_H
+
+#include <stdlib.h>
+
+// Bzip2 size type may be limited to unsigned int.
+// We need to prevent overflow by consuming max available unsigned int value.
+unsigned int bzs_consume_size(size_t size);
+
+#endif // BZS_EXT_UTILS_H

data/ext/extconf.rb

@@ -0,0 +1,94 @@
+# Ruby bindings for bzip2 library.
+# Copyright (c) 2022 AUTHORS, MIT License.
+
+require "mkmf"
+
+have_func "rb_thread_call_without_gvl", "ruby/thread.h"
+
+def require_header(name, constants: [], types: [])
+  abort "Can't find #{name} header" unless find_header name
+
+  constants.each do |constant|
+    abort "Can't find #{constant} constant in #{name} header" unless have_const constant, name
+  end
+
+  types.each do |type|
+    abort "Can't find #{type} type in #{name} header" unless find_type type, nil, name
+  end
+end
+
+require_header(
+  "bzlib.h",
+  :constants => %w[
+    BZ_RUN
+    BZ_RUN_OK
+    BZ_FINISH
+    BZ_FINISH_OK
+    BZ_FLUSH
+    BZ_FLUSH_OK
+    BZ_OK
+    BZ_PARAM_ERROR
+    BZ_STREAM_END
+    BZ_MEM_ERROR
+    BZ_DATA_ERROR
+    BZ_DATA_ERROR_MAGIC
+    BZ_UNEXPECTED_EOF
+  ],
+  :types     => %w[
+    bz_stream
+  ]
+)
+
+def require_library(name, functions)
+  functions.each do |function|
+    abort "Can't find #{function} function in #{name} library" unless find_library name, function
+  end
+end
+
+require_library(
+  "bz2",
+  %w[
+    BZ2_bzCompressInit
+    BZ2_bzCompress
+    BZ2_bzCompressEnd
+    BZ2_bzDecompressInit
+    BZ2_bzDecompress
+    BZ2_bzDecompressEnd
+    BZ2_bzlibVersion
+  ]
+)
+
+extension_name = "bzs_ext".freeze
+dir_config extension_name
+
+# rubocop:disable Style/GlobalVars
+$srcs = %w[
+  stream/compressor
+  stream/decompressor
+  buffer
+  error
+  io
+  main
+  option
+  string
+  utils
+]
+.map { |name| "src/#{extension_name}/#{name}.c" }
+.freeze
+
+# Removing library duplicates.
+$libs = $libs.split(%r{\s})
+  .reject(&:empty?)
+  .sort
+  .uniq
+  .join " "
+
+if ENV["CI"]
+  $CFLAGS << " --coverage"
+  $LDFLAGS << " --coverage"
+end
+
+$VPATH << "$(srcdir)/#{extension_name}:$(srcdir)/#{extension_name}/stream"
+# rubocop:enable Style/GlobalVars
+
+create_makefile extension_name

data/lib/bzs/error.rb

@@ -0,0 +1,26 @@
+# Ruby bindings for bzip2 library.
+# Copyright (c) 2022 AUTHORS, MIT License.
+
+require "adsp"
+
+module BZS
+  class BaseError < ::StandardError; end
+
+  class AllocateError < BaseError; end
+
+  class NotEnoughSourceBufferError       < BaseError; end
+  class NotEnoughDestinationBufferError  < BaseError; end
+  class DecompressorCorruptedSourceError < BaseError; end
+
+  class AccessIOError < BaseError; end
+  class ReadIOError   < BaseError; end
+  class WriteIOError  < BaseError; end
+
+  ValidateError = ADSP::ValidateError
+
+  NotEnoughDestinationError = ADSP::NotEnoughDestinationError
+  UsedAfterCloseError       = ADSP::UsedAfterCloseError
+
+  NotImplementedError = ADSP::NotImplementedError
+  UnexpectedError     = ADSP::UnexpectedError
+end

data/lib/bzs/file.rb

@@ -0,0 +1,25 @@
+# Ruby bindings for bzip2 library.
+# Copyright (c) 2022 AUTHORS, MIT License.
+
+require "adsp/file"
+require "bzs_ext"
+
+require_relative "option"
+
+module BZS
+  # BZS::File class.
+  class File < ADSP::File
+    # Current option class.
+    Option = BZS::Option
+
+    # Bypass native compress.
+    def self.native_compress_io(*args)
+      BZS._native_compress_io(*args)
+    end
+
+    # Bypass native decompress.
+    def self.native_decompress_io(*args)
+      BZS._native_decompress_io(*args)
+    end
+  end
+end

data/lib/bzs/option.rb

@@ -0,0 +1,101 @@
+# Ruby bindings for bzip2 library.
+# Copyright (c) 2022 AUTHORS, MIT License.
+
+require "bzs_ext"
+
+require_relative "error"
+require_relative "validation"
+
+module BZS
+  # BZS::Option module.
+  module Option
+    # Current default buffer length.
+    DEFAULT_BUFFER_LENGTH = 0
+
+    # Current compressor defaults.
+    COMPRESSOR_DEFAULTS = {
+      # Enables global VM lock where possible.
+      :gvl         => false,
+      # Block size to be used for compression.
+      :block_size  => nil,
+      # Controls threshold for switching from standard to fallback algorithm.
+      :work_factor => nil,
+      # Disables bzip2 library logging.
+      :quiet       => nil
+    }
+    .freeze
+
+    # Current decompressor defaults.
+    DECOMPRESSOR_DEFAULTS = {
+      # Enables global VM lock where possible.
+      :gvl   => false,
+      # Enables alternative decompression algorithm with less memory.
+      :small => nil,
+      # Disables bzip2 library logging.
+      :quiet => nil
+    }
+    .freeze
+
+    # Processes compressor +options+ and +buffer_length_names+.
+    # Option: +:source_buffer_length+ source buffer length.
+    # Option: +:destination_buffer_length+ destination buffer length.
+    # Option: +:gvl+ enables global VM lock where possible.
+    # Option: +:block_size+ block size to be used for compression.
+    # Option: +:work_factor+ controls threshold for switching from standard to fallback algorithm.
+    # Option: +:quiet+ disables bzip2 library logging.
+    # Returns processed compressor options.
+    def self.get_compressor_options(options, buffer_length_names)
+      Validation.validate_hash options
+
+      buffer_length_defaults = buffer_length_names.each_with_object({}) do |name, defaults|
+        defaults[name] = DEFAULT_BUFFER_LENGTH
+      end
+
+      options = COMPRESSOR_DEFAULTS.merge(buffer_length_defaults).merge options
+
+      buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
+
+      Validation.validate_bool options[:gvl]
+
+      block_size = options[:block_size]
+      Validation.validate_not_negative_integer block_size unless block_size.nil?
+
+      work_factor = options[:work_factor]
+      Validation.validate_not_negative_integer work_factor unless work_factor.nil?
+
+      quiet = options[:quiet]
+      Validation.validate_bool quiet unless quiet.nil?
+
+      options
+    end
+
+    # Processes decompressor +options+ and +buffer_length_names+.
+    # Option: +:source_buffer_length+ source buffer length.
+    # Option: +:destination_buffer_length+ destination buffer length.
+    # Option: +:gvl+ enables global VM lock where possible.
+    # Option: +:small+ enables alternative decompression algorithm with less memory.
+    # Option: +:quiet+ disables bzip2 library logging.
+    # Returns processed decompressor options.
+    def self.get_decompressor_options(options, buffer_length_names)
+      Validation.validate_hash options
+
+      buffer_length_defaults = buffer_length_names.each_with_object({}) do |name, defaults|
+        defaults[name] = DEFAULT_BUFFER_LENGTH
+      end
+
+      options = DECOMPRESSOR_DEFAULTS.merge(buffer_length_defaults).merge options
+
+      buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
+
+      Validation.validate_bool options[:gvl]
+
+      small = options[:small]
+      Validation.validate_bool small unless small.nil?
+
+      quiet = options[:quiet]
+      Validation.validate_bool quiet unless quiet.nil?
+
+      options
+    end
+  end
+end

data/lib/bzs/stream/raw/compressor.rb

@@ -0,0 +1,22 @@
+# Ruby bindings for bzip2 library.
+# Copyright (c) 2022 AUTHORS, MIT License.
+
+require "adsp/stream/raw/compressor"
+require "bzs_ext"
+
+require_relative "../../option"
+
+module BZS
+  module Stream
+    module Raw
+      # BZS::Stream::Raw::Compressor class.
+      class Compressor < ADSP::Stream::Raw::Compressor
+        # Current native compressor class.
+        NativeCompressor = Stream::NativeCompressor
+
+        # Current option class.
+        Option = BZS::Option
+      end
+    end
+  end
+end