ruby-brs 1.0.1

data/ext/brs_ext/string.c

@@ -0,0 +1,274 @@
+// Ruby bindings for brotli library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include "brs_ext/string.h"
+
+#include <brotli/decode.h>
+#include <brotli/encode.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "brs_ext/buffer.h"
+#include "brs_ext/common.h"
+#include "brs_ext/error.h"
+#include "brs_ext/macro.h"
+#include "brs_ext/option.h"
+#include "ruby.h"
+
+// -- buffer --
+
+static inline VALUE create_buffer(VALUE length)
+{
+  return rb_str_new(NULL, NUM2UINT(length));
+}
+
+#define CREATE_BUFFER(buffer, length, exception) \
+  VALUE buffer = rb_protect(create_buffer, UINT2NUM(length), &exception);
+
+static inline VALUE resize_buffer(VALUE args)
+{
+  VALUE buffer = rb_ary_entry(args, 0);
+  VALUE length = rb_ary_entry(args, 1);
+  return rb_str_resize(buffer, NUM2UINT(length));
+}
+
+#define RESIZE_BUFFER(buffer, length, exception)                                        \
+  VALUE resize_buffer_args = rb_ary_new_from_args(2, buffer, UINT2NUM(length));         \
+  buffer                   = rb_protect(resize_buffer, resize_buffer_args, &exception); \
+  RB_GC_GUARD(resize_buffer_args);
+
+static inline brs_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 BRS_EXT_ERROR_NOT_ENOUGH_DESTINATION_BUFFER;
+  }
+
+  int exception;
+
+  RESIZE_BUFFER(destination_value, destination_length + destination_buffer_length, exception);
+  if (exception != 0) {
+    return BRS_EXT_ERROR_ALLOCATE_FAILED;
+  }
+
+  *remaining_destination_buffer_length_ptr = destination_buffer_length;
+
+  return 0;
+}
+
+// -- utils --
+
+#define GET_SOURCE_DATA(source_value)                                 \
+  Check_Type(source_value, T_STRING);                                 \
+                                                                      \
+  const char*    source                  = RSTRING_PTR(source_value); \
+  size_t         source_length           = RSTRING_LEN(source_value); \
+  const uint8_t* remaining_source        = (const uint8_t*)source;    \
+  size_t         remaining_source_length = source_length;
+
+// -- compress --
+
+static inline brs_ext_result_t compress(
+  BrotliEncoderState* state_ptr,
+  const uint8_t* remaining_source, size_t remaining_source_length,
+  VALUE destination_value, size_t destination_buffer_length)
+{
+  brs_ext_result_t ext_result;
+
+  size_t destination_length                  = 0;
+  size_t remaining_destination_buffer_length = destination_buffer_length;
+
+  while (true) {
+    uint8_t* remaining_destination_buffer             = (uint8_t*)RSTRING_PTR(destination_value) + destination_length;
+    size_t   prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
+
+    BROTLI_BOOL result = BrotliEncoderCompressStream(
+      state_ptr,
+      BROTLI_OPERATION_FINISH,
+      &remaining_source_length, &remaining_source,
+      &remaining_destination_buffer_length, &remaining_destination_buffer,
+      NULL);
+
+    if (!result) {
+      return BRS_EXT_ERROR_UNEXPECTED;
+    }
+
+    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;
+
+    if (BrotliEncoderHasMoreOutput(state_ptr) || !BrotliEncoderIsFinished(state_ptr)) {
+      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;
+
+  RESIZE_BUFFER(destination_value, destination_length, exception);
+  if (exception != 0) {
+    return BRS_EXT_ERROR_ALLOCATE_FAILED;
+  }
+
+  return 0;
+}
+
+VALUE brs_ext_compress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value, VALUE options)
+{
+  GET_SOURCE_DATA(source_value);
+  Check_Type(options, T_HASH);
+  BRS_EXT_GET_COMPRESSOR_OPTIONS(options);
+  BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
+
+  BrotliEncoderState* state_ptr = BrotliEncoderCreateInstance(NULL, NULL, NULL);
+  if (state_ptr == NULL) {
+    brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  brs_ext_result_t ext_result = brs_ext_set_compressor_options(state_ptr, &compressor_options);
+  if (ext_result != 0) {
+    BrotliEncoderDestroyInstance(state_ptr);
+    brs_ext_raise_error(ext_result);
+  }
+
+  if (destination_buffer_length == 0) {
+    destination_buffer_length = BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR;
+  }
+
+  int exception;
+
+  CREATE_BUFFER(destination_value, destination_buffer_length, exception);
+  if (exception != 0) {
+    BrotliEncoderDestroyInstance(state_ptr);
+    brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  ext_result = compress(
+    state_ptr,
+    remaining_source, remaining_source_length,
+    destination_value, destination_buffer_length);
+
+  BrotliEncoderDestroyInstance(state_ptr);
+
+  if (ext_result != 0) {
+    brs_ext_raise_error(ext_result);
+  }
+
+  return destination_value;
+}
+
+// -- decompress --
+
+static inline brs_ext_result_t decompress(
+  BrotliDecoderState* state_ptr,
+  const uint8_t* remaining_source, size_t remaining_source_length,
+  VALUE destination_value, size_t destination_buffer_length)
+{
+  brs_ext_result_t ext_result;
+
+  size_t destination_length                  = 0;
+  size_t remaining_destination_buffer_length = destination_buffer_length;
+
+  while (true) {
+    uint8_t* remaining_destination_buffer             = (uint8_t*)RSTRING_PTR(destination_value) + destination_length;
+    size_t   prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
+
+    BrotliDecoderResult result = BrotliDecoderDecompressStream(
+      state_ptr,
+      &remaining_source_length, &remaining_source,
+      &remaining_destination_buffer_length, &remaining_destination_buffer,
+      NULL);
+
+    if (
+      result != BROTLI_DECODER_RESULT_SUCCESS &&
+      result != BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT &&
+      result != BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
+      BrotliDecoderErrorCode error_code = BrotliDecoderGetErrorCode(state_ptr);
+      return brs_ext_get_decompressor_error(error_code);
+    }
+
+    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;
+
+    if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
+      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;
+
+  RESIZE_BUFFER(destination_value, destination_length, exception);
+  if (exception != 0) {
+    brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  return 0;
+}
+
+VALUE brs_ext_decompress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value, VALUE options)
+{
+  GET_SOURCE_DATA(source_value);
+  Check_Type(options, T_HASH);
+  BRS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
+  BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
+
+  BrotliDecoderState* state_ptr = BrotliDecoderCreateInstance(NULL, NULL, NULL);
+  if (state_ptr == NULL) {
+    brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  brs_ext_result_t ext_result = brs_ext_set_decompressor_options(state_ptr, &decompressor_options);
+  if (ext_result != 0) {
+    BrotliDecoderDestroyInstance(state_ptr);
+    brs_ext_raise_error(ext_result);
+  }
+
+  if (destination_buffer_length == 0) {
+    destination_buffer_length = BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR;
+  }
+
+  int exception;
+
+  CREATE_BUFFER(destination_value, destination_buffer_length, exception);
+  if (exception != 0) {
+    BrotliDecoderDestroyInstance(state_ptr);
+    brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  ext_result = decompress(
+    state_ptr,
+    remaining_source, remaining_source_length,
+    destination_value, destination_buffer_length);
+
+  BrotliDecoderDestroyInstance(state_ptr);
+
+  if (ext_result != 0) {
+    brs_ext_raise_error(ext_result);
+  }
+
+  return destination_value;
+}
+
+void brs_ext_string_exports(VALUE root_module)
+{
+  rb_define_module_function(root_module, "_native_compress_string", RUBY_METHOD_FUNC(brs_ext_compress_string), 2);
+  rb_define_module_function(root_module, "_native_decompress_string", RUBY_METHOD_FUNC(brs_ext_decompress_string), 2);
+}

data/ext/brs_ext/string.h

@@ -0,0 +1,14 @@
+// Ruby bindings for brotli library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(BRS_EXT_STRING_H)
+#define BRS_EXT_STRING_H
+
+#include "ruby.h"
+
+VALUE brs_ext_compress_string(VALUE self, VALUE source, VALUE options);
+VALUE brs_ext_decompress_string(VALUE self, VALUE source, VALUE options);
+
+void brs_ext_string_exports(VALUE root_module);
+
+#endif // BRS_EXT_STRING_H

data/ext/extconf.rb

@@ -0,0 +1,66 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "mkmf"
+
+def require_header(name)
+  abort "Can't find #{name} header" unless find_header name
+end
+
+require_header "brotli/encode.h"
+require_header "brotli/decode.h"
+
+def require_library(name, functions)
+  functions.each do |function|
+    abort "Can't find #{name} library and #{function} function" unless find_library name, function
+  end
+end
+
+encoder_functions = %w[
+  BrotliEncoderCreateInstance
+  BrotliEncoderSetParameter
+  BrotliEncoderCompressStream
+  BrotliEncoderHasMoreOutput
+  BrotliEncoderIsFinished
+  BrotliEncoderDestroyInstance
+]
+.freeze
+
+require_library "brotlienc", encoder_functions
+
+decoder_functions = %w[
+  BrotliDecoderCreateInstance
+  BrotliDecoderSetParameter
+  BrotliDecoderDecompressStream
+  BrotliDecoderGetErrorCode
+  BrotliDecoderDestroyInstance
+]
+.freeze
+
+require_library "brotlidec", decoder_functions
+
+extension_name = "brs_ext".freeze
+dir_config extension_name
+
+sources = %w[
+  stream/compressor
+  stream/decompressor
+  buffer
+  error
+  io
+  main
+  option
+  string
+]
+.freeze
+
+# rubocop:disable Style/GlobalVars
+$srcs = sources
+  .map { |name| "src/#{extension_name}/#{name}.c" }
+  .freeze
+
+$CFLAGS << " -Wno-declaration-after-statement"
+$VPATH << "$(srcdir)/#{extension_name}:$(srcdir)/#{extension_name}/stream"
+# rubocop:enable Style/GlobalVars
+
+create_makefile extension_name

data/lib/brs/error.rb

@@ -0,0 +1,21 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+module BRS
+  class BaseError < ::StandardError; end
+
+  class AllocateError < BaseError; end
+  class ValidateError < BaseError; end
+
+  class UsedAfterCloseError              < BaseError; end
+  class NotEnoughSourceBufferError       < BaseError; end
+  class NotEnoughDestinationBufferError  < BaseError; end
+  class NotEnoughDestinationError        < BaseError; end
+  class DecompressorCorruptedSourceError < BaseError; end
+
+  class AccessIOError < BaseError; end
+  class ReadIOError   < BaseError; end
+  class WriteIOError  < BaseError; end
+
+  class UnexpectedError < BaseError; end
+end

data/lib/brs/file.rb

@@ -0,0 +1,44 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "brs_ext"
+
+require_relative "error"
+require_relative "option"
+require_relative "validation"
+
+module BRS
+  module File
+    BUFFER_LENGTH_NAMES = %i[source_buffer_length destination_buffer_length].freeze
+
+    def self.compress(source, destination, options = {})
+      Validation.validate_string source
+      Validation.validate_string destination
+
+      options = Option.get_compressor_options options, BUFFER_LENGTH_NAMES
+
+      open_files(source, destination) do |source_io, destination_io|
+        BRS._native_compress_io source_io, destination_io, options
+      end
+    end
+
+    def self.decompress(source, destination, options = {})
+      Validation.validate_string source
+      Validation.validate_string destination
+
+      options = Option.get_decompressor_options options, BUFFER_LENGTH_NAMES
+
+      open_files(source, destination) do |source_io, destination_io|
+        BRS._native_decompress_io source_io, destination_io, options
+      end
+    end
+
+    private_class_method def self.open_files(source, destination, &_block)
+      ::File.open source, "rb" do |source_io|
+        ::File.open destination, "wb" do |destination_io|
+          yield source_io, destination_io
+        end
+      end
+    end
+  end
+end

data/lib/brs/option.rb

@@ -0,0 +1,80 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require_relative "error"
+require_relative "validation"
+
+module BRS
+  module Option
+    DEFAULT_BUFFER_LENGTH = 0
+
+    COMPRESSOR_DEFAULTS = {
+      :mode                             => nil,
+      :quality                          => nil,
+      :lgwin                            => nil,
+      :lgblock                          => nil,
+      :disable_literal_context_modeling => nil,
+      :size_hint                        => nil,
+      :large_window                     => nil
+    }
+    .freeze
+
+    DECOMPRESSOR_DEFAULTS = {
+      :disable_ring_buffer_reallocation => nil,
+      :large_window                     => nil
+    }
+    .freeze
+
+    def self.get_compressor_options(options, buffer_length_names)
+      Validation.validate_hash options
+
+      buffer_length_defaults = buffer_length_names.each_with_object({}) { |name, defaults| defaults[name] = DEFAULT_BUFFER_LENGTH }
+      options                = COMPRESSOR_DEFAULTS.merge(buffer_length_defaults).merge options
+
+      buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
+
+      mode = options[:mode]
+      unless mode.nil?
+        Validation.validate_symbol mode
+        raise ValidateError, "invalid mode" unless MODES.include? mode
+      end
+
+      quality = options[:quality]
+      Validation.validate_not_negative_integer quality unless quality.nil?
+
+      lgwin = options[:lgwin]
+      Validation.validate_not_negative_integer lgwin unless lgwin.nil?
+
+      lgblock = options[:lgblock]
+      Validation.validate_not_negative_integer lgblock unless lgblock.nil?
+
+      disable_literal_context_modeling = options[:disable_literal_context_modeling]
+      Validation.validate_bool disable_literal_context_modeling unless disable_literal_context_modeling.nil?
+
+      size_hint = options[:size_hint]
+      Validation.validate_not_negative_integer size_hint unless size_hint.nil?
+
+      large_window = options[:large_window]
+      Validation.validate_bool large_window unless large_window.nil?
+
+      options
+    end
+
+    def self.get_decompressor_options(options, buffer_length_names)
+      Validation.validate_hash options
+
+      buffer_length_defaults = buffer_length_names.each_with_object({}) { |name, defaults| defaults[name] = DEFAULT_BUFFER_LENGTH }
+      options                = DECOMPRESSOR_DEFAULTS.merge(buffer_length_defaults).merge options
+
+      buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
+
+      disable_ring_buffer_reallocation = options[:disable_ring_buffer_reallocation]
+      Validation.validate_bool disable_ring_buffer_reallocation unless disable_ring_buffer_reallocation.nil?
+
+      large_window = options[:large_window]
+      Validation.validate_bool large_window unless large_window.nil?
+
+      options
+    end
+  end
+end

data/lib/brs/stream/abstract.rb

@@ -0,0 +1,153 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require_relative "delegates"
+require_relative "stat"
+require_relative "../error"
+require_relative "../validation"
+
+module BRS
+  module Stream
+    class Abstract
+      # Native stream is not seekable by design.
+      # Related methods like "seek" and "pos=" can't be implemented.
+
+      # It is not possible to maintain correspondance between bytes consumed from source and bytes written to destination by design.
+      # We will consume all source bytes and maintain buffer with remaining destination data.
+
+      include Delegates
+
+      attr_reader :io
+      attr_reader :stat
+      attr_reader :external_encoding
+      attr_reader :internal_encoding
+      attr_reader :transcode_options
+      attr_reader :pos
+      alias tell pos
+
+      def initialize(io, external_encoding: nil, internal_encoding: nil, transcode_options: {})
+        @raw_stream = create_raw_stream
+
+        Validation.validate_io io
+        @io = io
+
+        @stat = Stat.new @io.stat
+
+        set_encoding external_encoding, internal_encoding, transcode_options
+        reset_buffer
+        reset_io_advise
+
+        @pos = 0
+      end
+
+      # -- buffer --
+
+      protected def reset_buffer
+        @buffer = ::String.new :encoding => ::Encoding::BINARY
+      end
+
+      # -- advise --
+
+      protected def reset_io_advise
+        # Both compressor and decompressor need sequential io access.
+        @io.advise :sequential
+      rescue ::Errno::ESPIPE # rubocop:disable Lint/HandleExceptions
+        # ok
+      end
+
+      def advise
+        # Noop
+        nil
+      end
+
+      # -- encoding --
+
+      def set_encoding(*args)
+        external_encoding, internal_encoding, transcode_options = process_set_encoding_arguments(*args)
+
+        set_target_encoding :@external_encoding, external_encoding
+        set_target_encoding :@internal_encoding, internal_encoding
+        @transcode_options = transcode_options
+
+        self
+      end
+
+      protected def process_set_encoding_arguments(*args)
+        external_encoding = args[0]
+
+        unless external_encoding.nil? || external_encoding.is_a?(::Encoding)
+          Validation.validate_string external_encoding
+
+          # First argument can be "external_encoding:internal_encoding".
+          match = %r{(.+?):(.+)}.match external_encoding
+
+          unless match.nil?
+            external_encoding = match[0]
+            internal_encoding = match[1]
+
+            transcode_options = args[1]
+            Validation.validate_hash transcode_options unless transcode_options.nil?
+
+            return [external_encoding, internal_encoding, transcode_options]
+          end
+        end
+
+        internal_encoding = args[1]
+        Validation.validate_string internal_encoding \
+          unless internal_encoding.nil? || internal_encoding.is_a?(::Encoding)
+
+        transcode_options = args[2]
+        Validation.validate_hash transcode_options unless transcode_options.nil?
+
+        [external_encoding, internal_encoding, transcode_options]
+      end
+
+      protected def set_target_encoding(name, value)
+        unless value.nil? || value.is_a?(::Encoding)
+          begin
+            value = ::Encoding.find value
+          rescue ::ArgumentError
+            raise ValidateError, "invalid #{name} encoding"
+          end
+        end
+
+        instance_variable_set name, value
+      end
+
+      protected def target_encoding
+        return @internal_encoding unless @internal_encoding.nil?
+        return @external_encoding unless @external_encoding.nil?
+
+        ::Encoding::BINARY
+      end
+
+      # -- etc --
+
+      def rewind
+        @raw_stream = create_raw_stream
+
+        @io.rewind
+        reset_buffer
+        reset_io_advise
+
+        @pos = 0
+
+        0
+      end
+
+      def close
+        @io.close
+
+        nil
+      end
+
+      def closed?
+        @raw_stream.closed? && @io.closed?
+      end
+
+      def to_io
+        self
+      end
+    end
+  end
+end

data/lib/brs/stream/delegates.rb

@@ -0,0 +1,36 @@
+# Ruby bindings for brotli library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "forwardable"
+
+module BRS
+  module Stream
+    module Delegates
+      DELEGATES = %i[
+        autoclose=
+        autoclose?
+        binmode
+        binmode?
+        close_on_exec=
+        close_on_exec?
+        fcntl
+        fdatasync
+        fileno
+        fsync
+        ioctl
+        isatty
+        pid
+        sync
+        sync=
+        to_i
+        tty?
+      ]
+      .freeze
+
+      def self.included(klass)
+        klass.extend ::Forwardable
+        klass.def_delegators :@io, *DELEGATES
+      end
+    end
+  end
+end