omnizip 0.3.1

data/lib/omnizip/progress/progress_tracker.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+require_relative "operation_progress"
+require_relative "../eta"
+
+module Omnizip
+  module Progress
+    # Central progress tracking coordinator.
+    #
+    # This class tracks operation progress, calculates rates and ETA,
+    # and reports progress to configured reporters. It integrates the
+    # OperationProgress model with ETA calculation.
+    class ProgressTracker
+      attr_reader :operation_progress, :eta_estimator, :reporters,
+                  :update_interval, :last_report_time
+
+      # Initialize a new progress tracker
+      #
+      # @param total_files [Integer] Total number of files to process
+      # @param total_bytes [Integer] Total bytes to process
+      # @param reporters [Array<ProgressReporter>] Progress reporters
+      # @param update_interval [Float] Minimum seconds between reports
+      # @param eta_strategy [Symbol] ETA estimation strategy
+      def initialize(total_files:, total_bytes:, reporters: [],
+                     update_interval: 0.5, eta_strategy: :exponential_smoothing)
+        @operation_progress = OperationProgress.new(
+          total_files: total_files,
+          total_bytes: total_bytes,
+        )
+        @eta_estimator = ETA.create_estimator(eta_strategy)
+        @reporters = Array(reporters)
+        @update_interval = update_interval
+        @last_report_time = Time.now - update_interval # Allow immediate first report
+        @mutex = Mutex.new # Thread safety
+      end
+
+      # Update progress with new values
+      #
+      # @param files [Integer] Number of files completed
+      # @param bytes [Integer] Number of bytes processed
+      # @param current_file [String] Name of file currently processing
+      def update(files:, bytes:, current_file: nil)
+        @mutex.synchronize do
+          # Update operation progress
+          operation_progress.update(
+            files: files,
+            bytes: bytes,
+            current_file: current_file,
+          )
+
+          # Add sample to ETA estimator
+          eta_estimator.add_sample(
+            bytes_processed: bytes,
+            files_processed: files,
+          )
+
+          # Report if enough time has passed
+          report_if_needed
+        end
+      end
+
+      # Get current completion percentage
+      #
+      # @return [Float] Percentage complete (0.0-100.0)
+      def percentage
+        operation_progress.percentage
+      end
+
+      # Get number of files processed
+      #
+      # @return [Integer] Files processed
+      def files_processed
+        operation_progress.files_done
+      end
+
+      # Get number of bytes processed
+      #
+      # @return [Integer] Bytes processed
+      def bytes_processed
+        operation_progress.bytes_done
+      end
+
+      # Get current file being processed
+      #
+      # @return [String, nil] Current file name
+      def current_file
+        operation_progress.current_file
+      end
+
+      # Get processing rate in MB/s
+      #
+      # @return [Float] Megabytes per second
+      def rate_mbps
+        eta_estimator.rate_calculator.megabytes_per_second
+      end
+
+      # Get processing rate in bytes/s
+      #
+      # @return [Float] Bytes per second
+      def rate_bps
+        eta_estimator.rate_calculator.bytes_per_second
+      end
+
+      # Get formatted rate string
+      #
+      # @return [String] Formatted rate (e.g., "2.5 MB/s")
+      def rate_formatted
+        eta_estimator.rate_calculator.format_rate
+      end
+
+      # Get ETA in seconds
+      #
+      # @return [Float] Estimated seconds remaining
+      def eta_seconds
+        result = eta_estimator.estimate(operation_progress.remaining_bytes)
+        result.seconds_remaining
+      end
+
+      # Get formatted ETA string
+      #
+      # @return [String] Formatted ETA (e.g., "2m 30s")
+      def eta_formatted
+        result = eta_estimator.estimate(operation_progress.remaining_bytes)
+        result.formatted
+      end
+
+      # Get full ETA result with confidence
+      #
+      # @return [Models::ETAResult] Complete ETA result
+      def eta_result
+        eta_estimator.estimate(operation_progress.remaining_bytes)
+      end
+
+      # Force a progress report (regardless of interval)
+      def report
+        @mutex.synchronize do
+          reporters.each { |reporter| reporter.report(self) }
+          @last_report_time = Time.now
+        end
+      end
+
+      # Add a reporter
+      #
+      # @param reporter [ProgressReporter] Reporter to add
+      def add_reporter(reporter)
+        @mutex.synchronize do
+          @reporters << reporter
+        end
+      end
+
+      # Remove a reporter
+      #
+      # @param reporter [ProgressReporter] Reporter to remove
+      def remove_reporter(reporter)
+        @mutex.synchronize do
+          @reporters.delete(reporter)
+        end
+      end
+
+      # Check if operation is complete
+      #
+      # @return [Boolean] true if complete
+      def complete?
+        operation_progress.complete?
+      end
+
+      # Get elapsed time
+      #
+      # @return [Float] Seconds elapsed
+      def elapsed_seconds
+        operation_progress.elapsed_seconds
+      end
+
+      private
+
+      # Report progress if enough time has passed since last report
+      def report_if_needed
+        now = Time.now
+        return unless now - last_report_time >= update_interval
+
+        reporters.each { |reporter| reporter.report(self) }
+        @last_report_time = now
+      end
+    end
+  end
+end

data/lib/omnizip/progress/silent_reporter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+require_relative "progress_reporter"
+
+module Omnizip
+  module Progress
+    # Silent progress reporter that produces no output.
+    #
+    # This reporter is useful when you want to track progress internally
+    # but don't want any visible output.
+    class SilentReporter < ProgressReporter
+      # Report progress (does nothing)
+      #
+      # @param _progress [ProgressTracker] Progress tracker (ignored)
+      def report(_progress)
+        # Intentionally does nothing
+      end
+    end
+  end
+end

data/lib/omnizip/progress.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+require_relative "progress/operation_progress"
+require_relative "progress/progress_tracker"
+require_relative "progress/progress_reporter"
+require_relative "progress/silent_reporter"
+require_relative "progress/callback_reporter"
+require_relative "progress/log_reporter"
+require_relative "progress/progress_bar"
+require_relative "progress/console_reporter"
+
+module Omnizip
+  # Progress tracking module.
+  #
+  # This module provides real-time progress tracking for long-running
+  # operations with multiple reporting strategies (console, callback,
+  # log file, etc.) and integrated ETA calculation.
+  #
+  # @example Basic progress tracking
+  #   tracker = Omnizip::Progress.track(total_files: 100, total_bytes: 1.gigabyte)
+  #   # Update progress as work is done
+  #   tracker.update(files: 10, bytes: 100.megabytes, current_file: "file.txt")
+  #   puts tracker.percentage # => 10.0
+  #   puts tracker.eta_formatted # => "2m 30s"
+  #
+  # @example With console progress bar
+  #   tracker = Omnizip::Progress.track(
+  #     total_files: 100,
+  #     total_bytes: 1.gigabyte,
+  #     reporter: :console
+  #   )
+  #
+  # @example With custom callback
+  #   tracker = Omnizip::Progress.track(
+  #     total_files: 100,
+  #     total_bytes: 1.gigabyte
+  #   ) do |progress|
+  #     puts "#{progress.percentage}% complete"
+  #   end
+  module Progress
+    # Track an operation's progress
+    #
+    # @param total_files [Integer] Total number of files to process
+    # @param total_bytes [Integer] Total bytes to process
+    # @param reporter [Symbol, ProgressReporter, Array] Reporter(s) to use
+    # @param update_interval [Float] Minimum seconds between reports
+    # @param eta_strategy [Symbol] ETA estimation strategy
+    # @yield [progress] Optional callback block for custom reporting
+    # @return [ProgressTracker] Configured progress tracker
+    def self.track(total_files:, total_bytes:, reporter: :auto,
+                   update_interval: 0.5, eta_strategy: :exponential_smoothing,
+                   &block)
+      reporters = build_reporters(reporter, block)
+
+      ProgressTracker.new(
+        total_files: total_files,
+        total_bytes: total_bytes,
+        reporters: reporters,
+        update_interval: update_interval,
+        eta_strategy: eta_strategy,
+      )
+    end
+
+    # Configure global progress settings
+    #
+    # @yield [config] Configuration block
+    def self.configure
+      yield configuration
+    end
+
+    # Get global configuration
+    #
+    # @return [Configuration] Configuration object
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Build reporters from various input formats
+    #
+    # @param reporter [Symbol, ProgressReporter, Array] Reporter specification
+    # @param block [Proc] Optional callback block
+    # @return [Array<ProgressReporter>] Array of reporters
+    def self.build_reporters(reporter, block)
+      reporters = []
+
+      # Handle callback block
+      reporters << CallbackReporter.new(&block) if block
+
+      # Handle reporter parameter
+      case reporter
+      when :auto
+        reporters << ConsoleReporter.new if $stdout.tty?
+      when :console
+        reporters << ConsoleReporter.new
+      when :silent
+        reporters << SilentReporter.new
+      when Array
+        reporters.concat(reporter)
+      when ProgressReporter
+        reporters << reporter
+      when Symbol
+        raise ArgumentError, "Unknown reporter type: #{reporter}"
+      end
+
+      # Default to silent if no reporters
+      reporters << SilentReporter.new if reporters.empty?
+
+      reporters
+    end
+
+    # Global configuration class
+    class Configuration
+      attr_accessor :default_reporter, :default_update_interval,
+                    :default_eta_strategy
+
+      def initialize
+        @default_reporter = :auto
+        @default_update_interval = 0.5
+        @default_eta_strategy = :exponential_smoothing
+      end
+    end
+  end
+end

data/lib/omnizip/rubyzip_compat.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+#
+# Rubyzip Compatibility Layer
+#
+# This file provides a drop-in replacement for the 'zip' gem (rubyzip).
+# Simply require 'omnizip/rubyzip_compat' instead of 'zip' to use Omnizip
+# with existing rubyzip code.
+#
+# Usage:
+#   require 'omnizip/rubyzip_compat'
+#
+#   Zip::File.open('archive.zip') do |zip|
+#     zip.each { |entry| puts entry.name }
+#   end
+#
+
+require_relative "../omnizip"
+
+# Create Zip namespace as alias for Omnizip::Zip
+module Zip
+  # Rubyzip-compatible File class
+  File = Omnizip::Zip::File
+
+  # Rubyzip-compatible Entry class
+  Entry = Omnizip::Zip::Entry
+
+  # Rubyzip-compatible OutputStream class
+  OutputStream = Omnizip::Zip::OutputStream
+
+  # Rubyzip-compatible InputStream class
+  InputStream = Omnizip::Zip::InputStream
+
+  # Error classes for compatibility
+  Error = Omnizip::Error
+  FormatError = Omnizip::FormatError
+  CompressionError = Omnizip::CompressionError
+  DecompressionError = Omnizip::DecompressionError
+  ChecksumError = Omnizip::ChecksumError
+
+  # Version information
+  VERSION = Omnizip::VERSION
+
+  class << self
+    # Legacy compatibility method
+    # @deprecated Use Zip::File.open instead
+    def open(...)
+      File.open(...)
+    end
+
+    # Legacy compatibility method
+    # @deprecated Use Zip::File.create instead
+    def create(...)
+      File.create(...)
+    end
+  end
+end
+
+# Compatibility note
+if $VERBOSE
+  warn "Omnizip: Using Omnizip rubyzip compatibility layer. " \
+       "API is compatible with rubyzip, but implementation differs."
+end

data/lib/omnizip/temp/safe_extract.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+module Omnizip
+  module Temp
+    # Safe extraction with atomic move to destination
+    # Provides rollback capability on failure
+    class SafeExtract
+      # Error raised when extraction verification fails
+      class VerificationError < Omnizip::Error; end
+
+      attr_reader :archive_path, :dest_path
+
+      # Create new safe extractor
+      # @param archive_path [String] Path to archive
+      # @param dest_path [String] Destination path
+      def initialize(archive_path, dest_path)
+        @archive_path = archive_path
+        @dest_path = dest_path
+      end
+
+      # Extract safely with verification
+      # @yield [temp_dir] Block for verification (return truthy to proceed)
+      # @return [String] Destination path
+      def extract
+        unless File.exist?(@archive_path)
+          raise Errno::ENOENT, "Archive not found: #{@archive_path}"
+        end
+
+        Dir.mktmpdir("omniz_extract_") do |temp_dir|
+          # Extract to temp directory
+          extract_to_temp(temp_dir)
+
+          # User verification if block given
+          if block_given?
+            result = yield(temp_dir)
+            unless result
+              raise VerificationError, "Extraction verification failed"
+            end
+          end
+
+          # Atomic move to destination
+          move_to_destination(temp_dir)
+        end
+
+        @dest_path
+      end
+
+      # Extract with checksum verification
+      # @param expected_checksums [Hash] Map of filename => CRC32
+      # @return [String] Destination path
+      def extract_verified(expected_checksums)
+        extract do |temp_dir|
+          verify_checksums(temp_dir, expected_checksums)
+        end
+      end
+
+      # Extract with file count verification
+      # @param expected_count [Integer] Expected number of files
+      # @return [String] Destination path
+      def extract_with_count(expected_count)
+        extract do |temp_dir|
+          actual_count = count_files(temp_dir)
+          actual_count == expected_count
+        end
+      end
+
+      # Class method for quick safe extraction
+      # @param archive_path [String] Archive to extract
+      # @param dest_path [String] Destination
+      # @yield [temp_dir] Verification block
+      # @return [String] Destination path
+      def self.extract_safe(archive_path, dest_path, &block)
+        new(archive_path, dest_path).extract(&block)
+      end
+
+      private
+
+      def extract_to_temp(temp_dir)
+        # Detect archive format and extract
+        case detect_format
+        when :zip
+          extract_zip(temp_dir)
+        when :seven_zip
+          extract_7z(temp_dir)
+        else
+          raise Omnizip::UnsupportedFormatError,
+                "Unknown archive format: #{@archive_path}"
+        end
+      end
+
+      def extract_zip(dest)
+        require_relative "../zip/file"
+
+        Omnizip::Zip::File.open(@archive_path) do |zip|
+          zip.each do |entry|
+            entry_path = File.join(dest, entry.name)
+
+            if entry.directory?
+              FileUtils.mkdir_p(entry_path)
+            else
+              FileUtils.mkdir_p(File.dirname(entry_path))
+              zip.extract(entry, entry_path)
+            end
+          end
+        end
+      end
+
+      def extract_7z(dest)
+        # Placeholder for 7z extraction
+        # Would use Omnizip::SevenZip::File when available
+        raise NotImplementedError, "7z extraction not yet implemented"
+      end
+
+      def move_to_destination(temp_dir)
+        # Ensure parent directory exists
+        FileUtils.mkdir_p(File.dirname(@dest_path))
+
+        # Remove destination if it exists
+        FileUtils.rm_rf(@dest_path)
+
+        # Copy contents (can't move since Dir.mktmpdir will try to clean up)
+        FileUtils.cp_r(temp_dir, @dest_path)
+      end
+
+      def verify_checksums(dir, expected)
+        require_relative "../checksums/crc32"
+
+        expected.all? do |file, expected_sum|
+          file_path = File.join(dir, file)
+          next false unless File.exist?(file_path)
+
+          # Calculate checksum
+          crc = Omnizip::Checksums::Crc32.new
+          File.open(file_path, "rb") do |f|
+            while (chunk = f.read(64 * 1024))
+              crc.update(chunk)
+            end
+          end
+
+          crc.finalize == expected_sum
+        end
+      end
+
+      def count_files(dir)
+        count = 0
+        Dir.glob(File.join(dir, "**", "*")) do |path|
+          count += 1 unless File.directory?(path)
+        end
+        count
+      end
+
+      def detect_format
+        File.open(@archive_path, "rb") do |f|
+          magic = f.read(4)
+          case magic
+          when "PK\x03\x04"
+            :zip
+          when "7z\xBC\xAF"
+            :seven_zip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/temp/temp_file.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module Omnizip
+  module Temp
+    # RAII-pattern temporary file with automatic cleanup
+    class TempFile
+      attr_reader :path
+
+      # Create new temporary file
+      # @param prefix [String] Filename prefix
+      # @param suffix [String] Filename suffix
+      # @param directory [String, nil] Directory (nil = system default)
+      def initialize(prefix: "omniz_", suffix: "", directory: nil)
+        @prefix = prefix
+        @suffix = suffix
+        @directory = directory
+        @tempfile = nil
+        @path = nil
+        @kept = false
+        @finalized = false
+
+        create
+        setup_finalizer
+      end
+
+      # Get the underlying Tempfile object
+      # @return [Tempfile] The tempfile
+      def file
+        @tempfile
+      end
+
+      # Write data to temp file
+      # @param data [String] Data to write
+      # @return [Integer] Bytes written
+      def write(data)
+        @tempfile.write(data)
+      end
+
+      # Read data from temp file
+      # @param length [Integer, nil] Number of bytes to read
+      # @return [String, nil] Data read
+      def read(length = nil)
+        @tempfile.read(length)
+      end
+
+      # Rewind to beginning of file
+      def rewind
+        @tempfile.rewind
+      end
+
+      # Close the temp file
+      def close
+        @tempfile.close if @tempfile && !@tempfile.closed?
+      end
+
+      # Delete the temp file
+      def unlink
+        return if @finalized || @kept
+
+        if @tempfile
+          @tempfile.close unless @tempfile.closed?
+          @tempfile.unlink
+          @finalized = true
+        end
+      rescue StandardError
+        # Ignore errors during cleanup
+        nil
+      end
+
+      # Prevent automatic deletion
+      def keep!
+        @kept = true
+      end
+
+      # Check if file will be kept
+      # @return [Boolean] True if file won't be auto-deleted
+      def kept?
+        @kept
+      end
+
+      # Check if file has been finalized
+      # @return [Boolean] True if finalized
+      def finalized?
+        @finalized
+      end
+
+      private
+
+      def create
+        @tempfile = if @directory
+                      ::Tempfile.new(
+                        [@prefix, @suffix],
+                        @directory,
+                        binmode: true,
+                      )
+                    else
+                      ::Tempfile.new(
+                        [@prefix, @suffix],
+                        binmode: true,
+                      )
+                    end
+        @path = @tempfile.path
+      end
+
+      def setup_finalizer
+        ObjectSpace.define_finalizer(self, self.class.finalizer(@tempfile))
+      end
+
+      # rubocop:disable Lint/IneffectiveAccessModifier
+      def self.finalizer(tempfile)
+        proc do
+          tempfile.close unless tempfile.closed?
+          tempfile.unlink
+        rescue StandardError
+          # Ignore errors in finalizer
+          nil
+        end
+      end
+      # rubocop:enable Lint/IneffectiveAccessModifier
+    end
+  end
+end