omnizip 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48ed1a8b9fa1d9c51d338c611430fbd78f12de0a9d5d9de3ebff23ac3b9b767c
-  data.tar.gz: 6b173fab258e290030227c869b703631023c621699e810753259b14ef613ef34
+  metadata.gz: 34bab2534b75e9ca958c00130c6b5962dbd5422bd6e0f4683c8e756415d9961b
+  data.tar.gz: 9089d88fbe8ce8bda17fecd2a21454db2daa23c86e930b69cf8bb86a495b1ce0
 SHA512:
-  metadata.gz: 07fba2b58cca8f0c0429042e4a2813d5618158cb8231625ad1e6f5c32d1bc532d45a8bb952a3087d6274862647dbab0480aca8c96561f24c5a3debf2a1f7dd63
-  data.tar.gz: 8422215bde30fa926b235b20dddbeba195573a82d1678ea98d541be6e37e6e14c7a6ae444e53b1a4505733a6420a4d9d3a53cec3605c751c5bf6eac49678ef86
+  metadata.gz: d92441da2c757c65e1e5865abd446cd2a296adafcdf56d5dabfc00f6c792fd6f9b8f3e51dda0231ce5d8829eaf4b81662cfdadc13cdbc9495c73d088968c6c81
+  data.tar.gz: 30591da9a2e0af6922a49596133f98e5f05bf30e927b698e4b413c1f9f0d1907ab6f0f9a0cc32eff385772b7445aff36e271066690c85e3a134dd040e8185591

data/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### 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.
+
 ### Fixed
 - RAR recovery-record repair fails loudly instead of pretending:
   `recover_with_reed_solomon` returned nil and `recover_with_xor`

data/lib/omnizip/algorithms/deflate.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "stringio"
+
 # Copyright (C) 2025 Ribose Inc.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
@@ -78,8 +80,12 @@ module Omnizip
       # @return [void]
       def decompress(input_stream, output_stream, _options = nil)
         output_stream.set_encoding(Encoding::BINARY)
-        decoder = Decoder.new(input_stream)
-        decompressed = decoder.decode_stream
+        compressed = input_stream.read
+        # The encoder's streams carry the zlib wrapper (RFC 1950) —
+        # the Rust "zlib" name speaks exactly that framing.
+        decompressed = Backends.decompress("zlib", compressed, Backends::UNKNOWN_LENGTH) do
+          Decoder.new(StringIO.new(compressed)).decode_stream
+        end
         output_stream.write(decompressed)
       end
 

data/lib/omnizip/algorithms/deflate64.rb

@@ -73,10 +73,15 @@ module Omnizip
         output.set_encoding(Encoding::BINARY)
         output.binmode
 
-        # Use Zlib::Inflate with maximum window size
-        inflater = Zlib::Inflate.new(Zlib::MAX_WBITS)
-        decompressed = inflater.inflate(compressed)
-        inflater.close
+        # The streams this algorithm produces/consumes are zlib
+        # containers (RFC 1950); the Rust "zlib" name speaks exactly
+        # that, so the tier swap is byte-transparent.
+        decompressed = Backends.decompress("zlib", compressed, Backends::UNKNOWN_LENGTH) do
+          inflater = Zlib::Inflate.new(Zlib::MAX_WBITS)
+          result = inflater.inflate(compressed)
+          inflater.close
+          result
+        end
 
         # Force binary encoding to match original data
         decompressed.force_encoding(Encoding::BINARY)

data/lib/omnizip/algorithms/zstandard.rb

@@ -98,8 +98,10 @@ module Omnizip
       # @return [void]
       def decompress(input_stream, output_stream, _options = nil)
         output_stream.set_encoding(Encoding::BINARY)
-        decoder = Decoder.new(input_stream)
-        decompressed = decoder.decode_stream
+        compressed = input_stream.read
+        decompressed = Backends.decompress("zstd", compressed, Backends::UNKNOWN_LENGTH) do
+          Decoder.new(StringIO.new(compressed)).decode_stream
+        end
         output_stream.write(decompressed)
       end
 

data/lib/omnizip/backends.rb

@@ -62,12 +62,23 @@ module Omnizip
       end
 
       # Decompress through the tier-selected backend (output-
-      # invariant: :auto prefers Rust whenever loadable).
+      # invariant: :auto prefers Rust whenever loadable). A Rust
+      # failure falls back to the Ruby core — the Ruby readers are
+      # the tolerant superset (legacy container variants, malformed
+      # inputs they historically accept), so :auto must never be
+      # WORSE than pure Ruby. Only the forced `rust` mode propagates.
       def decompress(codec, data, expected_len, &ruby_core)
         backend = Backends.for(codec, :decode)
         return yield if backend == RubyBackend
 
-        backend.decompress(codec, data, expected_len)
+        begin
+          backend.decompress(codec, data, expected_len)
+        rescue Implementations::Rust::Error => e
+          raise if ENV.fetch("OMNIZIP_BACKEND", "auto") == "rust"
+
+          warn "omnizip: rust #{codec} decode failed (#{e.message}); using ruby" if ENV["OMNIZIP_BACKEND_DEBUG"]
+          yield
+        end
       end
 
       private

data/lib/omnizip/formats/gzip.rb

@@ -91,18 +91,15 @@ module Omnizip
           # Write GZIP header
           write_header(output_io, mtime, original_name)
 
-          # Compress data with Deflate
-          deflate = Zlib::Deflate.new(
-            level,
-            Zlib::MAX_WBITS + 16, # Use GZIP wrapper
-          )
-          compressed = deflate.deflate(input_data, Zlib::FINISH)
+          # RFC 1952 member: header + RAW deflate + CRC32/ISIZE footer.
+          # The old implementation layered zlib's own GZIP wrapper
+          # under this header (a second 1F 8B magic) — the gem's
+          # reader tolerated it, but every standard gzip tool
+          # rejected the output. Raw-window mode emits bare DEFLATE.
+          deflate = Zlib::Deflate.new(level, -Zlib::MAX_WBITS)
+          output_io.write(deflate.deflate(input_data, Zlib::FINISH))
           deflate.close
 
-          # Extract just the compressed data (remove zlib's GZIP wrapper)
-          # We'll write our own footer
-          output_io.write(compressed[0...-8]) if compressed.bytesize > 8
-
           # Write GZIP footer
           write_footer(output_io, input_data)
         end
@@ -113,15 +110,27 @@ module Omnizip
         # @param output_io [IO] Output stream
         # @return [Hash] Metadata (original_name, mtime)
         def decompress_stream(input_io, output_io)
-          # Read and parse header
-          metadata = read_header(input_io)
-
-          # Decompress with Deflate
-          inflate = Zlib::Inflate.new(Zlib::MAX_WBITS + 16)
-          decompressed = inflate.inflate(input_io.read)
-          inflate.close
+          data = input_io.read
+
+          # Metadata comes from the header either way (cheap parse).
+          metadata = read_header(StringIO.new(data))
+
+          # The tier gets the WHOLE member (header + deflate + trailer)
+          # — the Rust "gzip" name decodes the container end-to-end.
+          decompressed = Backends.decompress("gzip", data, Backends::UNKNOWN_LENGTH) do
+            body = StringIO.new(data)
+            read_header(body) # skip past the header
+            # Legacy double-header members (written before the RFC
+            # 1952 fix) carry zlib's own 10-byte GZIP header here;
+            # standard members carry bare DEFLATE.
+            rest = body.read
+            rest = rest.byteslice(10..) if rest.byteslice(0, 2) == "\x1F\x8B".b
+            inflate = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+            result = inflate.inflate(rest)
+            inflate.close
+            result
+          end
 
-          # Write decompressed data
           output_io.write(decompressed)
 
           metadata

data/lib/omnizip/formats/xz.rb

@@ -89,11 +89,17 @@ module Omnizip
 
           case format
           when :lz
-            decode_lzip(data)
+            Backends.decompress("lzip", data, Backends::UNKNOWN_LENGTH) do
+              decode_lzip(data)
+            end
           when :lzma_alone
-            decode_lzma_alone(data)
+            Backends.decompress("lzma-alone", data, Backends::UNKNOWN_LENGTH) do
+              decode_lzma_alone(data)
+            end
           when :xz
-            decode_xz_stream(data)
+            Backends.decompress("xz", data, Backends::UNKNOWN_LENGTH) do
+              decode_xz_stream(data)
+            end
           else
             raise FormatError, "Unknown LZMA format: cannot detect valid format"
           end

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

@@ -16,7 +16,13 @@ module Omnizip
       # built; compress/decompress are pure C calls).
       class Library
         # Codecs the cdylib dispatches by name.
-        CODECS = %w[bzip2 zstd lzma xz].freeze
+        # 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).
+        CODECS = %w[
+          bzip2 zstd lzma xz lzma-alone lzip
+          deflate deflate64 zlib gzip
+        ].freeze
 
         class << self
           # The shared handle, or nil when the cdylib cannot load.
@@ -36,7 +42,10 @@ module Omnizip
           # specs exercising fallback/absence paths need a clean
           # slate; production never calls this).
           def forget!
-            @instance = nil if defined?(@instance)
+            # Remove the ivar entirely: assigning nil would leave it
+            # defined, and `instance`'s `defined?` guard would return
+            # the nil forever without ever re-opening the library.
+            remove_instance_variable(:@instance) if defined?(@instance)
             nil
           end
 

data/lib/omnizip/version.rb

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

metadata

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