omnizip 0.3.44 → 0.3.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 358c03758aa086cbb4f3a22845af9f309542df3c272fc640faaaf807d3b2adb0
-  data.tar.gz: 96c8735854c4413b2cb802611eb7acd2d4480d1983b5dd4e4e4a45ebf35d3725
+  metadata.gz: eb792b03b604528825ce30f9d2ef6c7b6ac077535f5a4bf027498a44138ab692
+  data.tar.gz: 777e4ed705e6aa51b53ca8bccf2b394ae24f6f9b4404325db398a24e13b5a811
 SHA512:
-  metadata.gz: 67ab99068276c2eef687be2d7497c911cdb96f920dea552b9392fe860cbc805345c8bf87f5f6640934b09d46b7fc3c598c8bb140a296f37395d2020ff9e0bbd6
-  data.tar.gz: 256599715a8f9aa94ee2e94376122a6571b8a7eb0e80548b74e57f14d2d2522a12fc6f3b5566f08c3b6a63692b06e3845a3d8948dfdf24fc53f22d79eebd434d
+  metadata.gz: d512bfb76c29f2ca7a59bc6e46f558c2bc659b38dc1878b50ea879f91f93beff7c52a27a033b002f0a3e27ae2968484a8cb27b68aaa462a86aad9906f360a854
+  data.tar.gz: 25fdb5dacbe8dd8efb6835d916c8b455bcf07197845126dc8b832bbbf80418b80e904c5338a21e0300df6db83fd872fb6faa132f40e9b947ba19496a38eb44d2

data/CHANGELOG.md

@@ -7,6 +7,56 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.45] - 2026-08-31
+
+### Changed
+- The ZIP ArchiveHandler — the seam the facade, the convenience
+  layer, and the CLI all route through — now sits on the native
+  `Formats::Zip` tree instead of the rubyzip-compat
+  `Omnizip::Zip::File` layer (which remains for in-place entry
+  editing and Metadata, by design). The native reader gains
+  `#read_entry` (decompress + CRC-verify, shared with extraction)
+  and the central-directory entry model gains the `Omnizip::Entry`
+  contract plus DOS-time decoding.
+- CLI `archive list` and `archive extract` route through the
+  handler registry instead of hand-rolled format dispatch:
+  `archive list foo.tar` no longer falls into the 7z reader, zip
+  listing no longer opens the compat layer, and every handler's
+  `extract_to` returns the extracted file paths (7z/rar/tar
+  previously returned the reader or nil). Verbose listings show
+  real per-entry compressed sizes for the formats that track them.
+
+### Fixed
+- Parity hardening: a nil PAR2 index crashed five frames deep as a
+  `TypeError`; the repairer boundary now raises a named
+  `ArgumentError` and the spec fixture can no longer select a nil
+  index (the order-coupled CI flake from 0.3.44).
+
+## [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

data/lib/omnizip/archive_handlers/rar_handler.rb

@@ -1,24 +1,31 @@
 # frozen_string_literal: true
 
 require "tmpdir"
+require "tempfile"
 
 module Omnizip
   module ArchiveHandlers
-    # Read-only adapter for the RAR format. RAR compression is
-    # patented software (see link:README[RAR write support]); this
-    # handler exposes extraction/listing/reading only, so the
-    # convenience API and the Archive facade can operate on existing
-    # archives truthfully instead of raising on every operation.
+    # Adapter for the RAR format: extraction/listing/reading, plus
+    # creation through Formats::Rar (RAR5 STORE is unrar-verified;
+    # compressed methods fall back to STORE with a warning — see the
+    # README interop table).
     class RarHandler
-      def create(_path, **_options)
-        raise Omnizip::UnsupportedFormatError,
-              "RAR archives cannot be created (patented format); " \
-              "Omnizip reads RAR archives only"
+      def create(path, **options, &block)
+        proxy = nil
+        result = Omnizip::Formats::Rar.create(path, options) do |writer|
+          proxy = WriterProxy.new(writer)
+          block&.call(proxy)
+        end
+        proxy&.cleanup
+        result
       end
 
       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 +34,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
@@ -43,6 +51,44 @@ module Omnizip
           File.binread(dest)
         end
       end
+
+      # Translates the generic +add(name, source_path)+ /
+      # +add_data(name, data)+ / +add_directory(name)+ interface onto
+      # the RAR writers. The writers take file paths, so in-memory
+      # content spills to a temporary file.
+      class WriterProxy
+        def initialize(writer)
+          @writer = writer
+          @spill = []
+        end
+
+        def add(name, source_path = nil)
+          if source_path
+            @writer.add_file(source_path, name)
+          else
+            @writer.add_directory_entry(name)
+          end
+        end
+
+        def add_data(name, data)
+          file = Tempfile.new(["omnizip_rar_entry", File.extname(name)])
+          file.binmode
+          file.write(data)
+          file.close
+          @spill << file
+          @writer.add_file(file.path, name)
+        end
+
+        def add_directory(name)
+          @writer.add_directory_entry(name)
+        end
+
+        # Remove the temporary files add_data spilled
+        def cleanup
+          @spill.each(&:unlink)
+          @spill.clear
+        end
+      end
     end
   end
 end

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

@@ -355,6 +355,18 @@ module Omnizip
     rescue StandardError => e
       handle_error(e)
     end
+
+    desc "repair ARCHIVE OUTPUT", "Repair a damaged archive"
+    long_desc <<~DESC
+      Repair a damaged archive (currently RAR archives via recovery
+      records and .rev volumes). OUTPUT is the repaired archive path.
+    DESC
+    option :verbose, type: :boolean, default: false, aliases: "-v"
+    def repair(archive, output)
+      Omnizip::Commands::ArchiveRepairCommand.new(options).run(archive, output)
+    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/rar5/header.rb

@@ -106,8 +106,10 @@ header_data: "")
 
         # File header
         class FileHeader < Header
-          # File header flags
-          FILE_HAS_ATTRIBUTES = 0x0001
+          # File header flags. Per the RAR 5.0 spec, 0x0001 marks a
+          # directory entry (what this codebase once mislabeled as
+          # "has attributes" — attributes are an always-present field)
+          FILE_IS_DIRECTORY = 0x0001
           FILE_HAS_MTIME = 0x0002
           FILE_HAS_CRC32 = 0x0004
 
@@ -119,23 +121,27 @@ header_data: "")
 
           def initialize(filename:, file_size:, compressed_size:,
                          compression_method: 0, dict_size: 0,
-                         flags: 0, mtime: nil, crc32: nil, extra_area: nil)
+                         flags: 0, mtime: nil, crc32: nil,
+                         directory: false, extra_area: nil)
             # Build file flags based on what's provided
             file_flags = 0
+            file_flags |= FILE_IS_DIRECTORY if directory
             file_flags |= FILE_HAS_MTIME if mtime
             file_flags |= FILE_HAS_CRC32 if crc32
 
             # Build header data with file information
             data = build_file_data(filename, file_size,
                                    compression_method, dict_size,
-                                   file_flags, mtime, crc32)
+                                   file_flags, mtime, crc32,
+                                   directory: directory)
             super(HEADER_TYPE_FILE, flags: flags, data_area_size: compressed_size, header_data: data, extra_area: extra_area)
           end
 
           private
 
           def build_file_data(filename, file_size, compression_method,
-                              dict_size, file_flags, mtime, crc32)
+                              dict_size, file_flags, mtime, crc32,
+                              directory: false)
             data = []
 
             # File flags (VINT)
@@ -145,8 +151,9 @@ header_data: "")
             data.concat(VINT.encode(file_size))
 
             # Attributes (VINT) - ALWAYS present in RAR5.
-            # Unix host: standard regular-file mode 0o100644.
-            data.concat(VINT.encode(0o100644))
+            # Unix host: directory mode for directory entries,
+            # regular-file 0o100644 otherwise.
+            data.concat(VINT.encode(directory ? 0o040755 : 0o100644))
 
             # mtime (optional) - only if FILE_HAS_MTIME flag is set
             # RAR5 stores mtime as Unix timestamp (seconds since epoch)

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

@@ -121,6 +121,22 @@ module Omnizip
             }
           end
 
+          # Add a name-only directory entry (empty trees survive
+          # archive creation instead of vanishing)
+          #
+          # @param archive_path [String] Directory path inside the
+          #   archive (trailing slash optional)
+          # @return [self]
+          def add_directory_entry(archive_path)
+            @files << {
+              input: nil,
+              archive: archive_path.chomp("/"),
+              mtime: Time.now,
+              directory: true,
+            }
+            self
+          end
+
           # Add directory recursively
           #
           # @param dir_path [String] Directory path
@@ -227,11 +243,18 @@ module Omnizip
           # @param files [Array<Hash>] Files to compress in solid mode
           # @return [void]
           def write_solid_block(io, files)
+            # Directory entries carry no data; write their headers
+            # separately so the solid stream indexes stay aligned
+            files.each do |file|
+              write_directory_file_entry(io, file) if file[:directory]
+            end
+            solid_files = files.reject { |f| f[:directory] }
+
             # Create solid manager
             manager = Solid::SolidManager.new(level: @options[:level])
 
             # Add all files to solid stream
-            files.each do |file|
+            solid_files.each do |file|
               data = File.binread(file[:input])
               manager.add_file(file[:archive], data, mtime: file[:mtime],
                                                      stat: file[:stat])
@@ -242,7 +265,7 @@ module Omnizip
 
             # Write each file header with references to the solid block
             # In RAR5, all files share the same compressed data
-            files.each_with_index do |file, idx|
+            solid_files.each_with_index do |file, idx|
               file_info = result[:files][idx]
 
               # Calculate CRC32 if needed (note: only for STORE in non-solid)
@@ -286,6 +309,8 @@ module Omnizip
           # @param io [IO] Output stream
           # @param file [Hash] File information
           def write_file_entry(io, file)
+            return write_directory_file_entry(io, file) if file[:directory]
+
             # Read file data
             data = File.binread(file[:input])
 
@@ -350,6 +375,24 @@ module Omnizip
             io.write(final_data)
           end
 
+          # Write a directory entry: FileFlags directory bit, zero
+          # sizes, no data area
+          #
+          # @param io [IO] Output stream
+          # @param file [Hash] Entry with :archive name and :mtime
+          def write_directory_file_entry(io, file)
+            header = FileHeader.new(
+              filename: file[:archive],
+              file_size: 0,
+              compressed_size: 0,
+              compression_method: Compression::Store::METHOD,
+              dict_size: 0,
+              mtime: @options[:include_mtime] ? file[:mtime] : nil,
+              directory: true,
+            )
+            io.write(header.encode)
+          end
+
           # Write End header
           #
           # @param io [IO] Output stream

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

@@ -93,6 +93,21 @@ module Omnizip
           warn_unimplemented_options
         end
 
+        # Add a name-only directory entry (empty trees survive
+        # archive creation instead of vanishing)
+        #
+        # @param archive_path [String] Directory path inside the
+        #   archive (trailing slash optional)
+        # @return [self]
+        def add_directory_entry(archive_path)
+          @files << {
+            source: nil,
+            archive_path: archive_path.chomp("/"),
+            directory: true,
+          }
+          self
+        end
+
         # Add file to archive
         #
         # @param file_path [String] Path to file
@@ -241,10 +256,17 @@ module Omnizip
             (directory ? METHOD_STORE : select_compression_method(file_data))
           compressed_data = compress_data(file_data, method)
 
-          stat = File.stat(file_path)
-          file_attr = directory ? 0o040755 : stat.mode
-          file_time = dos_time(stat.mtime)
-          data_crc = Zlib.crc32(file_data)
+          if directory && file_path.nil?
+            # Name-only directory entry: no source to stat
+            file_attr = 0o040755
+            file_time = dos_time(Time.now)
+            data_crc = 0
+          else
+            stat = File.stat(file_path)
+            file_attr = directory ? 0o040755 : stat.mode
+            file_time = dos_time(stat.mtime)
+            data_crc = Zlib.crc32(file_data)
+          end
 
           name_bytes = archive_path.encode("UTF-8").bytes
 

data/lib/omnizip/formats/rar.rb

@@ -174,8 +174,8 @@ module Omnizip
         # @param archive_path [String] Path to corrupted RAR archive
         # @param output_path [String] Path for repaired archive
         # @return [ArchiveRepairer::RepairResult] Repair result
-        def repair(archive_path, output_path)
-          ArchiveRepairer.new.repair(archive_path, output_path)
+        def repair(archive_path, output_path, options = {})
+          ArchiveRepairer.new.repair(archive_path, output_path, options)
         end
 
         private

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.44"
+  VERSION = "0.3.46"
 end

metadata

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