omnizip 0.3.1

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

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "file_collector"
+require_relative "stream_compressor"
+require_relative "header_writer"
+require_relative "models/file_entry"
+require_relative "../../models/split_options"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Split archive writer for .7z format
+      # Creates multi-volume archives with size limits
+      class SplitArchiveWriter
+        include Constants
+
+        attr_reader :base_path, :options, :split_options, :entries, :volumes
+
+        # Volume information
+        class VolumeInfo
+          attr_accessor :path, :size, :start_offset, :end_offset
+
+          def initialize(path, start_offset = 0)
+            @path = path
+            @size = 0
+            @start_offset = start_offset
+            @end_offset = start_offset
+          end
+        end
+
+        # Initialize writer
+        #
+        # @param base_path [String] Base path (e.g., "backup.7z.001")
+        # @param options [Hash] Compression options
+        # @param split_options [Models::SplitOptions] Split configuration
+        def initialize(base_path, options = {}, split_options = nil)
+          @base_path = base_path
+          @options = {
+            algorithm: :lzma2,
+            level: 5,
+            solid: true,
+            filters: [],
+          }.merge(options)
+          @split_options = split_options || Models::SplitOptions.new
+          @split_options.validate!
+          @collector = FileCollector.new
+          @entries = []
+          @volumes = []
+          @current_volume = nil
+          @current_volume_number = 1
+          @global_offset = 0
+        end
+
+        # Add file to archive
+        #
+        # @param file_path [String] Path to file
+        # @param archive_path [String, nil] Path in archive
+        def add_file(file_path, archive_path = nil)
+          @collector.add_path(file_path, archive_path: archive_path,
+                                         recursive: false)
+        end
+
+        # Add directory to archive
+        #
+        # @param dir_path [String] Path to directory
+        # @param recursive [Boolean] Add contents recursively
+        def add_directory(dir_path, recursive: true)
+          @collector.add_path(dir_path, recursive: recursive)
+        end
+
+        # Add files matching glob pattern
+        #
+        # @param pattern [String] Glob pattern
+        def add_files(pattern)
+          @collector.add_glob(pattern)
+        end
+
+        # Write split archive
+        #
+        # @raise [RuntimeError] on write error
+        def write
+          # Collect files
+          @entries = @collector.collect_files
+
+          # Determine spanning strategy
+          if @split_options.span_strategy == Omnizip::Models::SplitOptions::STRATEGY_BALANCED
+            write_balanced
+          else
+            write_first_fit
+          end
+        end
+
+        private
+
+        # Write using first-fit strategy (default)
+        def write_first_fit
+          # Compress all files first
+          compressed_result = compress_files
+
+          # Calculate total size needed
+          compressed_result[:data].bytesize
+          header_data = build_next_header(compressed_result)
+          header_data.bytesize
+
+          # Create volumes and write data
+          start_first_volume
+          write_packed_data(compressed_result[:data])
+
+          # Write header at the end of last volume
+          header_offset = @global_offset - START_HEADER_SIZE
+          write_data(header_data)
+
+          # Write start header to first volume (this closes volumes)
+          write_start_header_to_first_volume(header_data, header_offset)
+        end
+
+        # Write using balanced strategy
+        # Pre-calculates optimal file distribution
+        def write_balanced
+          # For now, use first-fit strategy
+          # Full balanced implementation would require:
+          # 1. Calculate individual file sizes
+          # 2. Use bin-packing algorithm
+          # 3. Distribute files optimally
+          write_first_fit
+        end
+
+        # Compress all files
+        #
+        # @return [Hash] Compression results
+        def compress_files
+          compressor = StreamCompressor.new(
+            algorithm: @options[:algorithm],
+            level: @options[:level],
+            filters: @options[:filters],
+          )
+
+          files_with_data = @entries.select(&:has_stream?)
+
+          if @options[:solid]
+            # Solid: compress all files into one stream
+            result = compressor.compress_files(files_with_data)
+            files_with_data.each_with_index do |entry, i|
+              entry.crc = result[:crcs][i]
+              entry.size = result[:unpack_sizes][i]
+            end
+
+            {
+              data: result[:packed_data],
+              folders: [{
+                method_id: compressor.method_id,
+                properties: compressor.properties,
+                unpack_size: result[:unpack_size],
+              }],
+              pack_sizes: [result[:packed_size]],
+              unpack_sizes: result[:unpack_sizes],
+              digests: result[:crcs],
+            }
+          else
+            # Non-solid: compress each file separately
+            packed_data = String.new(encoding: "BINARY")
+            folders = []
+            pack_sizes = []
+            unpack_sizes = []
+            digests = []
+
+            files_with_data.each do |entry|
+              data = File.binread(entry.source_path)
+              compressed = compressor.compress(data)
+
+              packed_data << compressed
+              pack_sizes << compressed.bytesize
+              unpack_sizes << data.bytesize
+
+              # Calculate CRC
+              crc = Omnizip::Checksums::Crc32.new
+              crc.update(data)
+              entry.crc = crc.value
+              digests << crc.value
+
+              folders << {
+                method_id: compressor.method_id,
+                properties: compressor.properties,
+                unpack_size: data.bytesize,
+              }
+            end
+
+            {
+              data: packed_data,
+              folders: folders,
+              pack_sizes: pack_sizes,
+              unpack_sizes: unpack_sizes,
+              digests: digests,
+            }
+          end
+        end
+
+        # Build next header metadata
+        #
+        # @param compressed_result [Hash] Compression results
+        # @return [String] Encoded next header
+        def build_next_header(compressed_result)
+          header_writer = HeaderWriter.new
+
+          header_options = {
+            streams: {
+              pack_pos: 0,
+              pack_sizes: compressed_result[:pack_sizes],
+              pack_crcs: [],
+              folders: compressed_result[:folders],
+              unpack_sizes: compressed_result[:unpack_sizes],
+              digests: compressed_result[:digests],
+            },
+            entries: @entries,
+          }
+
+          header_writer.write_next_header(header_options)
+        end
+
+        # Start first volume
+        def start_first_volume
+          volume_path = @split_options.volume_filename(@base_path, 1)
+          @current_volume = File.open(volume_path, "wb")
+          @volumes << VolumeInfo.new(volume_path, 0)
+
+          # Reserve space for start header (will be written at end)
+          @current_volume.write("\0" * START_HEADER_SIZE)
+          @global_offset = START_HEADER_SIZE
+          @volumes.last.size = START_HEADER_SIZE
+          @volumes.last.end_offset = START_HEADER_SIZE
+        end
+
+        # Write packed data across volumes
+        #
+        # @param data [String] Data to write
+        def write_packed_data(data)
+          offset = 0
+          remaining = data.bytesize
+
+          while remaining.positive?
+            available = @split_options.volume_size - @volumes.last.size
+
+            # If current volume is full, start a new one
+            if available <= 0
+              close_current_volume
+              start_continuation_volume
+              available = @split_options.volume_size
+            end
+
+            chunk_size = [available, remaining].min
+
+            if chunk_size.positive?
+              chunk = data[offset, chunk_size]
+              @current_volume.write(chunk)
+              @volumes.last.size += chunk_size
+              @volumes.last.end_offset += chunk_size
+              @global_offset += chunk_size
+              offset += chunk_size
+              remaining -= chunk_size
+            end
+          end
+        end
+
+        # Write data (may span volumes)
+        #
+        # @param data [String] Data to write
+        def write_data(data)
+          write_packed_data(data)
+        end
+
+        # Start continuation volume
+        def start_continuation_volume
+          @current_volume_number += 1
+          volume_path = @split_options.volume_filename(@base_path,
+                                                       @current_volume_number)
+          @current_volume = File.open(volume_path, "wb")
+          @volumes << VolumeInfo.new(volume_path, @global_offset)
+        end
+
+        # Write start header to first volume
+        #
+        # @param header_data [String] Header data
+        # @param header_offset [Integer] Offset to header
+        def write_start_header_to_first_volume(header_data, header_offset)
+          # Close current volume first to ensure all data is flushed
+          close_current_volume
+
+          header_writer = HeaderWriter.new
+          start_header = header_writer.write_start_header(
+            header_data,
+            header_offset,
+          )
+
+          # Open first volume and write start header
+          first_volume_path = @volumes.first.path
+          File.open(first_volume_path, "r+b") do |io|
+            io.seek(0)
+            io.write(start_header)
+            io.flush
+          end
+        end
+
+        # Close current volume
+        def close_current_volume
+          return unless @current_volume
+
+          @current_volume.flush
+          @current_volume.close
+          @current_volume = nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../../checksums/crc32"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Compresses data streams using coder chains
+      # Opposite of StreamDecompressor - applies compression algorithms
+      class StreamCompressor
+        attr_reader :algorithm, :level, :filters
+
+        # Initialize compressor
+        #
+        # @param algorithm [Symbol] Compression algorithm
+        # @param level [Integer] Compression level (1-9)
+        # @param filters [Array<Symbol>] Filter chain
+        def initialize(algorithm: :lzma2, level: 5, filters: [])
+          @algorithm = algorithm
+          @level = level
+          @filters = Array(filters)
+        end
+
+        # Compress data
+        #
+        # @param data [String] Uncompressed data
+        # @return [String] Compressed data
+        def compress(data)
+          result = data
+
+          # Apply filters first
+          @filters.each do |filter_sym|
+            filter_class = FilterRegistry.get(filter_sym)
+            next unless filter_class
+
+            filter = filter_class.new
+            input_io = StringIO.new(result)
+            output_io = StringIO.new
+            output_io.set_encoding("BINARY")
+            filter.encode(input_io, output_io)
+            result = output_io.string
+          end
+
+          # Apply compression algorithm
+          if @algorithm && @algorithm != :copy
+            algo_class = AlgorithmRegistry.get(@algorithm)
+            raise "Algorithm not found: #{@algorithm}" unless algo_class
+
+            encoder = algo_class.new
+            input_io = StringIO.new(result)
+            output_io = StringIO.new
+            output_io.set_encoding("BINARY")
+
+            # 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 })
+            result = output_io.string
+          end
+
+          result
+        end
+
+        # Compress multiple files into single stream (solid compression)
+        #
+        # @param file_entries [Array<Models::FileEntry>] Files to compress
+        # @return [Hash] Compression result with packed/unpacked sizes
+        def compress_files(file_entries)
+          # Concatenate all file data
+          combined_data = String.new(encoding: "BINARY")
+          unpack_sizes = []
+          crcs = []
+
+          file_entries.each do |entry|
+            next unless entry.has_stream? && entry.source_path
+
+            data = File.binread(entry.source_path)
+            combined_data << data
+            unpack_sizes << data.bytesize
+
+            # Calculate CRC
+            crc = Omnizip::Checksums::Crc32.new
+            crc.update(data)
+            crcs << crc.value
+          end
+
+          # Compress combined data
+          packed_data = compress(combined_data)
+
+          {
+            packed_data: packed_data,
+            packed_size: packed_data.bytesize,
+            unpack_size: combined_data.bytesize,
+            unpack_sizes: unpack_sizes,
+            crcs: crcs,
+          }
+        end
+
+        # Get method ID for this compression algorithm
+        #
+        # @return [Integer] Method ID
+        def method_id
+          case @algorithm
+          when :copy then Constants::MethodId::COPY
+          when :lzma then Constants::MethodId::LZMA
+          when :lzma2 then Constants::MethodId::LZMA2
+          when :ppmd, :ppmd7 then Constants::MethodId::PPMD
+          when :bzip2 then Constants::MethodId::BZIP2
+          else Constants::MethodId::LZMA2
+          end
+        end
+
+        # Get filter IDs for filter chain
+        #
+        # @return [Array<Integer>] Filter IDs
+        def filter_ids
+          @filters.filter_map do |filter_sym|
+            case filter_sym
+            when :bcj_x86 then Constants::FilterId::BCJ_X86
+            when :delta then Constants::FilterId::DELTA
+            end
+          end
+        end
+
+        # Get properties for compression algorithm
+        #
+        # @return [String, nil] Binary properties
+        def properties
+          return nil if @algorithm == :copy || @algorithm.nil?
+
+          case @algorithm
+          when :lzma2
+            # LZMA2 properties: dictionary size encoded
+            dict_size = 1 << (15 + @level)
+            prop = 0
+            prop += 1 while dict_size > (2 << prop)
+            [prop].pack("C")
+          when :lzma
+            # LZMA properties: lc, lp, pb, dict_size
+            lc = 3
+            lp = 0
+            pb = 2
+            dict_size = 1 << (15 + @level)
+            [lc + (lp * 9) + (pb * 9 * 5)].pack("C") +
+              [dict_size].pack("V")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "coder_chain"
+require_relative "../../checksums/crc32"
+require "stringio"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Decompresses .7z streams using coder chains
+      # Handles packed stream extraction and CRC validation
+      class StreamDecompressor
+        attr_reader :archive_io, :folder, :chain_config
+
+        # Initialize decompressor
+        #
+        # @param archive_io [IO] Archive file handle
+        # @param folder [Models::Folder] Folder specification
+        # @param pack_pos [Integer] Position of packed data
+        # @param pack_size [Integer] Size of packed data
+        # @param header [Header, nil] Optional header for split archive handling
+        def initialize(archive_io, folder, pack_pos, pack_size, header = nil)
+          @archive_io = archive_io
+          @folder = folder
+          @pack_pos = pack_pos
+          @pack_size = pack_size
+          @header = header
+          @chain_config = CoderChain.build_from_folder(folder)
+        end
+
+        # Decompress stream to output
+        #
+        # @param size [Integer] Expected uncompressed size
+        # @return [String] Decompressed data
+        # @raise [RuntimeError] on decompression error
+        def decompress(size)
+          # Seek to packed data
+          @archive_io.seek(@pack_pos)
+
+          # For multi-volume archives, pack_size from stream_info may be incomplete.
+          # For solid archives spanning volumes, the actual compressed data extends
+          # from pack_pos to where the next header starts.
+          if @archive_io.is_a?(SplitArchiveReader::MultiVolumeIO) && @header
+            # next_header_offset is relative to start_pos_after_header
+            # Actual packed data size is from pack_pos to next header position
+            next_header_position = @header.start_pos_after_header + @header.next_header_offset
+            actual_pack_size = next_header_position - @pack_pos
+            packed_data = @archive_io.read(actual_pack_size)
+          else
+            # Regular single-file archive: use pack_size from stream info
+            packed_data = @archive_io.read(@pack_size)
+          end
+
+          return packed_data if @chain_config.nil? # No compression
+
+          # Get algorithm
+          algo_sym = @chain_config[:algorithm]
+          return packed_data unless algo_sym # Copy method
+
+          # Get algorithm class
+          algo_class = AlgorithmRegistry.get(algo_sym)
+          raise "Algorithm not found: #{algo_sym}" unless algo_class
+
+          # Decompress
+          input_io = StringIO.new(packed_data)
+          output_io = StringIO.new
+          output_io.set_encoding("BINARY")
+
+          # Build options from coder properties for 7-Zip format
+          decoder_options = build_decoder_options
+
+          decoder = algo_class.new(decoder_options)
+          decoder.decompress(input_io, output_io, size: size)
+
+          result = output_io.string
+
+          # Apply filters if present
+          if @chain_config[:filters] && !@chain_config[:filters].empty?
+            @chain_config[:filters].reverse_each do |filter_sym|
+              filter_class = FilterRegistry.get(filter_sym)
+              next unless filter_class
+
+              filter = filter_class.new
+              filtered = StringIO.new
+              filter.reverse(StringIO.new(result), filtered)
+              result = filtered.string
+            end
+          end
+
+          result
+        end
+
+        # Decompress and verify CRC
+        #
+        # @param size [Integer] Expected uncompressed size
+        # @param expected_crc [Integer, nil] Expected CRC32 value
+        # @return [String] Decompressed data
+        # @raise [RuntimeError] if CRC mismatch
+        def decompress_and_verify(size, expected_crc = nil)
+          data = decompress(size)
+
+          if expected_crc
+            crc = Omnizip::Checksums::Crc32.new
+            crc.update(data)
+            actual_crc = crc.value
+
+            unless actual_crc == expected_crc
+              raise "CRC mismatch: expected 0x#{expected_crc.to_s(16)}, " \
+                    "got 0x#{actual_crc.to_s(16)}"
+            end
+          end
+
+          data
+        end
+
+        private
+
+        # Build decoder options from coder properties
+        #
+        # For 7-Zip format, coder properties contain algorithm-specific data.
+        # For LZMA2, it's a single byte encoding the dictionary size.
+        #
+        # @return [Hash] Decoder options
+        def build_decoder_options
+          return {} unless @chain_config
+
+          options = {}
+          properties = @chain_config[:properties]
+
+          if properties && !properties.empty?
+            algo_sym = @chain_config[:algorithm]
+
+            case algo_sym
+            when :lzma2
+              # LZMA2 properties: single byte encoding dictionary size
+              prop_byte = properties.getbyte(0)
+              dict_size = Omnizip::Algorithms::LZMA2::Properties.decode_dict_size(prop_byte)
+              options[:raw_mode] = true # No property byte in data stream
+              options[:dict_size] = dict_size
+            when :lzma
+              # LZMA properties: 5 bytes (prop byte + dict size)
+              # Format: 1 byte (lc/lp/pb) + 4 bytes (dict size LE)
+              if properties.bytesize >= 5
+                props_byte = properties.getbyte(0)
+                dict_size = properties[1, 4].unpack1("V")
+                # Use lzma2_mode to skip header reading - 7-Zip provides properties separately
+                options[:lzma2_mode] = true
+                options[:lc] = props_byte % 9
+                remainder = props_byte / 9
+                options[:lp] = remainder % 5
+                options[:pb] = remainder / 5
+                options[:dict_size] = dict_size
+              end
+            end
+          end
+
+          options
+        end
+      end
+    end
+  end
+end