omnizip 0.4.1 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06cbc9a2cd22e74a84d82211efa5e000d857da117bae9a995b76520839211362
-  data.tar.gz: e8ab9ec5638953dda59f4b43aa299cfa55262f77d3c9e9f795bbe8800d443592
+  metadata.gz: 34bab2534b75e9ca958c00130c6b5962dbd5422bd6e0f4683c8e756415d9961b
+  data.tar.gz: 9089d88fbe8ce8bda17fecd2a21454db2daa23c86e930b69cf8bb86a495b1ce0
 SHA512:
-  metadata.gz: ecd9426b7a3f0a75c68821ec6c2c4c0f0f4f6f5e5ae7a252dc6e1e4fb9f5eb94a01b84f937c797581b44584e8cc4ba244d35e37c2338b1401c46de42299a1627
-  data.tar.gz: 268f70fb015d2e21b8079cae5ea4e09a83e036e967cf83bed03cc37de45b61f1875547b1443b419eec502a3bcc264e323d19bb8c503f72437cfb47bbd9d31853
+  metadata.gz: d92441da2c757c65e1e5865abd446cd2a296adafcdf56d5dabfc00f6c792fd6f9b8f3e51dda0231ce5d8829eaf4b81662cfdadc13cdbc9495c73d088968c6c81
+  data.tar.gz: 30591da9a2e0af6922a49596133f98e5f05bf30e927b698e4b413c1f9f0d1907ab6f0f9a0cc32eff385772b7445aff36e271066690c85e3a134dd040e8185591

data/CHANGELOG.md

@@ -7,6 +7,23 @@ 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`
+  applied a transform the record does not use. Neither unrar (its
+  recvol5/rs16 cover only the separate .rev volumes) nor any public
+  spec carries the in-archive RAR5 RS parameters, so both paths now
+  raise `NotImplementedError` with par2 guidance, surfaced through
+  `ArchiveRepairer` results. The `ozip repair` counterpart (Rust)
+  ships in omnizip-rs with the same honest contract.
+
 ### Added
 - `rake rust:build` — one command to build and vendor the Rust
   backend's cdylib (clones omnizip-rs or reuses a checkout via

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/rar/parity_handler.rb

@@ -266,10 +266,16 @@ module Omnizip
         # @param parity_data [String] Parity information
         # @return [String, nil] Recovered data
         def recover_with_reed_solomon(_corrupted_data, _parity_data)
-          # Placeholder for Reed-Solomon recovery
-          # Real implementation would use reed-solomon gem
-          # For now, return nil to indicate recovery not available
-          nil
+          # The in-archive RAR5 recovery record's RS parameters exist
+          # only in the proprietary rar binary — unrar carries no
+          # implementation (its recvol5/rs16 cover only the separate
+          # .rev volume feature), and no independent spec is public.
+          # Fail loudly with actionable guidance instead of pretending
+          # recovery happened.
+          raise NotImplementedError,
+                "in-archive RAR5 Reed-Solomon recovery is not implemented " \
+                "(rar-proprietary format); protect archives with external " \
+                "parity (par2) instead"
         end
 
         # Recover data using XOR (RAR4)
@@ -277,14 +283,15 @@ module Omnizip
         # @param corrupted_data [String] Corrupted block
         # @param parity_data [String] Parity information
         # @return [String] Recovered data
-        def recover_with_xor(corrupted_data, parity_data)
-          # Simple XOR recovery
-          result = corrupted_data.bytes.map.with_index do |byte, i|
-            parity_byte = parity_data.bytes[i % parity_data.size]
-            byte ^ parity_byte
-          end
-
-          result.pack("C*")
+        def recover_with_xor(_corrupted_data, _parity_data)
+          # RAR4's integrated recovery record is likewise rar-proprietary
+          # (unrar has no repair path for it either); a cyclic XOR with
+          # arbitrary parity bytes is not the record's actual transform
+          # and would silently fabricate corrupt bytes. Refuse honestly.
+          raise NotImplementedError,
+                "in-archive RAR4 recovery-record repair is not implemented " \
+                "(rar-proprietary format); protect archives with external " \
+                "parity (par2) instead"
         end
       end
     end

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.1"
+  VERSION = "0.4.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-19 00:00:00.000000000 Z
+date: 2026-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64