omnizip 0.3.42 → 0.3.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 060755f6c69bca46bcb999d0d36471045ae3d13e260cfa3c73601a8d440b1634
-  data.tar.gz: b524b77c579c824009821ca5d1bdb47327cfc55f3ebd1dab4ea8574d1ec3c631
+  metadata.gz: 358c03758aa086cbb4f3a22845af9f309542df3c272fc640faaaf807d3b2adb0
+  data.tar.gz: 96c8735854c4413b2cb802611eb7acd2d4480d1983b5dd4e4e4a45ebf35d3725
 SHA512:
-  metadata.gz: 237f14e0c479844a473d1830e956882a0d250f6c733522bcd9f3d36b7ba10b474b4564902791aecd52948ad330b82bb0bb7e61dd97db607bf3dcd85ab3dc847b
-  data.tar.gz: cfe4637c8ad1223ccb8b9735fc1494d61937b636f3d79dd7fbd2c1f59f6f35eb38686152ee56732f0cb29cfbf3c12f7ddfb6dae5bd6c146b8d833fca5315a00a
+  metadata.gz: 67ab99068276c2eef687be2d7497c911cdb96f920dea552b9392fe860cbc805345c8bf87f5f6640934b09d46b7fc3c598c8bb140a296f37395d2020ff9e0bbd6
+  data.tar.gz: 256599715a8f9aa94ee2e94376122a6571b8a7eb0e80548b74e57f14d2d2522a12fc6f3b5566f08c3b6a63692b06e3845a3d8948dfdf24fc53f22d79eebd434d

data/CHANGELOG.md

@@ -7,6 +7,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.43] - 2026-08-29
+
+### Changed
+- Reader invariant, library-wide: `Formats::SevenZip::Reader` and
+  `Formats::Rar::Reader` parse on first use, so `list_files`/
+  `extract_entry`/`extract_all` no longer silently operate on empty
+  entries when `#open` was not called first. "A reader is always
+  usable" is recorded in `CONTEXT.md`; `#open` remains for eager
+  loading. New specs pin the behavior for both readers.
+- 7z entries in single-stream folders report their exact
+  `compressed_size` (folder pack sizes were parsed but never mapped
+  onto entries); solid folders share packed bytes across streams, so
+  those entries keep nil rather than a fabricated split.
+
+## [0.3.42] - 2026-08-29
+
+### Changed
+- `Formats::Zip::Reader` is usable immediately: entries parse on
+  first use, so `extract_all`/listing no longer silently do nothing
+  when `#read` was not called first. `#read` remains for eager
+  loading.
+- `Temp::ArchiveHelper` writes zips through the native
+  `Formats::Zip::Writer` instead of the rubyzip-compat
+  `Omnizip::Zip::File` seam (the Metadata subsystem remains on
+  compat deliberately as an in-place central-directory editor).
+- The RAR extraction spill cache installs an `at_exit` sweeper on
+  first use, reclaiming spill directories at normal process exit.
+- Module docs tell the truth: `Formats::Rar` claimed read-only with
+  external tools required; `Formats::Iso` claimed read-only while
+  carrying the verified writer. New `CONTEXT.md` records the domain
+  glossary (primary parser vs adapters, native vs external decode,
+  interop-verified vs Omnizip-internal codecs, handler routes, the
+  compat seam, bridges).
+
 ## [0.3.41] - 2026-08-29
 
 ### Changed

data/CONTEXT.md

@@ -19,7 +19,11 @@ here.
   extract/list/read. `.rar`, `.cpio`, `.iso` are read-only routes;
   creating them raises truthfully.
 
-## Reading and decoding
+## Reading and decode
+
+- **Reader invariant — always usable** — every Reader
+  (`Formats::Zip`, `Formats::SevenZip`, `Formats::Rar`) parses on
+  first use; calling `#open` first is never required, only eager.
 
 - **Native decode** — decompression implemented in Ruby inside
   omnizip. RAR native decode is **CRC-gated**: the stored header CRC

data/lib/omnizip/cli.rb

@@ -344,6 +344,17 @@ module Omnizip
     rescue StandardError => e
       handle_error(e)
     end
+
+    desc "verify ARCHIVE", "Verify archive integrity"
+    long_desc <<~DESC
+      Verify the integrity of an archive (currently RAR archives via
+      header and recovery-record checks).
+    DESC
+    def verify(archive)
+      Omnizip::Commands::ArchiveVerifyCommand.new(options).run(archive)
+    rescue StandardError => e
+      handle_error(e)
+    end
   end
 
   # Command-line interface for Omnizip.

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

@@ -12,7 +12,7 @@ module Omnizip
       class Reader
         include Omnizip::Formats::Rar::Constants
 
-        attr_reader :file_path, :header, :entries, :archive_info,
+        attr_reader :file_path, :header, :archive_info,
                     :volume_manager
 
         # Initialize reader with file path
@@ -25,6 +25,7 @@ module Omnizip
           @archive_info = Models::RarArchive.new(file_path)
           @volume_manager = VolumeManager.new(file_path)
           @use_native = true # Prefer native decompression
+          @opened = false
         end
 
         # Open and parse RAR archive
@@ -34,14 +35,24 @@ module Omnizip
           File.open(@file_path, "rb") do |io|
             parse_archive(io)
           end
+          @opened = true
           self
         end
 
+        # All entries, parsing on first use — a Reader is always
+        # usable; #open remains for eager loading
+        #
+        # @return [Array<Models::RarEntry>] File entries
+        def entries
+          ensure_open
+          @entries
+        end
+
         # List all files in archive
         #
         # @return [Array<Models::RarEntry>] File entries
         def list_files
-          @entries
+          entries
         end
 
         # Extract file to output path
@@ -51,6 +62,7 @@ module Omnizip
         # @param password [String, nil] Optional password
         # @raise [RuntimeError] if entry not found or extraction fails
         def extract_entry(entry_name, output_path, password: nil)
+          ensure_open
           entry = @entries.find { |e| e.name == entry_name }
           raise "Entry not found: #{entry_name}" unless entry
 
@@ -79,6 +91,7 @@ module Omnizip
         # @param password [String, nil] Optional password
         # @raise [RuntimeError] on extraction error
         def extract_all(output_dir, password: nil)
+          ensure_open
           FileUtils.mkdir_p(output_dir)
 
           # Use decompressor to extract all
@@ -126,6 +139,11 @@ module Omnizip
 
         private
 
+        # Parse the archive once, on demand
+        def ensure_open
+          open unless @opened
+        end
+
         # Parse RAR archive structure
         #
         # @param io [IO] Input stream

data/lib/omnizip/formats/rar.rb

@@ -165,8 +165,8 @@ module Omnizip
         #
         # @param archive_path [String] Path to RAR archive
         # @return [ArchiveVerifier::VerificationResult] Verification result
-        def verify(archive_path)
-          ArchiveVerifier.new(archive_path).verify
+        def verify(archive_path, use_recovery: true)
+          ArchiveVerifier.new(archive_path).verify(use_recovery: use_recovery)
         end
 
         # Repair corrupted archive

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

@@ -28,6 +28,7 @@ module Omnizip
           @offset = options[:offset] || 0
           @solid_cache = {}
           @solid_cache_extracted = {}
+          @opened = false
         end
 
         # Open and parse .7z archive
@@ -79,10 +80,12 @@ module Omnizip
           @split_reader&.volumes || [@file_path]
         end
 
-        # List all files in archive
+        # List all files in archive, parsing on first use — a Reader
+        # is always usable; #open remains for eager loading
         #
         # @return [Array<Models::FileEntry>] File entries
         def list_files
+          ensure_open
           @entries.reject { |e| e.name.nil? || e.name.empty? }
         end
 
@@ -92,6 +95,7 @@ module Omnizip
         # @param output_path [String] Destination path
         # @raise [RuntimeError] if entry not found or extraction fails
         def extract_entry(entry_name, output_path)
+          ensure_open
           # Delegate to split reader if available
           if @split_reader
             @split_reader.extract_entry(entry_name, output_path)
@@ -132,6 +136,7 @@ module Omnizip
         # @param output_dir [String] Destination directory
         # @raise [RuntimeError] on extraction error
         def extract_all(output_dir)
+          ensure_open
           FileUtils.mkdir_p(output_dir)
 
           real_out = File.realpath(output_dir)
@@ -187,6 +192,11 @@ module Omnizip
 
         private
 
+        # Parse the archive once, on demand
+        def ensure_open
+          open unless @opened
+        end
+
         # Parse .7z archive structure
         #
         # @param io [io] Input stream
@@ -236,7 +246,16 @@ module Omnizip
 
           # Parse metadata
           parser = Parser.new(next_header_data)
-          @stream_info, @entries = parse_metadata(parser)
+          begin
+            @stream_info, @entries = parse_metadata(parser)
+          rescue StandardError => e
+            if @headers_decrypted
+              raise "Failed to decrypt headers: incorrect password " \
+                    "or corrupted data (#{e.message})"
+            end
+
+            raise
+          end
 
           # Map entries to their folders/streams
           map_entries_to_streams
@@ -257,11 +276,16 @@ module Omnizip
 
           # Decrypt using password
           encryptor = HeaderEncryptor.new(@password)
-          encryptor.decrypt(
+          decrypted = encryptor.decrypt(
             @encrypted_header.encrypted_data,
             @encrypted_header.salt,
             @encrypted_header.iv,
           )
+          # AES-CBC 'succeeds' with any key and yields garbage; wrong
+          # passwords surface as later header-parse failures, so mark
+          # the archive and translate those into the password error
+          @headers_decrypted = true
+          decrypted
         rescue OpenSSL::Cipher::CipherError => e
           raise "Failed to decrypt headers: incorrect password (#{e.message})"
         end
@@ -393,6 +417,20 @@ module Omnizip
             entry.folder_index = folder_idx
             entry.file_index = i
             entry.size = @stream_info.unpack_sizes[stream_idx] if @stream_info.unpack_sizes[stream_idx]
+
+            # Single-stream folders own their packed bytes outright,
+            # so the entry's compressed size is exact. Solid folders
+            # share packed bytes across streams — leave nil rather
+            # than fabricate a split.
+            num_in_folder = @stream_info.num_unpack_streams_in_folders[folder_idx]
+            if num_in_folder == 1
+              folder = @stream_info.folders[folder_idx]
+              packed = folder.pack_stream_indices.sum do |pi|
+                @stream_info.pack_sizes[pi] || 0
+              end
+              entry.compressed_size = packed
+            end
+
             stream_idx += 1
           end
         end
@@ -420,6 +458,12 @@ module Omnizip
             pack_idx += num_streams
           end
 
+          # Pack streams are laid out sequentially; skip past every
+          # stream owned by earlier folders to reach this folder's
+          # bytes (with stored archives pack sizes equal unpack
+          # sizes, which masked this offset in the past)
+          pack_idx.times { |i| pack_pos += @stream_info.pack_sizes[i] || 0 }
+
           # Check if this is a BCJ2 multi-stream folder
           if Bcj2StreamDecompressor.bcj2_folder?(folder)
             extract_bcj2_entry(io, entry, folder, pack_pos, pack_idx)

data/lib/omnizip/formats/seven_zip/writer.rb

@@ -169,15 +169,20 @@ module Omnizip
           [lzma2_chunk, [compressed_size]]
         end
 
-        # Build packed data for non-solid mode (COPY - no compression)
+        # Build packed data for non-solid mode: every file is its own
+        # LZMA2 stream. Empty files keep a zero-size pack stream.
         def build_non_solid_packed_data(file_data)
-          # For non-solid mode, concatenate raw file data without compression
-          packed_data = String.new(encoding: "BINARY")
+          packed_data = String.new(encoding: Encoding::BINARY)
           packed_sizes = []
 
           file_data[:streams].each do |stream|
-            packed_data << stream[:data]
-            packed_sizes << stream[:size]
+            if stream[:size].positive?
+              compressed = compress_with_lzma2(stream[:data])
+              packed_data << compressed
+              packed_sizes << compressed.bytesize
+            else
+              packed_sizes << 0
+            end
           end
 
           [packed_data, packed_sizes]
@@ -255,7 +260,8 @@ module Omnizip
                                      num_files)
           else
             # Non-solid mode: one pack stream per file, one folder per file
-            build_non_solid_streams_info(metadata, file_data[:streams])
+            build_non_solid_streams_info(metadata, file_data[:streams],
+                                         packed_sizes)
           end
 
           # kEnd for MainStreamsInfo
@@ -375,7 +381,7 @@ _num_files)
           metadata << [PropertyId::K_END].pack("C")
         end
 
-        def build_non_solid_streams_info(metadata, streams)
+        def build_non_solid_streams_info(metadata, streams, packed_sizes)
           num_streams = streams.size
 
           # kPackInfo property (0x06)
@@ -383,10 +389,10 @@ _num_files)
           metadata << write_number(0) # Pack position
           metadata << write_number(num_streams) # Number of pack streams
 
-          # kSize property - sizes of each pack stream
+          # kSize property - sizes of each pack stream (compressed)
           metadata << [PropertyId::SIZE].pack("C")
-          streams.each do |stream|
-            metadata << write_number(stream[:size])
+          packed_sizes.each do |packed|
+            metadata << write_number(packed)
           end
 
           # kEnd for PackInfo
@@ -402,18 +408,20 @@ _num_files)
           # External flag for all folders
           metadata << [0].pack("C")
 
-          # Folder definitions (coders only, no sizes yet)
-          streams.each do |_stream|
-            # Number of coders
-            metadata << write_number(1)
-            # Coder info for COPY
-            # MainByte format: bits 0-3 = num bytes for CodecID (0-15), bit 4 = is_complex, bits 5-7 = num props
-            # For COPY: 1 byte CodecID (0x00), no properties
-            metadata << COPY_MAIN_BYTE  # MainByte: 1 byte for CodecID, no props
-            metadata << COPY_METHOD_ID  # Method ID: COPY = 0x00
+          # Folder definitions (coders only, no sizes yet):
+          # one LZMA2 coder per non-empty stream, COPY for empties
+          streams.each do |stream|
+            if stream[:size].positive?
+              build_folder_coder(metadata)
+            else
+              metadata << write_number(1)
+              metadata << COPY_MAIN_BYTE
+              metadata << COPY_METHOD_ID
+            end
           end
 
           # kCodersUnpackSize - comes after ALL folder definitions
+          # (original sizes; kSize above carries the packed sizes)
           metadata << [PropertyId::CODERS_UNPACK_SIZE].pack("C")
           streams.each do |stream|
             metadata << write_number(stream[:size])

data/lib/omnizip/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.42
+  version: 0.3.44
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-29 00:00:00.000000000 Z
+date: 2026-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64