omnizip 0.3.39 → 0.3.41

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

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
-begin
-  require "lutaml/model"
-rescue LoadError, ArgumentError
-  # lutaml-model not available, using simple classes
-end
+require "stringio"
+require "tmpdir"
 
 module Omnizip
   module Formats
     module Rar5
       # RAR v5 archive reader
       #
-      # Reads RAR 5.x format archives, parsing headers and extracting file data
-      # according to the RAR v5 specification.
+      # Adapter over the primary `Formats::Rar::Reader` — the one RAR5
+      # parser verified against real archives and unrar — exposing the
+      # legacy entry shape (uncompressed_size, modified_time, ...).
       #
       # RAR 5 uses variable-length integers (vint) and improved header structure.
       #
@@ -23,6 +21,17 @@ module Omnizip
       #     entries.each { |entry| puts entry.name }
       #   end
       class Reader < Omnizip::Formats::Rar::RarFormatBase
+        # RAR5 compression-method byte (cinfo bits 8-10) to the legacy
+        # symbol vocabulary
+        METHOD_SYMBOLS = {
+          0x30 => :store,
+          0x31 => :fastest,
+          0x32 => :fast,
+          0x33 => :normal,
+          0x34 => :good,
+          0x35 => :best,
+        }.freeze
+
         # Initialize a RAR v5 reader
         def initialize
           super("rar5")
@@ -32,314 +41,88 @@ module Omnizip
         #
         # @param io [IO] The input stream
         # @return [Array<Entry>] The archive entries
-        # @raise [FormatError] If the archive format is invalid
+        # @raise [FormatError] If the archive signature is invalid
         def read_archive(io)
-          unless verify_magic_bytes(io)
+          data = io.read
+          unless verify_magic_bytes(StringIO.new(data))
             raise FormatError, "Invalid RAR v5 signature"
           end
 
-          # Skip past the magic bytes (8 bytes)
-          io.seek(8, ::IO::SEEK_SET)
-
-          entries = []
-
-          # Read main header
-          main_header = read_header(io)
-          unless main_header.type == block_type_code(:main_header)
-            raise FormatError, "Expected main archive header"
-          end
-
-          @archive_flags = main_header.flags
-
-          # Skip to end of main header
-          skip_to_header_end(io, main_header)
-
-          # Read blocks until end marker or EOF/error
-          loop do
-            header = read_header(io)
-            break if header.type == block_type_code(:end_marker)
+          Dir.mktmpdir("omnizip_rar5_read") do |tmp|
+            archive_path = File.join(tmp, "archive.rar")
+            File.binwrite(archive_path, data)
 
-            case header.type
-            when block_type_code(:file_header)
-              entry = read_file_entry(io, header)
-              entries << entry if entry
-            when block_type_code(:service_header)
-              skip_header_data(io, header)
-            when block_type_code(:encryption_header)
-              read_encryption_header(io, header)
-            else
-              skip_header_data(io, header)
-            end
-          rescue EOFError, RangeError, FormatError
-            # Truncated or corrupted file - return what we have
-            break
+            primary = Rar::Reader.new(archive_path)
+            primary.open
+            primary.list_files.map { |entry| adapt_entry(entry) }
           end
-
-          entries
-        rescue EOFError, RangeError, FormatError
-          # Handle truncated/invalid files gracefully
-          []
         end
 
         private
 
-        # Skip to the end of a header
-        #
-        # @param io [IO] The input stream
-        # @param header [HeaderBlock] The header
-        def skip_to_header_end(io, header)
-          # Calculate end of header: header_start + 4 (CRC) + header_size + vint_length
-          header_end = header.header_start + 4 + header.size.to_i + header.vint_length.to_i
-
-          # Validate the offset is reasonable (max 1GB)
-          max_offset = 1_073_741_824
-          raise RangeError, "Header offset too large" if header_end > max_offset
-          raise RangeError, "Header offset negative" if header_end.negative?
-
-          io.seek(header_end, ::IO::SEEK_SET)
-        end
-
-        # Read a RAR v5 header
-        #
-        # @param io [IO] The input stream
-        # @return [HeaderBlock] The header block
-        def read_header(io)
-          # Record start position (before CRC)
-          header_start = io.pos
-
-          header_crc = io.read(4)&.unpack1("V")
-
-          # Read header size vint and track its length
-          header_size, vint_length = read_vint_with_length(io)
-
-          # Now we're at the start of header content
-          # header_size is the size of the content (from header_type to end)
-          content_start = io.pos
-
-          header_type = read_vint(io)
-          header_flags = read_vint(io)
-
-          # Read extra size if present
-          extra_size = 0
-          extra_size = read_vint(io) if header_flags & 0x0001 != 0
-
-          # Read data size if present
-          data_size = 0
-          data_size = read_vint(io) if header_flags & 0x0002 != 0
-
-          # Store positions for proper skipping
-          HeaderBlock.new(
-            crc: header_crc,
-            size: header_size,
-            vint_length: vint_length,
-            type: header_type,
-            flags: header_flags,
-            extra_size: extra_size,
-            data_size: data_size,
-            header_start: header_start,
-            content_start: content_start,
-          )
-        end
-
-        # Read a vint and return both value and length
-        #
-        # @param io [IO] The input stream
-        # @return [Array<Integer, Integer>] Value and length in bytes
-        def read_vint_with_length(io)
-          result = 0
-          shift = 0
-          length = 0
-
-          loop do
-            byte = io.read(1)&.unpack1("C")
-            raise FormatError, "Unexpected EOF" unless byte
-
-            length += 1
-            result |= (byte & 0x7F) << shift
-            break if byte.nobits?(0x80)
-
-            shift += 7
-          end
-
-          [result, length]
-        end
-
-        # Read a file entry from archive
-        #
-        # @param io [IO] The input stream
-        # @param header [HeaderBlock] The file header
-        # @return [Entry] The file entry
-        def read_file_entry(io, header)
-          flags = read_vint(io)
-          unpacked_size = read_vint(io)
-          attributes = read_vint(io)
-
-          # Read modification time if present; nil when the header
-          # does not carry one
-          mtime = nil
-          if flags & 0x02 != 0 # time_present flag
-            mtime = read_file_time(io)
-          end
-
-          # Read CRC32 if present
-          data_crc = 0
-          if flags & 0x04 != 0 # crc32_present flag
-            data_crc = io.read(4)&.unpack1("V")
-          end
-
-          # Read compression info
-          compression_flags = read_vint(io)
-          host_os = read_vint(io)
-          name_length = read_vint(io)
-
-          # Read filename (UTF-8 encoded)
-          name_bytes = io.read(name_length)
-          filename = name_bytes.force_encoding("UTF-8")
-
-          # Determine if directory
-          is_directory = flags.anybits?(0x01) # directory flag
-
-          # Skip to end of header
-          skip_to_header_end(io, header)
-
-          # Record data offset before skipping
-          data_offset = io.pos
-
-          # Skip file data (so we can read the next header)
-          if header.data_size.to_i.positive?
-            io.seek(header.data_size,
-                    ::IO::SEEK_CUR)
-          end
-
+        # Map a primary RarEntry onto the legacy Entry shape
+        def adapt_entry(entry)
           Entry.new(
-            name: filename,
-            compressed_size: header.data_size || 0,
-            uncompressed_size: unpacked_size,
-            crc32: data_crc,
-            compression_method: extract_compression_method(compression_flags),
-            modified_time: mtime,
-            attributes: attributes,
-            encrypted: header.flags.anybits?(0x04),
-            data_offset: data_offset,
-            host_os: host_os,
-            is_directory: is_directory,
+            name: entry.name,
+            compressed_size: entry.compressed_size,
+            uncompressed_size: entry.size,
+            crc32: entry.crc,
+            compression_method: METHOD_SYMBOLS[entry.method],
+            modified_time: entry.mtime,
+            attributes: entry.attributes,
+            encrypted: entry.encrypted,
+            host_os: entry.host_os,
+            is_directory: entry.is_dir,
           )
         end
 
-        # Extract compression method from flags
-        #
-        # @param flags [Integer] The compression flags
-        # @return [Symbol] The compression method
-        def extract_compression_method(flags)
-          method_code = flags & 0x07
-
-          case method_code
-          when 0 then :store
-          when 1 then :fastest
-          when 2 then :fast
-          when 3 then :normal
-          when 4 then :good
-          when 5 then :best
-          else :normal
+        class HeaderBlock
+          attr_accessor :crc, :size, :vint_length, :type, :flags, :extra_size,
+                        :data_size, :header_start, :content_start
+
+          def initialize(crc: nil, size: nil, vint_length: 1, type: nil, flags: nil,
+                         extra_size: nil, data_size: nil, header_start: nil, content_start: nil)
+            @crc = crc
+            @size = size
+            @vint_length = vint_length
+            @type = type
+            @flags = flags
+            @extra_size = extra_size
+            @data_size = data_size
+            @header_start = header_start
+            @content_start = content_start
           end
         end
 
-        # Read file time in RAR5 format
-        #
-        # @param io [IO] The input stream
-        # @return [Time] The file time
-        # RAR5 file headers store a 32-bit Unix timestamp when the
-        # mtime flag is set
-        def read_file_time(io)
-          unix_time = io.read(4)&.unpack1("V")
-          Time.at(unix_time) if unix_time
-        end
-
-        # Read encryption header
-        #
-        # @param io [IO] The input stream
-        # @param header [HeaderBlock] The header
-        # @return [void]
-        def read_encryption_header(io, header)
-          # Read and skip encryption data
-          skip_header_data(io, header)
-        end
-
-        # Skip header data
-        #
-        # @param io [IO] The input stream
-        # @param header [HeaderBlock] The header
-        # @return [void]
-        def skip_header_data(io, header)
-          # Calculate end of header: header_start + 4 (CRC) + header_size + vint_length
-          header_end = header.header_start.to_i + 4 + header.size.to_i + header.vint_length.to_i
-          current_pos = io.pos
-
-          # Validate the offset is reasonable (max 1GB)
-          max_offset = 1_073_741_824
-          if header_end > max_offset || header_end.negative?
-            raise RangeError, "Invalid header offset"
+        # RAR v5 archive entry model
+        class Entry
+          include Omnizip::Entry
+
+          attr_accessor :name, :compressed_size, :uncompressed_size, :crc32,
+                        :compression_method, :modified_time, :attributes,
+                        :encrypted, :data_offset, :host_os, :is_directory
+
+          def entry_name = name
+          def entry_directory? = is_directory
+          def entry_size = uncompressed_size
+          def entry_mtime = modified_time
+
+          def initialize(name: nil, compressed_size: nil, uncompressed_size: nil,
+                         crc32: nil, compression_method: nil, modified_time: nil,
+                         attributes: nil, encrypted: nil, data_offset: nil,
+                         host_os: nil, is_directory: nil)
+            @name = name
+            @compressed_size = compressed_size
+            @uncompressed_size = uncompressed_size
+            @crc32 = crc32
+            @compression_method = compression_method
+            @modified_time = modified_time
+            @attributes = attributes
+            @encrypted = encrypted
+            @data_offset = data_offset
+            @host_os = host_os
+            @is_directory = is_directory
           end
-
-          if header_end > current_pos
-            io.seek(header_end - current_pos, ::IO::SEEK_CUR)
-          end
-
-          # Skip data section if present (with bounds checking)
-          data_size = header.data_size.to_i
-          if data_size.positive? && data_size < max_offset
-            io.seek(data_size, ::IO::SEEK_CUR)
-          end
-        end
-      end
-
-      # RAR v5 header block model
-      class HeaderBlock
-        attr_accessor :crc, :size, :vint_length, :type, :flags, :extra_size,
-                      :data_size, :header_start, :content_start
-
-        def initialize(crc: nil, size: nil, vint_length: 1, type: nil, flags: nil,
-                       extra_size: nil, data_size: nil, header_start: nil, content_start: nil)
-          @crc = crc
-          @size = size
-          @vint_length = vint_length
-          @type = type
-          @flags = flags
-          @extra_size = extra_size
-          @data_size = data_size
-          @header_start = header_start
-          @content_start = content_start
-        end
-      end
-
-      # RAR v5 archive entry model
-      class Entry
-        include Omnizip::Entry
-
-        attr_accessor :name, :compressed_size, :uncompressed_size, :crc32,
-                      :compression_method, :modified_time, :attributes,
-                      :encrypted, :data_offset, :host_os, :is_directory
-
-        def entry_name = name
-        def entry_directory? = is_directory
-        def entry_size = uncompressed_size
-        def entry_mtime = modified_time
-
-        def initialize(name: nil, compressed_size: nil, uncompressed_size: nil,
-                       crc32: nil, compression_method: nil, modified_time: nil,
-                       attributes: nil, encrypted: nil, data_offset: nil,
-                       host_os: nil, is_directory: nil)
-          @name = name
-          @compressed_size = compressed_size
-          @uncompressed_size = uncompressed_size
-          @crc32 = crc32
-          @compression_method = compression_method
-          @modified_time = modified_time
-          @attributes = attributes
-          @encrypted = encrypted
-          @data_offset = data_offset
-          @host_os = host_os
-          @is_directory = is_directory
         end
       end
     end

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

@@ -1,23 +1,13 @@
-# frozen_string_literal: true
+# frozen_string: true
 
-begin
-  require "lutaml/model"
-rescue LoadError, ArgumentError
-  # lutaml-model not available, using simple classes
-end
-
-require "stringio"
+require "fileutils"
+require "tmpdir"
 
 module Omnizip
   module Formats
     module Rar5
       # RAR v5 archive writer
       #
-      # Writes RAR 5.x format archives, creating headers and compressing file
-      # data according to the RAR v5 specification.
-      #
-      # RAR 5 uses variable-length integers and improved header structure.
-      #
       # @example Writing a RAR5 archive
       #   writer = Rar5::Writer.new
       #   File.open("archive.rar", "wb") do |file|
@@ -26,185 +16,48 @@ module Omnizip
       #     ]
       #     writer.write_archive(file, entries)
       #   end
-      class Writer < Rar::RarFormatBase
+      class Writer < Omnizip::Formats::Rar::RarFormatBase
         # Initialize a RAR v5 writer
         def initialize
           super("rar5")
-          @compressor = Compressor.new
         end
 
         # Write a RAR v5 archive
         #
+        # Delegates to the primary `Formats::Rar::Rar5::Writer` so the
+        # output is spec-conformant and unrar-verified: entries spill
+        # to a temporary file, the primary writer produces the
+        # archive, and the bytes are copied into the given IO.
+        # Compression methods above :store are not official-RAR
+        # compatible, so the primary writer stores them (with a
+        # warning) rather than emitting an undecodable stream.
+        #
         # @param io [IO] The output stream
         # @param entries [Array<Hash>] The entries to write
         # @return [void]
         def write_archive(io, entries)
-          # Write magic bytes
-          io.write(spec.magic_bytes.pack("C*"))
-
-          # Write main header
-          write_main_header(io)
-
-          # Write file entries
-          entries.each do |entry|
-            write_file_entry(io, entry)
+          Dir.mktmpdir("omnizip_rar5_write") do |tmp|
+            archive_path = File.join(tmp, "archive.rar")
+            primary = Rar::Rar5::Writer.new(archive_path,
+                                            include_mtime: true,
+                                            include_crc32: true)
+
+            entries.each do |entry|
+              name = entry[:name] || entry["name"]
+              data = entry[:data] || entry["data"]
+              mtime = entry[:time] || entry["time"] || Time.now
+
+              file_path = File.join(tmp, "entries", name)
+              FileUtils.mkdir_p(File.dirname(file_path))
+              File.binwrite(file_path, data.to_s)
+              File.utime(mtime, mtime, file_path)
+
+              primary.add_file(file_path, name)
+            end
+
+            primary.write
+            io.write(File.binread(archive_path))
           end
-
-          # Write end marker
-          write_end_marker(io)
-        end
-
-        private
-
-        # Write main archive header
-        #
-        # @param io [IO] The output stream
-        # @return [void]
-        def write_main_header(io)
-          flags = 0
-
-          header_data = StringIO.new
-          write_vint(header_data, flags)
-
-          write_header(
-            io,
-            type: block_type_code(:main_header),
-            flags: 0,
-            data: header_data.string,
-          )
-        end
-
-        # Write a file entry
-        #
-        # @param io [IO] The output stream
-        # @param entry [Hash] The entry data
-        # @return [void]
-        def write_file_entry(io, entry)
-          name = entry[:name] || entry["name"]
-          data = entry[:data] || entry["data"]
-          mtime = entry[:time] || entry["time"] || Time.now
-          method = entry[:method] || entry["method"] || :normal
-
-          # Compress data
-          compressed_data = @compressor.compress(data, method: method)
-
-          # Calculate sizes and CRC
-          compressed_data.bytesize
-          unpacked_size = data.bytesize
-          file_crc = calculate_crc32(data)
-
-          # Encode filename to UTF-8
-          name_bytes = name.encode("UTF-8")
-          name_length = name_bytes.bytesize
-
-          # Build file header data
-          file_flags = spec.format.file_header_flags[:time_present] |
-            spec.format.file_header_flags[:crc32_present]
-
-          compression_info = compression_method_code(method) & 0x07
-
-          header_data = StringIO.new
-          write_vint(header_data, file_flags)
-          write_vint(header_data, unpacked_size)
-          write_vint(header_data, 0x20) # Attributes (normal file)
-
-          # Write modification time
-          write_file_time(header_data, mtime)
-
-          # Write CRC32
-          header_data.write([file_crc].pack("V"))
-
-          # Write compression info
-          write_vint(header_data, compression_info)
-          write_vint(header_data, spec.format.host_os[:windows])
-          write_vint(header_data, name_length)
-          header_data.write(name_bytes)
-
-          # Write header with data
-          write_header(
-            io,
-            type: block_type_code(:file_header),
-            flags: 0x0002, # Has data size
-            data: header_data.string,
-            data_section: compressed_data,
-          )
-        end
-
-        # Write end marker
-        #
-        # @param io [IO] The output stream
-        # @return [void]
-        def write_end_marker(io)
-          write_header(
-            io,
-            type: block_type_code(:end_marker),
-            flags: 0x0004, # Archive end flag
-            data: "",
-          )
-        end
-
-        # Write a RAR v5 header
-        #
-        # @param io [IO] The output stream
-        # @param type [Integer] The header type
-        # @param flags [Integer] The header flags
-        # @param data [String] The header data
-        # @param data_section [String, nil] Optional data section
-        # @return [void]
-        def write_header(io, type:, flags:, data:, data_section: nil)
-          header_io = StringIO.new
-
-          # Calculate header size (not including CRC)
-          size_bytes = StringIO.new
-          write_vint(size_bytes, type)
-          write_vint(size_bytes, flags)
-
-          if data_section
-            flags |= 0x0002 # Has data size flag
-            write_vint(size_bytes, data_section.bytesize)
-          end
-
-          size_bytes.write(data)
-
-          header_size = size_bytes.string.bytesize
-
-          # Write size vint
-          write_vint(header_io, header_size)
-
-          # Write type and flags
-          write_vint(header_io, type)
-          write_vint(header_io, flags)
-
-          # Write data size if present
-          write_vint(header_io, data_section.bytesize) if data_section
-
-          # Write header data
-          header_io.write(data)
-
-          # Calculate CRC32 of header (excluding CRC field itself)
-          header_crc = calculate_crc32(header_io.string)
-
-          # Write CRC and header to output
-          io.write([header_crc].pack("V"))
-          io.write(header_io.string)
-
-          # Write data section if present
-          io.write(data_section) if data_section
-        end
-
-        # Write file time in RAR5 format
-        #
-        # @param io [IO] The output stream
-        # @param time [Time] The time to write
-        # @return [void]
-        def write_file_time(io, time)
-          # RAR5 uses Windows FILETIME format (100-nanosecond intervals since
-          # 1601-01-01). Simplified implementation.
-          unix_time = time.to_i
-          windows_time = (unix_time + 11_644_473_600) * 10_000_000
-
-          write_vint(io, 0x01) # Time flags (modification time present)
-          io.write([windows_time].pack("Q<"))
         end
       end
     end

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

@@ -68,6 +68,23 @@ module Omnizip
           @entries << entry
         end
 
+        # Add an explicit directory entry with no data or stream
+        #
+        # @param archive_path [String] Directory path inside the
+        #   archive (trailing slash optional)
+        # @return [self]
+        def add_directory_entry(archive_path)
+          entry = Models::FileEntry.new
+          entry.name = archive_path.chomp("/")
+          entry.source_path = nil
+          entry.size = 0
+          entry.is_dir = true
+          entry.has_stream = false
+          entry.mtime = Time.now
+          @entries << entry
+          self
+        end
+
         def write
           # Collect any files from the collector (if add_file/add_directory was used)
           collected_entries = @collector.collect_files