omnizip 0.3.43 → 0.3.45

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 436437db6697f7363305eda4e6a3e2b78b922aa12b3c43e29756efe187310b60
-  data.tar.gz: 6e0b17e143c50beae378cdb5b7902e773d888bca14183fcf83e61dfeabe56a5e
+  metadata.gz: c60c442839bff64ee405d6eb9c5f3ead4a97fa53df7ffd381ca0508dbb00b5e8
+  data.tar.gz: 22b8abfb94d6403e16ffea3c36115c6c7eb15eed654ef15f8a824453aa2eef20
 SHA512:
-  metadata.gz: f1e20ae301093cacb8c582e1b554a678c72cefa6bf21095d129bebc14b8c4095a68a87da653ef5ea16cb65c00de9edd6ae7b0d92191e49c25e05438ceba264ab
-  data.tar.gz: a6ad938ab6bdfd75586bcef013ba056cc523681ef34449d03bc44daf18a591e6485b292b7c62bd17c72c13c20c7ff8c45caf4faf6735d5cff79a0c2f4a5a010b
+  metadata.gz: f9a8b45c51e6c36d30273d7ac897eb4854793ed1548d4055dcf90335b836c9d3d1bb4db2faa374cf407345657fd5b459f16bf40021427387ae103ce54f1ed644
+  data.tar.gz: 412293ad5b9d9d3c361fe03f8ed88707f3cd5dc4fc4bc1221198e877a71eb98322ca4cc5664ac329dee117192738d4d1af6b8e79ca8cc080639cf69e83816d89

data/CHANGELOG.md

@@ -7,6 +7,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.44] - 2026-08-31
+
+### Fixed
+- Non-solid 7z archives now compress: the writer advertised
+  `algorithm: :lzma2` but the `solid: false` path concatenated raw
+  data under COPY coders (30 KB of compressible input produced a
+  30 KB archive). Each file now compresses independently with the
+  same SDK encoder as the solid path, folders carry LZMA2 coders
+  with the dictionary property, and kSize holds packed sizes while
+  kCodersUnpackSize keeps originals. 7zz-verified, extraction
+  byte-identical (30 KB -> 532 B in the fixture).
+- Latent 7z reader bug exposed by the above: multi-folder
+  non-solid archives read folder 1's packed stream for every entry
+  (pack positions never skipped earlier folders' bytes). Stored
+  archives masked it because pack sizes equalled unpack sizes, and
+  the tool-compat specs verify extraction through 7zz rather than
+  our reader. Fixed; new specs pin byte-exact multi-file
+  extraction through our own reader.
+- `omnizip archive verify` is reachable: the command existed but
+  was registered in no CLI group, and its `Formats::Rar.verify`
+  call passed a kwarg the module method never accepted (an arity
+  crash on first contact). The module method forwards
+  `use_recovery:` now; RAR archives verify with per-file results
+  and unsupported formats exit non-zero with an honest message.
+
+## [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

data/lib/omnizip/archive_handlers/rar_handler.rb

@@ -19,6 +19,9 @@ module Omnizip
       def extract_to(path, output_dir, password: nil, **_)
         Omnizip::Formats::Rar::Decompressor.extract(path, output_dir,
                                                     password: password)
+        reader = Omnizip::Formats::Rar::Reader.new(path).open
+        reader.list_files.reject(&:is_dir)
+          .map { |e| ::File.join(output_dir, e.name) }
       end
 
       def list(path, details: false, **_)
@@ -27,6 +30,7 @@ module Omnizip
         if details
           entries.map do |e|
             { name: e.name, size: e.size, directory: e.is_dir,
+              compressed_size: (e.compressed_size if e.compressed_size.positive?),
               mtime: e.mtime }
           end
         else

data/lib/omnizip/archive_handlers/seven_zip_handler.rb

@@ -15,9 +15,13 @@ module Omnizip
       end
 
       def extract_to(path, output_dir, **options)
+        extracted = []
         Omnizip::Formats::SevenZip.open(path, options) do |reader|
           reader.extract_all(output_dir)
+          extracted = reader.list_files.reject(&:is_dir)
+            .map { |e| ::File.join(output_dir, e.name) }
         end
+        extracted
       end
 
       def list(path, details: false, **options)
@@ -26,6 +30,7 @@ module Omnizip
           if details
             entries.map do |e|
               { name: e.name, size: e.size, directory: e.is_dir,
+                compressed_size: (e.compressed_size if e.compressed_size&.positive?),
                 mtime: e.mtime }
             end
           else

data/lib/omnizip/archive_handlers/tar_handler.rb

@@ -17,6 +17,8 @@ module Omnizip
 
       def extract_to(path, output_dir, **_)
         Omnizip::Formats::Tar.extract(path, output_dir)
+        Omnizip::Formats::Tar.list(path).reject(&:directory?)
+          .map { |e| ::File.join(output_dir, e.name) }
       end
 
       def list(path, details: false, **_)

data/lib/omnizip/archive_handlers/zip_handler.rb

@@ -3,65 +3,69 @@
 module Omnizip
   module ArchiveHandlers
     # Adapter that exposes the canonical +create+/+open+/+extract_to+
-    # /+list+ interface for the ZIP format. Wraps +Omnizip::Zip::File+.
+    # /+list+ interface for the ZIP format on the native
+    # +Formats::Zip+ tree. In-place entry editing (+add_entry+ /
+    # +remove_entry+) still goes through the rubyzip-compat
+    # +Omnizip::Zip::File+ layer: it is an in-place central-directory
+    # rewriter the native tree does not have (the same reason the
+    # Metadata subsystem lives there).
     class ZipHandler
-      # Zip::File has no archive-level compression options (method and
-      # level are per-entry in Zip::OutputStream), so extra keywords —
-      # e.g. profile-injected ones — are absorbed here.
-      def create(path, **_options, &block)
-        Omnizip::Zip::File.create(path) do |file|
-          block&.call(FileProxy.new(file))
-        end
+      def create(path, compression_method: nil, level: nil, **_, &block)
+        writer = Formats::Zip::Writer.new(path)
+        block&.call(WriterProxy.new(writer))
+
+        # The native writer takes archive-level compression at #write
+        # time; keep profile keywords out of it
+        kwargs = {}
+        kwargs[:compression_method] = compression_method if compression_method
+        kwargs[:level] = level if level
+        writer.write(**kwargs)
+        path
       end
 
       def open(path, &block)
-        Omnizip::Zip::File.open(path, &block)
+        reader = Formats::Zip::Reader.new(path)
+        block ? yield(reader) : reader
       end
 
       def extract_to(path, output_dir, overwrite: false, **_)
-        extracted = []
-        Omnizip::Zip::File.open(path) do |zip|
-          zip.each do |entry|
-            dest_path = ::File.join(output_dir, entry.name)
-            on_exists = if overwrite
-                          proc { true }
-                        else
-                          proc { |_e, p| raise "File exists: #{p}" }
-                        end
-            zip.extract(entry, dest_path, &on_exists)
+        reader = Formats::Zip::Reader.new(path)
+
+        if overwrite
+          reader.extract_all(output_dir)
+          reader.entries.map { |e| ::File.join(output_dir, e.filename) }
+        else
+          extracted = []
+          reader.entries.each do |entry|
+            dest_path = ::File.join(output_dir, entry.filename)
+            raise "File exists: #{dest_path}" if ::File.exist?(dest_path)
+
+            reader.extract_entry(entry, output_dir)
             extracted << dest_path
           end
+          extracted
         end
-        extracted
       end
 
       def list(path, details: false, **_)
-        Omnizip::Zip::File.open(path) do |zip|
-          if details
-            zip.entries.map do |entry|
-              {
-                name: entry.name,
-                size: entry.size,
-                compressed_size: entry.compressed_size,
-                compression_method: entry.compression_method,
-                crc: entry.crc,
-                time: entry.time,
-                directory: entry.directory?,
-              }
-            end
-          else
-            zip.names
-          end
+        reader = Formats::Zip::Reader.new(path)
+        return reader.entries.map(&:filename) unless details
+
+        reader.entries.map do |entry|
+          {
+            name: entry.filename,
+            size: entry.uncompressed_size,
+            compressed_size: entry.compressed_size,
+            compression_method: entry.compression_method,
+            crc: entry.crc32,
+            time: entry.time,
+            directory: entry.directory?,
+          }
         end
       end
 
       def read_entry(path, entry_name)
-        Omnizip::Zip::File.open(path) do |zip|
-          entry = zip.get_entry(entry_name)
-          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
-
-          zip.read(entry)
-        end
+        Formats::Zip::Reader.new(path).read_entry(entry_name)
       end
 
       def add_entry(path, entry_name, source_path)
@@ -73,20 +77,24 @@ module Omnizip
       end
 
       # Translates the generic +add(name, source_path)+ and
-      # +add_data(name, data)+ interface. +Zip::File#add_data+ is
-      # private, so in-memory content goes through the public block
-      # form +add(name) { data }+.
-      class FileProxy
-        def initialize(file)
-          @file = file
+      # +add_data(name, data)+ interface onto the native writer
+      class WriterProxy
+        def initialize(writer)
+          @writer = writer
         end
 
-        def add(name, source_path = nil)
-          @file.add(name, source_path)
+        def add(name, source_path = nil, &block)
+          if source_path
+            @writer.add_file(source_path, name)
+          elsif block
+            @writer.add_data(name, yield)
+          else
+            @writer.add_directory(name)
+          end
         end
 
         def add_data(name, data)
-          @file.add(name) { data }
+          @writer.add_data(name, data)
         end
       end
     end

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/commands/archive_extract_command.rb

@@ -111,54 +111,24 @@ module Omnizip
       end
 
       def extract_archive(archive_file, output_dir, verbose)
-        reader = case File.extname(archive_file).downcase
-                 when ".rar"
-                   Formats::Rar::Reader.new(archive_file).open
-                 when ".tar"
-                   Formats::Tar::Reader.new(archive_file).read
-                 when ".gz", ".gzip"
-                   # GZIP files are single-file compression, extract directly
-                   extract_gzip(archive_file, output_dir, verbose)
-                   return 1
-                 when ".bz2", ".bzip2"
-                   # BZIP2 files are single-file compression, extract directly
-                   extract_bzip2(archive_file, output_dir, verbose)
-                   return 1
-                 when ".xz"
-                   # XZ files are single-file compression, extract directly
-                   extract_xz(archive_file, output_dir, verbose)
-                   return 1
-                 else
-                   Formats::SevenZip::Reader.new(archive_file).open
-                 end
-        file_count = 0
-
-        reader.entries.each do |entry|
-          output_path = File.join(output_dir, entry.name)
-
-          if entry.directory?
-            CliOutputFormatter.verbose_puts(
-              "Creating directory: #{entry.name}",
-              verbose,
-            )
-            FileUtils.mkdir_p(output_path)
-          else
-            CliOutputFormatter.verbose_puts(
-              "Extracting: #{entry.name}",
-              verbose,
-            )
-
-            # Ensure parent directory exists
-            FileUtils.mkdir_p(File.dirname(output_path))
-
-            # Extract file
-            reader.extract_entry(entry.name, output_path)
-
-            file_count += 1
-          end
+        # Single-file compression formats decompress directly
+        case File.extname(archive_file).downcase
+        when ".gz", ".gzip"
+          extract_gzip(archive_file, output_dir, verbose)
+          return 1
+        when ".bz2", ".bzip2"
+          extract_bzip2(archive_file, output_dir, verbose)
+          return 1
+        when ".xz"
+          extract_xz(archive_file, output_dir, verbose)
+          return 1
         end
 
-        file_count
+        # Archives route through the handler seam: the extension
+        # routes pick each format's reader instead of hand-rolled
+        # branches, and zip/7z/rar/tar/cpio/iso all extract the same
+        # way
+        Omnizip.extract_archive(archive_file, output_dir).size
       rescue StandardError => e
         raise Omnizip::CompressionError,
               "Failed to extract archive: #{e.message}"

data/lib/omnizip/commands/archive_list_command.rb

@@ -58,19 +58,12 @@ module Omnizip
       end
 
       def list_archive(archive_file, verbose, patterns, excludes, count_only)
-        archive = if archive_file.end_with?(".zip")
-                    Omnizip::Zip::File.open(archive_file)
-                  elsif archive_file.end_with?(".rar")
-                    Formats::Rar::Reader.new(archive_file).open
-                  else
-                    Formats::SevenZip::Reader.new(archive_file).open
-                  end
+        # Route through the handler seam: every format's reader is
+        # chosen by the extension routes, not by hand-rolled branches
+        entries = Omnizip.list_archive(archive_file, details: true)
+          .map { |h| EntryAdapter.new(h) }
 
-        entries = if patterns || excludes
-                    filter_entries(archive, patterns, excludes)
-                  else
-                    archive.entries
-                  end
+        entries = filter_entries(entries, patterns, excludes) if patterns || excludes
 
         if count_only
           puts "Matches: #{entries.size}"
@@ -91,11 +84,9 @@ module Omnizip
       rescue StandardError => e
         raise Omnizip::CompressionError,
               "Failed to list archive: #{e.message}"
-      ensure
-        archive.close if archive.is_a?(Omnizip::Zip::File)
       end
 
-      def filter_entries(archive, patterns, excludes)
+      def filter_entries(entries, patterns, excludes)
         filter = Extraction::FilterChain.new
 
         # Add include patterns
@@ -104,7 +95,7 @@ module Omnizip
         # Add exclude patterns
         excludes&.each { |pattern| filter.exclude_pattern(pattern) }
 
-        filter.filter(archive.entries)
+        filter.filter(entries)
       end
 
       def display_simple_listing_filtered(entries)
@@ -202,16 +193,29 @@ module Omnizip
       end
 
       def entry_compressed_size(entry)
-        entry.compressed_size if entry.is_a?(Omnizip::Formats::SevenZip::Models::FileEntry)
+        entry.compressed_size
       end
 
       def entry_has_stream?(entry)
-        entry.has_stream? if entry.is_a?(Omnizip::Formats::SevenZip::Models::FileEntry)
+        entry.has_stream?
       end
 
       def entry_mtime(entry)
         entry.entry_mtime
       end
+
+      # Presents handler list-detail hashes under the Omnizip::Entry
+      # contract the display helpers already use
+      # :fields, not :hash — Struct members must not override
+      # Struct#hash
+      EntryAdapter = Struct.new(:fields) do
+        def entry_name = fields[:name]
+        def entry_directory? = fields[:directory]
+        def entry_size = fields[:size]
+        def entry_mtime = fields[:mtime] || fields[:time]
+        def compressed_size = fields[:compressed_size]
+        def has_stream? = !fields[:directory] && fields[:size].to_i.positive?
+      end
     end
   end
 end

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

@@ -458,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/formats/zip/central_directory_header.rb

@@ -60,6 +60,36 @@ module Omnizip
         end
 
         # Check if this is a directory entry
+        # DOS date/time (as stored in the central directory) to Time
+        def time
+          year = ((last_mod_date >> 9) & 0x7F) + 1980
+          month = (last_mod_date >> 5) & 0x0F
+          day = last_mod_date & 0x1F
+          hour = (last_mod_time >> 11) & 0x1F
+          minute = (last_mod_time >> 5) & 0x3F
+          second = (last_mod_time & 0x1F) * 2
+          Time.new(year, month, day, hour, minute, second)
+        rescue ArgumentError
+          nil
+        end
+
+        # Omnizip::Entry contract
+        def entry_name
+          filename
+        end
+
+        def entry_directory?
+          directory?
+        end
+
+        def entry_size
+          uncompressed_size
+        end
+
+        def entry_mtime
+          time
+        end
+
         def directory?
           filename.end_with?("/") ||
             external_attributes.anybits?(ATTR_DIRECTORY)

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

@@ -64,49 +64,14 @@ dereference_links: false)
           else
             FileUtils.mkdir_p(File.dirname(output_path))
 
-            File.open(file_path, "rb") do |io|
-              # Seek to local file header
-              io.seek(entry.local_header_offset, ::IO::SEEK_SET)
-
-              # Read fixed part of local file header (30 bytes)
-              fixed_header = io.read(30)
-
-              # Extract variable lengths from fixed header
-              _signature, _version, _flags, _method, _time, _date, _crc32,
-              _comp_size, _uncomp_size, filename_length, extra_length = fixed_header.unpack("VvvvvvVVVvv")
-
-              # Read variable parts
-              variable_data = io.read(filename_length + extra_length)
-
-              # Parse complete local file header
-              LocalFileHeader.from_binary(fixed_header + variable_data)
-
-              # Now we're positioned right after the local file header, read compressed data
-              compressed_data = io.read(entry.compressed_size)
-
-              # Decompress data
-              decompressed_data = decompress_data(
-                compressed_data,
-                entry.compression_method,
-                entry.uncompressed_size,
-              )
-
-              # Verify CRC
-              calculated_crc = Omnizip::Checksums::Crc32.new.tap do |c|
-                c.update(decompressed_data)
-              end.finalize
-              if calculated_crc != entry.crc32
-                raise Omnizip::ChecksumError,
-                      "CRC mismatch for #{entry.filename}"
-              end
-
-              # Write decompressed data
-              File.binwrite(output_path, decompressed_data)
-
-              # Set file permissions if Unix
-              if entry.unix_permissions.positive?
-                File.chmod(entry.unix_permissions & 0o777, output_path)
-              end
+            decompressed_data = read_entry_data(entry)
+
+            # Write decompressed data
+            File.binwrite(output_path, decompressed_data)
+
+            # Set file permissions if Unix
+            if entry.unix_permissions.positive?
+              File.chmod(entry.unix_permissions & 0o777, output_path)
             end
           end
         end
@@ -168,8 +133,57 @@ dereference_links: false)
           decompress_data(compressed_data, method, uncompressed_size)
         end
 
+        # Read an entry's decompressed content into a String.
+        # Directory entries return an empty string; symlinks return
+        # their target path.
+        #
+        # @param entry_name [String] Name of the entry to read
+        # @return [String] Decompressed content
+        # @raise [RuntimeError] if the entry is not found
+        def read_entry(entry_name)
+          ensure_read
+          entry = @entries.find { |e| e.filename == entry_name }
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
+
+          return "" if entry.directory?
+          return entry.link_target if entry.symlink?
+
+          read_entry_data(entry)
+        end
+
         private
 
+        # Decompress and CRC-verify a single entry's data
+        def read_entry_data(entry)
+          File.open(file_path, "rb") do |io|
+            io.seek(entry.local_header_offset, ::IO::SEEK_SET)
+
+            fixed_header = io.read(30)
+            _signature, _version, _flags, _method, _time, _date, _crc32,
+            _comp_size, _uncomp_size, filename_length, extra_length = fixed_header.unpack("VvvvvvVVVvv")
+
+            variable_data = io.read(filename_length + extra_length)
+            LocalFileHeader.from_binary(fixed_header + variable_data)
+
+            compressed_data = io.read(entry.compressed_size)
+            decompressed_data = decompress_data(
+              compressed_data,
+              entry.compression_method,
+              entry.uncompressed_size,
+            )
+
+            calculated_crc = Omnizip::Checksums::Crc32.new.tap do |c|
+              c.update(decompressed_data)
+            end.finalize
+            if calculated_crc != entry.crc32
+              raise Omnizip::ChecksumError,
+                    "CRC mismatch for #{entry.filename}"
+            end
+
+            decompressed_data
+          end
+        end
+
         # Parse the central directory once, on demand
         def ensure_read
           read if @entries.empty? && @central_directory.empty?

data/lib/omnizip/parity/par2_repairer.rb

@@ -54,6 +54,11 @@ module Omnizip
       # @param progress [Proc, nil] Progress callback
       # @raise [ArgumentError] if file doesn't exist
       def initialize(par2_file, progress: nil)
+        if par2_file.nil?
+          raise ArgumentError,
+                "PAR2 file is nil — no index .par2 was produced for this set"
+        end
+
         raise ArgumentError, "PAR2 file not found: #{par2_file}" unless
           File.exist?(par2_file)
 

data/lib/omnizip/version.rb

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

metadata

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