extbzip3 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d337adb887c6e5dbda229b8536addfcd5b5e91af292ff118ae586c94ce90d5c9
+  data.tar.gz: feea5218e03eb301e8b346993803572076259f446e8260bd4ff73b882735f85f
+SHA512:
+  metadata.gz: b8e1c8883e87f405f263451d479bd00f0ac3bf0631da8d2f19fb3faedac0e342f90815bdc3143c3c772d459778dc6f80df6ee779d751096bf61f432c510463a5
+  data.tar.gz: 918a07bcb7f75f91bea44e7e10fe5746d314393ecae805e48484324291cd8c92ddcd3c6900e330b9323273fc79ce54825cffe8d46e2472ec5c677f464bc5b1c4

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2023, dearblue. All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, are permitted provided that the following
+conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,159 @@
+extbzip3 - bzip3 for Ruby
+=========================
+
+This document is written in Japanese.
+
+[bzip3](https://github.com/kspalaiologos/bzip3) の非公式 Ruby バインディングです。
+
+
+できること
+----------
+
+  - `require "extbzip3"`
+      - `Bzip3` module
+
+        | method                   | annotation
+        | -----                    | -----
+        | `Bzip3.decode(str, ...)` | see `Bzip3::Decoder.decode`
+        | `Bzip3.encode(str, ...)` | see `Bzip3::Encoder.encode`
+        | `Bzip3.decode(obj, ...)` | see `Bzip3::Decoder.open`
+        | `Bzip3.encode(obj, ...)` | see `Bzip3::Encoder.open`
+
+      - `Bzip3::Decoder` class
+
+        | method                                                        | annotation
+        | -----                                                         | -----
+        | `Bzip3::Decoder.decode(str, maxdest = nil, dest = "", *opts)` | returns dest with bzip3 decoded
+        | `Bzip3::Decoder.decode(str, dest, *opts)`                     | returns dest with bzip3 decoded
+        | `Bzip3::Decoder.open(obj, *opts)`                             | returns bzip3 decoder
+        | `Bzip3::Decoder.open(obj, *opts) { \|decoder\| ... }`         | returns object from yield returned
+        | `Bzip3::Decoder#read(size = nil, dest = "")`                  | returns dest with bzip3 decoded
+        | `Bzip3::Decoder#close`                                        |
+        | `Bzip3::Decoder#eof?`                                         |
+
+      - `Bzip3::Encoder` class
+
+        | method                                                        | annotation
+        | -----                                                         | -----
+        | `Bzip3::Encoder.encode(str, maxdest = nil, dest = "", *opts)` | returns dest with bzip3'ed sequence
+        | `Bzip3::Encoder.encode(str, dest, *opts)`                     | returns dest with bzip3'ed sequence
+        | `Bzip3::Encoder.open(obj, *opts)`                             | returns bzip3 encoder
+        | `Bzip3::Encoder.open(obj, *opts) { \|encoder\| ... }`         | returns object from yield returned
+        | `Bzip3::Encoder#write(src)`                                   | returns receiver
+        | `Bzip3::Encoder#flush`                                        | returns receiver
+        | `Bzip3::Encoder#close`                                        |
+        | `Bzip3::Encoder#eof?`                                         |
+
+      - `Bzip3::BlockProcessor` class
+
+        | method                                                        | annotation
+        | -----                                                         | -----
+        | `Bzip3::BlockProcessor.new(blocksize)`                        |
+        | `Bzip3::BlockProcessor#decode(src, dest, original_size)`      | returns `dest` string as original data
+        | `Bzip3::BlockProcessor#encode(src, dest)`                     | returns `dest` string as bzip3'ed data
+        | `Bzip3::BlockProcessor#blocksize`                             | returns `blocksize` integer with when `new`
+
+      - `using Bzip3` (refinements)
+
+        | method                   | annotation
+        | -----                    | -----
+        | `String#to_bzip3(...)`   | see `Bzip3::Encoder.encode`
+        | `String#bunzip3(...)`    | see `Bzip3::Decoder.decode`
+        | `Object#to_bzip3(...)`   | see `Bzip3::Encoder.open`
+        | `Object#bunzip3(...)`    | see `Bzip3::Decoder.open`
+
+### データ形式について
+
+  - extbzip3 は [「bzip3 ファイル形式」](https://github.com/kspalaiologos/bzip3/blob/1.3.1/doc/file_format.md) を標準で扱います。
+    利用者は特別な操作や指定を行う必要がありません。
+  - extbzip3 は [「bzip3 ブロック形式」](https://github.com/kspalaiologos/bzip3/blob/1.3.1/doc/low_level_format.md) を扱うことも出来ます。
+    `Bzip3::BlockProcessor` クラスを使ってください。
+  - extbzip3 は [「bzip3 フレーム形式」](https://github.com/kspalaiologos/bzip3/blob/1.3.1/doc/high_level_format.md) を扱うことも出来ます。
+    文字列を圧縮・伸長する特異メソッド `Bzip3::Encoder.encode` または `Bzip3::Decoder.decode` にキーワード引数として `format: Bzip3::V1_FRAME_FORMAT` を与えてください。
+    ストリーム指向 API を「bzip3 フレーム形式」に対応させる予定はありません。
+
+
+つかいかた
+----------
+
+### 導入
+
+事前にシステム上へ [bzip3](https://github.com/kspalaiologos/bzip3) をインストールしてください。
+
+```console
+% sudo gem install extbzip3
+```
+
+### 単発圧縮・伸長
+
+```ruby
+require "extbzip3"
+
+src = "123456789"
+bin = Bzip3.encode(src)
+# => "BZ3v1\x00\x00\x10\x00\x11\x00\x00\x00\t\x00\x00\x00'F\xE3\xEB\xFF\xFF\xFF\xFF123456789"
+src1 = Bzip3.decode(bin)
+# => "123456789"
+```
+
+### ストリーミング圧縮と伸長
+
+```ruby
+require "extbzip3"
+
+# 圧縮処理してファイルとして出力
+File.open("/boot/kernel/kernel", "rb") do |src|
+  File.open("kernel.bz3", "wb") do |dest|
+    Bzip3.encode(dest) do |bz3|
+      buf = ""
+      bz3.write buf while src.read(123456, buf)
+    end
+  end
+end
+
+# 伸張処理してファイルとして出力
+File.open("kernel.bz3", "rb") do |src|
+  File.open("kernel.1", "wb") do |dest|
+    Bzip3.decode(src) do |bz3|
+      buf = ""
+      dest.write buf while bz3.read(123456, buf)
+    end
+  end
+end
+
+# ファイルの比較
+system "md5 /boot/kernel/kernel kernel.1"
+# => MD5 (/boot/kernel/kernel) = 71b8f6c6a29f4d647f45d9501d549cf3
+# => MD5 (kernel.1) = 71b8f6c6a29f4d647f45d9501d549cf3
+```
+
+### bzip3 フレーム形式による単発圧縮・伸長
+
+```ruby
+require "extbzip3"
+
+src = "123456789"
+bin = Bzip3.encode(src, format: Bzip3::V1_FRAME_FORMAT)
+# => "BZ3v1\x00\x00\x10\x00\x01\x00\x00\x00\x11\x00\x00\x00\t\x00\x00\x00'F\xE3\xEB\xFF\xFF\xFF\xFF123456789"
+src1 = Bzip3.decode(bin, format: Bzip3::V1_FRAME_FORMAT)
+# => "123456789"
+```
+
+
+しょげん
+--------
+
+  - Project page: <https://github.com/dearblue/ruby-extbzip3>
+  - Licensing: [2-clause BSD License](LICENSE) by [dearblue](https://github.com/dearblue)
+  - Version: 0.0.1
+  - Project status: CONCEPT
+  - Dependency gems: none
+  - Dependency external C libraries:
+      - [bzip3](https://github.com/kspalaiologos/bzip3)
+        version 1.3.2 or later
+        under [GNU Lesser General Public License version 3 or later](https://github.com/kspalaiologos/bzip3/blob/master/LICENSE)
+        by [Kamila Szewczyk](https://github.com/kspalaiologos)
+        and [Apache License, Version 2.0](https://github.com/kspalaiologos/bzip3/blob/master/libsais-LICENSE)
+        by [Ilya Grebnov](https://github.com/IlyaGrebnov)
+        and [Kamila Szewczyk](https://github.com/kspalaiologos)
+  - Bundled external C libraries: none

data/Rakefile

@@ -0,0 +1,247 @@
+
+require "pathname"
+require "rake/clean"
+
+RUBYSET ||= (ENV["RUBYSET"] || "").split(",").yield_self { |me| me.empty? ? nil : me }
+
+docnames = "{README,LICENSE,CHANGELOG,Changelog,HISTORY}"
+doctypes = "{,.txt,.rd,.rdoc,.md,.markdown}"
+cexttypes = "{c,C,cc,cxx,cpp,h,H,hh}"
+
+DOC = FileList["#{docnames}{,.ja}#{doctypes}"] +
+      FileList["{contrib,ext}/**/#{docnames}{,.ja}#{doctypes}"] +
+      FileList["ext/**/*.#{cexttypes}"]
+EXT = FileList["ext/**/*"]
+BIN = FileList["bin/*"]
+LIB = FileList["lib/**/*.rb"]
+SPEC = FileList["spec/**/*"]
+TEST = FileList["test/**/*"]
+EXAMPLE = FileList["examples/**/*"]
+GEMSTUB_SRC = "gemstub.rb"
+RAKEFILE = [File.basename(__FILE__), GEMSTUB_SRC]
+EXTRA = []
+EXTCONF = FileList["ext/**/extconf.rb"]
+EXTCONF.reject! { |n| !File.file?(n) }
+EXTMAP = {}
+
+load GEMSTUB_SRC
+
+EXTMAP.dup.each_pair do |dir, name|
+  EXTMAP[Pathname.new(dir).cleanpath.to_s] = Pathname.new(name).cleanpath.to_s
+end
+
+GEMSTUB.extensions += EXTCONF
+GEMSTUB.executables += FileList["bin/*"].map { |n| File.basename n }
+GEMSTUB.executables.sort!
+
+PACKAGENAME = "#{GEMSTUB.name}-#{GEMSTUB.version}"
+GEMFILE = "#{PACKAGENAME}.gem"
+GEMSPEC = "#{PACKAGENAME}.gemspec"
+BUNDLER_GEMFILE = "Gemfile"
+
+GEMSTUB.files += DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + EXTRA
+GEMSTUB.files.sort!
+if GEMSTUB.rdoc_options.nil? || GEMSTUB.rdoc_options.empty?
+  readme = %W(.md .markdown .rd .rdoc .txt #{""}).map { |ext| "README#{ext}" }.find { |m| DOC.find { |n| n == m } }
+  GEMSTUB.rdoc_options = %w(--charset UTF-8) + (readme ? %W(-m #{readme}) : [])
+end
+GEMSTUB.extra_rdoc_files += DOC + LIB + EXT.reject { |n| n.include?("/externals/") || !%w(.h .hh .c .cc .cpp .cxx).include?(File.extname(n)) }
+GEMSTUB.extra_rdoc_files.sort!
+
+GEMSTUB_TRYOUT = GEMSTUB.dup
+GEMSTUB_TRYOUT.version = "#{GEMSTUB.version}#{Time.now.strftime(".TRYOUT.%Y%m%d.%H%M%S")}"
+PACKAGENAME_TRYOUT = "#{GEMSTUB.name}-#{GEMSTUB_TRYOUT.version}"
+GEMFILE_TRYOUT = "#{PACKAGENAME_TRYOUT}.gem"
+GEMSPEC_TRYOUT = "#{PACKAGENAME_TRYOUT}.gemspec"
+
+CLEAN << GEMSPEC << GEMSPEC_TRYOUT
+CLOBBER << GEMFILE
+
+task :default => :tryout do
+  $stderr.puts <<-EOS
+#{__FILE__}:#{__LINE__}:
+\ttype ``rake release'' to build release package.
+  EOS
+end
+
+desc "build tryout package"
+task :tryout
+
+desc "build release package"
+task :release => :all
+
+unless EXTCONF.empty?
+  if RUBYSET.nil?
+    $stderr.puts <<-EOS
+#{__FILE__}:
+|
+| If you want binary gem package, launch rake with ``RUBYSET`` enviroment
+| variable for set ruby interpreters by comma separated.
+|
+|   e.g.) $ rake RUBYSET=ruby
+|     or) $ rake RUBYSET=ruby21,ruby22,ruby23
+|
+    EOS
+  else
+    platforms = RUBYSET.map { |ruby| `#{ruby} --disable-gems -e "puts RUBY_PLATFORM"`.chomp }
+    platforms1 = platforms.uniq
+    unless platforms1.size == 1 && !platforms1[0].empty?
+      abort <<-EOS
+#{__FILE__}:#{__LINE__}: different platforms:
+#{RUBYSET.zip(platforms).map { |ruby, platform| "%24s => %s" % [ruby, platform] }.join("\n")}
+ABORTED.
+      EOS
+    end
+    PLATFORM = platforms1[0]
+
+    RUBY_VERSIONS = RUBYSET.map do |ruby|
+      ver = `#{ruby} --disable-gems -e "puts RUBY_VERSION"`.slice(/\d+\.\d+/)
+      raise "failed ruby checking - ``#{ruby}''" unless $?.success?
+      [ver, ruby]
+    end
+
+    SOFILES_SET = RUBY_VERSIONS.map { |(ver, ruby)|
+      EXTCONF.map { |extconf|
+        extdir = Pathname.new(extconf).cleanpath.dirname.to_s
+        case
+        when soname = EXTMAP[extdir.sub(/^ext\//i, "")]
+          soname = soname.sub(/\.so$/i, "")
+        when extdir == "ext" || extdir == "."
+          soname = GEMSTUB.name
+        else
+          soname = File.basename(extdir)
+        end
+
+        [ruby, File.join("lib", "#{soname.sub(/(?<=\/)|^(?!.*\/)/, "#{ver}/")}.so"), extconf]
+      }
+    }.flatten(1)
+    SOFILES = SOFILES_SET.map { |(ruby, sopath, extconf)| sopath }
+
+    GEMSTUB_NATIVE = GEMSTUB.dup
+    GEMSTUB_NATIVE.files += SOFILES
+    GEMSTUB_NATIVE.platform = Gem::Platform.new(PLATFORM).to_s
+    GEMSTUB_NATIVE.extensions.clear
+    GEMFILE_NATIVE = "#{GEMSTUB_NATIVE.name}-#{GEMSTUB_NATIVE.version}-#{GEMSTUB_NATIVE.platform}.gem"
+    GEMSPEC_NATIVE = "#{GEMSTUB_NATIVE.name}-#{GEMSTUB_NATIVE.platform}.gemspec"
+
+    task :all => ["native-gem", GEMFILE]
+
+    desc "build binary gem package"
+    task "native-gem" => GEMFILE_NATIVE
+
+    desc "generate binary gemspec"
+    task "native-gemspec" => GEMSPEC_NATIVE
+
+    file GEMFILE_NATIVE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + SOFILES + RAKEFILE + [GEMSPEC_NATIVE] do
+      sh "gem build #{GEMSPEC_NATIVE}"
+    end
+
+    file GEMSPEC_NATIVE => RAKEFILE do
+      File.write(GEMSPEC_NATIVE, GEMSTUB_NATIVE.to_ruby, mode: "wb")
+    end
+
+    desc "build c-extension libraries"
+    task "sofiles" => SOFILES
+
+    task "test" => SOFILES
+
+    SOFILES_SET.each do |(ruby, soname, extconf)|
+      sodir = File.dirname(soname)
+      makefile = File.join(sodir, "Makefile")
+
+      CLEAN << GEMSPEC_NATIVE << sodir
+      CLOBBER << GEMFILE_NATIVE
+
+      directory sodir
+
+      desc "generate Makefile for binary extension library"
+      file makefile => [sodir, extconf] do
+        rel_extconf = Pathname.new(extconf).relative_path_from(Pathname.new(sodir)).to_s
+        cd sodir do
+          sh *%W"#{ruby} #{rel_extconf} --ruby=#{ruby} #{ENV["EXTCONF"]}"
+        end
+      end
+
+      desc "build binary extension library"
+      file soname => [makefile] + EXT do
+        cd sodir do
+          sh "make"
+        end
+      end
+    end
+  end
+end
+
+
+task :all => GEMFILE
+task :tryout => GEMFILE_TRYOUT
+
+desc "generate local rdoc"
+task :rdoc => DOC + LIB do
+  sh *(%w(rdoc) + GEMSTUB.rdoc_options + DOC + LIB)
+end
+
+desc "launch rspec"
+task rspec: :all do
+  sh "rspec"
+end
+
+desc "test library"
+task "test" do
+  (RUBYSET || ["ruby"]).each do |ruby|
+    lib = File.join(__dir__, "lib")
+    dir2 = __dir__.gsub(/[\[\{\*\?]/) { |m| "\\#{m}" }
+    Dir.glob(File.join(dir2, "test/**/test_*.rb")) do |test|
+      sh *%W(#{ruby} -I#{lib} #{test})
+    end
+  end
+end
+
+desc "build gem package"
+task gem: GEMFILE
+
+desc "generate gemspec"
+task gemspec: GEMSPEC
+
+desc "print package name"
+task "package-name" do
+  puts PACKAGENAME
+end
+
+desc "generate Gemfile for bundler"
+task "gemfile" => BUNDLER_GEMFILE
+
+file GEMFILE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + [GEMSPEC] do
+  sh "gem build #{GEMSPEC}"
+end
+
+file GEMFILE_TRYOUT => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + [GEMSPEC_TRYOUT] do
+#file GEMFILE_TRYOUT do
+  sh "gem build #{GEMSPEC_TRYOUT}"
+end
+
+file GEMSPEC => RAKEFILE do
+  File.write(GEMSPEC, GEMSTUB.to_ruby, mode: "wb")
+end
+
+file GEMSPEC_TRYOUT => RAKEFILE do
+  File.write(GEMSPEC_TRYOUT, GEMSTUB_TRYOUT.to_ruby, mode: "wb")
+end
+
+file BUNDLER_GEMFILE => RAKEFILE do
+  File.write(BUNDLER_GEMFILE, <<~GemfileSource, mode: "wb")
+    source "https://rubygems.org/"
+
+    group "default" do
+    #{GEMSTUB.runtime_dependencies.map { |e|
+      %(  gem #{e.name.inspect}, #{e.requirements_list.map { |ee| ee.inspect }.join(", ")})
+    }.join("\n")}
+    end
+
+    group "development", "test" do
+    #{GEMSTUB.development_dependencies.map { |e|
+      %(  gem #{e.name.inspect}, #{e.requirements_list.map { |ee| ee.inspect }.join(", ")})
+    }.join("\n")}
+    end
+  GemfileSource
+end

data/ext/compat.h

@@ -0,0 +1,32 @@
+/*
+ * Licensed under Creative Commons Zero License (CC0; Public Domain)
+ */
+
+#ifndef AUX_COMPAT_H
+
+// for older than 2.7.0
+#ifndef RUBY_ASSERT_ALWAYS
+# define RUBY_ASSERT_ALWAYS(...)
+#endif
+
+// for older than 3.0.0
+#ifndef TRUE
+# define TRUE 1
+#endif
+
+// for older than 3.0.0
+#ifndef RB_EXT_RACTOR_SAFE
+# define RB_EXT_RACTOR_SAFE(FEATURE)
+#endif
+
+// for older than 3.2.0
+#ifndef RB_UNDEF_P
+# define RB_UNDEF_P(OBJ) ((OBJ) == Qundef)
+#endif
+
+// for older than 3.2.0
+#ifndef RB_NIL_OR_UNDEF_P
+# define RB_NIL_OR_UNDEF_P(OBJ) (RB_NIL_P(OBJ) || RB_UNDEF_P(OBJ))
+#endif
+
+#endif // AUX_COMPAT_H

data/ext/extbzip3.c

@@ -0,0 +1,220 @@
+#include "extbzip3.h"
+
+static uint32_t
+aux_version_code(const char *ver)
+{
+    uint32_t code = 0;
+    const char *o = ver, *p = o;
+    int i = 4;
+
+    while (i > 0) {
+        if (*p == '\0' || *p == '.') {
+            char *pp = (char *)p;
+            unsigned long n = strtoul(o, &pp, 10);
+            code = (code << 8) | (uint32_t)n;
+            i--;
+
+            if (*p == '\0' || i <= 1) {
+                for (; i > 0; i--) {
+                    code <<= 8;
+                }
+
+                break;
+            }
+
+            o = p + 1;
+        }
+
+        p++;
+    }
+
+    return code;
+}
+
+static VALUE
+version_to_s(VALUE self)
+{
+    return rb_iv_get(self, "LIBBZIP3_VERSION");
+}
+
+static void
+init_version(VALUE bzip3_module)
+{
+    RDOCFAKE(VALUE bzip3_module = rb_define_module("Bzip3"))
+
+    VALUE libver = rb_ary_new_capa(3);
+    const char *bz3ver = bz3_version();
+    uint32_t code = aux_version_code(bz3ver);
+
+    if (code < 0x01030200) {
+        const char *e = getenv("RUBY_EXTBZIP3_USE_BZIP3_1_3_1_OR_OLDER");
+
+        if (!e || strtol(e, NULL, 10) < 1) {
+            rb_raise(rb_eLoadError, "%s",
+                     "YOU ARE USING AN BZIP3-1.3.1 OR OLDER LIBRARY.\n"
+                     "PLEASE UPDATE TO BZIP3-1.3.2 OR A NEWER LIBRARY ON YOUR SYSTEM.\n"
+                     "\n"
+                     "BZIP3-1.3.1 OR OLDER HAS DATA COMPATIBILITY ISSUES.\n"
+                     "IF YOU WANT TO FORCE THE USE OF EXTBZIP3,\n"
+                     "PLEASE SET THE FOLLOWING ENVIRONMENT VARIABLES:\n"
+                     "\n"
+                     "    RUBY_EXTBZIP3_USE_BZIP3_1_3_1_OR_OLDER=1");
+        } else {
+            rb_warn("%s",
+                    "YOU ARE USING AN BZIP3-1.3.1 OR OLDER LIBRARY.\n"
+                    "PLEASE UPDATE TO BZIP3-1.3.2 OR A NEWER LIBRARY ON YOUR SYSTEM.\n"
+                    "\n"
+                    "BZIP3-1.3.1 OR OLDER HAS DATA COMPATIBILITY ISSUES.\n"
+                    "IF YOU CONTINUE USE, YOUR DATA WILL NOT BE ABLE TO BE MIGRATED IN THE FUTURE.");
+        }
+    }
+
+    rb_ary_push(libver, INT2FIX((code >> 24) & 0xff));
+    rb_ary_push(libver, INT2FIX((code >> 16) & 0xff));
+    rb_ary_push(libver, INT2FIX((code >>  8) & 0xff));
+
+    rb_iv_set(libver, "LIBBZIP3_VERSION", rb_str_new_static(bz3ver, strlen(bz3ver)));
+    rb_iv_set(libver, "LIBBZIP3_VERSION_CODE", UINT2NUM(code));
+
+    rb_define_singleton_method(libver, "to_s", version_to_s, 0);
+    rb_obj_freeze(libver);
+
+    rb_define_const(bzip3_module, "LIBRARY_VERSION", libver);
+}
+
+static void
+init_constants(VALUE bzip3_module)
+{
+    RDOCFAKE(VALUE bzip3_module = rb_define_module("Bzip3"))
+
+    rb_define_const(bzip3_module, "V1_FILE_FORMAT", INT2FIX(AUX_BZIP3_V1_FILE_FORMAT));
+    rb_define_const(bzip3_module, "V1_FRAME_FORMAT", INT2FIX(AUX_BZIP3_V1_FRAME_FORMAT));
+    rb_define_const(bzip3_module, "BLOCKSIZE_MIN", UINT2NUM(65 << 10));
+    rb_define_const(bzip3_module, "BLOCKSIZE_MAX", UINT2NUM(511 << 20));
+}
+
+struct block_processor
+{
+    struct bz3_state *bzip3;
+    size_t blocksize;
+};
+
+#define BLOCK_PROCESSOR_FREE_BLOCK(P)                                   \
+        if ((P)->bzip3) {                                               \
+            bz3_free((P)->bzip3);                                       \
+        }                                                               \
+
+#define BLOCK_PROCESSOR_VALUE_FOREACH(DEF)
+
+AUX_DEFINE_TYPED_DATA(block_processor, block_processor_allocate, BLOCK_PROCESSOR_FREE_BLOCK, BLOCK_PROCESSOR_VALUE_FOREACH)
+
+/*
+ *  @overload initialize(blocksize)
+ */
+static VALUE
+block_processor_initialize(VALUE self, VALUE blocksize)
+{
+    struct block_processor *p = get_block_processor_ptr(self);
+    if (p->bzip3 != NULL) {
+        rb_raise(rb_eTypeError, "wrong re-initializing - %" PRIsVALUE, self);
+    }
+
+    p->blocksize = NUM2UINT(blocksize);
+
+    if (p->blocksize < AUX_BZIP3_BLOCKSIZE_MIN) {
+        p->blocksize = AUX_BZIP3_BLOCKSIZE_MIN;
+    } else if (p->blocksize > AUX_BZIP3_BLOCKSIZE_MAX) {
+        rb_raise(rb_eRuntimeError, "blocksize too big - %" PRIsVALUE " (expect ..%u)",
+                 blocksize, AUX_BZIP3_BLOCKSIZE_MAX);
+    }
+
+    p->bzip3 = aux_bz3_new((uint32_t)p->blocksize);
+
+    return self;
+}
+
+static VALUE
+block_processor_blocksize(VALUE self)
+{
+    return SIZET2NUM(get_block_processor(self)->blocksize);
+}
+
+static VALUE
+block_processor_decode(VALUE self, VALUE src, VALUE dest, VALUE originalsize)
+{
+    rb_check_type(src, RUBY_T_STRING);
+    rb_check_type(dest, RUBY_T_STRING);
+
+    struct block_processor *p = get_block_processor(self);
+
+    size_t origsize = NUM2SIZET(originalsize);
+    if (origsize > (size_t)p->blocksize) {
+        rb_raise(rb_eRuntimeError, "originalsize too big - %" PRIsVALUE, originalsize);
+    }
+
+    size_t srclen = RSTRING_LEN(src);
+    size_t destcapa = bz3_bound((uint32_t)origsize);
+    rb_str_modify(dest);
+    rb_str_set_len(dest, 0);
+    rb_str_modify_expand(dest, destcapa);
+
+    memmove(RSTRING_PTR(dest), RSTRING_PTR(src), srclen);
+    int32_t ret = aux_bz3_decode_block_nogvl(p->bzip3, RSTRING_PTR(dest), srclen, NUM2UINT(originalsize));
+    extbzip3_check_error(ret);
+
+    rb_str_set_len(dest, ret);
+
+    return dest;
+}
+
+static VALUE
+block_processor_encode(VALUE self, VALUE src, VALUE dest)
+{
+    rb_check_type(src, RUBY_T_STRING);
+    rb_check_type(dest, RUBY_T_STRING);
+
+    struct block_processor *p = get_block_processor(self);
+
+    size_t srclen = RSTRING_LEN(src);
+    if (srclen > p->blocksize) {
+        rb_raise(rb_eRuntimeError, "src too big - #<%" PRIsVALUE ":0x%" PRIxVALUE ">", rb_class_of(src), src);
+    }
+
+    size_t destcapa = bz3_bound((uint32_t)srclen);
+    rb_str_modify(dest);
+    rb_str_set_len(dest, 0);
+    rb_str_modify_expand(dest, (uint32_t)destcapa);
+
+    memmove(RSTRING_PTR(dest), RSTRING_PTR(src), srclen);
+    int32_t ret = aux_bz3_encode_block_nogvl(p->bzip3, RSTRING_PTR(dest), (int32_t)srclen);
+    extbzip3_check_error(ret);
+
+    rb_str_set_len(dest, ret);
+
+    return dest;
+}
+
+static void
+init_processor(VALUE bzip3_module)
+{
+    VALUE block_processor_class = rb_define_class_under(bzip3_module, "BlockProcessor", rb_cObject);
+    rb_define_alloc_func(block_processor_class, block_processor_allocate);
+    rb_define_method(block_processor_class, "initialize", block_processor_initialize, 1);
+    rb_define_method(block_processor_class, "blocksize", block_processor_blocksize, 0);
+    rb_define_method(block_processor_class, "decode", block_processor_decode, 3);
+    rb_define_method(block_processor_class, "encode", block_processor_encode, 2);
+}
+
+EXTBZIP3_API void
+Init_extbzip3(void)
+{
+    RB_EXT_RACTOR_SAFE(true);
+
+    VALUE bzip3_module = rb_define_module("Bzip3");
+
+    init_version(bzip3_module);
+    init_constants(bzip3_module);
+    init_processor(bzip3_module);
+    extbzip3_init_decoder(bzip3_module);
+    extbzip3_init_encoder(bzip3_module);
+}