omnizip 0.4.3 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34bab2534b75e9ca958c00130c6b5962dbd5422bd6e0f4683c8e756415d9961b
-  data.tar.gz: 9089d88fbe8ce8bda17fecd2a21454db2daa23c86e930b69cf8bb86a495b1ce0
+  metadata.gz: 5a55c37209e986f7e4499e8a485163728e9c8f0dff506e1aa852672a9585653f
+  data.tar.gz: ba0b5437026feed4c1fe4d0ab0146f868386ebe2284ec7b08b45c7260930d582
 SHA512:
-  metadata.gz: d92441da2c757c65e1e5865abd446cd2a296adafcdf56d5dabfc00f6c792fd6f9b8f3e51dda0231ce5d8829eaf4b81662cfdadc13cdbc9495c73d088968c6c81
-  data.tar.gz: 30591da9a2e0af6922a49596133f98e5f05bf30e927b698e4b413c1f9f0d1907ab6f0f9a0cc32eff385772b7445aff36e271066690c85e3a134dd040e8185591
+  metadata.gz: 13d25032be26ccd096718846ac74126fd14ab3e2729d1e9ed366a3c431815b69c0817e33092f214eea4ed041e41e2eebe070ac92862bd54c70b0379017281637
+  data.tar.gz: 8e68e9a4a0d7f489be9956baf6f2d18bb82d5cc0db123adaf689ab73aefca1dcb44c0172a8e774c0cbcfbcca2927c9f40b62da184678588e084642b3b86cd7eb

data/CHANGELOG.md

@@ -7,6 +7,18 @@ 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

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/deflate.rb

@@ -68,8 +68,13 @@ module Omnizip
       # @return [void]
       def compress(input_stream, output_stream, options = nil)
         input_data = input_stream.read
-        encoder = Encoder.new(output_stream, build_encoder_options(options))
-        encoder.encode_stream(input_data)
+        level = build_encoder_options(options)[:level] || 6
+        output_stream.write(
+          Backends.compress("zlib", input_data, level) do
+            encoder = Encoder.new(output_stream, build_encoder_options(options))
+            encoder.encode_stream(input_data)
+          end,
+        )
       end
 
       # Decompress Deflate-compressed data

data/lib/omnizip/algorithms/deflate64.rb

@@ -42,21 +42,22 @@ module Omnizip
       # @param options [Hash] Compression options
       # @option options [Integer] :level Compression level (1-9)
       def compress(input, output, options = {})
-        level = options[:level] || Zlib::DEFAULT_COMPRESSION
-
+        raw_level = options[:level] || Zlib::DEFAULT_COMPRESSION
         data = input.read
         return if data.nil? || data.empty?
 
-        # Use Zlib::Deflate with maximum window size
-        deflater = Zlib::Deflate.new(
-          level,
-          Zlib::MAX_WBITS, # Maximum window size
-          Zlib::MAX_MEM_LEVEL,
-        )
-
-        compressed = deflater.deflate(data, Zlib::FINISH)
-        deflater.close
-
+        # Zlib::DEFAULT_COMPRESSION (-1) maps to the FFI's 6.
+        level = raw_level.negative? ? 6 : raw_level.clamp(0, 9)
+        compressed = Backends.compress("zlib", data, level) do
+          deflater = Zlib::Deflate.new(
+            raw_level,
+            Zlib::MAX_WBITS,
+            Zlib::MAX_MEM_LEVEL,
+          )
+          result = deflater.deflate(data, Zlib::FINISH)
+          deflater.close
+          result
+        end
         output.write(compressed)
       end
 

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/algorithms/zstandard.rb

@@ -86,8 +86,13 @@ module Omnizip
       # @return [void]
       def compress(input_stream, output_stream, options = nil)
         input_data = input_stream.read
-        encoder = Encoder.new(output_stream, build_encoder_options(options))
-        encoder.encode_stream(input_data)
+        level = build_encoder_options(options)[:level] || 3
+        output_stream.write(
+          Backends.compress("zstd", input_data, level) do
+            encoder = Encoder.new(output_stream, build_encoder_options(options))
+            encoder.encode_stream(input_data)
+          end,
+        )
       end
 
       # Decompress Zstandard-compressed data

data/lib/omnizip/backends.rb

@@ -27,38 +27,51 @@ module Omnizip
   #     over frame stability.
   module Backends
     # Codecs whose Rust encoder is BYTE-IDENTICAL to the pure-Ruby
-    # encoder (empirical, differential-corpus-proven). 2026-09-19
-    # probe: bzip2 L6 on a 50 KB corpus => Ruby 906 B vs Rust 874 B —
-    # DIFFERENT valid streams. No codec qualifies; encode stays
-    # pure-Ruby under :auto so downstream content addressing never
-    # sees tier-dependent bytes. Force with OMNIZIP_BACKEND=rust.
-    RUST_ENCODE_IDENTICAL = {}.freeze
+    # 2026-09-20 policy flip (owner directive): RUST IS THE AUTHORITY
+    # — its encoders/decoders are the ports validated against the
+    # reference C/C++ implementations (bzip2, xz/liblzma, zstd,
+    # libdeflate), and they are determinism-contracted (same input +
+    # level => same bytes on every machine). :auto therefore routes
+    # BOTH directions through Rust whenever the cdylib loads; encode
+    # falls back to the Ruby core on any Rust error, so :auto is
+    # never worse than pure Ruby. The pure-Ruby cores remain the
+    # portable fallback and the OMNIZIP_BACKEND=ruby escape hatch.
+    RUST_AUTHORITATIVE = true
 
     # usize::MAX — the FFI's "caller does not know the plaintext
     # size" sentinel (streaming decode contract).
     UNKNOWN_LENGTH = 0xFFFF_FFFF_FFFF_FFFF
 
     class << self
-      def for(codec, direction)
+      def for(codec, _direction)
         mode = ENV.fetch("OMNIZIP_BACKEND", "auto")
 
         return backend_rust if mode == "rust"
         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)
 
-        direction == :encode && !RUST_ENCODE_IDENTICAL.fetch(codec, false) ? backend_ruby : backend_rust
+        backend_rust
       end
 
       # Compress through the tier-selected backend. The block is
       # the pure-Ruby core — evaluated ONLY on the Ruby path, so
-      # the accelerated path never pays for it.
+      # the accelerated path never pays for it. A Rust encode error
+      # falls back to the Ruby core (auto is never worse than pure
+      # Ruby); only the forced `rust` mode propagates.
       def compress(codec, data, level, &ruby_core)
         backend = Backends.for(codec, :encode)
         return yield if backend == RubyBackend
 
-        backend.compress(codec, data, level)
+        begin
+          backend.compress(codec, data, level)
+        rescue Implementations::Rust::Error => e
+          raise if ENV.fetch("OMNIZIP_BACKEND", "auto") == "rust"
+
+          warn "omnizip: rust #{codec} encode failed (#{e.message}); using ruby" if ENV["OMNIZIP_BACKEND_DEBUG"]
+          yield
+        end
       end
 
       # Decompress through the tier-selected backend (output-

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/library.rb

@@ -16,12 +16,12 @@ module Omnizip
       # built; compress/decompress are pure C calls).
       class Library
         # Codecs the cdylib dispatches by name.
-        # Names the cdylib dispatches: the codec-level acceleration surface
-        # (decode tier by default; encode only under forced rust mode —
-        # RUST_ENCODE_IDENTICAL gates the auto tier).
+        # Names the cdylib dispatches: 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
+          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).

data/lib/omnizip/implementations/rust.rb

@@ -13,11 +13,11 @@ module Omnizip
     #   1. ENV['OMNIZIP_FFI_DYLIB'] (explicit path)
     #   2. ../target/release/ inside a sibling omnizip-rs checkout
     #
-    # Tier policy (see Omnizip::Backends): decode is always
-    # output-invariant, so `auto` uses Rust for decode whenever
-    # available; encode uses Rust only when byte-identity with the
-    # pure-Ruby encoder has been verified for that codec
-    # (RUST_ENCODE_IDENTICAL), keeping content addressing stable.
+    # Tier policy (see Omnizip::Backends): Rust is the authority —
+    # validated against the reference C/C++ implementations and
+    # determinism-contracted — so `auto` routes BOTH directions
+    # through Rust whenever the library loads, with Ruby-core
+    # fallback on any Rust error.
     module Rust
       autoload :Library, "omnizip/implementations/rust/library"
     end

data/lib/omnizip/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.5
 platform: ruby
 authors:
 - Ribose Inc.