omnizip 0.3.1

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../../../../../../lib/omnizip/algorithms/lzma"
+
+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

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "solid_stream"
+require_relative "solid_encoder"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module Solid
+          # Solid compression manager
+          #
+          # This manager coordinates solid compression by:
+          # 1. Collecting files into a SolidStream
+          # 2. Compressing the entire stream with persistent dictionary
+          # 3. Tracking file boundaries for extraction
+          #
+          # The result is better compression ratios at the cost of:
+          # - Cannot extract individual files without decompressing entire solid block
+          # - Corruption in one file may affect others in the same block
+          #
+          # @example Create solid archive
+          #   manager = SolidManager.new(level: 5)
+          #   manager.add_file('file1.txt', data1)
+          #   manager.add_file('file2.txt', data2)
+          #   compressed = manager.compress_all
+          class SolidManager
+            # @return [SolidStream] File stream
+            attr_reader :stream
+
+            # @return [SolidEncoder] Compression encoder
+            attr_reader :encoder
+
+            # @return [Integer] Compression level
+            attr_reader :level
+
+            # Initialize solid manager
+            #
+            # @param options [Hash] Options
+            # @option options [Integer] :level Compression level (1-5, default: 3)
+            def initialize(options = {})
+              @level = options[:level] || 3
+              @stream = SolidStream.new
+              @encoder = SolidEncoder.new(level: @level)
+            end
+
+            # Add file to solid block
+            #
+            # @param filename [String] File name
+            # @param data [String] File data
+            # @param metadata [Hash] File metadata
+            # @return [void]
+            def add_file(filename, data, metadata = {})
+              @stream.add_file(filename, data, metadata)
+            end
+
+            # Compress all files in solid mode
+            #
+            # Returns compressed data and file metadata needed for headers.
+            #
+            # @return [Hash] Compressed result
+            # @option result [String] :compressed_data The compressed stream
+            # @option result [Integer] :compressed_size Size of compressed data
+            # @option result [Integer] :uncompressed_size Total uncompressed size
+            # @option result [Array<Hash>] :files File metadata with offsets
+            def compress_all
+              # Get concatenated data
+              data = @stream.concatenated_data
+
+              # Compress entire stream
+              compressed = @encoder.compress_stream(data)
+
+              {
+                compressed_data: compressed,
+                compressed_size: compressed.bytesize,
+                uncompressed_size: data.bytesize,
+                files: @stream.files.dup,
+              }
+            end
+
+            # Decompress solid stream and extract file
+            #
+            # @param compressed_data [String] Compressed data
+            # @param file_index [Integer] File index to extract
+            # @return [String, nil] File data or nil if not found
+            def extract_file(compressed_data, file_index)
+              # Validate index
+              return nil if file_index.negative? || file_index >= @stream.file_count
+
+              # Decompress entire stream
+              decompressed = @encoder.decompress_stream(compressed_data)
+
+              # Extract specific file
+              file = @stream.file_at(file_index)
+              return nil unless file
+
+              decompressed[file[:offset], file[:size]]
+            end
+
+            # Get file count
+            #
+            # @return [Integer] Number of files
+            def file_count
+              @stream.file_count
+            end
+
+            # Get total uncompressed size
+            #
+            # @return [Integer] Total size in bytes
+            def total_size
+              @stream.total_size
+            end
+
+            # Check if manager has files
+            #
+            # @return [Boolean] true if files added
+            def has_files?
+              !@stream.empty?
+            end
+
+            # Clear all data
+            #
+            # @return [void]
+            def clear
+              @stream.clear
+            end
+
+            # Calculate compression ratio
+            #
+            # @param compressed_size [Integer] Compressed data size
+            # @return [Float] Compression ratio (0.0-1.0)
+            def compression_ratio(compressed_size)
+              return 0.0 if total_size.zero?
+
+              compressed_size.to_f / total_size
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module Solid
+          # Solid stream for concatenating multiple files
+          #
+          # In solid compression, multiple files are concatenated into a single
+          # compression stream, allowing the compressor to use data from earlier
+          # files as dictionary/context for later files. This significantly
+          # improves compression ratios for similar files.
+          #
+          # The stream maintains file boundaries and metadata to enable proper
+          # extraction while keeping all data in one continuous buffer.
+          #
+          # @example Create solid stream with multiple files
+          #   stream = SolidStream.new
+          #   stream.add_file('file1.txt', File.binread('file1.txt'))
+          #   stream.add_file('file2.txt', File.binread('file2.txt'))
+          #   data = stream.concatenated_data
+          class SolidStream
+            # @return [Array<Hash>] File entries with metadata
+            attr_reader :files
+
+            # @return [String] Concatenated file data
+            attr_reader :concatenated_data
+
+            # Initialize solid stream
+            def initialize
+              @files = []
+              @concatenated_data = String.new(encoding: Encoding::BINARY)
+              @current_offset = 0
+            end
+
+            # Add file to solid stream
+            #
+            # @param filename [String] File name for archive
+            # @param data [String] File data (binary)
+            # @param metadata [Hash] Additional file metadata
+            # @option metadata [Time] :mtime Modification time
+            # @option metadata [File::Stat] :stat File stat object
+            # @return [void]
+            def add_file(filename, data, metadata = {})
+              # Store file information
+              file_entry = {
+                filename: filename,
+                offset: @current_offset,
+                size: data.bytesize,
+                mtime: metadata[:mtime],
+                stat: metadata[:stat],
+              }
+
+              @files << file_entry
+
+              # Append data to stream
+              @concatenated_data << data
+
+              # Update offset
+              @current_offset += data.bytesize
+            end
+
+            # Get total size of all files
+            #
+            # @return [Integer] Total size in bytes
+            def total_size
+              @concatenated_data.bytesize
+            end
+
+            # Get file count
+            #
+            # @return [Integer] Number of files
+            def file_count
+              @files.size
+            end
+
+            # Get file entry by index
+            #
+            # @param index [Integer] File index (0-based)
+            # @return [Hash, nil] File entry or nil if not found
+            def file_at(index)
+              return nil if index.negative? || index >= @files.size
+
+              @files[index]
+            end
+
+            # Extract file data by index
+            #
+            # @param index [Integer] File index (0-based)
+            # @return [String, nil] File data or nil if not found
+            def extract_file_data(index)
+              return nil if index.negative? || index >= @files.size
+
+              file = @files[index]
+              return nil unless file
+
+              @concatenated_data[file[:offset], file[:size]]
+            end
+
+            # Clear all data and reset
+            #
+            # @return [void]
+            def clear
+              @files.clear
+              @concatenated_data.clear
+              @current_offset = 0
+            end
+
+            # Check if stream is empty
+            #
+            # @return [Boolean] true if no files added
+            def empty?
+              @files.empty?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/rar5/vint.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        # Variable-length integer encoding/decoding for RAR5 format
+        module VINT
+          # Encode integer as VINT bytes
+          # @param value [Integer] Value to encode (0 to 2^62)
+          # @return [Array<Integer>] VINT bytes
+          def self.encode(value)
+            return [value] if value < 0x80
+
+            bytes = []
+            # Determine byte count needed
+            byte_count = 1
+            test_value = value
+            while test_value >= (1 << (7 * byte_count))
+              byte_count += 1
+            end
+
+            # First byte: continuation bits + high bits
+            first_byte = (0xFF << (9 - byte_count)) & 0xFF
+            first_byte |= (value >> (8 * (byte_count - 1))) & 0x7F
+            bytes << first_byte
+
+            # Remaining bytes
+            (byte_count - 1).downto(1) do |i|
+              bytes << ((value >> (8 * (i - 1))) & 0xFF)
+            end
+
+            bytes
+          end
+
+          # Decode VINT from IO stream
+          # @param io [IO] Input stream
+          # @return [Integer] Decoded value
+          def self.decode(io)
+            first_byte = io.readbyte
+            return first_byte if first_byte < 0x80
+
+            # Count continuation bits
+            byte_count = 0
+            mask = 0x80
+            while first_byte.anybits?(mask)
+              byte_count += 1
+              mask >>= 1
+            end
+
+            # Extract value from first byte
+            value = first_byte & (0xFF >> (byte_count + 1))
+
+            # Read remaining bytes
+            byte_count.times do
+              value = (value << 8) | io.readbyte
+            end
+
+            value
+          end
+        end
+      end
+    end
+  end
+end