omnizip 0.3.37 → 0.3.39

data/docs/reference/api/overview.adoc

@@ -99,15 +99,16 @@ writer.close
 [source,ruby]
 ----
 # 7z archive
-writer = Omnizip::Formats::SevenZip::Writer.new('archive.7z')
-writer.add_file('document.txt')
-writer.add_directory('photos/')
-writer.close
+Omnizip::Formats::SevenZip.create('archive.7z') do |writer|
+  writer.add_file('document.txt')
+  writer.add_directory('photos/')
+end
 
 # ZIP archive
 writer = Omnizip::Formats::Zip::Writer.new('archive.zip')
 writer.add_file('document.txt')
-writer.close
+writer.add_directory('photos/')
+writer.write
 ----
 
 ==== Extracting Archives
@@ -115,26 +116,24 @@ writer.close
 [source,ruby]
 ----
 # 7z archive
-reader = Omnizip::Formats::SevenZip::Reader.new('archive.7z')
-reader.extract_all('output/')
-reader.close
+Omnizip::Formats::SevenZip.open('archive.7z') do |reader|
+  reader.extract_all('output/')
+end
 
-# ZIP archive
-reader = Omnizip::Formats::Zip::Reader.new('archive.zip')
+# ZIP archive (call .read to parse before extracting)
+reader = Omnizip::Formats::Zip::Reader.new('archive.zip').read
 reader.extract_all('output/')
-reader.close
 ----
 
 ==== Listing Contents
 
 [source,ruby]
 ----
-reader = Omnizip::Formats::SevenZip::Reader.new('archive.7z')
-reader.open
-reader.each_file do |entry|
-  puts "#{entry.name}: #{entry.size} bytes"
+Omnizip::Formats::SevenZip.open('archive.7z') do |reader|
+  reader.list_files.each do |entry|
+    puts "#{entry.name}: #{entry.size} bytes"
+  end
 end
-reader.close
 ----
 
 === Error Handling
@@ -145,7 +144,7 @@ begin
   Omnizip.compress_file('input.txt', 'output.lzma')
 rescue Omnizip::CompressionError => e
   puts "Compression failed: #{e.message}"
-rescue Omnizip::AlgorithmNotFound => e
+rescue Omnizip::AlgorithmNotFoundError => e
   puts "Algorithm not found: #{e.message}"
 rescue IOError => e
   puts "I/O error: #{e.message}"

data/docs/troubleshooting/index.adoc

@@ -188,11 +188,8 @@ omnizip archive create archive.zip files/ \
 
 [source,ruby]
 ----
-# Try RAR4 reader
+# One reader covers both RAR4 and RAR5 (version auto-detected)
 reader = Omnizip::Formats::Rar::Reader.new('archive.rar')
-
-# Or RAR5 reader
-reader = Omnizip::Formats::Rar::Rar5::Reader.new('archive.rar')
 ----
 
 ### Getting Help

data/lib/omnizip/archive_handler.rb

@@ -71,6 +71,8 @@ module Omnizip
       tar: -> { Omnizip::ArchiveHandlers::TarHandler },
       seven_zip: -> { Omnizip::ArchiveHandlers::SevenZipHandler },
       rar: -> { Omnizip::ArchiveHandlers::RarHandler },
+      cpio: -> { Omnizip::ArchiveHandlers::CpioHandler },
+      iso: -> { Omnizip::ArchiveHandlers::IsoHandler },
     }.freeze
     private_constant :LAZY_LOAD_TRIGGERS
   end

data/lib/omnizip/archive_handlers/cpio_handler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Omnizip
+  module ArchiveHandlers
+    # Read-only adapter for the CPIO format (initramfs images, RPM
+    # payloads). Extraction and listing are supported; CPIO writing
+    # exists at the format level but is not exposed through the
+    # convenience archive API.
+    class CpioHandler
+      def create(_path, **_options)
+        raise Omnizip::UnsupportedFormatError,
+              "cpio archives cannot be created through the convenience " \
+              "API; use Omnizip::Formats::Cpio.create directly"
+      end
+
+      def extract_to(path, output_dir, **_)
+        Omnizip::Formats::Cpio.extract(path, output_dir)
+      end
+
+      def list(path, details: false, **_)
+        entries = Omnizip::Formats::Cpio.list(path)
+        if details
+          entries.map do |e|
+            { name: e.name, size: e.data.bytesize,
+              directory: e.name.end_with?("/"), mtime: nil }
+          end
+        else
+          entries.map(&:name)
+        end
+      end
+
+      def read_entry(path, entry_name, **_)
+        entry = Omnizip::Formats::Cpio.list(path)
+          .find { |e| e.name == entry_name }
+        unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_name}"
+        end
+
+        entry.data
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:cpio, Omnizip::ArchiveHandlers::CpioHandler.new)

data/lib/omnizip/archive_handlers/iso_handler.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Omnizip
+  module ArchiveHandlers
+    # Read-only adapter for the ISO 9660 format (disk images).
+    # Extraction and listing are supported; ISO writing exists at the
+    # format level but is not exposed through the convenience archive
+    # API.
+    class IsoHandler
+      def create(_path, **_options)
+        raise Omnizip::UnsupportedFormatError,
+              "iso images cannot be created through the convenience " \
+              "API; use Omnizip::Formats::Iso.create directly"
+      end
+
+      def extract_to(path, output_dir, **_)
+        Omnizip::Formats::Iso.extract(path, output_dir)
+      end
+
+      def list(path, details: false, **_)
+        entries = Omnizip::Formats::Iso.list(path)
+        if details
+          entries.map do |e|
+            { name: e.full_path, size: e.size, directory: e.directory?,
+              mtime: e.recording_date }
+          end
+        else
+          entries.map(&:full_path)
+        end
+      end
+
+      def read_entry(path, entry_name, **_)
+        entry = Omnizip::Formats::Iso.list(path)
+          .find { |e| e.full_path == entry_name }
+        unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_name}"
+        end
+        raise Errno::EISDIR, "Entry is a directory: #{entry_name}" if entry.directory?
+
+        Dir.mktmpdir("omnizip-iso-entry") do |dir|
+          dest = File.join(dir, "entry")
+          Omnizip::Formats::Iso.open(path) do |iso|
+            iso.extract_entry(entry_name, dest)
+          end
+          File.binread(dest)
+        end
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:iso, Omnizip::ArchiveHandlers::IsoHandler.new)

data/lib/omnizip/archive_handlers.rb

@@ -9,5 +9,7 @@ module Omnizip
     autoload :TarHandler, "omnizip/archive_handlers/tar_handler"
     autoload :SevenZipHandler, "omnizip/archive_handlers/seven_zip_handler"
     autoload :RarHandler, "omnizip/archive_handlers/rar_handler"
+    autoload :CpioHandler, "omnizip/archive_handlers/cpio_handler"
+    autoload :IsoHandler, "omnizip/archive_handlers/iso_handler"
   end
 end

data/lib/omnizip/cli.rb

@@ -25,6 +25,28 @@ module Omnizip
   # under Omnizip::Cli would re-trigger this file's autoload
   # mid-load.
   module Shared
+    # Thor 1.x does not treat --help/-h on subcommands as a request
+    # for help: the flag reaches the command as a positional argument
+    # and arity checking fails. Classes extending this module route
+    # those flags to the standard help output instead.
+    module HelpDispatch
+      def dispatch(meth, given_args, given_opts, config)
+        wants_help = [Array(given_args), Array(given_opts)].any? do |list|
+          list.include?("--help") || list.include?("-h")
+        end
+        if wants_help
+          name = meth || Array(given_args).grep_v(/\A-/).first
+          # Subcommand groups intercept their own --help (e.g.
+          # "archive create --help" must show the create usage).
+          return super if subcommands.include?(name)
+
+          return start(["help", name].compact, config)
+        end
+
+        super
+      end
+    end
+
     # Print a formatted error message and exit nonzero.
     #
     # @param error [StandardError] the error to display
@@ -51,6 +73,7 @@ module Omnizip
   # Profile commands subcommand group
   class ProfileCommands < Thor
     include Shared
+    extend Shared::HelpDispatch
 
     class << self
       def exit_on_failure?
@@ -99,6 +122,7 @@ module Omnizip
   # Archive commands subcommand group
   class ArchiveCommands < Thor
     include Shared
+    extend Shared::HelpDispatch
 
     class << self
       def exit_on_failure?
@@ -328,6 +352,7 @@ module Omnizip
   # files using various compression algorithms.
   class Cli < Thor
     include Shared
+    extend Shared::HelpDispatch
 
     class << self
       def exit_on_failure?

data/lib/omnizip/convenience.rb

@@ -230,16 +230,18 @@ module Omnizip
       ".7z" => :seven_zip,
     }.freeze
 
-    # Extensions naming real formats this gem can READ but not write
-    # through the convenience API. Writing them a ZIP under a foreign
-    # name was silent corruption; failing truthfully is the only
-    # honest behavior.
+    # Extensions naming formats with read-only convenience routing.
+    # Writing them a ZIP under a foreign name was silent corruption;
+    # creation raises truthfully instead (the format-level writers
+    # exist for RAR/CPIO/ISO but are not part of the archive API).
     READ_ONLY_FORMAT_EXTENSIONS = [".rar", ".iso", ".cpio"].freeze
 
     # Extensions whose format has a READ-ONLY handler: extraction and
     # listing route to it, while creation keeps raising.
     READ_ARCHIVE_FORMAT_EXTENSIONS = {
       ".rar" => :rar,
+      ".cpio" => :cpio,
+      ".iso" => :iso,
     }.freeze
 
     # Extension -> single-file decompressor (stream interface).

data/lib/omnizip/formats/iso/directory_builder.rb

@@ -43,6 +43,12 @@ module Omnizip
           # Allocate sectors for directories and files
           allocate_sectors(tree)
 
+          # Tree nodes are separate hashes from @files entries; copy
+          # the allocated file locations onto the tree so directory
+          # records reference the real extents (otherwise every
+          # record points at sector 0).
+          assign_file_locations(tree)
+
           # Build path table
           path_table = build_path_table(tree)
 
@@ -143,6 +149,24 @@ module Omnizip
           allocate_file_sectors
         end
 
+        # Copy allocated file locations onto the matching tree nodes
+        #
+        # @param tree [Hash] Directory tree root
+        def assign_file_locations(tree)
+          walk = lambda do |node|
+            (node[:children] || []).each do |child|
+              if child[:directory]
+                walk.call(child)
+              else
+                match = @files.find { |f| f[:iso_path] == child[:iso_path] }
+                child[:location] = match[:location] if match
+                child[:size] = match[:size] if match
+              end
+            end
+          end
+          walk.call(tree)
+        end
+
         # Allocate sectors for a directory
         #
         # @param dir_node [Hash] Directory node

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

@@ -90,8 +90,8 @@ module Omnizip
           @entries.each do |entry|
             next if entry.current_directory? || entry.parent_directory?
 
-            output_path = File.join(output_dir, entry.name)
-            extract_entry(entry.name, output_path)
+            output_path = File.join(output_dir, entry.full_path)
+            extract_entry(entry.full_path, output_path)
           end
         end
 

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

@@ -178,8 +178,13 @@ module Omnizip
             preparer: "OMNIZIP #{Omnizip::VERSION}",
             application: "OMNIZIP",
             level: 2,
-            rock_ridge: true,
-            joliet: true,
+            # Rock Ridge System Use fields and Joliet UCS-2 directory
+            # trees are not implemented; advertising either extension
+            # makes readers misparse the image (e.g. 7-Zip reads the
+            # ASCII names as UCS-2 via the cloned SVD), so both stay
+            # off until real implementations land.
+            rock_ridge: false,
+            joliet: false,
           }
         end
 
@@ -193,6 +198,7 @@ module Omnizip
             source: File.expand_path(dir_path),
             iso_path: iso_path,
             stat: File.stat(dir_path),
+            directory: true,
           }
 
           # Add all contents
@@ -219,6 +225,7 @@ module Omnizip
             source: File.expand_path(dir_path),
             iso_path: iso_path,
             stat: File.stat(dir_path),
+            directory: true,
           }
 
           Dir.foreach(dir_path) do |entry|
@@ -283,13 +290,22 @@ module Omnizip
         # @param builder [VolumeBuilder] Volume builder
         # @param dir_structure [Hash] Directory structure
         def write_volume_descriptors(io, builder, dir_structure)
+          # Fixed layout: 16 PVD, 17 terminator, 18 path table (L),
+          # 19 path table (BE), directory data from sector 22.
+          root = dir_structure[:root].merge(
+            total_sectors: dir_structure[:total_sectors],
+            path_table_size: dir_structure[:path_table_size],
+            path_table_location: 18,
+            path_table_location_be: 19,
+          )
+
           # Write primary volume descriptor
-          pvd = builder.build_primary(dir_structure[:root])
+          pvd = builder.build_primary(root)
           io.write(pvd)
 
           # Write Joliet supplementary descriptor if enabled
           if @joliet
-            svd = builder.build_joliet(dir_structure[:root])
+            svd = builder.build_joliet(root)
             io.write(svd)
           end
 

data/lib/omnizip/formats/iso.rb

@@ -69,7 +69,9 @@ module Omnizip
       # @param path [String] Path to ISO file
       # @return [Array<DirectoryRecord>] Directory entries
       def self.list(path)
-        open(path, &:entries)
+        entries = nil
+        open(path) { |iso| entries = iso.entries }
+        entries
       end
 
       # Extract ISO contents

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

@@ -76,6 +76,9 @@ module Omnizip
           # 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("\\", "/")
 
           # Set entry properties
           entry.size = unpack_size
@@ -88,18 +91,25 @@ module Omnizip
           entry.attributes = attr
           entry.mtime = dos_time_to_time(file_time)
 
-          # Set flags
-          entry.is_dir = head_flags.anybits?(FILE_DIRECTORY)
+          # Set flags. RAR4 directory entries carry the full
+          # dictionary mask 0xE0 in HEAD_FLAGS (a directory has no
+          # dictionary); the exact match avoids misreading a large
+          # dictionary size on files as the marker.
+          entry.is_dir = head_flags.allbits?(FILE_DIRECTORY)
+          # WinRAR writes directory names with a trailing backslash;
+          # normalize it away for host paths.
+          entry.name = entry.name.chomp("\\") if entry.is_dir
           entry.encrypted = head_flags.anybits?(FILE_ENCRYPTED)
           entry.split_before = head_flags.anybits?(FILE_SPLIT_BEFORE)
           entry.split_after = head_flags.anybits?(FILE_SPLIT_AFTER)
 
-          # Skip remaining header data and file data
-          # Fixed fields: TYPE(1) + FLAGS(2) + SIZE(2) + PACK_SIZE(4) + UNPACK_SIZE(4) +
-          #               HOST_OS(1) + FILE_CRC(4) + FILE_TIME(4) + VERSION(1) + METHOD(1) +
-          #               NAME_SIZE(2) + ATTR(4) = 30 bytes
-          remaining = head_size - (name_size + 30)
-          remaining += 8 if head_flags.anybits?(FILE_LARGE)
+          # Skip remaining header data and file data. HEAD_SIZE
+          # counts the whole block including the 2-byte HEAD_CRC;
+          # consumed so far: 2 (CRC) + 30 (fixed fields) + name, plus
+          # 8 more when high-size words were present. Leftover bytes
+          # cover salt/extra time fields without interpreting them.
+          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
 

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

@@ -21,6 +21,10 @@ module Omnizip
         BLOCK_SUBBLOCK = 0x7A
         BLOCK_ENDARC = 0x7B
 
+        # HEAD_FLAGS bit 0x8000 (LONG_BLOCK): the block carries a
+        # data area whose size is the PACK_SIZE field at offset 7
+        BLOCK_LONG = 0x8000
+
         # Archive flags
         ARCHIVE_VOLUME = 0x0001
         ARCHIVE_COMMENT = 0x0002

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

@@ -152,7 +152,7 @@ module Omnizip
                 "WinRAR", "UnRAR.exe"
               ),
             ].each do |path|
-              return "\"#{path}\"" if File.exist?(path)
+              return path if File.exist?(path)
             end
 
             nil
@@ -176,7 +176,7 @@ module Omnizip
           def command_version
             return nil unless command_available?
 
-            output = `#{command_path} 2>&1`
+            output = `"#{command_path}" 2>&1`
             output.match(/UNRAR\s+([\d.]+)/i)&.captures&.first || "unknown"
           end
 
@@ -191,7 +191,7 @@ module Omnizip
           # Extract with system command
           def extract_with_command(archive_path, output_dir, password)
             cmd = build_extract_command(archive_path, output_dir, password)
-            return if system(cmd)
+            return if system(*cmd)
 
             raise "Command extraction failed: #{archive_path}"
           end
@@ -215,7 +215,7 @@ module Omnizip
 
           # List with system command
           def list_with_command(archive_path)
-            output = `#{command_path} vb "#{archive_path}" 2>&1`
+            output = `"#{command_path}" vb "#{archive_path}" 2>&1`
             raise "Command listing failed" unless $CHILD_STATUS.success?
 
             output.split("\n").map do |line|
@@ -240,7 +240,7 @@ module Omnizip
                                          output_path, password)
             temp_dir = Dir.mktmpdir
             cmd = build_extract_command(archive_path, temp_dir, password)
-            unless system(cmd)
+            unless system(*cmd)
               raise "Command entry extraction failed: #{entry_name}"
             end
 
@@ -252,9 +252,13 @@ module Omnizip
 
           # Build extract command
           def build_extract_command(archive_path, output_dir, password)
-            cmd = "#{command_path} x -y"
-            cmd += " -p#{password}" if password
-            cmd += " \"#{archive_path}\" \"#{output_dir}/\""
+            # Array form: no shell involved, so paths and passwords
+            # with special characters stay literal. -idq silences the
+            # per-file progress banner.
+            cmd = [command_path, "x", "-idq", "-y"]
+            cmd << "-p#{password}" if password
+            cmd << archive_path
+            cmd << "#{output_dir}/"
             cmd
           end
 

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

@@ -84,20 +84,12 @@ module Omnizip
 
         # Parse RAR4 header
         #
+        # The 7-byte signature consumed by #parse IS the marker
+        # block, so the main header follows immediately.
+        #
         # @param io [IO] Input stream
         def parse_rar4_header(io)
-          # Read marker block
-          read_uint16(io)
-          head_type = io.read(1)&.ord
-          read_uint16(io)
-          read_uint16(io)
-
-          unless head_type == BLOCK_MARKER
-            raise "Expected marker block, got 0x#{head_type.to_s(16)}"
-          end
-
-          # Read archive header
-          read_uint16(io)
+          read_uint16(io) # HEAD_CRC
           head_type = io.read(1)&.ord
           head_flags = read_uint16(io)
           head_size = read_uint16(io)
@@ -112,9 +104,9 @@ module Omnizip
           @is_locked = head_flags.anybits?(ARCHIVE_LOCKED)
           @comment_present = head_flags.anybits?(ARCHIVE_COMMENT)
 
-          # Skip rest of archive header
-          # head_size includes TYPE(1) + FLAGS(2) + SIZE(2) = 5 bytes already read
-          remaining = head_size - 5
+          # Skip rest of archive header. HEAD_SIZE counts the whole
+          # block including the 2 HEAD_CRC bytes; 7 bytes consumed.
+          remaining = head_size - 7
           io.read(remaining) if remaining.positive?
         end
 

data/lib/omnizip/formats/rar/rar5/compression/lzss.rb

@@ -42,9 +42,11 @@ module Omnizip
               #
               # @return [Boolean] true if implemented
               def available?
-                # Full LZSS decoder is now implemented
-                # Encoder is not yet compatible with official RAR tools
-                true
+                # Decoder is implemented; the encoder is NOT compatible
+                # with official RAR tools (unrar "tests" its output as
+                # OK while extracting empty files). Callers fall back
+                # to STORE until a RAR-compatible encoder lands.
+                false
               end
 
               # Compress data using RAR5 LZSS