omnizip 0.4.7-arm-linux

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+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,53 @@
+# 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 per the RAR 5.0 spec: one or
+          # more bytes, each carrying 7 data bits starting with the
+          # least significant group; the high bit of every byte but
+          # the last is the continuation flag.
+          #
+          # @param value [Integer] Value to encode (0 to 2^63)
+          # @return [Array<Integer>] VINT bytes
+          def self.encode(value)
+            raise ArgumentError, "VINT cannot encode negative values" if value.negative?
+
+            bytes = []
+            loop do
+              byte = value & 0x7F
+              value >>= 7
+              byte |= 0x80 if value.positive?
+              bytes << byte
+              break if value.zero?
+            end
+
+            bytes
+          end
+
+          # Decode VINT from IO stream (spec encoding, mirroring
+          # BlockParser#read_vint)
+          #
+          # @param io [IO] Input stream
+          # @return [Integer] Decoded value
+          def self.decode(io)
+            result = 0
+            shift = 0
+            loop do
+              byte = io.readbyte
+              result |= (byte & 0x7F) << shift
+              break if byte.nobits?(0x80)
+
+              shift += 7
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end