omnizip 0.3.44 → 0.3.45

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 358c03758aa086cbb4f3a22845af9f309542df3c272fc640faaaf807d3b2adb0
-  data.tar.gz: 96c8735854c4413b2cb802611eb7acd2d4480d1983b5dd4e4e4a45ebf35d3725
+  metadata.gz: c60c442839bff64ee405d6eb9c5f3ead4a97fa53df7ffd381ca0508dbb00b5e8
+  data.tar.gz: 22b8abfb94d6403e16ffea3c36115c6c7eb15eed654ef15f8a824453aa2eef20
 SHA512:
-  metadata.gz: 67ab99068276c2eef687be2d7497c911cdb96f920dea552b9392fe860cbc805345c8bf87f5f6640934b09d46b7fc3c598c8bb140a296f37395d2020ff9e0bbd6
-  data.tar.gz: 256599715a8f9aa94ee2e94376122a6571b8a7eb0e80548b74e57f14d2d2522a12fc6f3b5566f08c3b6a63692b06e3845a3d8948dfdf24fc53f22d79eebd434d
+  metadata.gz: f9a8b45c51e6c36d30273d7ac897eb4854793ed1548d4055dcf90335b836c9d3d1bb4db2faa374cf407345657fd5b459f16bf40021427387ae103ce54f1ed644
+  data.tar.gz: 412293ad5b9d9d3c361fe03f8ed88707f3cd5dc4fc4bc1221198e877a71eb98322ca4cc5664ac329dee117192738d4d1af6b8e79ca8cc080639cf69e83816d89

data/CHANGELOG.md

@@ -7,6 +7,31 @@ 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

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/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/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.45"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.44
+  version: 0.3.45
 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