omnizip 0.4.8-arm-linux → 0.4.10-arm-linux

data/.rubocop.yml

@@ -1,7 +1,15 @@
 # Auto-generated by Cimas: Do not edit it manually!
 # See https://github.com/metanorma/cimas
+#
+# PINNED SNAPSHOT (2026-09-21): the config used to inherit the
+# oss-guides file over HTTPS directly. A remote main that moves under
+# us — combined with CI's fresh dependency resolution — made rubocop
+# behavior change with zero repo-side diffs (the 2026-09-21
+# Metrics/BlockLength + standard-custom CI breakage). The snapshot is
+# refreshed deliberately: refresh with
+#   curl -sL https://raw.githubusercontent.com/riboseinc/oss-guides/main/ci/rubocop.yml -o .rubocop-oss.yml
 inherit_from:
-  - https://raw.githubusercontent.com/riboseinc/oss-guides/main/ci/rubocop.yml
+  - .rubocop-oss.yml
   - .rubocop_todo.yml
 
 # local repo-specific modifications
@@ -10,6 +18,12 @@ inherit_from:
 AllCops:
   NewCops: enable
   TargetRubyVersion: 3.0
+  # rake rust:build clones omnizip-rs under lib/tasks/build (and a
+  # build/ dir may exist at the root) — never lint the vendored
+  # checkout's Ruby files.
+  Exclude:
+    - "build/**/*"
+    - "lib/tasks/build/**/*"
 
 # 7-Zip SDK uses is_char_state? naming convention (IsCharState in C)
 # We keep this naming to match the SDK reference

data/.rubocop_todo.yml

@@ -138,6 +138,13 @@ Metrics/AbcSize:
 # AllowedMethods: refine
 Metrics/BlockLength:
   Max: 81
+  # Merge with the inherited exclusions (oss-guides excludes
+  # spec/**/* here) — a bare Exclude key REPLACES the inherited list,
+  # which un-excluded every spec and re-activated ~190 dormant
+  # offenses under rubocop 1.91 (2026-09-21 CI).
+  inherit_mode:
+    merge:
+      - Exclude
   Exclude:
     - "lib/tasks/platform_gems.rake"
 

data/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- ffi tier — JRuby/TruffleRuby acceleration (leptris-ruby model):
+  the cdylib's C ABI is additionally bound through the `ffi` gem
+  (`FfiLibrary`, same surface as the Fiddle binding), with
+  `Library` dispatching Fiddle → ffi → pure Ruby and
+  `OMNIZIP_BINDING=fiddle|ffi` to force a layer. `ffi` becomes a
+  runtime dependency (JRuby/TruffleRuby bundle it).
+- Owned CI build matrix (windows-11-arm, musl containers, armv7
+  qemu, JRuby ffi gate) replacing the cimas rake job, whose fresh
+  dependency resolution made rubocop break with zero repo-side
+  diffs. The installed-gem smoke reports its binding layer.
+
+### Fixed
+- `Zlib::RLE` is CRuby-only: `require "omnizip"` raised NameError on
+  JRuby (and any engine without CRuby's zlib extension) as soon as
+  the Deflate algorithm loaded. RLE/FIXED strategy constants are now
+  guarded with their spec-defined values (3 and 4). Found by the new
+  JRuby CI leg — the matrix found a bug on day one.
+- RPM archive-tier readiness: the dylib requirement is
+  **0.21.112**, not 0.21.111 — 0.21.111's `./`-stripping was half the
+  fix (the Ruby handler's names are ABSOLUTE, from the header's
+  DIRNAMES/BASENAMES; 0.21.112 normalizes the cpio names to
+  `/usr/…`). The tier spec version-guards accordingly, and with
+  0.21.112 the rpm tier is fully active (list stays Ruby by design;
+  read_entry is accelerated). Ships with the rubocop exclusion for
+  the tier spec that a CI-skipped merge dropped.
+
 ### Added
 - Archive-level tier for every handler: tar, cpio, iso, xar, 7z and
   rar3/4/5 (with `password:` passthrough) route list(names) and

data/Gemfile

@@ -9,7 +9,16 @@ gemspec
 gem "csv"
 gem "rake"
 gem "rspec"
-gem "rubocop"
+# Pinned: CI resolves dependencies fresh (no lockfile), and rubocop
+# 1.91 changed Metrics/BlockLength scoping + plugin loading, which
+# resurrected ~190 dormant spec offenses and crashes on the inherited
+# oss-guides `standard-custom` require. Re-pin after triage upstream.
+gem "rubocop", "1.90.0"
+# rubocop's plugin loader auto-declares this via standard's
+# default_lint_roller_plugin metadata where the gem is present; on
+# runners without it the require crashes rubocop outright. Ship it in
+# the bundle so the load always resolves (its plugin is inert without
+# a .standard.yml).
 gem "rubocop-performance"
 gem "rubocop-rake"
 gem "rubocop-rspec"

data/README.adoc

@@ -38,9 +38,11 @@ automatically — no Rust toolchain, no compilation:
 * arm64-darwin, x86_64-darwin
 * x64-mingw-ucrt, aarch64-mingw-ucrt, x64-mingw32
 
-Everywhere else — including JRuby/TruffleRuby and any platform without
-a binary — the gem stays fully functional on its pure-Ruby core (the
-acceleration is strictly optional). Three escape hatches:
+Everywhere else — including any platform without a binary — the gem
+stays fully functional on its pure-Ruby core (the acceleration is
+strictly optional). JRuby and TruffleRuby get acceleration too
+whenever a cdylib is available: they bind through the bundled `ffi`
+gem (MRI uses stdlib Fiddle). Three escape hatches:
 
 * `OMNIZIP_NO_RUST=1` — force the pure-Ruby core everywhere.
 * `OMNIZIP_FFI_DYLIB=/path/to/libomnizip_ffi` — load a specific build.

data/lib/omnizip/algorithms/deflate/constants.rb

@@ -13,11 +13,13 @@ module Omnizip
         BEST_COMPRESSION = Zlib::BEST_COMPRESSION
         DEFAULT_COMPRESSION = Zlib::DEFAULT_COMPRESSION
 
-        # Compression strategies
+        # Compression strategies. RLE and FIXED are CRuby-only Zlib
+        # constants (JRuby's zlib omits them — found by the JRuby CI
+        # leg); the numeric values are fixed by the zlib spec.
         FILTERED = Zlib::FILTERED
         HUFFMAN_ONLY = Zlib::HUFFMAN_ONLY
-        RLE = Zlib::RLE
-        FIXED = Zlib::FIXED
+        RLE = Zlib.const_defined?(:RLE) ? Zlib::RLE : 3
+        FIXED = Zlib.const_defined?(:FIXED) ? Zlib::FIXED : 4
         DEFAULT_STRATEGY = Zlib::DEFAULT_STRATEGY
 
         # Buffer size for streaming operations

data/lib/omnizip/implementations/rust/archive.rb

@@ -7,64 +7,45 @@ module Omnizip
       # format (auto-detected), list entries, read entry bytes. This is
       # the archive-level tier surface — the Ruby core remains the
       # fallback (the cdylib unavailable ⇒ these raise LibraryMissing
-      # and callers fall back).
+      # and callers fall back). Binding-agnostic: dispatches through
+      # whichever backend loaded (Fiddle on MRI, ffi on
+      # JRuby/TruffleRuby).
       class Archive
         class LibraryMissing < StandardError; end
 
-        # Built lazily inside #initialize: the Fiddle::TYPE_* constants
-        # only resolve after a successful require, and Ruby 4.0 moved
-        # fiddle out of the default gems (same reason
-        # Library.function_table is a method, not a constant).
         def initialize(data, password: nil)
           lib = Library.instance
           raise LibraryMissing, "omnizip-ffi cdylib not loaded" unless lib
 
           @lib = lib
-          funcs = function_table
-          @funcs = funcs.each_with_object({}) do |(key, (name, args, ret)), h|
-            h[key] = lib.bind(name, args, ret)
-          end
-
-          pw = password&.to_s
-          pw_ptr = pw && !pw.empty? ? Fiddle::Pointer[pw] : nil
-          @handle = @funcs[:arch_open].call(Fiddle::Pointer[data], data.bytesize, pw_ptr)
-          return unless @handle.null?
-
-          raise Error, @lib.last_error
+          @handle = @lib.arch_open(data, password)
         end
 
         def entry_count
-          @funcs[:arch_count].call(@handle)
+          @lib.arch_count(@handle)
         end
 
         def entry_names
           (0...entry_count).map do |i|
-            ptr = @funcs[:arch_entry_name].call(@handle, i)
-            next nil if ptr.null?
-
-            ptr.to_s
+            @lib.arch_entry_name(@handle, i)
           end
         end
 
         def entry_size(index)
-          @funcs[:arch_entry_size].call(@handle, index)
+          @lib.arch_entry_size(@handle, index)
         end
 
         # Read one entry's uncompressed bytes.
         #
         # @return [String] binary
         def read_entry(index)
-          out_len = [0].pack("Q")
-          ptr = @funcs[:arch_read_entry].call(@handle, index, out_len)
-          raise Error, @lib.last_error if ptr.null?
-
-          @lib.take_buffer(ptr, out_len.unpack1("Q"))
+          @lib.arch_read_entry(@handle, index)
         end
 
         def close
           return unless @handle
 
-          @funcs[:arch_close].call(@handle)
+          @lib.arch_close(@handle)
           @handle = nil
         end
 
@@ -74,19 +55,6 @@ module Omnizip
         ensure
           archive&.close
         end
-
-        private
-
-        def function_table
-          {
-            arch_open: ["ozip_arch_open", %i[voidp size_t voidp], Fiddle::TYPE_VOIDP],
-            arch_count: ["ozip_arch_count", [:voidp], Fiddle::TYPE_SIZE_T],
-            arch_entry_name: ["ozip_arch_entry_name", %i[voidp size_t], Fiddle::TYPE_VOIDP],
-            arch_entry_size: ["ozip_arch_entry_size", %i[voidp size_t], Fiddle::TYPE_VOIDP],
-            arch_read_entry: ["ozip_arch_read_entry", %i[voidp size_t voidp], Fiddle::TYPE_VOIDP],
-            arch_close: ["ozip_arch_close", [:voidp], Fiddle::TYPE_VOID],
-          }
-        end
       end
     end
   end

data/lib/omnizip/implementations/rust/ffi_library.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Implementations
+    module Rust
+      # The ffi-gem binding of the cdylib's C ABI — the JRuby /
+      # TruffleRuby acceleration path (leptris-ruby's model): those
+      # engines ship no Fiddle, so the Fiddle tier cannot load.
+      # Mirrors FiddleLibrary's public surface exactly, so the Library
+      # facade and the Archive class are binding-agnostic.
+      class FfiLibrary
+        attr_reader :mod
+
+        # Attach via a fresh module: FFI::Library is an extend-time
+        # DSL — one module per loaded image, like one Fiddle::Handle.
+        def self.attach(path)
+          mod = Module.new do
+            extend ::FFI::Library
+
+            ffi_lib path.to_s
+          end
+          mod.attach_function :ozip_compress,
+                              %i[string buffer_in size_t int pointer], :pointer
+          mod.attach_function :ozip_decompress,
+                              %i[string buffer_in size_t size_t pointer], :pointer
+          mod.attach_function :ozip_last_error, [], :pointer
+          mod.attach_function :ozip_free, %i[pointer size_t], :void
+          mod.attach_function :ozip_version, [], :pointer
+          mod.attach_function :ozip_arch_open,
+                              %i[buffer_in size_t string], :pointer
+          mod.attach_function :ozip_arch_count, [:pointer], :size_t
+          mod.attach_function :ozip_arch_entry_name,
+                              %i[pointer size_t], :pointer
+          mod.attach_function :ozip_arch_entry_size,
+                              %i[pointer size_t], :uint64
+          mod.attach_function :ozip_arch_read_entry,
+                              %i[pointer size_t pointer], :pointer
+          mod.attach_function :ozip_arch_close, [:pointer], :void
+          mod
+        end
+
+        def initialize(path)
+          @mod = self.class.attach(path)
+        end
+
+        def compress(codec, data, level)
+          out_len = ::FFI::MemoryPointer.new(:size_t)
+          ptr = mod.ozip_compress(codec, data, data.bytesize, level, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.read_ulong)
+        end
+
+        def decompress(codec, data, expected_len)
+          out_len = ::FFI::MemoryPointer.new(:size_t)
+          ptr = mod.ozip_decompress(codec, data, data.bytesize,
+                                    expected_len, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.read_ulong)
+        end
+
+        def last_error
+          ptr = mod.ozip_last_error
+          ptr.null? ? "unknown error" : ptr.read_string
+        end
+
+        # Copy out + free one returned buffer: the buffer belongs to
+        # the Rust allocator and must never outlive ozip_free.
+        def take(ptr, len)
+          s = ptr.read_string(len)
+          mod.ozip_free(ptr, len)
+          s
+        end
+
+        def take_buffer(ptr, len)
+          take(ptr, len)
+        end
+
+        # The Rust release this cdylib was built from, or nil when the
+        # symbol is absent (dylibs older than 0.21.109).
+        def dylib_version
+          ptr = mod.ozip_version
+          ptr.null? ? nil : ptr.read_string
+        rescue ::FFI::NotFoundError
+          nil
+        end
+
+        # ---- whole-archive surface (ArchHandle) ----
+        # FFI auto-converts a Ruby String for a :pointer argument and
+        # nil to NULL, and the handle travels as a naked pointer.
+
+        def arch_open(data, password)
+          ptr = mod.ozip_arch_open(data, data.bytesize, password)
+          raise Rust::Error, last_error if ptr.null?
+
+          ptr
+        end
+
+        def arch_count(handle)
+          mod.ozip_arch_count(handle)
+        end
+
+        def arch_entry_name(handle, index)
+          ptr = mod.ozip_arch_entry_name(handle, index)
+          ptr.null? ? nil : ptr.read_string
+        end
+
+        def arch_entry_size(handle, index)
+          mod.ozip_arch_entry_size(handle, index)
+        end
+
+        def arch_read_entry(handle, index)
+          out_len = ::FFI::MemoryPointer.new(:size_t)
+          ptr = mod.ozip_arch_read_entry(handle, index, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.read_ulong)
+        end
+
+        def arch_close(handle)
+          mod.ozip_arch_close(handle)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/implementations/rust/fiddle_library.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Implementations
+    module Rust
+      # The Fiddle binding of the cdylib's C ABI — the MRI fast path
+      # (stdlib, zero gems). One public surface shared with
+      # FfiLibrary: codec methods, whole-archive methods, error and
+      # version accessors — the binding Library's facade and the
+      # Archive class dispatch through.
+      class FiddleLibrary
+        attr_reader :handle
+
+        # The shared function table (Fiddle::TYPE_* constants resolve
+        # only after a successful require — same reason Library keeps
+        # this out of the class body).
+        FUNCTION_TABLE = lambda {
+          {
+            last_error: ["ozip_last_error", [], Fiddle::TYPE_VOIDP],
+            free: ["ozip_free", %i[voidp size_t], Fiddle::TYPE_VOID],
+            compress: [
+              "ozip_compress",
+              %i[voidp voidp size_t int voidp],
+              Fiddle::TYPE_VOIDP,
+            ],
+            decompress: [
+              "ozip_decompress",
+              %i[voidp voidp size_t size_t voidp],
+              Fiddle::TYPE_VOIDP,
+            ],
+          }
+        }
+
+        FIDDLE_ARG_TYPES = {
+          pointer: ->(v) { v.nil? ? nil : Fiddle::Pointer[v] },
+        }.freeze
+        FIDDLE_RET_TYPES = {
+          pointer: Fiddle::TYPE_VOIDP,
+          void: Fiddle::TYPE_VOID,
+          size_t: Fiddle::TYPE_SIZE_T,
+          uint64: Fiddle::TYPE_VOIDP,
+        }.freeze
+
+        def initialize(path)
+          @handle = Fiddle.dlopen(path.to_s)
+          @funcs = FUNCTION_TABLE.call.each_with_object({}) do |(key, (name, args, ret)), h|
+            h[key] = Fiddle::Function.new(@handle[name], args, ret)
+          end
+        end
+
+        def compress(codec, data, level)
+          out_len = [0].pack("Q")
+          ptr = @funcs[:compress].call(codec, data, data.bytesize, level, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.unpack1("Q"))
+        end
+
+        def decompress(codec, data, expected_len)
+          out_len = [0].pack("Q")
+          ptr = @funcs[:decompress].call(codec, data, data.bytesize, expected_len, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.unpack1("Q"))
+        end
+
+        def last_error
+          ptr = @funcs[:last_error].call
+          ptr.null? ? "unknown error" : ptr.to_s
+        end
+
+        # Copy out + free one returned buffer: the buffer belongs to
+        # the Rust allocator and must never outlive ozip_free.
+        def take(ptr, len)
+          s = ptr.to_s(len)
+          @funcs[:free].call(ptr, len)
+          s
+        end
+
+        def take_buffer(ptr, len)
+          take(ptr, len)
+        end
+
+        # The Rust release this cdylib was built from, or nil when the
+        # symbol is absent (dylibs older than 0.21.109).
+        def dylib_version
+          func = Fiddle::Function.new(@handle["ozip_version"], [], Fiddle::TYPE_VOIDP)
+          ptr = func.call
+          ptr.null? ? nil : ptr.to_s
+        rescue StandardError
+          nil
+        end
+
+        # ---- whole-archive surface (ArchHandle) ----
+
+        def arch_open(data, password)
+          pw = password&.to_s
+          pw_ptr = pw && !pw.empty? ? Fiddle::Pointer[pw] : nil
+          ptr = Fiddle::Function.new(
+            @handle["ozip_arch_open"],
+            %i[voidp size_t voidp],
+            Fiddle::TYPE_VOIDP,
+          ).call(Fiddle::Pointer[data], data.bytesize, pw_ptr)
+          raise Rust::Error, last_error if ptr.null?
+
+          ptr
+        end
+
+        def arch_count(handle)
+          fn = Fiddle::Function.new(@handle["ozip_arch_count"], [:voidp], Fiddle::TYPE_SIZE_T)
+          fn.call(handle)
+        end
+
+        def arch_entry_name(handle, index)
+          ptr = Fiddle::Function.new(
+            @handle["ozip_arch_entry_name"], %i[voidp size_t], Fiddle::TYPE_VOIDP
+          ).call(handle, index)
+          ptr.null? ? nil : ptr.to_s
+        end
+
+        def arch_entry_size(handle, index)
+          Fiddle::Function.new(
+            @handle["ozip_arch_entry_size"], %i[voidp size_t], Fiddle::TYPE_VOIDP
+          ).call(handle, index)
+        end
+
+        def arch_read_entry(handle, index)
+          out_len = [0].pack("Q")
+          ptr = Fiddle::Function.new(
+            @handle["ozip_arch_read_entry"], %i[voidp size_t voidp], Fiddle::TYPE_VOIDP
+          ).call(handle, index, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.unpack1("Q"))
+        end
+
+        def arch_close(handle)
+          Fiddle::Function.new(@handle["ozip_arch_close"], [:voidp], Fiddle::TYPE_VOID)
+            .call(handle)
+        end
+      end
+    end
+  end
+end