omnizip 0.4.7-x86_64-linux

data/lib/omnizip/formats/rar3/decompressor.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Omnizip
+  module Formats
+    module Rar3
+      # RAR v3 decompressor
+      #
+      # Decompresses data using RAR v3 decompression algorithms.
+      # This implementation uses DEFLATE as a compatible fallback
+      # for demonstration purposes. Full RAR decompression requires
+      # proprietary algorithms.
+      #
+      # @example Decompressing data
+      #   decompressor = Rar3::Decompressor.new
+      #   original = decompressor.decompress(compressed, method: :normal)
+      class Decompressor < Rar::RarFormatBase
+        # Initialize a RAR v3 decompressor
+        def initialize
+          super("rar3")
+        end
+
+        # Decompress data using RAR v3 methods
+        #
+        # @param data [String] The compressed data
+        # @param method [Symbol] The compression method
+        # @param options [Hash] Decompression options
+        # @return [String] The decompressed data
+        def decompress(data, method: :normal, **_options)
+          case method
+          when :store
+            decompress_store(data)
+          when :fastest, :fast, :normal, :good, :best
+            decompress_deflate(data)
+          else
+            raise FormatError,
+                  "Unsupported decompression method: #{method}"
+          end
+        end
+
+        private
+
+        # Return stored data without decompression
+        #
+        # @param data [String] The stored data
+        # @return [String] The uncompressed data
+        def decompress_store(data)
+          data
+        end
+
+        # Decompress using DEFLATE (compatible fallback)
+        #
+        # @param data [String] The compressed data
+        # @return [String] The decompressed data
+        def decompress_deflate(data)
+          Zlib::Inflate.inflate(data)
+        rescue Zlib::Error => e
+          raise FormatError, "Decompression failed: #{e.message}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "tmpdir"
+
+module Omnizip
+  module Formats
+    module Rar3
+      # RAR v3 (RAR4-family) archive reader
+      #
+      # Adapter over the primary `Formats::Rar::Reader` — the one
+      # parser verified against real WinRAR archives — exposing the
+      # legacy entry shape (uncompressed_size, modified_time, ...).
+      #
+      # @example Reading a RAR3 archive
+      #   reader = Rar3::Reader.new
+      #   File.open("archive.rar", "rb") do |file|
+      #     reader.read_archive(file).each { |entry| puts entry.name }
+      #   end
+      class Reader < Omnizip::Formats::Rar::RarFormatBase
+        # RAR4 method byte to the legacy symbol vocabulary
+        METHOD_SYMBOLS = {
+          0x30 => :store,
+          0x31 => :fastest,
+          0x32 => :fast,
+          0x33 => :normal,
+          0x34 => :good,
+          0x35 => :best,
+        }.freeze
+
+        # Initialize a RAR v3 reader
+        def initialize
+          super("rar3")
+        end
+
+        # Read a RAR v3 archive
+        #
+        # @param io [IO] The input stream
+        # @return [Array<Entry>] The archive entries
+        # @raise [FormatError] If the archive signature is invalid
+        def read_archive(io)
+          data = io.read
+          unless verify_magic_bytes(StringIO.new(data))
+            raise FormatError, "Invalid RAR v3 signature"
+          end
+
+          Dir.mktmpdir("omnizip_rar3_read") do |tmp|
+            archive_path = File.join(tmp, "archive.rar")
+            File.binwrite(archive_path, data)
+
+            primary = Rar::Reader.new(archive_path)
+            primary.open
+            primary.list_files.map { |entry| adapt_entry(entry) }
+          end
+        end
+
+        private
+
+        # Map a primary RarEntry onto the legacy Entry shape
+        def adapt_entry(entry)
+          Entry.new(
+            name: entry.name,
+            compressed_size: entry.compressed_size,
+            uncompressed_size: entry.size,
+            crc32: entry.crc,
+            compression_method: METHOD_SYMBOLS[entry.method],
+            modified_time: entry.mtime,
+            attributes: entry.attributes,
+            encrypted: entry.encrypted,
+            host_os: entry.host_os,
+          )
+        end
+
+        # RAR archive entry model (legacy shape)
+        class Entry
+          include Omnizip::Entry
+
+          attr_accessor :name, :compressed_size, :uncompressed_size, :crc32,
+                        :compression_method, :modified_time, :attributes,
+                        :encrypted, :data_offset, :host_os, :salt
+
+          def entry_name = name
+          def entry_directory? = false
+          def entry_size = uncompressed_size
+          def entry_mtime = modified_time
+
+          def initialize(name: nil, compressed_size: nil, uncompressed_size: nil,
+                         crc32: nil, compression_method: nil, modified_time: nil,
+                         attributes: nil, encrypted: nil, data_offset: nil,
+                         host_os: nil, salt: nil)
+            @name = name
+            @compressed_size = compressed_size
+            @uncompressed_size = uncompressed_size
+            @crc32 = crc32
+            @compression_method = compression_method
+            @modified_time = modified_time
+            @attributes = attributes
+            @encrypted = encrypted
+            @data_offset = data_offset
+            @host_os = host_os
+            @salt = salt
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+begin
+  require "lutaml/model"
+rescue LoadError, ArgumentError
+  # lutaml-model not available, using simple classes
+end
+
+require "stringio"
+
+module Omnizip
+  module Formats
+    module Rar3
+      # RAR v3 archive writer
+      #
+      # Writes RAR 3.x format archives, creating headers and compressing file
+      # data according to the RAR v3 specification.
+      #
+      # @example Writing a RAR3 archive
+      #   writer = Rar3::Writer.new
+      #   File.open("archive.rar", "wb") do |file|
+      #     entries = [
+      #       {name: "file.txt", data: "content", time: Time.now}
+      #     ]
+      #     writer.write_archive(file, entries)
+      #   end
+      class Writer < Omnizip::Formats::Rar::RarFormatBase
+        # Initialize a RAR v3 writer
+        def initialize
+          super("rar3")
+          @compressor = Compressor.new
+        end
+
+        # Write a RAR v3 archive
+        #
+        # @param io [IO] The output stream
+        # @param entries [Array<Hash>] The entries to write
+        # @return [void]
+        def write_archive(io, entries)
+          # Write marker block
+          write_marker_block(io)
+
+          # Write archive header
+          write_archive_header(io)
+
+          # Write file entries
+          entries.each do |entry|
+            write_file_entry(io, entry)
+          end
+
+          # Write terminator block
+          write_terminator_block(io)
+        end
+
+        private
+
+        # Write marker block (RAR signature)
+        #
+        # @param io [IO] The output stream
+        # @return [void]
+        def write_marker_block(io)
+          io.write(spec.magic_bytes.pack("C*"))
+        end
+
+        # Write archive header block
+        #
+        # @param io [IO] The output stream
+        # @return [void]
+        def write_archive_header(io)
+          flags = 0
+          # Set default flags if needed
+
+          header_data = StringIO.new
+          # Reserved fields: HighPosAV (2) + PosAV (4) = 6 bytes,
+          # making the main header 13 bytes total like WinRAR's
+          header_data.write([0].pack("v") + [0].pack("V"))
+
+          header = create_block_header(
+            type: block_type_code(:archive),
+            flags: flags,
+            data: header_data.string,
+          )
+
+          write_block_header(io, header)
+          io.write(header_data.string)
+        end
+
+        # Write a file entry
+        #
+        # @param io [IO] The output stream
+        # @param entry [Hash] The entry data
+        # @return [void]
+        def write_file_entry(io, entry)
+          name = entry[:name] || entry["name"]
+          data = entry[:data] || entry["data"]
+          mtime = entry[:time] || entry["time"] || Time.now
+          method = entry[:method] || entry["method"] || :normal
+
+          # Compress data
+          compressed_data = @compressor.compress(data, method: method)
+
+          # Calculate sizes and CRC
+          packed_size = compressed_data.bytesize
+          unpacked_size = data.bytesize
+          file_crc = calculate_crc32(data)
+
+          # Encode filename
+          name_bytes = name.encode("UTF-8")
+          name_size = name_bytes.bytesize
+
+          # Set flags: LONG_BLOCK marks the PACK_SIZE data area; names
+          # are written as plain bytes without the Unicode flag (the
+          # 0x0200 encoding appends a second encoded name we do not
+          # write)
+          flags = spec.format.file_flags[:long_block]
+          if unpacked_size > 0xFFFFFFFF
+            flags |= spec.format.file_flags[:large_file]
+          end
+
+          # Build file header data. High size words precede the name
+          # per the RAR4 layout.
+          header_data = StringIO.new
+          header_data.write([packed_size & 0xFFFFFFFF].pack("V"))
+          header_data.write([unpacked_size & 0xFFFFFFFF].pack("V"))
+          header_data.write([spec.format.host_os[:win32]].pack("C"))
+          header_data.write([file_crc].pack("V"))
+          header_data.write([encode_dos_time(mtime)].pack("V"))
+          header_data.write([0x14].pack("C"))  # Version needed
+          header_data.write([compression_method_code(method)].pack("C"))
+          header_data.write([name_size].pack("v"))
+          header_data.write([0x20].pack("V"))  # File attributes
+          if flags & spec.format.file_flags[:large_file] != 0
+            header_data.write([(packed_size >> 32) & 0xFFFFFFFF].pack("V"))
+            header_data.write([(unpacked_size >> 32) & 0xFFFFFFFF].pack("V"))
+          end
+          header_data.write(name_bytes)
+
+          # Create and write block header
+          header = create_block_header(
+            type: block_type_code(:file),
+            flags: flags,
+            data: header_data.string,
+          )
+
+          write_block_header(io, header)
+          io.write(header_data.string)
+          io.write(compressed_data)
+        end
+
+        # Write terminator block
+        #
+        # @param io [IO] The output stream
+        # @return [void]
+        def write_terminator_block(io)
+          header = create_block_header(
+            type: block_type_code(:terminator),
+            flags: 0,
+            data: "",
+          )
+
+          write_block_header(io, header)
+        end
+
+        # Create a block header
+        #
+        # @param type [Integer] The block type
+        # @param flags [Integer] The block flags
+        # @param data [String] The block data
+        # @return [Hash] The block header
+        def create_block_header(type:, flags:, data:)
+          size = 7 + data.bytesize # Header size + data size
+
+          # Calculate header CRC
+          temp = StringIO.new
+          temp.write([type].pack("C"))
+          temp.write([flags].pack("v"))
+          temp.write([size].pack("v"))
+          temp.write(data) unless data.empty?
+
+          header_crc = calculate_crc32(temp.string) & 0xFFFF
+
+          {
+            crc: header_crc,
+            type: type,
+            flags: flags,
+            size: size,
+          }
+        end
+
+        # Write a block header to stream
+        #
+        # @param io [IO] The output stream
+        # @param header [Hash] The header data
+        # @return [void]
+        def write_block_header(io, header)
+          io.write([header[:crc]].pack("v"))
+          io.write([header[:type]].pack("C"))
+          io.write([header[:flags]].pack("v"))
+          io.write([header[:size]].pack("v"))
+        end
+
+        # Encode Ruby Time to DOS date/time format
+        #
+        # @param time [Time] The time to encode
+        # @return [Integer] The DOS timestamp
+        def encode_dos_time(time)
+          second = time.sec / 2
+          minute = time.min
+          hour = time.hour
+          day = time.day
+          month = time.month
+          year = time.year - 1980
+
+          (year << 25) | (month << 21) | (day << 16) |
+            (hour << 11) | (minute << 5) | second
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar3.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    # Standalone RAR3 reader/writer tree (see Formats::Rar for the
+    # primary RAR support). Classes under this namespace load lazily;
+    # require "omnizip" first so sibling namespaces resolve.
+    module Rar3
+      autoload :Compressor, "omnizip/formats/rar3/compressor"
+      autoload :Decompressor, "omnizip/formats/rar3/decompressor"
+      autoload :Reader, "omnizip/formats/rar3/reader"
+      autoload :Writer, "omnizip/formats/rar3/writer"
+    end
+  end
+end

data/lib/omnizip/formats/rar5/compressor.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Omnizip
+  module Formats
+    module Rar5
+      # RAR v5 compressor
+      #
+      # Compresses data using RAR v5 compression algorithms.
+      # This implementation uses DEFLATE as a compatible fallback
+      # for demonstration purposes. Full RAR5 compression requires
+      # proprietary algorithms.
+      #
+      # @example Compressing data
+      #   compressor = Rar5::Compressor.new
+      #   compressed = compressor.compress("Hello, World!", method: :normal)
+      class Compressor < Rar::RarFormatBase
+        # Initialize a RAR v5 compressor
+        def initialize
+          super("rar5")
+        end
+
+        # Compress data using RAR v5 methods
+        #
+        # @param data [String] The data to compress
+        # @param method [Symbol] The compression method
+        # @param options [Hash] Compression options
+        # @return [String] The compressed data
+        def compress(data, method: :normal, **_options)
+          case method
+          when :store
+            compress_store(data)
+          when :fastest
+            compress_deflate(data, level: Zlib::BEST_SPEED)
+          when :fast
+            compress_deflate(data, level: 3)
+          when :normal
+            compress_deflate(data, level: Zlib::DEFAULT_COMPRESSION)
+          when :good
+            compress_deflate(data, level: 7)
+          when :best
+            compress_deflate(data, level: Zlib::BEST_COMPRESSION)
+          else
+            raise FormatError,
+                  "Unsupported compression method: #{method}"
+          end
+        end
+
+        private
+
+        # Store data without compression
+        #
+        # @param data [String] The data to store
+        # @return [String] The uncompressed data
+        def compress_store(data)
+          data
+        end
+
+        # Compress using DEFLATE (compatible fallback)
+        #
+        # @param data [String] The data to compress
+        # @param level [Integer] The compression level
+        # @return [String] The compressed data
+        def compress_deflate(data, level:)
+          Zlib::Deflate.deflate(data, level)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar5/decompressor.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Omnizip
+  module Formats
+    module Rar5
+      # RAR v5 decompressor
+      #
+      # Decompresses data using RAR v5 decompression algorithms.
+      # This implementation uses DEFLATE as a compatible fallback
+      # for demonstration purposes. Full RAR5 decompression requires
+      # proprietary algorithms.
+      #
+      # @example Decompressing data
+      #   decompressor = Rar5::Decompressor.new
+      #   original = decompressor.decompress(compressed, method: :normal)
+      class Decompressor < Rar::RarFormatBase
+        # Initialize a RAR v5 decompressor
+        def initialize
+          super("rar5")
+        end
+
+        # Decompress data using RAR v5 methods
+        #
+        # @param data [String] The compressed data
+        # @param method [Symbol] The compression method
+        # @param options [Hash] Decompression options
+        # @return [String] The decompressed data
+        def decompress(data, method: :normal, **_options)
+          case method
+          when :store
+            decompress_store(data)
+          when :fastest, :fast, :normal, :good, :best
+            decompress_deflate(data)
+          else
+            raise FormatError,
+                  "Unsupported decompression method: #{method}"
+          end
+        end
+
+        private
+
+        # Return stored data without decompression
+        #
+        # @param data [String] The stored data
+        # @return [String] The uncompressed data
+        def decompress_store(data)
+          data
+        end
+
+        # Decompress using DEFLATE (compatible fallback)
+        #
+        # @param data [String] The compressed data
+        # @return [String] The decompressed data
+        def decompress_deflate(data)
+          Zlib::Inflate.inflate(data)
+        rescue Zlib::Error => e
+          raise FormatError, "Decompression failed: #{e.message}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "tmpdir"
+
+module Omnizip
+  module Formats
+    module Rar5
+      # RAR v5 archive reader
+      #
+      # Adapter over the primary `Formats::Rar::Reader` — the one RAR5
+      # parser verified against real archives and unrar — exposing the
+      # legacy entry shape (uncompressed_size, modified_time, ...).
+      #
+      # RAR 5 uses variable-length integers (vint) and improved header structure.
+      #
+      # @example Reading a RAR5 archive
+      #   reader = Rar5::Reader.new
+      #   File.open("archive.rar", "rb") do |file|
+      #     entries = reader.read_archive(file)
+      #     entries.each { |entry| puts entry.name }
+      #   end
+      class Reader < Omnizip::Formats::Rar::RarFormatBase
+        # RAR5 compression-method byte (cinfo bits 8-10) to the legacy
+        # symbol vocabulary
+        METHOD_SYMBOLS = {
+          0x30 => :store,
+          0x31 => :fastest,
+          0x32 => :fast,
+          0x33 => :normal,
+          0x34 => :good,
+          0x35 => :best,
+        }.freeze
+
+        # Initialize a RAR v5 reader
+        def initialize
+          super("rar5")
+        end
+
+        # Read a RAR v5 archive
+        #
+        # @param io [IO] The input stream
+        # @return [Array<Entry>] The archive entries
+        # @raise [FormatError] If the archive signature is invalid
+        def read_archive(io)
+          data = io.read
+          unless verify_magic_bytes(StringIO.new(data))
+            raise FormatError, "Invalid RAR v5 signature"
+          end
+
+          Dir.mktmpdir("omnizip_rar5_read") do |tmp|
+            archive_path = File.join(tmp, "archive.rar")
+            File.binwrite(archive_path, data)
+
+            primary = Rar::Reader.new(archive_path)
+            primary.open
+            primary.list_files.map { |entry| adapt_entry(entry) }
+          end
+        end
+
+        private
+
+        # Map a primary RarEntry onto the legacy Entry shape
+        def adapt_entry(entry)
+          Entry.new(
+            name: entry.name,
+            compressed_size: entry.compressed_size,
+            uncompressed_size: entry.size,
+            crc32: entry.crc,
+            compression_method: METHOD_SYMBOLS[entry.method],
+            modified_time: entry.mtime,
+            attributes: entry.attributes,
+            encrypted: entry.encrypted,
+            host_os: entry.host_os,
+            is_directory: entry.is_dir,
+          )
+        end
+
+        class HeaderBlock
+          attr_accessor :crc, :size, :vint_length, :type, :flags, :extra_size,
+                        :data_size, :header_start, :content_start
+
+          def initialize(crc: nil, size: nil, vint_length: 1, type: nil, flags: nil,
+                         extra_size: nil, data_size: nil, header_start: nil, content_start: nil)
+            @crc = crc
+            @size = size
+            @vint_length = vint_length
+            @type = type
+            @flags = flags
+            @extra_size = extra_size
+            @data_size = data_size
+            @header_start = header_start
+            @content_start = content_start
+          end
+        end
+
+        # RAR v5 archive entry model
+        class Entry
+          include Omnizip::Entry
+
+          attr_accessor :name, :compressed_size, :uncompressed_size, :crc32,
+                        :compression_method, :modified_time, :attributes,
+                        :encrypted, :data_offset, :host_os, :is_directory
+
+          def entry_name = name
+          def entry_directory? = is_directory
+          def entry_size = uncompressed_size
+          def entry_mtime = modified_time
+
+          def initialize(name: nil, compressed_size: nil, uncompressed_size: nil,
+                         crc32: nil, compression_method: nil, modified_time: nil,
+                         attributes: nil, encrypted: nil, data_offset: nil,
+                         host_os: nil, is_directory: nil)
+            @name = name
+            @compressed_size = compressed_size
+            @uncompressed_size = uncompressed_size
+            @crc32 = crc32
+            @compression_method = compression_method
+            @modified_time = modified_time
+            @attributes = attributes
+            @encrypted = encrypted
+            @data_offset = data_offset
+            @host_os = host_os
+            @is_directory = is_directory
+          end
+        end
+      end
+    end
+  end
+end