omnizip 0.3.1

data/lib/omnizip/chunked/memory_manager.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module Omnizip
+  module Chunked
+    # Manage memory usage and enforce limits during chunked operations
+    class MemoryManager
+      DEFAULT_MAX_MEMORY = 256 * 1024 * 1024 # 256MB
+
+      attr_reader :current_usage, :max_memory
+
+      # Initialize memory manager
+      # @param options [Hash] Manager options
+      # @option options [Integer] :max Maximum memory in bytes
+      # @option options [String] :temp_dir Temporary directory for spill files
+      # @option options [Symbol] :strategy Spill strategy (:disk or :error)
+      def initialize(max: DEFAULT_MAX_MEMORY, temp_dir: nil, strategy: :disk)
+        @max_memory = max
+        @current_usage = 0
+        @buffers = {} # buffer => size mapping
+        @temp_files = []
+        @temp_dir = temp_dir
+        @strategy = strategy
+      end
+
+      # Allocate memory or spill to disk
+      # @param size [Integer] Size to allocate in bytes
+      # @return [String, Tempfile] Buffer or temp file
+      def allocate(size)
+        if can_allocate_in_memory?(size)
+          allocate_buffer(size)
+        else
+          handle_overflow(size)
+        end
+      end
+
+      # Release allocated memory or temp file
+      # @param buffer [String, Tempfile] Buffer to release
+      # @return [Integer] Bytes released
+      def release(buffer)
+        case buffer
+        when String
+          release_buffer(buffer)
+        when Tempfile, File
+          release_temp_file(buffer)
+        else
+          0
+        end
+      end
+
+      # Get available memory
+      # @return [Integer] Available memory in bytes
+      def available
+        [@max_memory - @current_usage, 0].max
+      end
+
+      # Check if over memory limit
+      # @return [Boolean] True if over limit
+      def over_limit?
+        @current_usage > @max_memory
+      end
+
+      # Get memory usage ratio
+      # @return [Float] Usage from 0.0 to 1.0
+      def usage_ratio
+        return 0.0 if @max_memory.zero?
+
+        @current_usage.to_f / @max_memory
+      end
+
+      # Cleanup all resources
+      # @return [self]
+      def cleanup
+        @buffers.clear
+        @temp_files.each do |tf|
+          begin
+            tf.close
+          rescue StandardError
+            nil
+          end
+          begin
+            tf.unlink
+          rescue StandardError
+            nil
+          end
+        end
+        @temp_files.clear
+        @current_usage = 0
+        self
+      end
+
+      # Execute block with automatic cleanup
+      # @yield [manager] Block to execute with manager
+      # @return [Object] Block result
+      def self.with_manager(**options)
+        manager = new(**options)
+        begin
+          yield manager
+        ensure
+          manager.cleanup
+        end
+      end
+
+      # Spill buffer to disk
+      # @param buffer [String] Buffer data to spill
+      # @return [Tempfile] Temporary file
+      def spill_to_disk(buffer = nil)
+        tf = create_temp_file
+        tf.write(buffer) if buffer
+        tf.rewind
+        @temp_files << tf
+        tf
+      end
+
+      private
+
+      # Check if size can be allocated in memory
+      def can_allocate_in_memory?(size)
+        @current_usage + size <= @max_memory
+      end
+
+      # Allocate in-memory buffer
+      def allocate_buffer(size)
+        buffer = String.new(capacity: size, encoding: Encoding::BINARY)
+        @buffers[buffer] = size
+        @current_usage += size
+        buffer
+      end
+
+      # Release in-memory buffer
+      def release_buffer(buffer)
+        size = @buffers.delete(buffer)
+        if size
+          @current_usage -= size
+          size
+        else
+          0
+        end
+      end
+
+      # Release temp file
+      def release_temp_file(file)
+        if @temp_files.delete(file)
+          size = begin
+            file.size
+          rescue StandardError
+            0
+          end
+          begin
+            file.close
+          rescue StandardError
+            nil
+          end
+          begin
+            file.unlink
+          rescue StandardError
+            nil
+          end
+          size
+        else
+          0
+        end
+      end
+
+      # Handle memory overflow based on strategy
+      def handle_overflow(size)
+        case @strategy
+        when :disk
+          spill_to_disk
+        when :error
+          message = "Memory limit exceeded: " \
+                    "#{@current_usage + size} > #{@max_memory}"
+          raise MemoryError, message
+        else
+          raise ArgumentError, "Unknown spill strategy: #{@strategy}"
+        end
+      end
+
+      # Create temporary file
+      def create_temp_file
+        Tempfile.new(
+          ["omnizip_chunk_", ".tmp"],
+          @temp_dir,
+          binmode: true,
+        )
+      end
+    end
+
+    # Error raised when memory limit is exceeded
+    class MemoryError < Omnizip::Error
+    end
+  end
+end

data/lib/omnizip/chunked/reader.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Chunked
+    # Read large files in chunks for memory-efficient processing
+    class Reader
+      DEFAULT_CHUNK_SIZE = 64 * 1024 * 1024 # 64MB
+
+      attr_reader :file_path, :chunk_size, :total_size
+
+      # Initialize a chunked reader
+      # @param file_path [String] Path to file to read
+      # @param options [Hash] Reader options
+      # @option options [Integer] :chunk_size Chunk size in bytes
+      def initialize(file_path, chunk_size: DEFAULT_CHUNK_SIZE)
+        @file_path = file_path
+        @chunk_size = chunk_size
+        @total_size = File.size(file_path)
+        @position = 0
+      end
+
+      # Read next chunk from file
+      # @return [String, nil] Chunk data or nil if EOF
+      def read_chunk
+        return nil if @position >= @total_size
+
+        File.open(@file_path, "rb") do |f|
+          f.seek(@position)
+          chunk = f.read(@chunk_size)
+          @position += chunk.bytesize if chunk
+          chunk
+        end
+      end
+
+      # Iterate through all chunks
+      # @yield [chunk, position, total] Block called for each chunk
+      def each_chunk
+        reset
+        while (chunk = read_chunk)
+          yield chunk, @position - chunk.bytesize, @total_size
+        end
+      end
+
+      # Get current progress as percentage
+      # @return [Float] Progress from 0.0 to 1.0
+      def progress
+        return 1.0 if @total_size.zero?
+
+        @position.to_f / @total_size
+      end
+
+      # Reset reader to beginning of file
+      # @return [self]
+      def reset
+        @position = 0
+        self
+      end
+
+      # Check if at end of file
+      # @return [Boolean] True if at EOF
+      def eof?
+        @position >= @total_size
+      end
+
+      # Get number of chunks needed for file
+      # @return [Integer] Number of chunks
+      def chunk_count
+        (@total_size.to_f / @chunk_size).ceil
+      end
+
+      # Get remaining bytes to read
+      # @return [Integer] Remaining bytes
+      def remaining
+        @total_size - @position
+      end
+    end
+  end
+end

data/lib/omnizip/chunked/writer.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Chunked
+    # Write large files incrementally in chunks
+    class Writer
+      DEFAULT_CHUNK_SIZE = 64 * 1024 * 1024 # 64MB
+      FLUSH_THRESHOLD = 10 # Flush every N chunks
+
+      attr_reader :output_path, :chunk_size, :written
+
+      # Initialize a chunked writer
+      # @param output_path [String] Path to output file
+      # @param options [Hash] Writer options
+      # @option options [Integer] :chunk_size Chunk size in bytes
+      def initialize(output_path, chunk_size: DEFAULT_CHUNK_SIZE)
+        @output_path = output_path
+        @chunk_size = chunk_size
+        @written = 0
+        @chunks_written = 0
+        @file_handle = nil
+      end
+
+      # Write a chunk to file
+      # @param chunk [String] Data to write
+      # @return [Integer] Bytes written
+      def write_chunk(chunk)
+        ensure_file_open
+
+        bytes = @file_handle.write(chunk)
+        @written += bytes
+        @chunks_written += 1
+
+        # Flush periodically to disk
+        flush if (@chunks_written % FLUSH_THRESHOLD).zero?
+
+        bytes
+      end
+
+      # Write data from a source in chunks
+      # @param source [String, IO] Source to read from
+      # @return [Integer] Total bytes written
+      def write_from(source)
+        case source
+        when String
+          # File path
+          if File.exist?(source)
+            Reader.new(source, chunk_size: @chunk_size).each_chunk do |chunk|
+              write_chunk(chunk)
+            end
+          else
+            # Treat as data
+            write_chunk(source)
+          end
+        when IO, StringIO
+          # IO object
+          while (chunk = source.read(@chunk_size))
+            break if chunk.empty?
+
+            write_chunk(chunk)
+          end
+        else
+          raise ArgumentError, "Unsupported source type: #{source.class}"
+        end
+
+        @written
+      end
+
+      # Flush buffered data to disk
+      # @return [self]
+      def flush
+        @file_handle&.flush
+        self
+      end
+
+      # Close the file handle
+      # @return [self]
+      def close
+        if @file_handle
+          flush
+          @file_handle.close
+          @file_handle = nil
+        end
+        self
+      end
+
+      # Finalize the file (alias for close)
+      # @return [self]
+      def finish
+        close
+      end
+
+      # Execute block with writer, auto-close
+      # @yield [writer] Block to write data
+      # @return [Integer] Total bytes written
+      def self.with_writer(output_path, **options)
+        writer = new(output_path, **options)
+        begin
+          yield writer
+          writer.written
+        ensure
+          writer.close
+        end
+      end
+
+      private
+
+      # Ensure file handle is open
+      def ensure_file_open
+        return if @file_handle
+
+        # Create parent directory if needed
+        dir = File.dirname(@output_path)
+        FileUtils.mkdir_p(dir)
+
+        @file_handle = File.open(@output_path, "wb")
+      end
+    end
+  end
+end

data/lib/omnizip/chunked.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Chunked processing for memory-efficient large file handling
+  module Chunked
+    # Configuration for chunked operations
+    class Configuration
+      attr_accessor :chunk_size, :max_memory, :temp_directory, :spill_strategy
+
+      def initialize
+        @chunk_size = 64 * 1024 * 1024 # 64MB
+        @max_memory = 256 * 1024 * 1024 # 256MB
+        @temp_directory = nil # Use system default
+        @spill_strategy = :disk # or :error
+      end
+    end
+
+    class << self
+      # Global configuration
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      # Configure chunked operations
+      # @yield [config] Configuration block
+      def configure
+        yield configuration
+      end
+
+      # Compress file with chunked processing
+      # @param input [String] Input file path
+      # @param output [String] Output file path
+      # @param options [Hash] Compression options
+      # @option options [Integer] :chunk_size Chunk size in bytes
+      # @option options [Integer] :max_memory Maximum memory usage in bytes
+      # @option options [Symbol] :compression Compression method
+      # @option options [Proc] :progress Progress callback
+      # @return [String] Output file path
+      def compress_file(input, output, **options)
+        chunk_size = options[:chunk_size] || configuration.chunk_size
+        options[:max_memory] || configuration.max_memory
+        progress = options[:progress]
+
+        unless File.exist?(input)
+          raise Errno::ENOENT,
+                "Input file not found: #{input}"
+        end
+
+        reader = Reader.new(input, chunk_size: chunk_size)
+        total_size = reader.total_size
+        processed = 0
+
+        Omnizip::Zip::File.create(output) do |zip|
+          basename = File.basename(input)
+
+          # Use add with a block instead of private add_data
+          zip.add(basename) do
+            data = String.new(encoding: Encoding::BINARY)
+
+            reader.each_chunk do |chunk|
+              data << chunk
+              processed += chunk.bytesize
+
+              if progress
+                percentage = (processed.to_f / total_size * 100).round(2)
+                progress.call(processed, total_size, percentage)
+              end
+            end
+
+            data
+          end
+        end
+
+        output
+      end
+
+      # Decompress file with chunked processing
+      # @param input [String] Input archive path
+      # @param output [String] Output file path
+      # @param options [Hash] Decompression options
+      # @option options [Integer] :chunk_size Chunk size in bytes
+      # @option options [Proc] :progress Progress callback
+      # @return [String] Output file path
+      def decompress_file(input, output, **options)
+        chunk_size = options[:chunk_size] || configuration.chunk_size
+        progress = options[:progress]
+
+        unless File.exist?(input)
+          raise Errno::ENOENT,
+                "Input archive not found: #{input}"
+        end
+
+        writer = Writer.new(output, chunk_size: chunk_size)
+        processed = 0
+
+        Omnizip::Zip::File.open(input) do |zip|
+          entry = zip.entries.first
+          total_size = entry.size
+
+          # Read the full entry content
+          content = zip.get_input_stream(entry)
+
+          # Write in chunks
+          offset = 0
+          while offset < content.bytesize
+            chunk = content.byteslice(offset, chunk_size) || ""
+            break if chunk.empty?
+
+            writer.write_chunk(chunk)
+            processed += chunk.bytesize
+            offset += chunk.bytesize
+
+            if progress
+              percentage = (processed.to_f / total_size * 100).round(2)
+              progress.call(processed, total_size, percentage)
+            end
+          end
+        end
+
+        writer.close
+        output
+      end
+    end
+  end
+end
+
+require_relative "chunked/reader"
+require_relative "chunked/writer"
+require_relative "chunked/memory_manager"

data/lib/omnizip/cli/output_formatter.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  # Output formatting utilities for CLI commands.
+  #
+  # Provides methods for formatting compression statistics, error messages,
+  # and other CLI output in a user-friendly manner.
+  module CliOutputFormatter
+    class << self
+      # Format compression statistics for display.
+      #
+      # @param input_size [Integer] Original size in bytes
+      # @param output_size [Integer] Compressed size in bytes
+      # @param elapsed_time [Float] Time taken in seconds
+      # @return [String] Formatted statistics
+      def format_compression_stats(input_size, output_size, elapsed_time)
+        ratio = if input_size.positive?
+                  (output_size.to_f / input_size * 100).round(2)
+                else
+                  0.0
+                end
+
+        [
+          "Input size:  #{format_size(input_size)}",
+          "Output size: #{format_size(output_size)}",
+          "Ratio:       #{ratio}%",
+          "Time:        #{elapsed_time.round(3)}s",
+        ].join("\n")
+      end
+
+      # Format file size in human-readable format.
+      #
+      # @param bytes [Integer] Size in bytes
+      # @return [String] Formatted size
+      def format_size(bytes)
+        units = %w[B KB MB GB TB]
+        return "0 B" if bytes.zero?
+
+        exp = (Math.log(bytes) / Math.log(1024)).floor
+        exp = [exp, units.length - 1].min
+
+        size = (bytes.to_f / (1024**exp)).round(2)
+        "#{size} #{units[exp]}"
+      end
+
+      # Format error message for display.
+      #
+      # @param error [Exception] The error object
+      # @return [String] Formatted error message
+      def format_error(error)
+        "Error: #{error.message}"
+      end
+
+      # Format algorithm information as a table.
+      #
+      # @param algorithms [Array<Models::AlgorithmMetadata>] Algorithms
+      # @return [String] Formatted table
+      def format_algorithms_table(algorithms)
+        return "No algorithms registered." if algorithms.empty?
+
+        lines = []
+        lines << "Available compression algorithms:"
+        lines << ""
+
+        max_name = algorithms.map { |a| a.name.to_s.length }.max
+        max_desc = algorithms.map { |a| a.description.length }.max
+
+        algorithms.each do |algo|
+          name = algo.name.to_s.ljust(max_name)
+          desc = algo.description.ljust(max_desc)
+          version = "v#{algo.version}"
+          lines << "  #{name} - #{desc} (#{version})"
+        end
+
+        lines.join("\n")
+      end
+
+      # Print verbose message if verbose mode is enabled.
+      #
+      # @param message [String] The message to print
+      # @param verbose [Boolean] Whether verbose mode is enabled
+      # @return [void]
+      def verbose_puts(message, verbose)
+        puts message if verbose
+      end
+    end
+  end
+end