omnizip 0.3.1

data/lib/omnizip/zip/input_stream.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require_relative "entry"
+require_relative "../formats/zip/constants"
+require_relative "../formats/zip/local_file_header"
+
+module Omnizip
+  module Zip
+    # Rubyzip-compatible InputStream class
+    # Provides streaming read API for ZIP archives
+    class InputStream
+      include Omnizip::Formats::Zip::Constants
+
+      # Open an input stream
+      # @param file_path_or_io [String, IO] File path or IO object
+      # @yield [stream] Block to read from the stream
+      # @return [InputStream] The stream (if no block given)
+      def self.open(file_path_or_io, &block)
+        stream = new(file_path_or_io)
+
+        if block
+          begin
+            yield(stream)
+          ensure
+            stream.close
+          end
+        else
+          stream
+        end
+      end
+
+      # Initialize input stream
+      # @param file_path_or_io [String, IO] File path or IO object
+      def initialize(file_path_or_io)
+        if file_path_or_io.is_a?(String)
+          @file_path = file_path_or_io
+          @io = ::File.open(file_path_or_io, "rb")
+          @owns_io = true
+        else
+          @io = file_path_or_io
+          @owns_io = false
+        end
+
+        @current_entry = nil
+        @current_entry_io = nil
+        @current_index = 0
+        @closed = false
+        @hit_nil = false
+
+        # Find and parse central directory for efficient access
+        parse_central_directory
+      end
+
+      # Get next entry in the archive
+      # @return [Entry, nil] Next entry or nil if no more entries
+      def get_next_entry
+        # Check if we can fetch another entry
+        if @current_index >= @all_entries.size
+          # Mark that get_next_entry returned nil
+          @hit_nil = true
+          return nil
+        end
+
+        # Close previous entry data if open
+        @current_entry_io = nil
+
+        # Get next entry from our parsed list
+        header = @all_entries[@current_index]
+        @current_index += 1
+
+        # Successfully got an entry - clear the nil flag
+        @hit_nil = false
+
+        # Position at entry data
+        position_at_entry_data(header)
+
+        @current_entry = Entry.new(header)
+        @current_entry
+      end
+
+      # Read from current entry
+      # @param size [Integer, nil] Number of bytes to read (nil for all)
+      # @return [String, nil] Data read or nil if no current entry
+      def read(size = nil)
+        return nil unless @current_entry
+
+        # Initialize entry IO if needed
+        unless @current_entry_io
+          compressed_data = @io.read(@current_entry.compressed_size)
+          decompressed = decompress_data(
+            compressed_data,
+            @current_entry.compression_method,
+            @current_entry.size,
+          )
+          require "stringio"
+          @current_entry_io = StringIO.new(decompressed, "rb")
+        end
+
+        @current_entry_io.read(size)
+      end
+
+      # Rewind the stream
+      def rewind
+        @current_index = 0
+        @current_entry = nil
+        @current_entry_io = nil
+        @hit_nil = false
+      end
+
+      # Close the stream
+      def close
+        return if @closed
+
+        @current_entry_io = nil
+        @io.close if @owns_io
+        @closed = true
+      end
+
+      # Check if stream is closed
+      def closed?
+        @closed
+      end
+
+      # Check if at end of file
+      # Returns true if the NEXT call to get_next_entry would return nil
+      def eof?
+        @current_index >= @all_entries.size
+      end
+      alias_method :eof, :eof?
+
+      private
+
+      # Parse central directory to get all entries
+      def parse_central_directory
+        # Find End of Central Directory
+        eocd = find_eocd
+
+        # Read central directory entries
+        @io.seek(eocd[:central_directory_offset], ::IO::SEEK_SET)
+        @all_entries = []
+
+        eocd[:total_entries].times do
+          header_data = @io.read(46)
+          break unless header_data && header_data.size == 46
+
+          # Get dynamic field lengths
+          _, _, _, _, _, _, _, _, _, _,
+          filename_length, extra_field_length, comment_length = header_data.unpack("VvvvvvvVVVvvv")
+
+          # Read complete header
+          complete_data = header_data + @io.read(filename_length + extra_field_length + comment_length)
+          entry = Omnizip::Formats::Zip::CentralDirectoryHeader.from_binary(complete_data)
+
+          @all_entries << entry
+        end
+      end
+
+      # Find End of Central Directory record
+      def find_eocd
+        # Start from end of file
+        @io.seek(0, ::IO::SEEK_END)
+        file_size = @io.pos
+
+        # EOCD is at least 22 bytes
+        return nil if file_size < 22
+
+        # Search backwards for EOCD signature
+        # Maximum comment length is 65535, so search up to 65557 bytes from end
+        search_start = [file_size - 65557, 0].max
+        @io.seek(search_start, ::IO::SEEK_SET)
+        buffer = @io.read
+
+        # Find signature
+        signature = [END_OF_CENTRAL_DIRECTORY_SIGNATURE].pack("V")
+        pos = buffer.rindex(signature)
+
+        unless pos
+          raise Omnizip::FormatError,
+                "End of Central Directory not found"
+        end
+
+        # Parse EOCD
+        eocd_data = buffer[pos..]
+
+        sig, disk_num, disk_with_cd, entries_this_disk, total_entries,
+        cd_size, cd_offset, comment_length = eocd_data.unpack("VvvvvVVv")
+
+        {
+          signature: sig,
+          disk_number: disk_num,
+          disk_number_with_cd: disk_with_cd,
+          total_entries_this_disk: entries_this_disk,
+          total_entries: total_entries,
+          central_directory_size: cd_size,
+          central_directory_offset: cd_offset,
+          comment_length: comment_length,
+          comment: eocd_data[22, comment_length] || "",
+        }
+      end
+
+      # Position IO at entry's data (after local file header)
+      def position_at_entry_data(header)
+        # Seek to local file header
+        @io.seek(header.local_header_offset, ::IO::SEEK_SET)
+
+        # Read fixed part of local file header
+        fixed_header = @io.read(30)
+
+        # Extract variable lengths
+        _, _, _, _, _, _, _, _, _, filename_length, extra_length =
+          fixed_header.unpack("VvvvvvVVVvv")
+
+        # Skip variable parts to get to data
+        @io.read(filename_length + extra_length)
+      end
+
+      # Decompress data based on compression method
+      def decompress_data(compressed_data, method, uncompressed_size)
+        case method
+        when COMPRESSION_STORE
+          compressed_data
+        when COMPRESSION_DEFLATE
+          decompress_deflate(compressed_data)
+        when COMPRESSION_BZIP2
+          decompress_bzip2(compressed_data)
+        when COMPRESSION_LZMA
+          decompress_lzma(compressed_data, uncompressed_size)
+        when COMPRESSION_ZSTANDARD
+          decompress_zstandard(compressed_data)
+        else
+          raise Omnizip::UnsupportedFormatError,
+                "Unsupported compression method: #{method}"
+        end
+      end
+
+      # Decompress using Deflate
+      def decompress_deflate(data)
+        require "zlib"
+        Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(data)
+      rescue StandardError => e
+        raise Omnizip::DecompressionError,
+              "Deflate decompression failed: #{e.message}"
+      end
+
+      # Decompress using BZip2
+      def decompress_bzip2(data)
+        algorithm = Omnizip::AlgorithmRegistry.get(:bzip2)
+        algorithm.decompress(data)
+      rescue StandardError => e
+        raise Omnizip::DecompressionError,
+              "BZip2 decompression failed: #{e.message}"
+      end
+
+      # Decompress using LZMA
+      def decompress_lzma(data, uncompressed_size)
+        algorithm = Omnizip::AlgorithmRegistry.get(:lzma)
+        algorithm.decompress(data, uncompressed_size: uncompressed_size)
+      rescue StandardError => e
+        raise Omnizip::DecompressionError,
+              "LZMA decompression failed: #{e.message}"
+      end
+
+      # Decompress using Zstandard
+      def decompress_zstandard(data)
+        algorithm = Omnizip::AlgorithmRegistry.get(:zstandard)
+        algorithm.decompress(data)
+      rescue StandardError => e
+        raise Omnizip::DecompressionError,
+              "Zstandard decompression failed: #{e.message}"
+      end
+    end
+  end
+end

data/lib/omnizip/zip/output_stream.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../formats/zip/constants"
+require_relative "../formats/zip/local_file_header"
+require_relative "../formats/zip/central_directory_header"
+require_relative "../formats/zip/end_of_central_directory"
+
+module Omnizip
+  module Zip
+    # Rubyzip-compatible OutputStream class
+    # Provides streaming write API for ZIP archives
+    class OutputStream
+      include Omnizip::Formats::Zip::Constants
+
+      # Open a new output stream
+      # @param file_path [String] Path to ZIP file
+      # @yield [stream] Block to write to the stream
+      # @return [OutputStream] The stream (if no block given)
+      def self.open(file_path, &block)
+        stream = new(file_path)
+
+        if block
+          begin
+            yield(stream)
+          ensure
+            stream.close
+          end
+        else
+          stream
+        end
+      end
+
+      # Initialize output stream
+      # @param file_path_or_io [String, IO] File path or IO object
+      def initialize(file_path_or_io)
+        if file_path_or_io.is_a?(String)
+          @file_path = file_path_or_io
+          @io = ::File.open(file_path_or_io, "wb")
+          @owns_io = true
+        else
+          @io = file_path_or_io
+          @owns_io = false
+        end
+
+        @entries = []
+        @current_entry = nil
+        @current_entry_data = nil
+        @closed = false
+      end
+
+      # Start a new entry
+      # @param name [String] Entry name
+      # @param time [Time] Modification time
+      # @param comment [String] Entry comment
+      # @param compression [Symbol] Compression method (:store or :deflate)
+      # @param level [Integer] Compression level (1-9)
+      def put_next_entry(name, time: Time.now, comment: "",
+compression: :deflate, level: 6)
+        close_entry if @current_entry
+
+        @current_entry = {
+          name: name,
+          time: time,
+          comment: comment,
+          compression: compression_method_for(compression),
+          level: level,
+          offset: @io.pos,
+          directory: name.end_with?("/"),
+        }
+        @current_entry_data = String.new(encoding: Encoding::BINARY)
+
+        # Write placeholder local file header (will update later)
+        write_local_file_header_placeholder
+
+        self
+      end
+
+      # Write data to current entry
+      # @param data [String] Data to write
+      def write(data)
+        raise "No entry started. Call put_next_entry first" unless @current_entry
+
+        @current_entry_data << data.b
+        self
+      end
+      alias_method :<<, :write
+
+      # Print data to current entry
+      def print(*args)
+        write(args.join)
+      end
+
+      # Put data to current entry
+      def puts(*args)
+        args.each { |arg| write("#{arg}\n") }
+      end
+
+      # Close current entry
+      def close_entry
+        return unless @current_entry
+
+        # Compress data if needed
+        compressed_data = compress_entry_data
+
+        # Calculate CRC32
+        crc32 = @current_entry[:directory] ? 0 : calculate_crc32(@current_entry_data)
+
+        # Write compressed data
+        @io.write(compressed_data) unless @current_entry[:directory]
+
+        # Update entry info
+        @current_entry.merge!({
+                                crc32: crc32,
+                                compressed_size: compressed_data.bytesize,
+                                uncompressed_size: @current_entry_data.bytesize,
+                              })
+
+        # Update local file header with correct sizes
+        current_pos = @io.pos
+        @io.seek(@current_entry[:offset], ::IO::SEEK_SET)
+        write_local_file_header
+        @io.seek(current_pos, ::IO::SEEK_SET)
+
+        # Save entry for central directory
+        @entries << @current_entry
+
+        @current_entry = nil
+        @current_entry_data = nil
+      end
+
+      # Set archive comment
+      def comment=(comment)
+        @comment = comment
+      end
+
+      # Get archive comment
+      def comment
+        @comment || ""
+      end
+
+      # Close the stream
+      def close
+        return if @closed
+
+        close_entry if @current_entry
+
+        # Write central directory
+        central_directory_offset = @io.pos
+        write_central_directory
+        central_directory_size = @io.pos - central_directory_offset
+
+        # Write end of central directory
+        write_end_of_central_directory(central_directory_offset,
+                                       central_directory_size)
+
+        @io.close if @owns_io
+        @closed = true
+      end
+
+      # Check if stream is closed
+      def closed?
+        @closed
+      end
+
+      private
+
+      # Get compression method code
+      def compression_method_for(symbol)
+        case symbol
+        when :store, :none then COMPRESSION_STORE
+        when :deflate then COMPRESSION_DEFLATE
+        when :bzip2 then COMPRESSION_BZIP2
+        when :lzma then COMPRESSION_LZMA
+        when :zstandard then COMPRESSION_ZSTANDARD
+        else COMPRESSION_DEFLATE
+        end
+      end
+
+      # Write local file header placeholder
+      def write_local_file_header_placeholder
+        # Write zeros for now, will update after compression
+        @io.write("\x00" * 30) # Fixed part
+        @io.write(@current_entry[:name].b) # Filename
+        @current_entry[:filename_length] = @current_entry[:name].bytesize
+        @current_entry[:extra_field_length] = 0
+      end
+
+      # Write actual local file header
+      def write_local_file_header
+        header = Omnizip::Formats::Zip::LocalFileHeader.new(
+          version_needed: version_for_method(@current_entry[:compression]),
+          flags: FLAG_UTF8,
+          compression_method: @current_entry[:directory] ? COMPRESSION_STORE : @current_entry[:compression],
+          last_mod_time: dos_time(@current_entry[:time]),
+          last_mod_date: dos_date(@current_entry[:time]),
+          crc32: @current_entry[:crc32],
+          compressed_size: @current_entry[:compressed_size],
+          uncompressed_size: @current_entry[:uncompressed_size],
+          filename: @current_entry[:name],
+        )
+
+        @io.write(header.to_binary)
+      end
+
+      # Compress current entry data
+      def compress_entry_data
+        return "" if @current_entry[:directory]
+
+        case @current_entry[:compression]
+        when COMPRESSION_STORE
+          @current_entry_data
+        when COMPRESSION_DEFLATE
+          compress_deflate(@current_entry_data, @current_entry[:level])
+        when COMPRESSION_BZIP2
+          compress_bzip2(@current_entry_data, @current_entry[:level])
+        when COMPRESSION_LZMA
+          compress_lzma(@current_entry_data, @current_entry[:level])
+        when COMPRESSION_ZSTANDARD
+          compress_zstandard(@current_entry_data, @current_entry[:level])
+        else
+          @current_entry_data
+        end
+      end
+
+      # Write central directory
+      def write_central_directory
+        @entries.each do |entry|
+          external_attrs = if entry[:directory]
+                             UNIX_DIR_PERMISSIONS | ATTR_DIRECTORY
+                           else
+                             UNIX_FILE_PERMISSIONS
+                           end
+
+          header = Omnizip::Formats::Zip::CentralDirectoryHeader.new(
+            version_made_by: VERSION_MADE_BY_UNIX | version_for_method(entry[:compression]),
+            version_needed: version_for_method(entry[:compression]),
+            flags: FLAG_UTF8,
+            compression_method: entry[:directory] ? COMPRESSION_STORE : entry[:compression],
+            last_mod_time: dos_time(entry[:time]),
+            last_mod_date: dos_date(entry[:time]),
+            crc32: entry[:crc32],
+            compressed_size: entry[:compressed_size],
+            uncompressed_size: entry[:uncompressed_size],
+            disk_number_start: 0,
+            internal_attributes: 0,
+            external_attributes: external_attrs,
+            local_header_offset: entry[:offset],
+            filename: entry[:name],
+            extra_field: "",
+            comment: entry[:comment] || "",
+          )
+
+          @io.write(header.to_binary)
+        end
+      end
+
+      # Write end of central directory
+      def write_end_of_central_directory(offset, size)
+        eocd = Omnizip::Formats::Zip::EndOfCentralDirectory.new(
+          disk_number: 0,
+          disk_number_with_cd: 0,
+          total_entries_this_disk: @entries.size,
+          total_entries: @entries.size,
+          central_directory_size: size,
+          central_directory_offset: offset,
+          comment: comment,
+        )
+
+        @io.write(eocd.to_binary)
+      end
+
+      # Compress using Deflate
+      def compress_deflate(data, level)
+        require "zlib"
+        Zlib::Deflate.new(level, -Zlib::MAX_WBITS).deflate(data, Zlib::FINISH)
+      end
+
+      # Compress using BZip2
+      def compress_bzip2(data, level)
+        algorithm = Omnizip::AlgorithmRegistry.get(:bzip2)
+        algorithm.compress(data, level: level)
+      end
+
+      # Compress using LZMA
+      def compress_lzma(data, level)
+        algorithm = Omnizip::AlgorithmRegistry.get(:lzma)
+        algorithm.compress(data, level: level)
+      end
+
+      # Compress using Zstandard
+      def compress_zstandard(data, level)
+        algorithm = Omnizip::AlgorithmRegistry.get(:zstandard)
+        algorithm.compress(data, level: level)
+      end
+
+      # Calculate CRC32
+      def calculate_crc32(data)
+        Omnizip::Checksums::Crc32.new.tap { |c| c.update(data) }.finalize
+      end
+
+      # Get version needed for compression method
+      def version_for_method(method)
+        case method
+        when COMPRESSION_STORE then VERSION_DEFAULT
+        when COMPRESSION_DEFLATE then VERSION_DEFLATE
+        when COMPRESSION_BZIP2 then VERSION_BZIP2
+        when COMPRESSION_LZMA then VERSION_LZMA
+        else VERSION_DEFAULT
+        end
+      end
+
+      # Convert Time to DOS time
+      def dos_time(time)
+        ((time.hour << 11) | (time.min << 5) | (time.sec / 2)) & 0xFFFF
+      end
+
+      # Convert Time to DOS date
+      def dos_date(time)
+        (((time.year - 1980) << 9) | (time.month << 5) | time.day) & 0xFFFF
+      end
+    end
+  end
+end