omnizip 0.3.40 → 0.3.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5013ae71553867968422f57b01425820f17c5cd6e471ea0cb5b5d46d1cc6a1bd
-  data.tar.gz: 94698e90386f195cdd7f5fd7a8ebae3010f2f206e70eb96463ce8e4d2ece09b0
+  metadata.gz: 060755f6c69bca46bcb999d0d36471045ae3d13e260cfa3c73601a8d440b1634
+  data.tar.gz: b524b77c579c824009821ca5d1bdb47327cfc55f3ebd1dab4ea8574d1ec3c631
 SHA512:
-  metadata.gz: 415d4cdcb48375d0ba0d1d57dc2592c18d47fcafb9817d956dbe5a3ec7e1fa1048063372759de1ff0c0ef194d06eaa7f5855cfead144681e1fb454ac4fc510b2
-  data.tar.gz: a901b525b49f60b94098d43a5c4517f5163e07b64ef08099c02f693fc50775461c584ee35f2a6227167bbd461cfcbd9e3985b2383c586610817363170f45a2ef
+  metadata.gz: 237f14e0c479844a473d1830e956882a0d250f6c733522bcd9f3d36b7ba10b474b4564902791aecd52948ad330b82bb0bb7e61dd97db607bf3dcd85ab3dc847b
+  data.tar.gz: cfe4637c8ad1223ccb8b9735fc1494d61937b636f3d79dd7fbd2c1f59f6f35eb38686152ee56732f0cb29cfbf3c12f7ddfb6dae5bd6c146b8d833fca5315a00a

data/CHANGELOG.md

@@ -7,6 +7,95 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.41] - 2026-08-29
+
+### Changed
+- One RAR parser. `Formats::Rar3::Reader` and `Formats::Rar5::Reader`
+  are adapters over the primary `Formats::Rar::Reader` — the only
+  parser verified against real WinRAR archives — replacing ~600
+  lines of duplicate parsing. Both legacy interfaces gain real-
+  archive fidelity for free (exact mtimes, backslash normalization,
+  directory detection, CRC fields). The legacy RAR5 writer — whose
+  output not even unrar could list (garbage names, 2038 dates) —
+  now bridges onto the spec-conformant primary writer; its archives
+  pass `unrar t`. The primary Header learned minimal archives (file
+  block first, no main header) for RAR4 and RAR5, restoring a legacy
+  capability in one place.
+- Direct-seek extraction: the parser records each entry's
+  data_offset, so native extraction is one seek + read instead of
+  re-parsing the archive per entry. unrar-backed extraction spills
+  the archive once per archive path instead of extracting the whole
+  archive per entry (O(n^2) -> O(n)). Fixed a latent off-by-two in
+  the fallback block walk.
+- Converter symmetry: zip -> 7z uses the native reader with the
+  same extract-to-temp/write-from-tree shape as 7z -> zip; internal
+  code no longer calls the rubyzip-compat `Omnizip::Zip::File` seam.
+- `omnizip archive create` passes one flat options hash;
+  `Formats::Rar.create` applies the RAR4/RAR5-specific semantics
+  (the RAR4 writer's recovery guard no longer trips on explicit
+  false).
+
+### Fixed
+- Native-decode CRC guard referenced `Compression::DecompressionError`
+  which does not exist (the classes live under
+  `Compression::Dispatcher`); the NameError was silently masked by
+  the fallback rescue.
+- Unicode-flagged RAR4 names can carry non-UTF-8 bytes;
+  String#tr raised and aborted the block walk under non-UTF-8
+  locales (CI runners). Names are scrubbed before normalization.
+- Corrupt size fields drove unbounded reads: a garbage pack_size
+  attempted a multi-gigabyte read (NoMemoryError on CI) or an
+  overflowing seek (EINVAL on Linux, silently clamped on macOS).
+  Packed data is now seeked past — never allocated to skip — with
+  sizes bounds-checked against the archive length and corrupt skips
+  clamped to EOF so entries still list.
+
+## [0.3.40] - 2026-08-29
+
+### Fixed
+- Every CLI command now works end-to-end (each was exercised against
+  real archives and its failure fixed):
+  - `omnizip list` printed "No algorithms registered." — all builtin
+    algorithms register lazily, so the available list was empty until
+    each was first used. `AlgorithmRegistry.available` now includes
+    the builtins.
+  - `omnizip convert a.7z a.zip` crashed on a fictional reader/writer
+    API inside the conversion strategy; rewritten on the real APIs and
+    round-trips byte-identically through unzip.
+  - `omnizip archive create x.rar ...` raised NoMethodError (a
+    module-level `Formats::Rar.create` never existed). It exists now
+    (RAR5 default, `version: 4` for RAR4); directory inputs work —
+    the stale "RAR5 does not support directories" restriction is gone
+    and trees archive under their own name like `.7z`, verified with
+    unrar.
+  - `omnizip archive metadata` opened every input as a ZIP: `.7z`
+    crashed with a ZIP parse error, and runs with no edit option
+    still printed "Metadata updated successfully". 7z now shows real
+    read-only metadata, unknown formats raise truthful errors, and
+    ZIPs default to show mode when nothing is being edited.
+  - `omnizip decompress archive.zip out/` — the behavior the
+    command's own help documents — failed with "Is a directory".
+    Archive inputs (zip/7z/tar/rar/cpio/iso) and directory outputs
+    now extract through the convenience layer, content-verified with
+    diff for zip, 7z, rar, and tar.
+- Deflate64.metadata returned a raw Hash, crashing the CLI algorithm
+  table; it returns `Models::AlgorithmMetadata` like every other
+  algorithm.
+- Guides referenced a nonexistent `:zstd` algorithm-registry key;
+  corrected to `:zstandard` everywhere (the registry key differs from
+  RPM's `:zstd` compression type).
+
+### Added
+- `Omnizip::Buffer` 7z support: `create(:seven_zip)` /
+  `create_from_hash(hash, :seven_zip)`, `open`, `extract_to_memory`,
+  and `MemoryExtractor` all handle 7z through a temporary-file bridge
+  (the format has no in-memory stream implementation), including
+  explicit directory entries via a new
+  `SevenZip::Writer#add_directory_entry`. Format auto-detection fixed
+  to compare binary magic literals — UTF-8 literals never matched
+  binary data, so 7z buffers raised "Unknown archive format".
+- README gains an In-Memory Archives section (examples run verbatim).
+
 ## [0.3.39] - 2026-08-28
 
 ### Fixed

data/CONTEXT.md

@@ -0,0 +1,63 @@
+# Domain Glossary
+
+Names for the concepts that keep coming up in omnizip. Use these
+words in code, docs, and reviews; when a term sharpens, update it
+here.
+
+## Archive access
+
+- **Archive facade** — `Omnizip::Archive`: the format-neutral entry
+  point. `create` yields a Builder (add_file/add_directory/add_data),
+  `open` yields a ReaderSession (entries/read/extract/extract_all).
+- **ArchiveHandler** — per-format adapter registered in the handler
+  registry (create/extract_to/list/read_entry) plus its extension
+  route. The facade and the convenience layer dispatch through
+  handlers, never through format classes directly.
+- **Extension route** — mapping from a file extension to a format
+  symbol. Writable routes (`ARCHIVE_FORMAT_EXTENSIONS`) may create
+  archives; read routes (`READ_ARCHIVE_FORMAT_EXTENSIONS`) only
+  extract/list/read. `.rar`, `.cpio`, `.iso` are read-only routes;
+  creating them raises truthfully.
+
+## Reading and decoding
+
+- **Native decode** — decompression implemented in Ruby inside
+  omnizip. RAR native decode is **CRC-gated**: the stored header CRC
+  must match the decoded bytes or the result is discarded.
+- **External fallback** — delegating to an external tool (the unrar
+  command) when native decode cannot be trusted. RAR extraction
+  spills the archive once per archive path (the **extraction spill
+  cache**) and copies entries out of it.
+
+## Writing and interop
+
+- **Interop-verified** — output accepted by the official tool for
+  the format (unrar for RAR, 7zz for 7z/ISO, unzip for ZIP), checked
+  with `test` plus a byte-identical extraction round-trip.
+- **Omnizip-internal codec** — a compression stream only omnizip can
+  decode (RAR methods above :store). Archives carrying them must be
+  labeled honestly; official tools fail loudly, never silently.
+- **STORE** — the uncompressed method; the interoperability floor
+  for every archive writer in this library.
+
+## Seams
+
+- **Compat seam** — `Omnizip::Zip` (aliased into the global `Zip`
+  namespace by `omnizip/rubyzip_compat`): a rubyzip-compatible
+  layer for library consumers migrating off rubyzip. Internal code
+  must use the native `Formats::Zip` tree instead; the Metadata
+  subsystem is its one deliberate in-house consumer (in-place
+  central-directory editing).
+- **Bridge** — an adapter that carries a file-based implementation
+  across to a non-file interface, spilling through a temporary file
+  (the RAR3/RAR5 legacy readers, `Buffer::SevenZipBridge`).
+- **Primary parser** — the one parser per format family verified
+  against real archives (e.g. `Formats::Rar::Reader`). Legacy
+  interfaces are adapters over primary parsers, never parallel
+  implementations.
+
+## In memory
+
+- **Buffer** — `Omnizip::Buffer`: in-memory archive create/read for
+  ZIP (stream-based) and 7z (through the bridge). Format detection
+  compares binary magic literals.

data/lib/omnizip/commands/archive_create_command.rb

@@ -120,35 +120,23 @@ module Omnizip
 
         start_time = Time.now
 
+        # Format-agnostic options; Formats::Rar applies the
+        # version-specific semantics
         writer_opts = {
           version: version,
           compression: compression,
           level: level,
           include_mtime: include_mtime,
           include_crc32: include_crc32,
-        }
-
-        # Add solid compression for RAR5
-        writer_opts[:solid] = solid if version == 5 && solid
-
-        # Add multi-volume options for RAR5
-        if version == 5 && multi_volume && volume_size
-          writer_opts[:multi_volume] = true
-          writer_opts[:volume_size] = volume_size
-          writer_opts[:volume_naming] = volume_naming
-        end
-
-        # Add encryption options for RAR5
-        if version == 5 && password
-          writer_opts[:password] = password
-          writer_opts[:kdf_iterations] = kdf_iterations
-        end
-
-        # Add recovery options for RAR5
-        if version == 5 && recovery
-          writer_opts[:recovery] = true
-          writer_opts[:recovery_percent] = recovery_percent
-        end
+          solid: solid,
+          multi_volume: multi_volume,
+          volume_size: volume_size,
+          volume_naming: volume_naming,
+          password: password,
+          kdf_iterations: kdf_iterations,
+          recovery: recovery,
+          recovery_percent: recovery_percent,
+        }.compact
 
         result_files = Omnizip::Formats::Rar.create(output_file,
                                                     writer_opts) do |rar|

data/lib/omnizip/converter/zip_to_seven_zip_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "tmpdir"
+
 module Omnizip
   module Converter
     # Convert ZIP archives to 7-Zip format
@@ -10,14 +12,20 @@ module Omnizip
         start_time = Time.now
         entry_count = 0
 
-        # Open source ZIP archive
-        Omnizip::Zip::File.open(source_path) do |zip|
-          # Collect all entries and their data
-          entries_data = collect_entries(zip)
-          entry_count = entries_data.size
+        Dir.mktmpdir("omnizip_convert_zip") do |tmp|
+          # Extract the ZIP through the native reader; directories are
+          # implied by extracted file paths
+          Omnizip::Formats::Zip.extract(source_path, tmp)
+
+          writer = Omnizip::Formats::SevenZip::Writer.new(target_path,
+                                                          writer_options)
+          Dir.glob(File.join(tmp, "**", "*")).each do |path|
+            next if File.directory?(path)
 
-          # Create target 7z archive
-          create_seven_zip(entries_data)
+            entry_count += 1
+            writer.add_file(path, path.delete_prefix("#{tmp}/"))
+          end
+          writer.write
         end
 
         create_result(start_time, entry_count)
@@ -45,62 +53,12 @@ module Omnizip
 
       private
 
-      def collect_entries(zip)
-        entries = []
-
-        zip.entries.each do |entry|
-          data = {
-            name: entry.name,
-            directory: entry.directory?,
-            mtime: entry.time,
-            content: nil,
-          }
-
-          unless entry.directory?
-            data[:content] = zip.get_input_stream(entry)
-
-            if options.preserve_metadata && entry.unix_perms.positive?
-              data[:unix_perms] = entry.unix_perms
-            end
-          end
-
-          entries << data
-        end
-
-        entries
-      end
-
-      def create_seven_zip(entries)
-        writer = Omnizip::Formats::SevenZip::Writer.new(target_path)
-
-        # Set compression options
-        compression = options.compression || :lzma2
-        level = options.compression_level || 5
-        options.solid.nil? || options.solid
-
-        # Add each entry
-        entries.each do |entry_data|
-          if entry_data[:directory]
-            # 7z doesn't have explicit directory entries
-            # Directories are implied by file paths
-            next
-          end
-
-          writer.add_data(
-            entry_data[:name],
-            entry_data[:content],
-            algorithm: compression,
-            level: level,
-          )
-        end
-
-        # Apply filter if specified
-        if options.filter
-          add_warning("Filters not yet supported in 7z conversion")
-        end
-
-        # Write the archive
-        writer.write
+      # SevenZip::Writer takes algorithm/level/solid as keywords
+      def writer_options
+        {
+          algorithm: options.compression || :lzma2,
+          level: options.compression_level || 5,
+        }
       end
     end
   end

data/lib/omnizip/formats/iso.rb

@@ -3,14 +3,13 @@
 module Omnizip
   module Formats
     # ISO 9660 CD-ROM filesystem format support
-    # Provides read-only access to ISO images
     #
-    # ISO 9660 is the standard filesystem for CD-ROMs and DVD-ROMs.
-    # This implementation supports:
-    # - Primary Volume Descriptor parsing
-    # - Directory structure traversal
-    # - File extraction
-    # - Rock Ridge extensions (basic)
+    # Reads and writes ISO 9660 images: Primary Volume Descriptor
+    # parsing, directory traversal, file extraction, and image
+    # creation whose directory records point at allocated extents
+    # (verified against 7-Zip). Rock Ridge and Joliet are NOT
+    # implemented — the writer's options stay false rather than
+    # advertising extensions readers would misparse.
     module Iso
       # Nested classes - autoloaded
       autoload :Reader, "omnizip/formats/iso/reader"

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

@@ -45,6 +45,7 @@ module Omnizip
         # @return [Models::RarEntry, nil] Parsed entry or nil
         def parse_rar4_file_block(io)
           entry = Models::RarEntry.new
+          block_start = io.pos
 
           # Read block header
           read_uint16(io)
@@ -73,12 +74,23 @@ module Omnizip
             unpack_size |= (high_unpack_size << 32)
           end
 
+          # Sanity bounds: corrupt headers must not drive huge reads.
+          # head_size can never exceed the bytes left from the block
+          # start, and the name must fit inside the header.
+          if head_size > io.size - block_start ||
+              name_size + 32 > head_size
+            return nil
+          end
+
           # Read file name
           name_bytes = io.read(name_size)
           entry.name = decode_filename(name_bytes, head_flags)
           # RAR4 archives store DOS-style backslash separators;
-          # normalize to forward slashes like unrar on Unix.
-          entry.name = entry.name.tr("\\", "/")
+          # normalize to forward slashes like unrar on Unix. Scrub
+          # first: unicode-flagged names may carry bytes that are not
+          # valid UTF-8, and String#tr raises on them under any
+          # locale.
+          entry.name = entry.name.scrub.tr("\\", "/")
 
           # Set entry properties
           entry.size = unpack_size
@@ -111,7 +123,14 @@ module Omnizip
           remaining = head_size - (name_size + 32)
           remaining -= 8 if head_flags.anybits?(FILE_LARGE)
           io.read(remaining) if remaining.positive?
-          io.read(pack_size) # Skip compressed data
+          # Record where the packed data starts so extraction can seek
+          # straight to it instead of re-parsing the archive
+          entry.data_offset = io.pos
+          # Seek past the data: never allocate the packed bytes just
+          # to skip them. A corrupt pack_size (bigger than the file)
+          # would overflow the seek offset on Linux — clamp to EOF so
+          # the entry still lists.
+          skip_past(io, pack_size)
 
           entry
         end
@@ -135,6 +154,10 @@ module Omnizip
           extra_size = header_flags.anybits?(RAR5_FLAG_EXTRA_AREA) ? read_vint(io) : 0
           data_size = header_flags.anybits?(RAR5_FLAG_DATA_AREA) ? read_vint(io) : 0
 
+          # Sanity bounds: corrupt headers must not drive huge reads
+          remaining_bytes = io.size - io.pos
+          return nil if extra_size > remaining_bytes || data_size > remaining_bytes
+
           # Read file header
           file_flags = read_vint(io)
           unpack_size = read_vint(io)
@@ -155,7 +178,7 @@ module Omnizip
 
           # Read file name
           name_bytes = io.read(name_length)
-          entry.name = name_bytes.force_encoding("UTF-8")
+          entry.name = name_bytes.to_s.scrub.force_encoding("UTF-8")
 
           # Set entry properties
           entry.size = unpack_size
@@ -168,13 +191,26 @@ module Omnizip
           entry.is_dir = file_flags.anybits?(RAR5_FLAG_IS_DIR)
           entry.version = 5
 
-          # Skip extra area, then compressed data
+          # Skip extra area, then compressed data; record the data
+          # start for direct-seek extraction. The data is seeked past,
+          # never read: corrupt sizes must not drive huge allocations.
           io.read(extra_size) if extra_size.positive?
-          io.read(data_size) if data_size.positive?
+          entry.data_offset = io.pos
+          skip_past(io, data_size)
 
           entry
         end
 
+        # Skip forward without allocating: clamp corrupt sizes to EOF
+        # so an overflowing seek (EINVAL on Linux) cannot abort the
+        # block walk
+        def skip_past(io, bytes)
+          return if bytes <= 0
+
+          remaining = io.size - io.pos
+          io.seek([bytes, remaining].min, ::IO::SEEK_CUR)
+        end
+
         # Decode filename from bytes
         #
         # @param bytes [String] Raw filename bytes

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

@@ -236,18 +236,54 @@ module Omnizip
           end
 
           # Extract entry with command
+          #
+          # unrar cannot extract a single entry without walking the
+          # archive, so the archive spills to a cache directory ONCE
+          # per archive path; subsequent extractions copy out of the
+          # cache instead of re-running unrar over the whole file.
           def extract_entry_with_command(archive_path, entry_name,
                                          output_path, password)
-            temp_dir = Dir.mktmpdir
-            cmd = build_extract_command(archive_path, temp_dir, password)
-            unless system(*cmd)
-              raise "Command entry extraction failed: #{entry_name}"
+            cache_key = begin
+              File.realpath(archive_path)
+            rescue StandardError
+              archive_path
+            end
+
+            cached_dir = extract_cache[cache_key]
+            unless cached_dir
+              cached_dir = Dir.mktmpdir("omnizip_unrar")
+              cmd = build_extract_command(archive_path, cached_dir, password)
+              unless system(*cmd)
+                FileUtils.rm_rf(cached_dir)
+                raise "Command entry extraction failed: #{entry_name}"
+              end
+              extract_cache[cache_key] = cached_dir
+              install_exit_sweeper
             end
 
-            source = File.join(temp_dir, entry_name)
-            FileUtils.mv(source, output_path) if File.exist?(source)
-          ensure
-            FileUtils.rm_rf(temp_dir) if temp_dir
+            source = File.join(cached_dir, entry_name)
+            FileUtils.cp(source, output_path) if File.exist?(source)
+          end
+
+          # Extracted-archive cache: archive path => spill directory.
+          # Cleared by .clear_extract_cache!; an at_exit sweeper
+          # reclaims everything at normal process termination.
+          def extract_cache
+            @extract_cache ||= {}
+          end
+
+          # Drop the extraction cache and remove its directories
+          def clear_extract_cache!
+            extract_cache.each_value { |dir| FileUtils.rm_rf(dir) }
+            extract_cache.clear
+          end
+
+          # Reclaim spill directories when the process exits normally
+          def install_exit_sweeper
+            return if @exit_sweeper_installed
+
+            at_exit { clear_extract_cache! }
+            @exit_sweeper_installed = true
           end
 
           # Build extract command

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

@@ -85,7 +85,9 @@ module Omnizip
         # Parse RAR4 header
         #
         # The 7-byte signature consumed by #parse IS the marker
-        # block, so the main header follows immediately.
+        # block, so the main header follows immediately. Minimal
+        # archives skip the main header and start with a file block —
+        # accept those by rewinding to the block.
         #
         # @param io [IO] Input stream
         def parse_rar4_header(io)
@@ -94,6 +96,12 @@ module Omnizip
           head_flags = read_uint16(io)
           head_size = read_uint16(io)
 
+          if head_type == BLOCK_FILE
+            io.seek(-7, ::IO::SEEK_CUR)
+            @flags = 0
+            return
+          end
+
           unless head_type == BLOCK_ARCHIVE
             raise "Expected archive block, got 0x#{head_type.to_s(16)}"
           end
@@ -117,11 +125,20 @@ module Omnizip
           # RAR5 uses variable-length integer encoding. Layout per the
           # RAR 5.0 format: HeaderCRC32(4), Header size(vint), Header
           # type(vint), Header flags(vint), then type-specific fields.
+          header_start = io.pos
           read_uint32(io)
           read_vint(io) # header size (redundant: areas carry their own)
           header_type = read_vint(io)
           header_flags = read_vint(io)
 
+          # Minimal archives skip the main header and start with a
+          # file header (type 2) — rewind so block iteration reads it
+          if header_type == RAR5_HEADER_FILE
+            io.seek(header_start, ::IO::SEEK_SET)
+            @flags = 0
+            return
+          end
+
           unless header_type == RAR5_HEADER_MAIN
             raise "Expected main header, got #{header_type}"
           end

data/lib/omnizip/formats/rar/models/rar_entry.rb

@@ -10,7 +10,7 @@ module Omnizip
           attr_accessor :name, :size, :compressed_size, :crc, :is_dir,
                         :host_os, :mtime, :attributes, :method,
                         :version, :flags, :volume_index, :split_before,
-                        :split_after, :encrypted
+                        :split_after, :encrypted, :data_offset
 
           # Initialize RAR entry
           def initialize

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

@@ -268,7 +268,7 @@ module Omnizip
           # fall back to unrar.
           data = output.string
           if entry.crc && Zlib.crc32(data) != entry.crc
-            raise Compression::DecompressionError,
+            raise Compression::Dispatcher::DecompressionError,
                   "CRC mismatch for #{entry.name}"
           end
 
@@ -296,19 +296,26 @@ module Omnizip
         # @param entry [Models::RarEntry] File entry
         # @return [StringIO] Compressed data stream
         def read_compressed_data(entry)
-          # Find the entry's data offset in the archive
+          # The parser records each entry's data offset, so native
+          # extraction is a single seek + read
+          if entry.data_offset && entry.compressed_size
+            File.open(@file_path, "rb") do |io|
+              io.seek(entry.data_offset)
+              return StringIO.new(io.read(entry.compressed_size) || "")
+            end
+          end
+
+          # Fallback for entries parsed without offsets (e.g. by older
+          # parsers): walk the blocks to locate the entry
           File.open(@file_path, "rb") do |io|
-            # Skip signature and headers
             Header.read(io)
 
-            # Parse file blocks to find our entry
             parser = BlockParser.new(@header.version)
 
             loop do
               block_start = io.pos
               break if io.eof?
 
-              # Peek at block type
               crc_bytes = io.read(2)
               break unless crc_bytes
 
@@ -317,45 +324,33 @@ module Omnizip
 
               head_type = type_byte.ord
 
-              # If end block, stop
               break if head_type == BLOCK_ENDARC
 
-              # Reset to block start
               io.seek(block_start)
 
-              # If not a file block, read and skip it
               unless head_type == BLOCK_FILE
-                # Read header
                 io.read(2) # CRC
                 io.read(1) # TYPE
-                io.read(2)&.unpack1("v") || 0
+                io.read(2) # FLAGS
                 size = io.read(2)&.unpack1("v") || 0
 
-                # Skip rest of block (size includes TYPE+FLAGS+SIZE = 5 bytes)
-                remaining = size - 5
+                # 7 bytes consumed (CRC/TYPE/FLAGS/SIZE); skip the rest
+                remaining = size - 7
                 io.read(remaining) if remaining.positive?
                 next
               end
 
-              # Parse this file block
               test_entry = parser.parse_file_block(io)
 
-              # Check if this is our entry
               if test_entry && test_entry.name == entry.name
-                # BlockParser positions us right after the compressed data
-                # So we need to back up and read it
-                data_end = io.pos
-                data_start = data_end - entry.compressed_size
+                data_start = io.pos - entry.compressed_size
 
                 io.seek(data_start)
-                compressed = io.read(entry.compressed_size)
-
-                return StringIO.new(compressed)
+                return StringIO.new(io.read(entry.compressed_size) || "")
               end
             end
           end
 
-          # If we didn't find it, return empty
           StringIO.new("")
         end
       end

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

@@ -169,7 +169,7 @@ module Omnizip
             warn "RAR4 writer ignores volume_size: not implemented " \
                  "(no corresponding flag is written)"
           end
-          return unless @options[:recovery].to_i.positive?
+          return unless @options[:recovery]&.to_i&.positive?
 
           warn "RAR4 writer ignores recovery: not implemented " \
                "(no corresponding flag is written)"