omnizip 0.3.2 → 0.3.4

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

@@ -22,17 +22,20 @@ module Omnizip
         def self.build_from_folder(folder)
           return nil if folder.coders.empty?
 
-          # For now, support single coder or coder+filter combinations
-          main_coder = folder.coders.last
+          # Find the compression method (not a filter) among coders
+          # Filters like BCJ, BCJ2 have specific method IDs
+          main_coder = find_compression_coder(folder.coders)
+          raise "No compression method found in folder" unless main_coder
+
           algorithm = algorithm_for_method(main_coder.method_id)
 
-          # Check for filters
+          # Check for filters (all coders except the compression method)
           filters = []
-          if folder.coders.size > 1
-            folder.coders[0..-2].each do |coder|
-              filter = filter_for_method(coder.method_id)
-              filters << filter if filter
-            end
+          folder.coders.each do |coder|
+            next if coder == main_coder
+
+            filter = filter_for_method(coder.method_id)
+            filters << filter if filter
           end
 
           {
@@ -43,6 +46,25 @@ module Omnizip
           }
         end
 
+        # Find the compression coder among all coders
+        #
+        # @param coders [Array<Models::CoderInfo>] All coders in the folder
+        # @return [Models::CoderInfo, nil] The compression coder or nil
+        def self.find_compression_coder(coders)
+          # Try to find a known compression method
+          coders.each do |coder|
+            case coder.method_id
+            when MethodId::LZMA, MethodId::LZMA2, MethodId::BZIP2,
+                 MethodId::DEFLATE, MethodId::DEFLATE64, MethodId::PPMD,
+                 MethodId::COPY
+              return coder
+            end
+          end
+
+          # Fall back to last coder if no known compression method found
+          coders.last
+        end
+
         # Map method ID to algorithm
         #
         # @param method_id [Integer] Method ID from .7z file
@@ -92,6 +114,8 @@ module Omnizip
             :bcj_arm64
           when FilterId::DELTA
             :delta
+          when FilterId::BCJ2
+            :bcj2
           end
         end
 

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

@@ -84,7 +84,7 @@ module Omnizip
           ARM64 = 0x03030601
 
           # BCJ2 filter
-          BCJ2 = 0x03030111
+          BCJ2 = 0x0303011B
 
           # Swap filters for byte order conversion
           SWAP2 = 0x03030204

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

@@ -6,6 +6,7 @@ require_relative "parser"
 require_relative "models/stream_info"
 require_relative "models/file_entry"
 require_relative "stream_decompressor"
+require_relative "bcj2_stream_decompressor"
 require_relative "split_archive_reader"
 require_relative "header_encryptor"
 require_relative "encrypted_header"
@@ -26,12 +27,14 @@ module Omnizip
         # @param file_path [String] Path to .7z file
         # @param options [Hash] Reader options
         # @option options [String] :password Password for encrypted headers
+        # @option options [Integer] :offset Offset for embedded archives
         def initialize(file_path, options = {})
           @file_path = file_path
           @entries = []
           @stream_info = nil
           @split_reader = nil
           @password = options[:password]
+          @offset = options[:offset] || 0
         end
 
         # Open and parse .7z archive
@@ -47,6 +50,8 @@ module Omnizip
             @stream_info = @split_reader.stream_info
           else
             File.open(@file_path, "rb") do |io|
+              # Seek to offset for embedded archives
+              io.seek(@offset) if @offset.positive?
               parse_archive(io)
             end
           end
@@ -111,6 +116,8 @@ module Omnizip
             FileUtils.mkdir_p(output_path)
           elsif entry.has_stream?
             File.open(@file_path, "rb") do |io|
+              # Seek to offset for embedded archives
+              io.seek(@offset) if @offset.positive?
               data = extract_entry_data(io, entry)
               File.binwrite(output_path, data)
             end
@@ -173,7 +180,8 @@ module Omnizip
           # Read next header metadata
           # NOTE: next_header_offset is from the END of the Start Header (byte 32)
           # NOT from the end of the file
-          next_header_pos = Constants::START_HEADER_SIZE + @header.next_header_offset
+          # For embedded archives, add offset to get absolute position
+          next_header_pos = @offset + Constants::START_HEADER_SIZE + @header.next_header_offset
           io.seek(next_header_pos)
           next_header_data = io.read(@header.next_header_size)
 
@@ -272,7 +280,8 @@ module Omnizip
           end
 
           # Decompress the header using the stream info
-          pack_pos = @header.start_pos_after_header + stream_info.pack_pos
+          # For embedded archives, add offset to get absolute file position
+          pack_pos = @offset + @header.start_pos_after_header + stream_info.pack_pos
           folder = stream_info.folders[0]
           pack_size = stream_info.pack_sizes[0]
           unpack_size = folder.uncompressed_size
@@ -383,16 +392,86 @@ module Omnizip
           folder = @stream_info.folders[entry.folder_index]
           return "" unless folder
 
-          # Calculate pack position
-          pack_pos = @header.start_pos_after_header +
+          # Calculate pack position (add offset for embedded archives)
+          pack_pos = @offset + @header.start_pos_after_header +
             @stream_info.pack_pos
 
-          # Get pack size for this folder
+          # Get pack sizes for this folder
           pack_idx = 0
           entry.folder_index.times do |i|
             num_streams = @stream_info.folders[i].pack_stream_indices.size
             pack_idx += num_streams
           end
+
+          # Check if this is a BCJ2 multi-stream folder
+          if Bcj2StreamDecompressor.bcj2_folder?(folder)
+            extract_bcj2_entry(io, entry, folder, pack_pos, pack_idx)
+          else
+            extract_regular_entry(io, entry, folder, pack_pos, pack_idx)
+          end
+        rescue StandardError => e
+          warn "Extraction failed for #{entry.name}: #{e.message}"
+          raise
+        end
+
+        # Extract entry from BCJ2 multi-stream folder
+        #
+        # @param io [IO] Archive file handle
+        # @param entry [Models::FileEntry] Entry to extract
+        # @param folder [Models::Folder] Folder specification
+        # @param pack_pos [Integer] Base pack position
+        # @param pack_idx [Integer] Starting pack index
+        # @return [String] Extracted data
+        def extract_bcj2_entry(io, entry, folder, pack_pos, pack_idx)
+          # BCJ2 folders have multiple pack streams
+          num_pack_streams = folder.pack_stream_indices.size
+          pack_sizes = Array.new(num_pack_streams) do |i|
+            @stream_info.pack_sizes[pack_idx + i] || 0
+          end
+
+          # Decompress the entire BCJ2 folder
+          decompressor = Bcj2StreamDecompressor.new(
+            io, folder, pack_pos, pack_sizes, @stream_info
+          )
+          full_data = decompressor.decompress(folder.uncompressed_size)
+
+          # For solid archives, extract this file's portion
+          num_files_in_folder = @stream_info.num_unpack_streams_in_folders[entry.folder_index] || 1
+
+          if num_files_in_folder > 1
+            # Find offset of this file within the uncompressed stream
+            file_offset = 0
+            @entries.each do |e|
+              break if e.file_index == entry.file_index
+
+              file_offset += e.size if e.has_stream? && e.folder_index == entry.folder_index
+            end
+            data = full_data[file_offset, entry.size]
+          else
+            data = full_data[0, entry.size]
+          end
+
+          # Verify CRC if available
+          if entry.crc
+            crc = Omnizip::Checksums::Crc32.new
+            crc.update(data)
+            unless crc.value == entry.crc
+              raise "CRC mismatch for #{entry.name}: expected 0x#{entry.crc.to_s(16)}, got 0x#{crc.value.to_s(16)}"
+            end
+          end
+
+          data
+        end
+
+        # Extract entry from regular (non-BCJ2) folder
+        #
+        # @param io [IO] Archive file handle
+        # @param entry [Models::FileEntry] Entry to extract
+        # @param folder [Models::Folder] Folder specification
+        # @param pack_pos [Integer] Base pack position
+        # @param pack_idx [Integer] Starting pack index
+        # @return [String] Extracted data
+        def extract_regular_entry(io, entry, folder, pack_pos, pack_idx)
           pack_size = @stream_info.pack_sizes[pack_idx] || 0
 
           # For solid archives, multiple files share one compressed stream
@@ -434,9 +513,6 @@ module Omnizip
             expected_crc = entry.crc
             decompressor.decompress_and_verify(entry.size, expected_crc)
           end
-        rescue StandardError => e
-          warn "Extraction failed for #{entry.name}: #{e.message}"
-          raise
         end
 
         # Check if file path indicates a split archive

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

@@ -54,7 +54,8 @@ module Omnizip
 
             # For 7-Zip format, use raw_mode (no property byte in compressed data)
             # The properties are encoded in the 7-Zip header instead
-            encoder.compress(input_io, output_io, { raw_mode: true, standalone: false })
+            encoder.compress(input_io, output_io,
+                             { raw_mode: true, standalone: false })
             result = output_io.string
           end
 

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

@@ -80,6 +80,12 @@ module Omnizip
               filter_class = FilterRegistry.get(filter_sym)
               next unless filter_class
 
+              # BCJ2 requires special handling with multiple streams
+              if filter_sym == :bcj2
+                raise "BCJ2 archives require multi-stream decompression which is not yet implemented. " \
+                      "Please use the 7z command-line tool for this archive."
+              end
+
               filter = filter_class.new
               filtered = StringIO.new
               filter.reverse(StringIO.new(result), filtered)

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

@@ -134,7 +134,8 @@ module Omnizip
 
           # Step 3: Build Next Header properties
           # This includes kHeader, MAIN_STREAMS_INFO, FILES_INFO, etc.
-          next_header_data = build_next_header_properties(file_data, packed_sizes)
+          next_header_data = build_next_header_properties(file_data,
+                                                          packed_sizes)
 
           # Step 4: Write the complete data section
           # Note: CRC is stored in StartHeader, NOT appended to Next Header
@@ -150,7 +151,8 @@ module Omnizip
           # (CRC32 is appended after the header data, not included in size)
           next_header_size = next_header_data.bytesize
 
-          write_start_header(io, next_header_offset, next_header_size, next_header_data)
+          write_start_header(io, next_header_offset, next_header_size,
+                             next_header_data)
         end
 
         # Build packed data for solid mode (LZMA2 compression)
@@ -192,7 +194,8 @@ module Omnizip
               entry.size = data.bytesize
             end
 
-            { data: combined, total_size: total_size, streams: [{ data: combined, size: total_size }] }
+            { data: combined, total_size: total_size,
+              streams: [{ data: combined, size: total_size }] }
           else
             # Non-solid mode: each file gets its own stream
             streams = []
@@ -240,7 +243,8 @@ module Omnizip
             # Solid mode: one pack stream, one folder
             # packed_sizes is a single-element array with compressed size
             compressed_size = packed_sizes.first
-            build_solid_streams_info(metadata, unpack_size, compressed_size, num_files)
+            build_solid_streams_info(metadata, unpack_size, compressed_size,
+                                     num_files)
           else
             # Non-solid mode: one pack stream per file, one folder per file
             build_non_solid_streams_info(metadata, file_data[:streams])
@@ -286,7 +290,8 @@ module Omnizip
           encrypted_header.to_binary
         end
 
-        def build_solid_streams_info(metadata, unpack_size, compressed_size, num_files)
+        def build_solid_streams_info(metadata, unpack_size, compressed_size,
+num_files)
           # kPackInfo property (0x06)
           metadata << [PropertyId::PACK_INFO].pack("C")
           metadata << write_number(0)  # Pack position
@@ -624,7 +629,8 @@ module Omnizip
           footer
         end
 
-        def write_start_header(io, next_header_offset, next_header_size, next_header_data)
+        def write_start_header(io, next_header_offset, next_header_size,
+next_header_data)
           header = String.new(encoding: "BINARY")
 
           # Signature (6 bytes)
@@ -711,17 +717,23 @@ module Omnizip
             # 11110xxx pattern
             first_byte = 0xF0 | (value >> 32)
             result << [first_byte].pack("C")
-            4.downto(1) { |i| result << [(value >> (8 * (i - 1))) & 0xFF].pack("C") }
+            4.downto(1) do |i|
+              result << [(value >> (8 * (i - 1))) & 0xFF].pack("C")
+            end
           when 6
             # 111110xx pattern
             first_byte = 0xF8 | (value >> 40)
             result << [first_byte].pack("C")
-            5.downto(1) { |i| result << [(value >> (8 * (i - 1))) & 0xFF].pack("C") }
+            5.downto(1) do |i|
+              result << [(value >> (8 * (i - 1))) & 0xFF].pack("C")
+            end
           when 7
             # 1111110x pattern
             first_byte = 0xFC | (value >> 48)
             result << [first_byte].pack("C")
-            6.downto(1) { |i| result << [(value >> (8 * (i - 1))) & 0xFF].pack("C") }
+            6.downto(1) do |i|
+              result << [(value >> (8 * (i - 1))) & 0xFF].pack("C")
+            end
           else
             # 8 bytes: 11111110 or 11111111 prefix
             result << if value < (1 << 56)

data/lib/omnizip/formats/seven_zip.rb

@@ -80,6 +80,16 @@ module Omnizip
         reader
       end
 
+      # Search for embedded .7z archive in self-extracting executable
+      #
+      # @param path [String] Path to potential self-extracting archive
+      # @return [Integer, nil] Offset of embedded 7z signature, or nil if not found
+      def self.search_embedded(path)
+        data = File.binread(path)
+        signature = Constants::SIGNATURE
+        data.index(signature)
+      end
+
       # Auto-register .7z format when loaded
       def self.register!
         require_relative "../format_registry"

data/lib/omnizip/formats/xar/entry.rb

@@ -191,13 +191,26 @@ module Omnizip
             data_hash[:length] = @data_size if @data_size&.positive?
 
             if @data_encoding && @data_encoding != COMPRESSION_NONE
-              data_hash[:encoding] = COMPRESSION_MIME_TYPES[@data_encoding] || @data_encoding
+              data_hash[:encoding] =
+                COMPRESSION_MIME_TYPES[@data_encoding] || @data_encoding
             end
 
-            data_hash[:archived_checksum] = @archived_checksum if @archived_checksum
-            data_hash[:archived_checksum_style] = @archived_checksum_style if @archived_checksum_style
-            data_hash[:extracted_checksum] = @extracted_checksum if @extracted_checksum
-            data_hash[:extracted_checksum_style] = @extracted_checksum_style if @extracted_checksum_style
+            if @archived_checksum
+              data_hash[:archived_checksum] =
+                @archived_checksum
+            end
+            if @archived_checksum_style
+              data_hash[:archived_checksum_style] =
+                @archived_checksum_style
+            end
+            if @extracted_checksum
+              data_hash[:extracted_checksum] =
+                @extracted_checksum
+            end
+            if @extracted_checksum_style
+              data_hash[:extracted_checksum_style] =
+                @extracted_checksum_style
+            end
 
             hash[:data] = data_hash
           end

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

@@ -28,11 +28,35 @@ module Omnizip
         # @return [Header] Parsed header object
         # @raise [ArgumentError] If data is invalid
         def self.parse(data)
-          raise ArgumentError, "Header data too short (#{data.bytesize} bytes)" if data.bytesize < HEADER_SIZE
+          if data.bytesize < HEADER_SIZE
+            raise ArgumentError,
+                  "Header data too short (#{data.bytesize} bytes)"
+          end
 
           magic = data[0, 4].unpack1("N")
-          header_size = data[4, 2].unpack1("v")  # little-endian
-          version = data[6, 2].unpack1("v")      # little-endian
+          # XAR spec: header_size and version are little-endian, rest are big-endian
+          # However, some tools (like macOS xar) store these in big-endian format.
+          # We detect this by checking if the parsed values make sense.
+          header_size_le = data[4, 2].unpack1("v")  # little-endian
+          header_size_be = data[4, 2].unpack1("n")  # big-endian
+          version_le = data[6, 2].unpack1("v")      # little-endian
+          version_be = data[6, 2].unpack1("n")      # big-endian
+
+          # Detect endianness: standard header is 28 bytes, version is 1
+          # If little-endian gives valid values, use it; otherwise use big-endian
+          if header_size_le == HEADER_SIZE && version_le == XAR_VERSION
+            header_size = header_size_le
+            version = version_le
+          elsif header_size_be == HEADER_SIZE && version_be == XAR_VERSION
+            header_size = header_size_be
+            version = version_be
+          else
+            # Default to little-endian (spec-compliant)
+            header_size = header_size_le
+            version = version_le
+            # Normalize version 256 to 1 (big-endian encoding of version 1)
+            version = 1 if version == 256
+          end
           toc_compressed_size = data[8, 8].unpack1("Q>") # big-endian uint64
           toc_uncompressed_size = data[16, 8].unpack1("Q>") # big-endian uint64
           checksum_algorithm = data[24, 4].unpack1("N")
@@ -104,7 +128,9 @@ module Omnizip
         # @raise [ArgumentError] If header is invalid
         def validate!
           unless @magic == MAGIC
-            raise ArgumentError, format("Invalid magic: 0x%08x (expected 0x%08x)", @magic, MAGIC)
+            raise ArgumentError,
+                  format("Invalid magic: 0x%08x (expected 0x%08x)", @magic,
+                         MAGIC)
           end
 
           unless @header_size >= HEADER_SIZE
@@ -115,8 +141,10 @@ module Omnizip
             raise ArgumentError, "Unsupported version: #{@version}"
           end
 
-          unless [CKSUM_NONE, CKSUM_SHA1, CKSUM_MD5, CKSUM_OTHER].include?(@checksum_algorithm)
-            raise ArgumentError, "Unknown checksum algorithm: #{@checksum_algorithm}"
+          unless [CKSUM_NONE, CKSUM_SHA1, CKSUM_MD5,
+                  CKSUM_OTHER].include?(@checksum_algorithm)
+            raise ArgumentError,
+                  "Unknown checksum algorithm: #{@checksum_algorithm}"
           end
 
           if @checksum_algorithm == CKSUM_OTHER && @checksum_name.to_s.strip.empty?

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

@@ -114,10 +114,13 @@ module Omnizip
         # @param entry [Entry] Entry to read
         # @return [String, nil] Entry data or nil if no data
         def read_data(entry)
-          return nil unless entry.data_size&.positive?
+          return nil unless entry.data_length&.positive?
           return nil unless @file
 
           @file.seek(@heap_offset + entry.data_offset)
+          # In XAR format:
+          # - data_length is the compressed (archived) size (what to read from heap)
+          # - data_size is the uncompressed (extracted) size (decompressed size)
           compressed_data = @file.read(entry.data_length)
 
           decompress_data(compressed_data, entry.data_encoding, entry.data_size)
@@ -130,7 +133,9 @@ module Omnizip
           FileUtils.mkdir_p(output_dir)
 
           # Sort entries to ensure directories are created first
-          sorted_entries = @entries.sort_by { |e| [e.directory? ? 0 : 1, e.name] }
+          sorted_entries = @entries.sort_by do |e|
+            [e.directory? ? 0 : 1, e.name]
+          end
 
           sorted_entries.each do |entry|
             extract_entry(entry, output_dir)
@@ -206,9 +211,11 @@ module Omnizip
           @toc = Toc.parse(compressed_toc, @header.toc_uncompressed_size)
           @entries = @toc.entries
 
-          # Calculate heap offset (after header + compressed TOC + TOC checksum)
+          # Calculate heap offset:
+          # The heap starts immediately after the compressed TOC.
+          # The TOC checksum is stored INSIDE the heap (at offset 0), not after it.
+          # File data offsets in the TOC are relative to the heap start.
           @heap_offset = @header.header_size + @header.toc_compressed_size
-          @heap_offset += @header.checksum_size if @header.checksum?
         end
 
         # Decompress data based on encoding
@@ -235,14 +242,40 @@ module Omnizip
 
         # Decompress gzip data
         #
-        # @param data [String] Gzip compressed data
+        # @param data [String] Zlib compressed data (XAR uses zlib, not actual gzip)
         # @return [String] Decompressed data
         def decompress_gzip(data)
-          zlib = Zlib::Inflate.new(-Zlib::MAX_WBITS)
-          result = zlib.inflate(data)
-          zlib.finish
-          zlib.close
-          result
+          # XAR "gzip" compression is actually zlib format (with 0x78xx header)
+          # Try different decompression methods for robustness
+
+          # Method 1: Standard zlib format (with header)
+          begin
+            result = Zlib::Inflate.inflate(data)
+            return result
+          rescue Zlib::Error
+            # Continue to next method
+          end
+
+          # Method 2: Raw deflate (some implementations may use this)
+          begin
+            inf = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+            result = inf.inflate(data)
+            inf.finish
+            inf.close
+            return result
+          rescue Zlib::Error
+            # Continue to next method
+          end
+
+          # Method 3: Raw deflate without finish (for truncated data)
+          begin
+            inf = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+            result = inf.inflate(data)
+            inf.close
+            result
+          rescue Zlib::Error => e
+            raise "Failed to decompress data: #{e.message}"
+          end
         end
 
         # Decompress bzip2 data

data/lib/omnizip/formats/xar/toc.rb

@@ -20,7 +20,8 @@ module Omnizip
       class Toc
         include Constants
 
-        attr_accessor :creation_time, :checksum_offset, :checksum_size, :checksum_style
+        attr_accessor :creation_time, :checksum_offset, :checksum_size,
+                      :checksum_style
         attr_reader :entries
 
         # Parse TOC from compressed data
@@ -36,17 +37,23 @@ module Omnizip
 
         # Decompress TOC data
         #
-        # @param compressed_data [String] GZIP-compressed data
+        # @param compressed_data [String] Zlib-compressed data
         # @param expected_size [Integer, nil] Expected size for validation
         # @return [String] Decompressed XML
         def self.decompress(compressed_data, expected_size = nil)
-          zlib = Zlib::Inflate.new(-Zlib::MAX_WBITS) # Raw deflate
-          result = zlib.inflate(compressed_data)
-          zlib.finish
-          zlib.close
+          # XAR TOC is zlib compressed (with zlib headers, 0x78xx)
+          # Try zlib format first (most common), then fall back to raw deflate
+          result = begin
+            # Try standard zlib format (with header)
+            Zlib::Inflate.inflate(compressed_data)
+          rescue Zlib::DataError
+            # Fall back to raw deflate for non-conforming implementations
+            Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(compressed_data)
+          end
 
           if expected_size && result.bytesize != expected_size
-            raise ArgumentError, "TOC size mismatch: #{result.bytesize} != #{expected_size}"
+            raise ArgumentError,
+                  "TOC size mismatch: #{result.bytesize} != #{expected_size}"
           end
 
           result
@@ -279,10 +286,10 @@ module Omnizip
           if (data = elem.elements["data"])
             options[:data_offset] = int_content(data.elements["offset"]) || 0
             # In XAR format:
-            # - <length> is the uncompressed (extracted) size
-            # - <size> is the compressed (archived) size
-            options[:data_size] = int_content(data.elements["length"]) || 0
-            options[:data_length] = int_content(data.elements["size"]) || 0
+            # - <size> is the uncompressed (extracted) size
+            # - <length> is the compressed (archived) size in the heap
+            options[:data_size] = int_content(data.elements["size"]) || 0
+            options[:data_length] = int_content(data.elements["length"]) || 0
 
             if (encoding = data.elements["encoding"])
               style = encoding.attributes["style"]
@@ -291,12 +298,14 @@ module Omnizip
 
             if (archived_sum = data.elements["archived-checksum"])
               options[:archived_checksum] = text_content(archived_sum)
-              options[:archived_checksum_style] = archived_sum.attributes["style"]
+              options[:archived_checksum_style] =
+                archived_sum.attributes["style"]
             end
 
             if (extracted_sum = data.elements["extracted-checksum"])
               options[:extracted_checksum] = text_content(extracted_sum)
-              options[:extracted_checksum_style] = extracted_sum.attributes["style"]
+              options[:extracted_checksum_style] =
+                extracted_sum.attributes["style"]
             end
           end
 
@@ -347,7 +356,10 @@ module Omnizip
           elem.elements.each("file") do |file_elem|
             entry = parse_file_element(file_elem)
             # Prepend parent path to name
-            entry.name = File.join(parent_entry.name, entry.name) unless parent_entry.name.empty?
+            unless parent_entry.name.empty?
+              entry.name = File.join(parent_entry.name,
+                                     entry.name)
+            end
             toc.add_entry(entry)
 
             # Recurse for deeper nesting
@@ -392,7 +404,8 @@ module Omnizip
         # @param entry [Entry] Entry to add
         # @param children_map [Hash] Children by parent path
         # @param parent_path [String] Path of parent directory (for nested entries)
-        def add_file_element(parent_elem, entry, children_map, parent_path = nil)
+        def add_file_element(parent_elem, entry, children_map,
+parent_path = nil)
           file_elem = parent_elem.add_element("file")
           file_elem.add_attribute("id", entry.id.to_s)
 
@@ -453,16 +466,16 @@ module Omnizip
             offset_elem.add_text(entry.data_offset.to_s)
 
             # In XAR format:
-            # - <length> is the uncompressed (extracted) size
-            # - <size> is the compressed (archived) size
-            if entry.data_size&.positive?
+            # - <length> is the compressed (archived) size in the heap
+            # - <size> is the uncompressed (extracted) size
+            if entry.data_length&.positive?
               length_elem = data_elem.add_element("length")
-              length_elem.add_text(entry.data_size.to_s)
+              length_elem.add_text(entry.data_length.to_s)
             end
 
-            if entry.data_length&.positive?
+            if entry.data_size&.positive?
               size_elem = data_elem.add_element("size")
-              size_elem.add_text(entry.data_length.to_s)
+              size_elem.add_text(entry.data_size.to_s)
             end
 
             if entry.data_encoding && entry.data_encoding != COMPRESSION_NONE