omnizip 0.4.9-arm-linux → 0.4.11-arm-linux

data/docs/compatibility.adoc

@@ -483,7 +483,7 @@ Zip::File.open('archive.zip') do |zip|
 end
 ----
 
-See link:guides/migration-rubyzip.html[Complete Migration Guide]
+See the migration notes in the Rubyzip compatibility sections of link:../readme-docs/api-usage.adoc[API usage]
 
 === From 7-Zip CLI to Omnizip API
 
@@ -574,6 +574,5 @@ This makes Omnizip ideal for Ruby applications needing advanced compression beyo
 == See Also
 
 * link:getting-started/installation.html[Installation Guide]
-* link:guides/migration-rubyzip.html[Migration from Rubyzip]
 * link:getting-started/quick-start.html[Quick Start Tutorial]
 * link:reference/index.html[API Reference]

data/docs/lychee.toml

@@ -9,12 +9,9 @@ max_cache_age = "1d"
 # Check both source files and built site
 include_verbatim = true
 
-# Recursively check all files
-recursive = true
-
 # File types to check
 include = [
-  "_site/**/*.html"
+  "site/**/*.html"
 ]
 
 # Excluded paths
@@ -46,9 +43,6 @@ user_agent = "lychee/omnizip-docs-link-checker"
 # Check HTTP, HTTPS, and file:// schemes
 scheme = ["https", "http", "file"]
 
-# Include file:// URLs for local link checking
-include_file = true
-
 # Handle different link types
 include_mail = false  # Don't check mailto: links
 

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

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

@@ -11,23 +11,32 @@ end
 module Omnizip
   module Implementations
     module Rust
-      # The loaded cdylib: one handle, lazily opened, thread-safe
-      # after initialization (Fiddle::Function is immutable once
-      # built; compress/decompress are pure C calls).
+      # The loaded cdylib binding: one handle, lazily opened. The
+      # BINDING LAYER is chosen at load (leptris-ruby's model):
+      #
+      #   1. Fiddle (MRI stdlib — the zero-gem fast path)
+      #   2. the ffi gem (JRuby / TruffleRuby ship it bundled; MRI
+      #      without fiddle — Ruby 4.0 without the gem — uses it too)
+      #   3. unavailable (pure-Ruby core everywhere)
+      #
+      # OMNIZIP_BINDING=fiddle|ffi forces a layer (spec seam; also the
+      # way to prove the ffi path on MRI). `instance` returns a
+      # FiddleLibrary or FfiLibrary — both expose the identical
+      # surface (compress / decompress / last_error / take_buffer /
+      # dylib_version / arch_*), so callers are binding-agnostic.
       class Library
-        # Codecs the cdylib dispatches by name.
-        # Names the cdylib dispatches: the codec-level acceleration
-        # surface (both directions by default — Rust is the
-        # authority; Ruby is the fallback).
+        # Codecs the cdylib dispatches by name: the codec-level
+        # acceleration surface (both directions by default — Rust is
+        # the authority; Ruby is the fallback).
         CODECS = %w[
           bzip2 zstd lzma xz lzma-alone lzip
           deflate deflate64 zlib gzip ppmd7 ppmd8
         ].freeze
 
         class << self
-          # The shared handle, or nil when the cdylib cannot load.
-          # Load failures are cached: a missing library is a stable
-          # condition, not something to re-attempt per call.
+          # The shared binding, or nil when no layer can load. Load
+          # failures are cached per layer: a missing library is a
+          # stable condition, not something to re-attempt per call.
           def instance
             return @instance if defined?(@instance)
 
@@ -38,6 +47,13 @@ module Omnizip
             !instance.nil?
           end
 
+          # Which binding loaded: "fiddle", "ffi", or nil.
+          def binding_layer
+            return nil if instance.nil?
+
+            instance.class.name.end_with?("FfiLibrary") ? "ffi" : "fiddle"
+          end
+
           # Whether the cdylib dispatches this codec name — exact, or
           # a param-carrying prefix ("ppmd7:o6:m16777216" under
           # "ppmd7").
@@ -45,7 +61,7 @@ module Omnizip
             CODECS.any? { |c| name == c || name.start_with?("#{c}:") }
           end
 
-          # Drop the cached handle so resolution reruns (test seam:
+          # Drop the cached binding so resolution reruns (test seam:
           # specs exercising fallback/absence paths need a clean
           # slate; production never calls this).
           def forget!
@@ -56,39 +72,12 @@ module Omnizip
             nil
           end
 
-          # Built lazily: the Fiddle::TYPE_* constants only resolve
-          # after a successful require; environments without fiddle
-          # (Ruby 4.0 without the gem) never touch this table.
-          def function_table
-            {
-              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,
-              ],
-            }
-          end
-
           # The Rust release the loaded cdylib was built from (e.g.
-          # "0.21.108"), read through the ozip_version symbol — the
+          # "0.21.112"), read through the ozip_version symbol — the
           # platform-gem smoke gate asserts it matches. nil when the
           # library is absent or predates the symbol.
           def dylib_version
-            handle = instance&.instance_handle
-            return nil if handle.nil?
-
-            func = Fiddle::Function.new(handle["ozip_version"], [], Fiddle::TYPE_VOIDP)
-            ptr = func.call
-            ptr.null? ? nil : ptr.to_s
-          rescue StandardError
-            nil
+            instance&.dylib_version
           end
 
           # Resolve the cdylib path. Precedence:
@@ -133,12 +122,17 @@ module Omnizip
             path = resolve_path
             return nil if path.nil?
 
-            handle = Fiddle.dlopen(path.to_s)
-            funcs = function_table.each_with_object({}) do |(key, (name, args, ret)), h|
-              h[key] = Fiddle::Function.new(handle[name], args, ret)
+            forced = ENV.fetch("OMNIZIP_BINDING", nil)
+            if forced != "ffi" && defined?(Fiddle)
+              return FiddleLibrary.new(path)
             end
-            new(funcs, handle)
-          rescue StandardError => e # includes Fiddle::DLError
+
+            # The ffi path: JRuby/TruffleRuby bundle the gem; MRI
+            # needs it installed (it is a runtime dependency). A
+            # forced layer must not silently fall back to another.
+            require "ffi"
+            FfiLibrary.new(path)
+          rescue LoadError, StandardError => e # Fiddle::DLError, FFI::LoadError, ...
             warn "omnizip: rust backend unavailable (#{e.message}); using pure Ruby" if ENV["OMNIZIP_BACKEND"] == "rust"
             nil
           end
@@ -152,65 +146,6 @@ module Omnizip
             end
           end
         end
-
-        def initialize(functions, handle = nil)
-          @functions = functions.freeze
-          @handle = handle
-        end
-
-        def compress(codec, data, level)
-          out_len = [0].pack("Q")
-          ptr = call(:compress, codec, data, data.bytesize, level, out_len)
-          take(ptr, out_len.unpack1("Q"))
-        end
-
-        def decompress(codec, data, expected_len)
-          out_len = [0].pack("Q")
-          ptr = call(:decompress, codec, data, data.bytesize, expected_len, out_len)
-          take(ptr, out_len.unpack1("Q"))
-        end
-
-        # Bind one extra C symbol from the loaded cdylib (the archive
-        # surface uses this; Fiddle::Function is immutable once built).
-        def bind(symbol, args, ret)
-          handle = instance_handle
-          raise Error, "cdylib not loaded" if handle.nil?
-
-          Fiddle::Function.new(handle[symbol.to_s], args, ret)
-        end
-
-        def last_error
-          ptr = @functions[:last_error].call
-          ptr.null? ? "unknown error" : ptr.to_s
-        end
-
-        # The raw Fiddle::Handle (for extra symbol binds).
-        def instance_handle
-          @handle
-        end
-
-        # Copy out + free one returned buffer (public seam for the
-        # archive surface).
-        def take_buffer(ptr, len)
-          take(ptr, len)
-        end
-
-        private
-
-        def call(name, codec, input, input_len, a, out_len)
-          ptr = @functions[name].call(codec, input, input_len, a, out_len)
-          raise Error, last_error if ptr.null?
-
-          ptr
-        end
-
-        # Copy out + free in one breath: the buffer belongs to the
-        # Rust allocator and must never outlive ozip_free.
-        def take(ptr, len)
-          string = ptr.to_s(len)
-          @functions[:free].call(ptr, len)
-          string
-        end
       end
 
       # Raised when a codec call fails; #message carries the Rust

data/lib/omnizip/implementations/rust.rb

@@ -20,6 +20,8 @@ module Omnizip
     # fallback on any Rust error.
     module Rust
       autoload :Library, "omnizip/implementations/rust/library"
+      autoload :FiddleLibrary, "omnizip/implementations/rust/fiddle_library"
+      autoload :FfiLibrary, "omnizip/implementations/rust/ffi_library"
       autoload :Archive, "omnizip/implementations/rust/archive"
     end
   end

data/lib/omnizip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Omnizip
-  VERSION = "0.4.9"
+  VERSION = "0.4.11"
 end