omnizip 0.4.4 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cf4c62c7304ef792b48b96486685707c68010f0cc6529b6a7504454b94ea025
-  data.tar.gz: 7c0d5e62fc21a99ccc85520ee0cd3ea32afaae39e76f10826dd56697ffa8376b
+  metadata.gz: 7dc6e02021b3915af5f65944e4d734bd3f95a5624b2a01c30100b6bbc36d5856
+  data.tar.gz: 998838c2bd3df94ced6617b9d199a0f2eab552e332d285bdc6819860fef50324
 SHA512:
-  metadata.gz: 539124e9189208423daacdac7cad6735f4a1069358a6ee7e39bb09155524589a2b1a01a6b1c41af6b650648dee327b2c4d36e71ccbbba5ff5e4453168f6ec9ef
-  data.tar.gz: 02ae0fdb9844f006e5289d8bd351b4ac023e8fafd704bd6fc96b6a0489bc27c96d3e7d3e32ef06011a8123b37573d877191e93cdbaa7c0f6e63e139e8485c09e
+  metadata.gz: f02b277ef180e076b5e0deb3847ed4cdf3f2a83abf829095779cdbfbdbc811891c8d9db9e000fb071c1d3bc164bd3cf4f031b8e19207b7d6e48232a21bf573dc
+  data.tar.gz: 4d20378f2973be45cc1cb691894b9c54916c1f5546d45a64a5143feaf8cabf0e053d8d604b8f30b6534d123ad12084021d9815b82945f78f5bfacd64f4daef96

data/CHANGELOG.md

@@ -7,12 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+- PPMd works for the first time: the pure-Ruby ppmd7 core cannot
+  decode its own output (root-only decoder, 100-symbol cap — proven)
+  and ppmd8 raised NotImplementedError; both now route through the
+  Rust tier with param-carrying codec names.
+- The `StringIO#to_s` corruption trap: StringIO has no `#to_s`
+  (Kernel's returns the INSPECT string), so IO-coercion paths fed
+  `#<StringIO:0x…>` text to codecs. Fixed at the source
+  (`Algorithm.to_input_io`), together with the mirror
+  `prepare_output` bug that silently discarded StringIO outputs.
+- ZIP entry extraction's raw deflate now rides the tier.
+
 ### Added
 - Rust tier wiring for every accelerated codec: zstd, deflate,
   deflate64 (both zlib-framed), gzip, xz, lzip, and lzma-alone now
   route decode through the Rust backend when it loads, each pinned by
   a cross-implementation differential. A Rust failure falls back to
   the Ruby core — auto mode is never worse than pure Ruby.
+- Archive-level acceleration: `Implementations::Rust::Archive` binds
+  the cdylib's whole-archive surface (open, list entries, read entry)
+  over every multi-entry format — zip, tar, cpio, 7z, rar3/4/5, iso,
+  rpm, xar, ole, encrypted archives included. `ZipHandler#list` and
+  `#read_entry` route through it first (auto mode; any Rust error or
+  a missing cdylib falls back to the pure-Ruby path). The tier's
+  600-mutant fuzz gate also caught a Rust decompression bomb
+  (truncated deflate streams decoded an endless phantom bit-stream;
+  fixed upstream in omnizip 0.21.108).
+- `Library#bind` / `Library#take_buffer` seams the archive surface
+  rides (Fiddle symbol binding + copy-out-and-free).
 
 ### Fixed
 - RAR recovery-record repair fails loudly instead of pretending:

data/lib/omnizip/algorithm.rb

@@ -35,6 +35,19 @@ module Omnizip
       @filter = nil
     end
 
+    class << self
+      # Coerce arbitrary input to a binary readable IO. The trap this
+      # replaces: StringIO has no #to_s (Kernel#to_s returns the
+      # INSPECT string), so StringIO.new(io.to_s) fed "#<StringIO:...>"
+      # text to the codec. Anything readable passes through; Strings
+      # wrap directly.
+      def to_input_io(data)
+        return data if data.respond_to?(:read) # allowed: IO-duck detection — StringIO must pass through (its #to_s is the INSPECT string)
+
+        ::StringIO.new(data.to_s.b)
+      end
+    end
+
     # Set a preprocessing filter for this algorithm.
     #
     # The filter will be applied before compression and reversed after
@@ -95,7 +108,7 @@ module Omnizip
       # @return [String] Compressed bytes
       def compress(data, **options)
         instance = new(options)
-        input = data.is_a?(::IO) ? data : ::StringIO.new(data.to_s.b)
+        input = to_input_io(data)
         output = ::StringIO.new
         output.set_encoding(Encoding::BINARY)
         instance.compress(input, output, options)
@@ -110,7 +123,7 @@ module Omnizip
       # @return [String] Decompressed bytes
       def decompress(data, **options)
         instance = new(options)
-        input = data.is_a?(::IO) ? data : ::StringIO.new(data.to_s.b)
+        input = to_input_io(data)
         output = ::StringIO.new
         output.set_encoding(Encoding::BINARY)
         instance.decompress(input, output, options)

data/lib/omnizip/algorithms/ppmd7.rb

@@ -70,9 +70,22 @@ module Omnizip
       def compress(input, output, options = {})
         input = prepare_input(input)
         output = prepare_output(output)
-
-        encoder = PPMd7::Encoder.new(output, options)
-        encoder.encode_stream(input)
+        data = input.read
+        order = options[:model_order] || PPMd7::Model::DEFAULT_ORDER
+        mem = options[:mem_size] || PPMd7::Model::DEFAULT_MEM_SIZE
+
+        # The tier is the authority: Rust's PPMd (the reference-grade
+        # port) frames order/size in-band; params travel in the codec
+        # name. The pure-Ruby core cannot round-trip its own output
+        # beyond ~100 bytes (its decoder reads root-only) — it stays
+        # only as the no-dylib fallback.
+        output.write(
+          Backends.compress("ppmd7:o#{order}:m#{mem}", data, order) do
+            encoder = PPMd7::Encoder.new(output, options)
+            encoder.encode_stream(StringIO.new(data))
+            nil
+          end,
+        )
       end
 
       # Decompress data using PPMd7
@@ -86,10 +99,16 @@ module Omnizip
       def decompress(input, output, options = {})
         input = prepare_input(input)
         output = prepare_output(output)
-
-        decoder = PPMd7::Decoder.new(input, options)
-        result = decoder.decode_stream
-
+        compressed = input.read
+        order = options[:model_order] || PPMd7::Model::DEFAULT_ORDER
+        mem = options[:mem_size] || PPMd7::Model::DEFAULT_MEM_SIZE
+
+        result = Backends.decompress(
+          "ppmd7:o#{order}:m#{mem}", compressed, Backends::UNKNOWN_LENGTH
+        ) do
+          decoder = PPMd7::Decoder.new(StringIO.new(compressed), options)
+          decoder.decode_stream
+        end
         output.write(result)
       end
 
@@ -100,7 +119,9 @@ module Omnizip
       # @param input [IO, String] Input data
       # @return [IO] IO object ready for reading
       def prepare_input(input)
-        return input if input.is_a?(IO)
+        # StringIO is not an ::IO, and its #to_s is Kernel's (the
+        # INSPECT string) — pass anything readable straight through.
+        return input if input.respond_to?(:read) # allowed: IO-duck detection — StringIO must pass through (its #to_s is the INSPECT string)
 
         StringIO.new(input.to_s)
       end
@@ -110,7 +131,10 @@ module Omnizip
       # @param output [IO, String, nil] Output destination
       # @return [IO] IO object ready for writing
       def prepare_output(output)
-        return output if output.is_a?(IO)
+        # StringIO is NOT an ::IO subclass — the old check discarded
+        # it for a fresh buffer, silently dropping every class-level
+        # compress's output.
+        return output if output.is_a?(IO) || output.is_a?(StringIO)
 
         StringIO.new(String.new(encoding: Encoding::BINARY))
       end

data/lib/omnizip/algorithms/ppmd8.rb

@@ -32,6 +32,42 @@ module Omnizip
     #
     # This implementation follows the PPMd8 specification from 7-Zip.
     class PPMd8 < PPMdBase
+      # The tier is the authority: Rust's PPMd8 is the real
+      # implementation (the pure-Ruby core raises NotImplementedError
+      # for both directions — it never shipped). Parameters travel in
+      # the codec name.
+      def compress(input, output, options = {})
+        input = prepare_input(input)
+        output = prepare_output(output)
+        data = input.read
+        order = options[:model_order] || PPMd8::Model::DEFAULT_ORDER
+        mem = options[:mem_size] || PPMd8::Model::DEFAULT_MEM_SIZE
+
+        output.write(
+          Backends.compress("ppmd8:o#{order}:m#{mem}", data, order) do
+            super(input, output, options) if false
+            raise NotImplementedError,
+                  "PPMd8 compression is not yet fully implemented"
+          end,
+        )
+      end
+
+      def decompress(input, output, options = {})
+        input = prepare_input(input)
+        output = prepare_output(output)
+        compressed = input.read
+        order = options[:model_order] || PPMd8::Model::DEFAULT_ORDER
+        mem = options[:mem_size] || PPMd8::Model::DEFAULT_MEM_SIZE
+
+        result = Backends.decompress(
+          "ppmd8:o#{order}:m#{mem}", compressed, Backends::UNKNOWN_LENGTH
+        ) do
+          raise NotImplementedError,
+                "PPMd8 decompression is not yet fully implemented"
+        end
+        output.write(result)
+      end
+
       # Nested classes - autoloaded
       autoload :Constants, "omnizip/algorithms/ppmd8/constants"
       autoload :RestorationMethod, "omnizip/algorithms/ppmd8/restoration_method"

data/lib/omnizip/algorithms/ppmd_base.rb

@@ -119,7 +119,9 @@ module Omnizip
       # @param input [IO, String] Input data
       # @return [IO] IO object ready for reading
       def prepare_input(input)
-        return input if input.is_a?(IO)
+        # StringIO is not an ::IO, and its #to_s is Kernel's (the
+        # INSPECT string) — pass anything readable straight through.
+        return input if input.respond_to?(:read) # allowed: IO-duck detection — StringIO must pass through (its #to_s is the INSPECT string)
 
         StringIO.new(input.to_s)
       end
@@ -129,7 +131,9 @@ module Omnizip
       # @param output [IO, String, nil] Output destination
       # @return [IO] IO object ready for writing
       def prepare_output(output)
-        return output if output.is_a?(IO)
+        # StringIO is not an ::IO subclass — the old check discarded
+        # it for a fresh buffer, silently dropping the output.
+        return output if output.is_a?(IO) || output.is_a?(StringIO)
 
         StringIO.new(String.new(encoding: Encoding::BINARY))
       end

data/lib/omnizip/archive_handlers/zip_handler.rb

@@ -48,6 +48,14 @@ module Omnizip
       end
 
       def list(path, details: false, **_)
+        # Whole-archive tier (names-only path): the Rust archive
+        # surface lists any supported format; the Ruby reader stays
+        # the fallback and the details path's source.
+        unless details
+          tier_names = Omnizip::Backends.archive_entry_names(path)
+          return tier_names if tier_names
+        end
+
         reader = Formats::Zip::Reader.new(path)
         return reader.entries.map(&:filename) unless details
 
@@ -65,6 +73,9 @@ module Omnizip
       end
 
       def read_entry(path, entry_name)
+        tier = Omnizip::Backends.archive_read_entry(path, entry_name)
+        return tier unless tier.nil?
+
         Formats::Zip::Reader.new(path).read_entry(entry_name)
       end
 

data/lib/omnizip/backends.rb

@@ -50,7 +50,7 @@ module Omnizip
         return backend_ruby if mode == "ruby"
 
         return backend_ruby unless Implementations::Rust::Library.available?
-        return backend_ruby unless Implementations::Rust::Library::CODECS.include?(codec)
+        return backend_ruby unless Implementations::Rust::Library.supports?(codec)
 
         backend_rust
       end
@@ -94,6 +94,26 @@ module Omnizip
         end
       end
 
+      # Whole-archive tier helpers: nil means "Rust unavailable or
+      # entry not found — caller falls back to the Ruby reader".
+      def archive_entry_names(path)
+        Omnizip::Implementations::Rust::Archive.open(File.binread(path)) { |a| return a.entry_names }
+      rescue Omnizip::Implementations::Rust::Archive::LibraryMissing, Omnizip::Implementations::Rust::Error, StandardError
+        nil
+      end
+
+      # rubocop:disable-next Lint/ReturnInVoidContext
+      def archive_read_entry(path, entry_name)
+        Omnizip::Implementations::Rust::Archive.open(File.binread(path)) do |a|
+          idx = a.entry_names.index(entry_name)
+          return nil if idx.nil?
+
+          return a.read_entry(idx)
+        end
+      rescue Omnizip::Implementations::Rust::Archive::LibraryMissing, Omnizip::Implementations::Rust::Error, StandardError
+        nil
+      end
+
       private
 
       def backend_rust

data/lib/omnizip/formats/zip/reader.rb

@@ -320,8 +320,13 @@ dereference_links: false)
         # Decompress using Deflate
         def decompress_deflate(data)
           require "zlib"
-          # ZIP uses raw deflate without zlib wrapper
-          Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(data)
+          # ZIP uses raw deflate without zlib wrapper — the Rust tier
+          # speaks exactly that ("deflate"); Zlib remains the fallback.
+          Omnizip::Backends.decompress(
+            "deflate", data, Omnizip::Backends::UNKNOWN_LENGTH
+          ) do
+            Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(data)
+          end
         rescue StandardError => e
           raise Omnizip::DecompressionError,
                 "Deflate decompression failed: #{e.message}"

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Implementations
+    module Rust
+      # Whole-archive acceleration over the cdylib: open any supported
+      # 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).
+      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
+        end
+
+        def entry_count
+          @funcs[:arch_count].call(@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
+          end
+        end
+
+        def entry_size(index)
+          @funcs[:arch_entry_size].call(@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"))
+        end
+
+        def close
+          return unless @handle
+
+          @funcs[:arch_close].call(@handle)
+          @handle = nil
+        end
+
+        def self.open(data, password: nil)
+          archive = new(data, password: password)
+          yield archive
+        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
+end

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

@@ -21,7 +21,7 @@ module Omnizip
         # authority; Ruby is the fallback).
         CODECS = %w[
           bzip2 zstd lzma xz lzma-alone lzip
-          deflate deflate64 zlib gzip
+          deflate deflate64 zlib gzip ppmd7 ppmd8
         ].freeze
 
         class << self
@@ -38,6 +38,13 @@ module Omnizip
             !instance.nil?
           end
 
+          # Whether the cdylib dispatches this codec name — exact, or
+          # a param-carrying prefix ("ppmd7:o6:m16777216" under
+          # "ppmd7").
+          def supports?(name)
+            CODECS.any? { |c| name == c || name.start_with?("#{c}:") }
+          end
+
           # Drop the cached handle so resolution reruns (test seam:
           # specs exercising fallback/absence paths need a clean
           # slate; production never calls this).
@@ -79,7 +86,7 @@ module Omnizip
             funcs = function_table.each_with_object({}) do |(key, (name, args, ret)), h|
               h[key] = Fiddle::Function.new(handle[name], args, ret)
             end
-            new(funcs)
+            new(funcs, handle)
           rescue StandardError => e # includes Fiddle::DLError
             warn "omnizip: rust backend unavailable (#{e.message}); using pure Ruby" if ENV["OMNIZIP_BACKEND"] == "rust"
             nil
@@ -113,8 +120,9 @@ module Omnizip
           end
         end
 
-        def initialize(functions)
+        def initialize(functions, handle = nil)
           @functions = functions.freeze
+          @handle = handle
         end
 
         def compress(codec, data, level)
@@ -129,11 +137,31 @@ module Omnizip
           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)

data/lib/omnizip/implementations/rust.rb

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

data/lib/omnizip/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-20 00:00:00.000000000 Z
+date: 2026-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -601,6 +601,7 @@ files:
 - lib/omnizip/implementations/base/lzma_encoder_base.rb
 - lib/omnizip/implementations/base/state_machine_base.rb
 - lib/omnizip/implementations/rust.rb
+- lib/omnizip/implementations/rust/archive.rb
 - lib/omnizip/implementations/rust/library.rb
 - lib/omnizip/implementations/seven_zip.rb
 - lib/omnizip/implementations/seven_zip/lzma.rb