omnizip 0.4.7-aarch64-linux

data/lib/omnizip/progress/progress_bar.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+module Omnizip
+  module Progress
+    # Visual progress bar for terminal output.
+    #
+    # This class renders a progress bar with percentage, file counts,
+    # rate, and ETA information. It supports color output and automatic
+    # width detection.
+    class ProgressBar
+      attr_reader :width, :use_color
+
+      # Initialize a new progress bar
+      #
+      # @param width [Integer] Bar width in characters (auto-detect if nil)
+      # @param use_color [Boolean] Enable color output
+      def initialize(width: nil, use_color: true)
+        @width = width || detect_terminal_width
+        @use_color = use_color && color_supported?
+      end
+
+      # Render progress bar string
+      #
+      # @param progress [ProgressTracker] Progress tracker
+      # @return [String] Formatted progress bar
+      def render(progress)
+        bar = build_bar(progress.percentage)
+        info = build_info(progress)
+
+        "\r#{bar} #{info}"
+      end
+
+      # Clear the progress bar line
+      #
+      # @return [String] Clear string
+      def clear
+        "\r#{' ' * width}\r"
+      end
+
+      private
+
+      # Build the progress bar component
+      #
+      # @param percentage [Float] Completion percentage (0.0-100.0)
+      # @return [String] Progress bar string
+      def build_bar(percentage)
+        bar_width = 20
+        filled = ((percentage / 100.0) * bar_width).round
+        empty = bar_width - filled
+
+        bar = "[#{'=' * filled}#{'>' if filled.positive?}#{' ' * [empty - 1,
+                                                                  0].max}]"
+
+        if use_color
+          colorize(bar, :green)
+        else
+          bar
+        end
+      end
+
+      # Build the info component (percentage, files, rate, ETA)
+      #
+      # @param progress [ProgressTracker] Progress tracker
+      # @return [String] Info string
+      def build_info(progress)
+        parts = []
+
+        # Percentage
+        parts << format("%3.0f%%", progress.percentage)
+
+        # File count
+        parts << format(
+          "(%d/%d files)",
+          progress.files_processed,
+          progress.operation_progress.total_files,
+        )
+
+        # Current file (truncate if too long)
+        if progress.current_file
+          filename = truncate_filename(progress.current_file, 30)
+          parts << filename
+        end
+
+        # Rate
+        parts << progress.rate_formatted if progress.rate_bps.positive?
+
+        # ETA
+        eta = progress.eta_formatted
+        parts << "ETA: #{eta}" unless eta == "calculating..."
+
+        parts.join(" - ")
+      end
+
+      # Truncate filename to fit width
+      #
+      # @param filename [String] Filename to truncate
+      # @param max_length [Integer] Maximum length
+      # @return [String] Truncated filename
+      def truncate_filename(filename, max_length)
+        return filename if filename.length <= max_length
+
+        "...#{filename[(-max_length + 3)..]}"
+      end
+
+      # Detect terminal width
+      #
+      # @return [Integer] Terminal width in characters
+      def detect_terminal_width
+        if ENV["COLUMNS"]
+          ENV["COLUMNS"].to_i
+        elsif $stdout.tty?
+          begin
+            require "io/console"
+            $stdout.winsize[1]
+          rescue LoadError, NoMethodError
+            80 # Default fallback
+          end
+        else
+          80
+        end
+      end
+
+      # Check if terminal supports color
+      #
+      # @return [Boolean] true if color is supported
+      def color_supported?
+        return false unless $stdout.tty?
+        return false if ENV["TERM"] == "dumb"
+
+        true
+      end
+
+      # Colorize string with ANSI color codes
+      #
+      # @param text [String] Text to colorize
+      # @param color [Symbol] Color name (:green, :yellow, :red, etc.)
+      # @return [String] Colorized string
+      def colorize(text, color)
+        color_codes = {
+          green: 32,
+          yellow: 33,
+          red: 31,
+          blue: 34,
+          cyan: 36,
+        }
+
+        code = color_codes[color] || 0
+        "\e[#{code}m#{text}\e[0m"
+      end
+    end
+  end
+end

data/lib/omnizip/progress/progress_reporter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+module Omnizip
+  module Progress
+    # Abstract base class for progress reporters.
+    #
+    # This class defines the interface for progress reporting strategies.
+    # Subclasses implement specific reporting mechanisms (console, callback,
+    # log file, etc.).
+    #
+    # @abstract Subclass and override {#report} to implement a reporter
+    class ProgressReporter
+      # Report progress to the output mechanism
+      #
+      # @param progress [ProgressTracker] Progress tracker with current state
+      # @raise [NotImplementedError] if not implemented by subclass
+      def report(progress)
+        raise NotImplementedError, "#{self.class} must implement #report"
+      end
+
+      # Called when operation starts (optional hook)
+      #
+      # @param progress [ProgressTracker] Progress tracker
+      def start(progress)
+        # Optional hook for subclasses
+      end
+
+      # Called when operation completes (optional hook)
+      #
+      # @param progress [ProgressTracker] Progress tracker
+      def finish(progress)
+        # Optional hook for subclasses
+      end
+    end
+  end
+end

data/lib/omnizip/progress/progress_tracker.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+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
+
+      # Announce the operation to every reporter (#start hooks).
+      # Call once before the first #update.
+      #
+      # @return [self]
+      def start
+        @mutex.synchronize { @started = true }
+        reporters.each { |reporter| reporter.start(self) }
+        self
+      end
+
+      # Complete the operation: fire a final report and the #finish
+      # hooks. Idempotent — a second call is a no-op.
+      #
+      # @return [self]
+      def finish
+        @mutex.synchronize do
+          return self if @finished
+
+          @finished = true
+        end
+
+        reporters.each do |reporter|
+          reporter.report(self)
+          reporter.finish(self)
+        end
+        self
+      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,22 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+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,131 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+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
+    # Nested classes - autoloaded
+    autoload :OperationProgress, "omnizip/progress/operation_progress"
+    autoload :ProgressTracker, "omnizip/progress/progress_tracker"
+    autoload :ProgressReporter, "omnizip/progress/progress_reporter"
+    autoload :SilentReporter, "omnizip/progress/silent_reporter"
+    autoload :CallbackReporter, "omnizip/progress/callback_reporter"
+    autoload :LogReporter, "omnizip/progress/log_reporter"
+    autoload :ProgressBar, "omnizip/progress/progress_bar"
+    autoload :ConsoleReporter, "omnizip/progress/console_reporter"
+
+    # Cross-namespace dependencies - autoloaded
+    autoload :Eta, "omnizip/eta"
+
+    # 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/registry.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Generic, thread-safe registry base class.
+  #
+  # Subclasses override the hooks +#not_found_error_class+,
+  # +#normalize_key+, and +#label+ to specialize behavior. They may also
+  # override +#register+ / +#get+ to add domain-specific arguments
+  # (e.g., +#register_with_formats+ on FilterRegistry).
+  #
+  # The base class is intentionally minimal: it owns a Hash store and a
+  # Mutex, and exposes the canonical CRUD quintet (+register+, +get+,
+  # +registered?+, +available+, +reset!+). Backward-compat aliases are
+  # provided so existing call sites keep working.
+  class Registry
+    class << self
+      def not_found_error_class
+        Omnizip::Error
+      end
+
+      def normalize_key(key)
+        key.to_sym
+      end
+
+      def label
+        return "Item" unless name
+
+        name.gsub(/^Omnizip::/, "")
+      end
+
+      def register(key, value)
+        synchronize { storage[normalize_key(key)] = value }
+        value
+      end
+
+      # Register a lazy trigger for +key+. When +get(key)+ is called and
+      # the key isn't yet in storage, the block is invoked. The block is
+      # expected to trigger autoload of the implementation file (e.g., by
+      # referencing a constant), which then self-registers.
+      def register_lazy(key, &trigger)
+        lazy_triggers[normalize_key(key)] = trigger
+      end
+
+      def get(key)
+        normalized = normalize_key(key)
+        value = storage[normalized]
+        return value if value
+
+        trigger = lazy_triggers[normalized]
+        if trigger
+          trigger.call
+          value = storage[normalized]
+          return value if value
+        end
+
+        raise not_found_error_class,
+              "#{label} not registered: #{key.inspect}. " \
+              "Available: #{available.join(', ')}"
+      end
+
+      def registered?(key)
+        normalized = normalize_key(key)
+        storage.key?(normalized) || lazy_triggers.key?(normalized)
+      end
+
+      def available
+        storage.keys
+      end
+      alias all available
+      alias strategies available
+
+      def reset!
+        # Clear stored entries but keep lazy triggers — the builtin
+        # autoload list should survive a reset so subsequent +get+ calls
+        # for builtins still trigger the autoload (which re-registers).
+        synchronize { storage.clear }
+      end
+      alias clear reset!
+      alias clear! reset!
+      alias reset reset!
+
+      def entries
+        synchronize { storage.dup }
+      end
+
+      def each(&block)
+        return to_enum(:each) unless block
+
+        entries.each(&block)
+      end
+
+      private
+
+      def storage
+        @storage ||= {}
+      end
+
+      def lazy_triggers
+        @lazy_triggers ||= {}
+      end
+
+      def synchronize(&block)
+        mutex.synchronize(&block)
+      end
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
+    end
+  end
+end