ob64 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf866c04fac9e6cf9d4f8c98741f17e2109e0bd5fd545d2d0482b4c28a6dd61a
-  data.tar.gz: e6ee12aebbece01e6e1ce8181aafdfe9b32b7fbd2d1307c07d7af02d46b73f4e
+  metadata.gz: 110cd68288a2dd3ff785dca2a4dc2bdc0b3d47445fae88d0fef3a3a3db1b0d96
+  data.tar.gz: a0d837a2ba44079613b99fd862cdf156d3105b69359edbefeae32711a2be402e
 SHA512:
-  metadata.gz: 280e35ae08985662cc05a26c5f30ef5e9897b8d7a641a83e7a0bc8bf91a1790dbf8c36f5129ff7dface1e5eeb8d286ef43387688202b26a254a6bad860faa65d
-  data.tar.gz: f246fed35467cce900ffb7664ca62012c6d0e7bda5c2180a99814fba558331f83ab33d21a1868a0d850fa39b59eec223e39445584703f0302f339e159ce9be83
+  metadata.gz: 6a4fa2cabc1fad23055020ed1c49906de65e494f82fbf19966cc0a511cc8e073026dc77c4e0cb9b57d77d67e21f068fdbf79c6dfa2de978381444e1793a4793a
+  data.tar.gz: 432523720a899411c6a3840fc410bd4e540b7f8211dda82dff2643046959ce52ceec8bc0a8f15a6518bddb913cce69129b52ade76d8dbd33f3a7e980a690c693

data/.github/dependabot.yml

@@ -0,0 +1,9 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+    groups:
+      github-actions:
+        patterns: ["*"]

data/.github/workflows/main.yml

@@ -1,34 +1,96 @@
-name: Test
+name: CI
 
 on: [push, pull_request]
 
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
 jobs:
+  lint:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - uses: ruby/setup-ruby@7f797815d8adceb1c412e7abefdd1ab4abc47a5f # v1.335.0
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+
+      - run: bundle exec standardrb --no-fix
+
   test:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['2.5', '2.6', '2.7', '3.0']
-    runs-on: ubuntu-latest
+        ruby: ["3.3", "3.4", "4.0"]
+        os: [ubuntu-24.04, ubuntu-24.04-arm]
+        cc: [gcc, clang]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
     steps:
-      - name: repository checkout
-        uses: actions/checkout@v2
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
-          submodules: true
+          persist-credentials: false
 
-      - name: load ruby
-        uses: ruby/setup-ruby@v1
+      - uses: ruby/setup-ruby@7f797815d8adceb1c412e7abefdd1ab4abc47a5f # v1.335.0
         with:
           ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
 
-      - name: RubyGems, Bundler Update
-        run: gem update --system --no-document --conservative
-
-      - name: bundle install
-        run: bundle install --path .bundle/gems --without development
+      - name: Install Clang
+        if: matrix.cc == 'clang'
+        run: command -v clang || { sudo apt-get update && sudo apt-get install -y clang; }
 
-      - name: compile
+      - name: Compile
+        env:
+          # Same warnings for both compilers; Ruby's defaults are GCC-only.
+          MAKEFLAGS: 'CC=${{ matrix.cc }} warnflags=-Wall\ -Wextra\ -Wno-unused-parameter\ -Werror'
         run: bundle exec rake compile
 
-      - name: test
+      - name: Show codecs
+        run: bundle exec ruby -Ilib -rob64 -e 'p Ob64.codecs, Ob64.codec'
+
+      - name: Test
         run: bundle exec rake spec
-        timeout-minutes: 10
+
+  package:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - uses: ruby/setup-ruby@7f797815d8adceb1c412e7abefdd1ab4abc47a5f # v1.335.0
+        with:
+          ruby-version: "3.4"
+
+      - name: Build gem
+        run: gem build ob64.gemspec
+
+      - name: Install gem
+        run: gem install --local ./ob64-*.gem
+
+      - name: Smoke test
+        working-directory: ${{ runner.temp }}
+        run: |
+          ruby -e '
+            require "ob64"
+            require "ob64/core_ext"
+            s = Random.bytes(4096)
+            abort "RFC 4648 round trip failed" unless Ob64::Base64::RFC4648.decode(Ob64::Base64::RFC4648.encode(s)) == s
+            abort "RFC 2045 round trip failed" unless Ob64::Base64::RFC2045.decode(Ob64::Base64::RFC2045.encode(s)) == s
+            abort "UU round trip failed" unless Ob64::UU.decode(Ob64::UU.encode(s)) == s
+            abort "pack round trip failed" unless [s].pack("m0").unpack1("m0") == s
+          '

data/.standard.yml

@@ -5,6 +5,5 @@ format: progress
 ignore:
   - 'benchmark.rb'
   - 'ext/**/*'
-  - 'vendor/**/*'
   - 'spec/**/*':
-    - Layout/AlignHash
+    - Layout/HashAlignment

data/CHANGELOG.md

@@ -1,4 +1,22 @@
-## [Unreleased]
+## [0.7.0] - 2026-10-26
+
+- **Breaking:** Split `Ob64::Base64` into one module per RFC. `Ob64::Base64::RFC4648` has `encode`, `decode`, `encode_urlsafe`, `decode_urlsafe`, `encoded_length_of` and `decoded_length_of` (were `Ob64::Base64.encode`, `decode`, `urlsafe_encode`, `urlsafe_decode`, `encoded_length_of` and `decoded_length_of`).
+- Add `Ob64::Base64::RFC2045` with `encode` (optionally with CRLF line breaks), `decode`, `encoded_length_of` and `decoded_length_of`, like `pack("m")` and `unpack1("m")`.
+
+## [0.6.0] - 2026-10-26
+
+- **Breaking:** `ob64/core_ext` patches `Array#pack`, `String#unpack` and `String#unpack1` instead of `Base64`.
+- **Breaking:** Require Ruby >= 3.3.
+- **Breaking:** Drop CMake and libbase64. Require GCC or Clang.
+- **Breaking:** Base64 methods move from `Ob64` to `Ob64::Base64` (e.g. `Ob64.encode` is now `Ob64::Base64.encode`).
+- **Breaking:** `decode` and `urlsafe_decode` reject non-zero trailing bits (e.g. `"AB=="`), like `unpack1("m0")`.
+- Port SIMD codecs (AVX2, AVX512, NEON64) into the extension. They also run line-wrapped `m` and `u`.
+- AVX512 requires VBMI2.
+- Add `Ob64.codec`, `Ob64.codec=`, `Ob64.codecs` and `Ob64.best_codec`.
+- Add `Ob64::Base64.decode(string, loose: true)`.
+- Add `Ob64::UU.encode`, `Ob64::UU.decode`, `Ob64::UU.encoded_length_of` and `Ob64::UU.decoded_length_of`.
+- Encode and decode URL-safe in C.
+- Support Linux on AArch64.
 
 # [0.5.0] - 2021-09-29
 

data/Gemfile

@@ -5,7 +5,7 @@ source "https://rubygems.org"
 gemspec
 
 gem "benchmark-ips"
-gem "byebug"
+gem "debug"
 gem "guard"
 gem "guard-rspec"
 gem "rake", "~> 13.0"

data/README.md

@@ -1,20 +1,18 @@
 # Ob64 gem
 
 [![Gem Version](https://badge.fury.io/rb/ob64.svg)](http://rubygems.org/gems/ob64)
-[![Build Status](https://github.com/jcmfernandes/ob64/workflows/Test/badge.svg?branch=master&event=push)](https://github.com/jcmfernandes/ob64/actions?query=workflow:Test)
-[![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/gems/ob64/0.5.0)
+[![CI](https://github.com/jcmfernandes/ob64/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/jcmfernandes/ob64/actions/workflows/main.yml)
+[![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/gems/ob64/0.7.0)
 
-A *fast* Base64 encoder and decoder as a Ruby gem.
+A *fast* Base64 and uuencode encoder and decoder as a Ruby gem.
 
 How fast? Try it yourself, execute:
 
     $ rake benchmark
 
-When compared to Ruby's own `Base64` module, expect a 4x speedup in encoding, and a 2x speedup in decoding. YMMV.
-
 ## Acknowledgements
 
-Ob64 uses `libbase64` under the hood. Originally developed by [aklomp](https://github.com/aklomp), here we started from [BurningEnlightenment](https://github.com/BurningEnlightenment)'s fork. `libbase64` takes advantage of SIMD (AVX2, NEON, AArch64/NEON, SSSE3, SSE4.1, SSE4.2, AVX) acceleration available on x86, x86-64, and ARM systems.
+The SIMD codecs (AVX2, AVX512, NEON64) derive from [aklomp/base64](https://github.com/aklomp/base64).
 
 ## Installation
 
@@ -32,33 +30,83 @@ Or install it yourself as:
 
     $ gem install ob64
 
-Requires CMake and a C99 compiler.
-
-**WARNING:** Only tested on Linux and x86-64.
+Requires Ruby >= 3.3 and GCC or Clang. Linux on x86-64 and AArch64.
 
 ## Usage
 
 ```ruby
 require "ob64"
+```
+
+### Base64
 
+One module per RFC, each with `encode`, `decode`, `encoded_length_of` and `decoded_length_of`.
+
+RFC 4648, no line breaks, same output as `pack("m0")` / `unpack1("m0")`:
+
+```ruby
 bin1 = "This is data!"
-string = Ob64.encode(bin1)
+string = Ob64::Base64::RFC4648.encode(bin1)
 # string = "VGhpcyBpcyBkYXRhIQ=="
 
-bin2 = Ob64.decode(string)
+bin2 = Ob64::Base64::RFC4648.decode(string)
 puts "Same? #{bin1 == bin2}"
 # "Same? true"
+
+Ob64::Base64::RFC4648.decode("VGhpcyBpcyBkYXRhIQ", loose: true)  # padding optional
+Ob64::Base64::RFC4648.encode_urlsafe(bin1, padding: false)        # '-' and '_' instead of '+' and '/'
+Ob64::Base64::RFC4648.decode_urlsafe(string)
+```
+
+Bad padding, non-zero trailing bits and non-alphabet characters raise `ArgumentError`.
+
+RFC 2045 (MIME), line-wrapped, same output as `pack("m")` / `unpack1("m")`:
+
+```ruby
+Ob64::Base64::RFC2045.encode(bin)              # 60-char lines, each ending in "\n"
+Ob64::Base64::RFC2045.encode(bin, 76, crlf: true)
+Ob64::Base64::RFC2045.decode(string)           # skips line breaks and other non-alphabet characters
 ```
 
-If you want to replace Ruby's own `Base64` module with Ob64 **(NOT RECOMMENDED!)**:
+### uuencode
+
+Same output as `pack("u")` / `unpack1("u")`:
+
+```ruby
+string = Ob64::UU.encode("This is data!")
+# string = "-5&AI<R!I<R!D871A(0``\n"
+
+Ob64::UU.decode(string)
+# "This is data!"
+```
+
+### Codecs
+
+The best codec this CPU runs is picked at load and used for every call. `Ob64.codec=` forces one for the whole process (e.g. `:scalar`, plain C).
+
+```ruby
+Ob64.codecs
+# x86-64 with AVX512 => [:scalar, :avx2, :avx512]
+# x86-64 with AVX2   => [:scalar, :avx2]
+# AArch64            => [:scalar, :neon64]
+# other              => [:scalar]
+
+Ob64.best_codec     # => :avx512
+Ob64.codec          # => :avx512
+Ob64.codec = :scalar
+Ob64.codec = Ob64.best_codec
+```
+
+AVX512 needs VL, VBMI and VBMI2.
+
+### `pack` / `unpack`
 
 ```ruby
 require "ob64/core_ext"
-# It does NOT replace:
-#   - Base64.encode64
-#   - Base64.decode64
 ```
 
+Patches `Array#pack`, `String#unpack` and `String#unpack1`. Fast only for single-directive formats `m`, `mN`, `m*`, `u`, `uN`, `u*`. Everything else runs Ruby's own code. Passing `buffer:`, `offset:`, a block, or a non-String first element also runs Ruby's own code. Output is identical to Ruby's.
+
 See [YARD documentation](http://www.rubydoc.info/gems/ob64).
 
 ## Releases
@@ -77,11 +125,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/jcmfer
 
 ## TODO
 
-* URL-safe encoding/decoding using separate alphabet/tables
 * Streaming interface
-* RFC 2045 (MIME) encoding/decoding
-* Make the OpenMP threshold configurable (and enable OpenMP acceleration)
-* Windows support
 
 ## License
 
@@ -107,9 +151,9 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
-### libbase64
+### aklomp/base64
 
-Released under the BSD 2-clause License. See [LICENSE](https://github.com/jcmfernandes/base64-cmake/blob/feature/cmake/LICENSE).
+Released under the BSD 2-clause License. See [LICENSE](https://github.com/aklomp/base64/blob/master/LICENSE).
 
 Copyright (c) 2005-2007, Nick Galbreath  
 Copyright (c) 2013-2019, Alfred Klomp  

data/benchmark.rb

@@ -1,118 +1,85 @@
 require "benchmark/ips"
-require "securerandom"
+
+# Ruby's own, captured before ob64/core_ext patches them.
+NATIVE_PACK = Array.instance_method(:pack)
+NATIVE_UNPACK1 = String.instance_method(:unpack1)
 
 require "ob64"
-require "base64"
+require "ob64/core_ext"
 
-$run_encode_benchmark = true
-$run_decode_benchmark = true
-$run_urlsafe_encode_benchmark = true
-$run_urlsafe_decode_benchmark = true
+$run_base64_benchmark = true
+$run_uu_benchmark = true
 
 def to_size(bytes)
   bytes >= 2**20 ? "#{bytes / 2**20} MB" : "#{bytes / 2**10} kB"
 end
 
-def each_block
-  [
-    [1, :kb],
-    [4, :kb],
-    [64, :kb],
-    [1, :mb],
-    [10, :mb],
-    [64, :mb]
-  ].each do |(n, unit)|
-    yield(n * 2**({kb: 10, mb: 20}.fetch(unit)))
-  end
-end
-
-def benchmark(setup_block)
-  each_block do |size|
-    setup_block.call(size)
-    GC.start
+def each_size
+  [1 * 2**10, 4 * 2**10, 64 * 2**10, 1 * 2**20, 10 * 2**20, 64 * 2**20].each do |size|
     puts "\n\n#{"=" * 60}\nbenchmark with block size #{to_size(size)}"
-    yield
+    yield Random.bytes(size)
   end
 end
 
-def encode_benchmark(&block)
-  benchmark(
-    lambda { |size| $unencoded = File.open("/dev/urandom") { |f| f.read(size) } },
-    &block
-  )
-end
-
-def decode_benchmark(&block)
-  benchmark(
-    lambda { |size| $encoded = SecureRandom.base64(size) },
-    &block
-  )
-end
-
-encode_benchmark do
-  Benchmark.ips do |x|
-    x.time = 5
-    x.warmup = 2
-
-    x.report("base64 .strict_encode64") do
-      Base64.strict_encode64($unencoded)
-    end
-
-    x.report("ob64 .encode") do
-      Ob64.encode($unencoded)
-    end
-
-    x.compare!
-  end
-end if $run_encode_benchmark
-
-decode_benchmark do
-  Benchmark.ips do |x|
-    x.time = 5
-    x.warmup = 2
-
-    x.report("base64 .strict_decode64") do
-      Base64.strict_decode64($encoded)
-    end
-
-    x.report("ob64 .decode") do
-      Ob64.decode($encoded)
-    end
-
-    x.compare!
-  end
-end if $run_decode_benchmark
-
-encode_benchmark do
+# Compares reports, label => block
+def compare(reports)
+  GC.start
   Benchmark.ips do |x|
     x.time = 5
     x.warmup = 2
 
-    x.report("base64 .urlsafe_encode64") do
-      Base64.urlsafe_encode64($unencoded)
-    end
-
-    x.report("ob64 .urlsafe_encode") do
-      Ob64.urlsafe_encode($unencoded)
-    end
+    reports.each { |label, block| x.report(label, &block) }
 
-    x.compare!
+    x.compare!(order: :baseline)
   end
-end if $run_urlsafe_encode_benchmark
+end
 
-decode_benchmark do
-  Benchmark.ips do |x|
-    x.time = 5
-    x.warmup = 2
+each_size do |bin|
+  m0 = NATIVE_PACK.bind_call([bin], "m0")
+  urlsafe = m0.tr("+/", "-_")
+  m = NATIVE_PACK.bind_call([bin], "m")
 
-    x.report("base64 .urlsafe_decode64") do
-      Base64.urlsafe_decode64($encoded)
-    end
+  compare(
+    "Ruby pack(\"m0\")" => -> { NATIVE_PACK.bind_call([bin], "m0") },
+    "ob64 Base64::RFC4648.encode" => -> { Ob64::Base64::RFC4648.encode(bin) },
+    "ob64 pack(\"m0\")" => -> { [bin].pack("m0") }
+  )
+  compare(
+    "Ruby unpack1(\"m0\")" => -> { NATIVE_UNPACK1.bind_call(m0, "m0") },
+    "ob64 Base64::RFC4648.decode" => -> { Ob64::Base64::RFC4648.decode(m0) },
+    "ob64 unpack1(\"m0\")" => -> { m0.unpack1("m0") }
+  )
+  compare(
+    "Ruby pack(\"m0\").tr" => -> { NATIVE_PACK.bind_call([bin], "m0").tr("+/", "-_") },
+    "ob64 Base64::RFC4648.encode_urlsafe" => -> { Ob64::Base64::RFC4648.encode_urlsafe(bin) }
+  )
+  compare(
+    "Ruby tr.unpack1(\"m0\")" => -> { NATIVE_UNPACK1.bind_call(urlsafe.tr("-_", "+/"), "m0") },
+    "ob64 Base64::RFC4648.decode_urlsafe" => -> { Ob64::Base64::RFC4648.decode_urlsafe(urlsafe) }
+  )
+  compare(
+    "Ruby pack(\"m\")" => -> { NATIVE_PACK.bind_call([bin], "m") },
+    "ob64 Base64::RFC2045.encode" => -> { Ob64::Base64::RFC2045.encode(bin) },
+    "ob64 pack(\"m\")" => -> { [bin].pack("m") }
+  )
+  compare(
+    "Ruby unpack1(\"m\")" => -> { NATIVE_UNPACK1.bind_call(m, "m") },
+    "ob64 Base64::RFC2045.decode" => -> { Ob64::Base64::RFC2045.decode(m) },
+    "ob64 unpack1(\"m\")" => -> { m.unpack1("m") }
+  )
+end if $run_base64_benchmark
 
-    x.report("ob64 .urlsafe_decode") do
-      Ob64.urlsafe_decode($encoded)
-    end
+each_size do |bin|
+  u = NATIVE_PACK.bind_call([bin], "u")
 
-    x.compare!
-  end
-end if $run_urlsafe_decode_benchmark
+  compare(
+    "Ruby pack(\"u\")" => -> { NATIVE_PACK.bind_call([bin], "u") },
+    "ob64 UU.encode" => -> { Ob64::UU.encode(bin) },
+    "ob64 pack(\"u\")" => -> { [bin].pack("u") }
+  )
+  compare(
+    "Ruby unpack1(\"u\")" => -> { NATIVE_UNPACK1.bind_call(u, "u") },
+    "ob64 UU.decode" => -> { Ob64::UU.decode(u) },
+    "ob64 unpack1(\"u\")" => -> { u.unpack1("u") }
+  )
+end if $run_uu_benchmark

data/bin/rake

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/ext/ob64/extconf.rb

@@ -2,46 +2,4 @@
 
 require "mkmf"
 
-def sys(cmd)
-  puts " -- #{cmd}"
-  unless ret = xsystem(cmd)
-    raise "ERROR: '#{cmd}' failed"
-  end
-  ret
-end
-
-def run_cmake(args)
-  pid = Process.spawn("cmake #{args}")
-  Process.waitpid(pid)
-end
-
-if !find_executable("cmake")
-  abort "ERROR: CMake is required to build ob64"
-end
-
-MAKE = find_executable("make") || find_executable("gmake")
-if !MAKE
-  abort "ERROR: make is required to build ob64"
-end
-
-CWD = __dir__
-LIBBASE64_DIR = File.join(CWD, "..", "..", "vendor", "libbase64")
-
-Dir.chdir(LIBBASE64_DIR) do
-  Dir.mkdir("build") unless Dir.exist?("build")
-
-  Dir.chdir("build") do
-    run_cmake(".. -DBUILD_SHARED_LIBS=true -DOPENMP=false")
-    sys(MAKE)
-  end
-
-  $DEFLIBPATH.unshift("#{LIBBASE64_DIR}/build/bin")
-  dir_config("base64", "#{LIBBASE64_DIR}/include", "#{LIBBASE64_DIR}/build/bin")
-end
-
-unless have_library("base64") && have_header("libbase64.h")
-  abort "ERROR: Failed to build libbase64"
-end
-
-dir_config("ob64_ext")
 create_makefile("ob64_ext")

data/ext/ob64/ob64.h

@@ -1,7 +1,9 @@
 #ifndef OB64_H
 #define OB64_H 1
 
-#include "libbase64.h"
+#include "pack_base64.h"
 #include "ruby.h"
 
+void Init_ob64_pack(VALUE mExt);
+
 #endif /* OB64_H */