omnizip 0.4.7-arm-linux

data/lib/omnizip/formats/rar/rar5/multi_volume/volume_manager.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module MultiVolume
+          # Volume manager for multi-volume archive creation
+          #
+          # This class coordinates the creation of multi-volume RAR5 archives
+          # by managing volume splitting, file distribution, and volume writing.
+          #
+          # @example Create multi-volume archive
+          #   manager = VolumeManager.new('archive.rar',
+          #     max_volume_size: 10 * 1024 * 1024,  # 10 MB
+          #     compression: :lzma,
+          #     level: 5
+          #   )
+          #   manager.add_file('large_file.dat')
+          #   manager.create_volumes
+          class VolumeManager
+            # @return [String] Base archive path
+            attr_reader :base_path
+
+            # @return [VolumeOptions] Volume options
+            attr_reader :volume_options
+
+            # @return [Hash] Compression options
+            attr_reader :compression_options
+
+            # @return [Array<Hash>] Files to archive
+            attr_reader :files
+
+            # Initialize volume manager
+            #
+            # @param base_path [String] Base archive path (e.g., "archive.rar")
+            # @param options [Hash] Options
+            # @option options [Integer] :max_volume_size Maximum volume size in bytes
+            # @option options [String] :volume_naming Naming pattern ("part", "volume", "numeric")
+            # @option options [Symbol] :compression Compression method (:store, :lzma)
+            # @option options [Integer] :level Compression level (1-5)
+            # @option options [Boolean] :include_mtime Include modification time
+            # @option options [Boolean] :include_crc32 Include CRC32
+            def initialize(base_path, options = {})
+              @base_path = base_path
+              @volume_options = Models::VolumeOptions.new(
+                max_volume_size: options[:max_volume_size] || 104_857_600,
+                volume_naming: options[:volume_naming] || "part",
+              )
+              @volume_options.validate!
+
+              @compression_options = {
+                compression: options[:compression] || :store,
+                level: options[:level] || 3,
+                include_mtime: options[:include_mtime] || false,
+                include_crc32: options[:include_crc32] || false,
+              }
+
+              @files = []
+            end
+
+            # Add file to archive
+            #
+            # @param input_path [String] Path to file on disk
+            # @param archive_path [String, nil] Path within archive
+            # @return [void]
+            def add_file(input_path, archive_path = nil)
+              unless File.exist?(input_path)
+                raise ArgumentError,
+                      "File not found: #{input_path}"
+              end
+
+              archive_path ||= File.basename(input_path)
+
+              @files << {
+                input: input_path,
+                archive: archive_path,
+                mtime: File.mtime(input_path),
+                stat: File.stat(input_path),
+                size: File.size(input_path),
+              }
+            end
+
+            # Add directory recursively
+            #
+            # @param dir_path [String] Directory path
+            # @param base_path [String, nil] Base path for relative names
+            # @return [void]
+            def add_directory(dir_path, base_path = nil)
+              base_path ||= dir_path
+
+              Dir.glob(File.join(dir_path, "**", "*")).each do |path|
+                next unless File.file?(path)
+
+                relative_path = path.sub(
+                  /^#{Regexp.escape(base_path)}#{File::SEPARATOR}?/, ""
+                )
+                add_file(path, relative_path)
+              end
+            end
+
+            # Create multi-volume archives
+            #
+            # @return [Array<String>] Paths to created volume files
+            def create_volumes
+              # Prepare file entries with compression
+              prepared_files = prepare_files
+
+              # Calculate file distribution across volumes
+              splitter = VolumeSplitter.new(max_volume_size: @volume_options.max_volume_size)
+              distribution = splitter.calculate_file_distribution(prepared_files)
+
+              # Create each volume
+              volume_paths = []
+              distribution.each_with_index do |file_indices, volume_idx|
+                volume_number = volume_idx + 1
+                is_last = (volume_idx == distribution.size - 1)
+
+                volume_path = VolumeWriter.volume_filename(
+                  @base_path,
+                  volume_number,
+                  naming: @volume_options.volume_naming,
+                )
+
+                write_volume(volume_path, volume_number, file_indices,
+                             prepared_files, is_last)
+                volume_paths << volume_path
+              end
+
+              volume_paths
+            end
+
+            # Check if archive needs splitting
+            #
+            # @return [Boolean] true if multi-volume needed
+            def needs_splitting?
+              total_size = estimate_total_size
+              VolumeSplitter.needs_splitting?(total_size,
+                                              @volume_options.max_volume_size)
+            end
+
+            private
+
+            # Prepare files with compression and metadata
+            #
+            # @return [Array<Hash>] Prepared file information
+            def prepare_files
+              @files.map do |file|
+                # Read and compress file data
+                data = File.binread(file[:input])
+                compression_method = select_compression_method(data)
+                compressed_data = compress_data(data, compression_method)
+
+                # Calculate CRC32 if needed
+                use_crc32 = @compression_options[:include_crc32] && compression_method == Compression::Store::METHOD
+                file_crc32 = use_crc32 ? CRC32.calculate(data) : nil
+
+                # Create file header
+                header = FileHeader.new(
+                  filename: file[:archive],
+                  file_size: data.bytesize,
+                  compressed_size: compressed_data.bytesize,
+                  compression_method: compression_method,
+                  mtime: @compression_options[:include_mtime] ? file[:mtime] : nil,
+                  crc32: file_crc32,
+                )
+
+                # Estimate header size (approximate)
+                header_data = header.encode
+                header_size = header_data.bytesize
+
+                {
+                  file: file,
+                  header: header,
+                  header_size: header_size,
+                  compressed_data: compressed_data,
+                  compressed_size: compressed_data.bytesize,
+                }
+              end
+            end
+
+            # Write single volume file
+            #
+            # @param volume_path [String] Volume file path
+            # @param volume_number [Integer] Volume number (1-based)
+            # @param file_indices [Array<Integer>] File indices to include
+            # @param prepared_files [Array<Hash>] All prepared files
+            # @param is_last [Boolean] Is this the last volume?
+            # @return [void]
+            def write_volume(volume_path, volume_number, file_indices,
+prepared_files, is_last)
+              writer = VolumeWriter.new(volume_path,
+                                        volume_number: volume_number, is_last: is_last)
+
+              writer.write do |vol|
+                vol.write_signature
+                vol.write_main_header
+
+                file_indices.each do |idx|
+                  prepared = prepared_files[idx]
+                  vol.write_file_data(prepared[:header],
+                                      prepared[:compressed_data])
+                end
+
+                vol.write_end_header
+              end
+            end
+
+            # Select compression method
+            #
+            # @param data [String] File data
+            # @return [Integer] Compression method ID
+            def select_compression_method(data)
+              case @compression_options[:compression]
+              when :store
+                Compression::Store::METHOD
+              when :lzma
+                level = @compression_options[:level] || 3
+                Compression::Lzma.method_id(level)
+              when :auto
+                if data.bytesize < 1024
+                  Compression::Store::METHOD
+                else
+                  level = @compression_options[:level] || 3
+                  Compression::Lzma.method_id(level)
+                end
+              else
+                Compression::Store::METHOD
+              end
+            end
+
+            # Compress data
+            #
+            # @param data [String] Data to compress
+            # @param method [Integer] Compression method ID
+            # @return [String] Compressed data
+            def compress_data(data, method)
+              if method == Compression::Store::METHOD
+                Compression::Store.compress(data)
+              else
+                level = method.clamp(1, 5)
+                Compression::Lzma.compress(data, level: level)
+              end
+            end
+
+            # Estimate total archive size
+            #
+            # @return [Integer] Estimated size in bytes
+            def estimate_total_size
+              # Rough estimate: sum of file sizes + overhead
+              file_sizes = @files.sum { |f| f[:size] }
+              overhead = 1024 * @files.size # Header overhead per file
+              file_sizes + overhead
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/rar5/multi_volume/volume_splitter.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module MultiVolume
+          # Volume splitter for multi-volume archives
+          #
+          # This class handles splitting compressed data streams across
+          # multiple volumes while respecting size boundaries and file atomicity.
+          #
+          # @example Split data across volumes
+          #   splitter = VolumeSplitter.new(max_volume_size: 10_485_760)
+          #   splitter.start_volume(1)
+          #   splitter.write_to_current_volume(file1_data)
+          #   if !splitter.can_fit_in_current_volume?(file2_data.bytesize)
+          #     splitter.finalize_volume
+          #     splitter.start_volume(2)
+          #   end
+          class VolumeSplitter
+            # @return [Integer] Maximum size per volume in bytes
+            attr_reader :max_volume_size
+
+            # @return [Integer] Current volume number (1-based)
+            attr_reader :current_volume_number
+
+            # @return [Integer] Bytes written to current volume
+            attr_reader :current_volume_bytes
+
+            # @return [Array<Hash>] Volume metadata
+            attr_reader :volumes
+
+            # Minimum space reserved for headers (signature + main + end headers)
+            HEADER_OVERHEAD = 1024
+
+            # Initialize volume splitter
+            #
+            # @param max_volume_size [Integer] Maximum size per volume in bytes
+            def initialize(max_volume_size:)
+              @max_volume_size = max_volume_size
+              @current_volume_number = 0
+              @current_volume_bytes = 0
+              @current_volume_data = []
+              @volumes = []
+            end
+
+            # Start a new volume
+            #
+            # @param volume_number [Integer] Volume number (1-based)
+            # @return [void]
+            def start_volume(volume_number)
+              @current_volume_number = volume_number
+              @current_volume_bytes = HEADER_OVERHEAD # Reserve space for headers
+              @current_volume_data = []
+            end
+
+            # Check if data can fit in current volume
+            #
+            # @param data_size [Integer] Size of data to write
+            # @return [Boolean] true if data fits, false if new volume needed
+            def can_fit_in_current_volume?(data_size)
+              (@current_volume_bytes + data_size) <= @max_volume_size
+            end
+
+            # Get remaining space in current volume
+            #
+            # @return [Integer] Bytes available
+            def remaining_space
+              @max_volume_size - @current_volume_bytes
+            end
+
+            # Write data to current volume
+            #
+            # @param data [String] Data to write
+            # @return [void]
+            # @raise [RuntimeError] if no volume is active
+            # @raise [RuntimeError] if data doesn't fit
+            def write_to_current_volume(data)
+              raise Omnizip::CompressionError, "No active volume" if @current_volume_number.zero?
+              raise Omnizip::CompressionError, "Data doesn't fit in current volume" unless can_fit_in_current_volume?(data.bytesize)
+
+              @current_volume_data << data
+              @current_volume_bytes += data.bytesize
+            end
+
+            # Finalize current volume
+            #
+            # @return [Hash] Volume metadata
+            def finalize_volume
+              volume_info = {
+                number: @current_volume_number,
+                size: @current_volume_bytes,
+                data: @current_volume_data.join,
+              }
+
+              @volumes << volume_info
+              volume_info
+            end
+
+            # Calculate optimal file distribution across volumes
+            #
+            # This method determines how to distribute files across volumes
+            # to minimize volume count while respecting atomicity.
+            #
+            # @param files [Array<Hash>] File information with :compressed_size
+            # @return [Array<Array<Integer>>] Volume assignments (file indices per volume)
+            def calculate_file_distribution(files)
+              distribution = []
+              current_volume_files = []
+              current_volume_used = HEADER_OVERHEAD
+
+              files.each_with_index do |file, idx|
+                file_size = file[:compressed_size] + file[:header_size]
+
+                # Check if file fits in current volume
+                if (current_volume_used + file_size) <= @max_volume_size
+                  current_volume_files << idx
+                  current_volume_used += file_size
+                else
+                  # Start new volume
+                  distribution << current_volume_files unless current_volume_files.empty?
+                  current_volume_files = [idx]
+                  current_volume_used = HEADER_OVERHEAD + file_size
+
+                  # Check if single file exceeds volume size
+                  if current_volume_used > @max_volume_size
+                    # File must span multiple volumes (not implemented yet)
+                    # For now, just place it in its own volume
+                    distribution << [idx]
+                    current_volume_files = []
+                    current_volume_used = HEADER_OVERHEAD
+                  end
+                end
+              end
+
+              # Add final volume if not empty
+              distribution << current_volume_files unless current_volume_files.empty?
+
+              distribution
+            end
+
+            # Check if archive needs splitting
+            #
+            # @param total_size [Integer] Total archive size
+            # @return [Boolean] true if splitting needed
+            def self.needs_splitting?(total_size, max_volume_size)
+              total_size > max_volume_size
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/rar5/multi_volume/volume_writer.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module MultiVolume
+          # Volume writer for multi-volume archives
+          #
+          # This class writes individual .rar volume files with proper
+          # RAR5 headers and volume-specific flags.
+          #
+          # @example Write a volume
+          #   writer = VolumeWriter.new('archive.part1.rar', volume_number: 1, is_last: false)
+          #   writer.write_signature
+          #   writer.write_main_header
+          #   writer.write_file_data(file_header, compressed_data)
+          #   writer.write_end_header
+          #   writer.close
+          class VolumeWriter
+            # Main ARCHIVE flags (spec): 0x0001 volume,
+            # 0x0002 volume number field present
+            VOLUME_ARCHIVE_FLAG = MainHeader::ARCHIVE_FLAG_VOLUME
+            VOLUME_NUMBER_FLAG  = MainHeader::ARCHIVE_FLAG_VOLUME_NUMBER
+
+            # End header flags
+            VOLUME_END_FLAG = 0x0001 # Not the last volume (more volumes follow)
+
+            # @return [String] Volume file path
+            attr_reader :path
+
+            # @return [Integer] Volume number (1-based)
+            attr_reader :volume_number
+
+            # @return [Boolean] Is this the last volume?
+            attr_reader :is_last
+
+            # @return [IO] File handle
+            attr_reader :io
+
+            # Initialize volume writer
+            #
+            # @param path [String] Output volume file path
+            # @param volume_number [Integer] Volume number (1-based)
+            # @param is_last [Boolean] Is this the last volume?
+            def initialize(path, volume_number:, is_last: false)
+              @path = path
+              @volume_number = volume_number
+              @is_last = is_last
+              @io = nil
+            end
+
+            # Open volume file for writing
+            #
+            # @return [void]
+            def open
+              @io = File.open(@path, "wb")
+            end
+
+            # Close volume file
+            #
+            # @return [void]
+            def close
+              @io&.close
+              @io = nil
+            end
+
+            # Write with automatic open/close
+            #
+            # @yield [writer] Yields self for writing operations
+            # @return [void]
+            def write
+              open
+              yield self
+            ensure
+              close
+            end
+
+            # Write RAR5 signature
+            #
+            # @return [void]
+            def write_signature
+              raise Omnizip::IOError, "Volume not open" unless @io
+
+              # RAR5 signature: "Rar!\x1A\x07\x01\x00"
+              signature = [0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x01,
+                           0x00].pack("C*")
+              @io.write(signature)
+            end
+
+            # Write Main header with volume flags
+            #
+            # @return [void]
+            def write_main_header
+              raise Omnizip::IOError, "Volume not open" unless @io
+
+              # Archive flags: every volume declares 0x0001; volumes
+              # after the first also carry the volume number field
+              # (spec: number is N-1, absent on the first volume).
+              archive_flags = VOLUME_ARCHIVE_FLAG
+              volume_number = nil
+              if @volume_number > 1
+                archive_flags |= VOLUME_NUMBER_FLAG
+                volume_number = @volume_number - 1
+              end
+
+              @io.write(MainHeader.new(archive_flags: archive_flags,
+                                       volume_number: volume_number).encode)
+            end
+
+            # Write file data (header + compressed data)
+            #
+            # @param file_header [FileHeader] File header
+            # @param compressed_data [String] Compressed file data
+            # @return [void]
+            def write_file_data(file_header, compressed_data)
+              raise Omnizip::IOError, "Volume not open" unless @io
+
+              @io.write(file_header.encode)
+              @io.write(compressed_data)
+            end
+
+            # Write End header with volume flags
+            #
+            # @return [void]
+            def write_end_header
+              raise Omnizip::IOError, "Volume not open" unless @io
+
+              # End-of-archive flags: 0x0001 marks a volume with more
+              # volumes following; the last volume ends with 0.
+              end_flags = @is_last ? 0 : VOLUME_END_FLAG
+              @io.write(EndHeader.new(end_flags: end_flags).encode)
+            end
+
+            # Generate volume filename from base name
+            #
+            # @param base_path [String] Base archive path (e.g., "archive.rar")
+            # @param volume_number [Integer] Volume number (1-based)
+            # @param naming [String] Naming pattern ("part" or "volume")
+            # @return [String] Volume filename (e.g., "archive.part1.rar")
+            def self.volume_filename(base_path, volume_number, naming: "part")
+              dir = File.dirname(base_path)
+              basename = File.basename(base_path, ".*")
+              ext = File.extname(base_path)
+
+              volume_name = case naming
+                            when "part"
+                              "#{basename}.part#{volume_number}#{ext}"
+                            when "volume"
+                              "#{basename}.vol#{volume_number}#{ext}"
+                            when "numeric"
+                              # Simple numeric suffix: archive.rar, archive.r00, archive.r01, etc.
+                              if volume_number == 1
+                                "#{basename}#{ext}"
+                              else
+                                # Volume 2 => r00, Volume 3 => r01, etc.
+                                "#{basename}.r#{format('%02d',
+                                                       volume_number - 2)}"
+                              end
+                            else
+                              "#{basename}.part#{volume_number}#{ext}"
+                            end
+
+              # Handle relative vs absolute paths
+              if dir == "."
+                volume_name
+              else
+                File.join(dir, volume_name)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/rar5/solid/solid_encoder.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module Solid
+          # Solid LZMA encoder with persistent dictionary
+          #
+          # This encoder maintains LZMA dictionary state across multiple files,
+          # allowing later files to reference data from earlier files. This is
+          # the core technique behind solid compression's improved ratios.
+          #
+          # Unlike normal compression where each file is independent, solid
+          # compression treats all files as one continuous stream, maximizing
+          # dictionary-based compression efficiency.
+          #
+          # @example Compress multiple files in solid mode
+          #   encoder = SolidEncoder.new(level: 5)
+          #   compressed = encoder.compress_stream(concatenated_data)
+          class SolidEncoder
+            # @return [Integer] Compression level (1-5)
+            attr_reader :level
+
+            # @return [Hash] LZMA options
+            attr_reader :lzma_options
+
+            # Initialize solid encoder
+            #
+            # @param options [Hash] Encoder options
+            # @option options [Integer] :level Compression level (1-5, default: 3)
+            def initialize(options = {})
+              @level = options[:level] || 3
+              @lzma_options = build_lzma_options(@level)
+            end
+
+            # Compress data with persistent dictionary
+            #
+            # @param data [String] Data to compress (concatenated files)
+            # @return [String] Compressed data
+            def compress_stream(data)
+              input = StringIO.new(data)
+              output = StringIO.new
+              output.set_encoding(Encoding::BINARY)
+
+              # Create LZMA encoder
+              lzma = Algorithms::LZMA.new
+
+              # Compress entire stream at once (maintains dictionary)
+              lzma.compress(input, output, @lzma_options)
+
+              output.string
+            end
+
+            # Decompress solid stream
+            #
+            # @param data [String] Compressed data
+            # @return [String] Decompressed data
+            def decompress_stream(data)
+              input = StringIO.new(data)
+              output = StringIO.new
+              output.set_encoding(Encoding::BINARY)
+
+              lzma = Algorithms::LZMA.new
+              lzma.decompress(input, output)
+
+              output.string
+            end
+
+            # Build LZMA options for solid compression
+            #
+            # Solid compression benefits from larger dictionaries since
+            # we're compressing more data at once.
+            #
+            # @param level [Integer] RAR5 compression level (1-5)
+            # @return [LzmaOptions] LZMA encoder options
+            def build_lzma_options(level)
+              # Use larger dictionaries for solid mode
+              # This allows better cross-file references
+              dict_size = 1 << case level
+                               when 1 then 20  # 1 MB (fastest)
+                               when 2 then 22  # 4 MB (fast)
+                               when 3 then 24  # 16 MB (normal)
+                               when 4 then 25  # 32 MB (good)
+                               when 5 then 26  # 64 MB (best)
+                               else 24 # default: 16 MB
+                               end
+
+              LzmaOptions.new(level, dict_size)
+            end
+
+            # Simple options class for LZMA parameters
+            class LzmaOptions
+              attr_reader :level, :dict_size
+
+              def initialize(level, dict_size)
+                @level = level
+                @dict_size = dict_size
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end