omnizip 0.3.40 → 0.3.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5013ae71553867968422f57b01425820f17c5cd6e471ea0cb5b5d46d1cc6a1bd
-  data.tar.gz: 94698e90386f195cdd7f5fd7a8ebae3010f2f206e70eb96463ce8e4d2ece09b0
+  metadata.gz: 919a322870094f270bd574530af4c463b6446586fdf869026b79ad017834bc1e
+  data.tar.gz: 55507eb0b2da4109cb094e711cda2d39df10773c9774c4a01614edc0d8548d9a
 SHA512:
-  metadata.gz: 415d4cdcb48375d0ba0d1d57dc2592c18d47fcafb9817d956dbe5a3ec7e1fa1048063372759de1ff0c0ef194d06eaa7f5855cfead144681e1fb454ac4fc510b2
-  data.tar.gz: a901b525b49f60b94098d43a5c4517f5163e07b64ef08099c02f693fc50775461c584ee35f2a6227167bbd461cfcbd9e3985b2383c586610817363170f45a2ef
+  metadata.gz: 73b03468e2bb51d227059f316ab4fce911ce19ee6e0c175559de7b1df58a69536d9284d2b5ee2a0a19366ef0c53d448d02e4b95f397042c69c569630aacea86f
+  data.tar.gz: dad012852021f331f77a36bf86842274f612d215e32829965bf4bbaf5ad8b9b17539eb7e531a55e73c93d206c73a66760ccde6dfcf234b49e371f17f79451df8

data/CHANGELOG.md

@@ -7,6 +7,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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/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/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,45 @@ 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
             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! (tests); directories live
+          # in the system temp dir until process exit.
+          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
 
           # 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)"

data/lib/omnizip/formats/rar.rb

@@ -127,6 +127,9 @@ module Omnizip
       class << self
         # Create a RAR archive, yielding the writer for entries.
         # RAR5 is the default; pass version: 4 for the RAR4 writer.
+        # RAR5-only options (solid, multi-volume, password, recovery)
+        # are ignored for RAR4 — its writer warns about the
+        # unimplemented ones and raises for passwords.
         #
         # @param path [String] Output archive path
         # @param options [Hash] Writer options
@@ -137,7 +140,7 @@ module Omnizip
           writer = if version == 4
                      Writer.new(path, options)
                    else
-                     Rar5::Writer.new(path, options)
+                     Rar5::Writer.new(path, rar5_options(options))
                    end
           yield writer if block_given?
           writer.write
@@ -173,6 +176,16 @@ module Omnizip
         def repair(archive_path, output_path)
           ArchiveRepairer.new.repair(archive_path, output_path)
         end
+
+        private
+
+        # Writer keywords the RAR5 writer understands
+        def rar5_options(options)
+          options.slice(:compression, :level, :solid, :multi_volume,
+                        :volume_size, :volume_naming, :password,
+                        :kdf_iterations, :recovery, :recovery_percent,
+                        :include_mtime, :include_crc32, :dict_size)
+        end
       end
     end
   end