omnizip 0.4.7-arm-linux

data/lib/omnizip/chunked.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Chunked processing for memory-efficient large file handling
+  module Chunked
+    # Nested classes - autoloaded
+    autoload :Reader, "omnizip/chunked/reader"
+    autoload :Writer, "omnizip/chunked/writer"
+    autoload :MemoryManager, "omnizip/chunked/memory_manager"
+
+    # 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
+
+        reader = Omnizip::Formats::Zip::Reader.new(input)
+        entry = reader.entries.first
+        raise Omnizip::Error, "No entries to decompress in #{input}" unless entry
+
+        total_size = entry.uncompressed_size.to_i
+        processed = 0
+        writer = Writer.new(output, chunk_size: chunk_size)
+
+        # Streams entry-by-entry in bounded memory — the whole entry
+        # is never held at once
+        reader.read_entry_stream(entry.filename, chunk_size: chunk_size) do |chunk|
+          writer.write_chunk(chunk)
+          processed += chunk.bytesize
+
+          if progress
+            percentage = (processed.to_f / total_size * 100).round(2)
+            progress.call(processed, total_size, percentage)
+          end
+        end
+
+        writer.close
+        output
+      end
+    end
+  end
+end

data/lib/omnizip/cli/output_formatter.rb

@@ -0,0 +1,112 @@
+# 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. This is THE byte
+      # formatter — commands, the CLI, and display-oriented models
+      # delegate here instead of carrying private copies.
+      #
+      # @param bytes [Integer, nil] Size in bytes
+      # @return [String] Formatted size ("512 B", "1.5 KB", "2.0 MB")
+      def format_size(bytes)
+        return "0 B" if bytes.nil? || bytes.zero?
+
+        units = %w[B KB MB GB TB]
+        size = bytes.to_f
+        unit_index = 0
+
+        while size >= 1024.0 && unit_index < units.size - 1
+          size /= 1024.0
+          unit_index += 1
+        end
+
+        return format("%d B", bytes) if unit_index.zero?
+
+        format("%.1f %s", size, units[unit_index])
+      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