progress_bar_none_overload_3000 1.0.0

data/lib/progress/360/237/246/253bar/360/237/246/253none/metrics/360/237/246/253.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ProgressBarNone
+  # Tracks custom metrics reported by work items
+  class Metrics
+    # Individual metric tracker
+    class Metric
+      attr_reader :name, :values, :sum, :min, :max, :count
+
+      def initialize(name)
+        @name = name
+        @values = []
+        @sum = 0.0
+        @min = Float::INFINITY
+        @max = -Float::INFINITY
+        @count = 0
+      end
+
+      def add(value)
+        value = value.to_f
+        @values << value
+        @sum += value
+        @min = value if value < @min
+        @max = value if value > @max
+        @count += 1
+
+        # Keep only last 100 values for sparklines
+        @values.shift if @values.length > 100
+      end
+
+      def avg
+        return 0.0 if @count.zero?
+        @sum / @count
+      end
+
+      def last
+        @values.last || 0.0
+      end
+
+      # Recent values for sparkline (last n)
+      def recent(n = 20)
+        @values.last(n)
+      end
+
+      def to_h
+        {
+          avg: avg.round(2),
+          min: @min == Float::INFINITY ? 0 : @min.round(2),
+          max: @max == -Float::INFINITY ? 0 : @max.round(2),
+          sum: @sum.round(2),
+          count: @count,
+          last: last.round(2),
+        }
+      end
+    end
+
+    attr_reader :metrics
+
+    def initialize
+      @metrics = {}
+      @mutex = Mutex.new
+    end
+
+    # Record metrics from a hash
+    # @param data [Hash] Key-value pairs of metric names and values
+    def record(data)
+      return unless data.is_a?(Hash)
+
+      @mutex.synchronize do
+        data.each do |key, value|
+          next unless value.is_a?(Numeric)
+
+          key_sym = key.to_sym
+          @metrics[key_sym] ||= Metric.new(key.to_s)
+          @metrics[key_sym].add(value)
+        end
+      end
+    end
+
+    # Get a specific metric
+    def [](name)
+      @metrics[name.to_sym]
+    end
+
+    # Get all metric names
+    def names
+      @metrics.keys
+    end
+
+    # Check if we have any metrics
+    def any?
+      @metrics.any?
+    end
+
+    # Format metrics for display
+    # @param width [Integer] Available width for each metric
+    # @param palette [Symbol] Color palette to use
+    # @return [Array<String>] Formatted metric lines
+    def format_all(width: 60, palette: :crystal, sparkline_width: 15)
+      @mutex.synchronize do
+        @metrics.map do |name, metric|
+          format_metric(name, metric, width: width, palette: palette, sparkline_width: sparkline_width)
+        end
+      end
+    end
+
+    # Format a single metric with sparkline
+    def format_metric(name, metric, width: 60, palette: :crystal, sparkline_width: 15)
+      # Build the metric display
+      sparkline = Sparkline.generate_colored(
+        metric.recent(sparkline_width),
+        width: sparkline_width,
+        palette: palette
+      )
+
+      # Colorized label
+      label_color = ANSI.palette_color(palette, 0.3)
+      value_color = ANSI.palette_color(palette, 0.7)
+      dim = ANSI::DIM
+
+      # Format numbers nicely
+      avg_str = format_number(metric.avg)
+      min_str = format_number(metric.min == Float::INFINITY ? 0 : metric.min)
+      max_str = format_number(metric.max == -Float::INFINITY ? 0 : metric.max)
+      sum_str = format_number(metric.sum)
+
+      # Build the line
+      "#{label_color}#{name}#{ANSI::RESET} " \
+        "#{sparkline} " \
+        "#{dim}avg:#{ANSI::RESET}#{value_color}#{avg_str}#{ANSI::RESET} " \
+        "#{dim}min:#{ANSI::RESET}#{value_color}#{min_str}#{ANSI::RESET} " \
+        "#{dim}max:#{ANSI::RESET}#{value_color}#{max_str}#{ANSI::RESET} " \
+        "#{dim}Σ:#{ANSI::RESET}#{value_color}#{sum_str}#{ANSI::RESET}"
+    end
+
+    private
+
+    def format_number(num)
+      if num.abs >= 1_000_000
+        "#{(num / 1_000_000.0).round(1)}M"
+      elsif num.abs >= 1_000
+        "#{(num / 1_000.0).round(1)}K"
+      elsif num == num.to_i
+        num.to_i.to_s
+      else
+        num.round(2).to_s
+      end
+    end
+  end
+end

data/lib/progress/360/237/246/253bar/360/237/246/253none/multi_bar/360/237/246/253.rb

@@ -0,0 +1,379 @@
+# frozen_string_literal: true
+
+module ProgressBarNone
+  # Multi-bar progress display with nested/hierarchical bars.
+  # Sub-bars compose into parent bars. Bars can start indeterminate
+  # and become specific once the total is discovered.
+  #
+  # @example Basic usage
+  #   multi = ProgressBarNone::MultiBar.new
+  #   multi.add(:total, title: "TOTAL", style: :fire, palette: :neon, rainbow_mode: true)
+  #   multi.add(:search, title: "Searching", parent: :total, style: :electric, palette: :ocean)
+  #   multi.add(:import, title: "Importing", parent: :total, style: :crystal, palette: :crystal)
+  #   multi.start
+  #
+  #   multi.set_total(:search, 3)
+  #   3.times { multi.increment(:search) }
+  #
+  #   multi.set_total(:import, 57)
+  #   57.times { multi.increment(:import) }
+  #
+  #   multi.finish
+  #
+  class MultiBar
+    PALETTES_CYCLE = %i[neon fire ocean synthwave acid crystal vaporwave matrix lava ice galaxy toxic].freeze
+    STYLES_CYCLE = %i[fire electric crystal plasma wave nyan matrix glitch rocket cyberpunk stars skull].freeze
+
+    BarState = Struct.new(
+      :name, :title, :parent, :children,
+      :total, :current, :started_at, :finished,
+      :style, :palette, :spinner, :rainbow_mode, :glow,
+      :indeterminate, :weight,
+      keyword_init: true
+    )
+
+    def initialize(output: $stderr, fps: 12, width: 40)
+      @bars = {}
+      @bar_order = []
+      @output = output
+      @fps = fps
+      @width = width
+      @mutex = Mutex.new
+      @lines_rendered = 0
+      @render_thread = nil
+      @started = false
+      @finished = false
+      @frame = 0
+      @start_time = nil
+    end
+
+    # Add a bar to the display.
+    # @param name [Symbol] Unique identifier
+    # @param title [String] Display title
+    # @param total [Integer, nil] Total items (nil = indeterminate)
+    # @param parent [Symbol, nil] Parent bar name (for nesting)
+    # @param style [Symbol] Bar style
+    # @param palette [Symbol] Color palette
+    # @param weight [Float] How much this bar contributes to parent (auto-calculated if not set)
+    def add(name, title:, total: nil, parent: nil, style: nil, palette: nil,
+            spinner: :braille, rainbow_mode: false, glow: false, weight: nil)
+      @mutex.synchronize do
+        depth = parent ? depth_of(parent) + 1 : 0
+        style ||= STYLES_CYCLE[depth % STYLES_CYCLE.size]
+        palette ||= PALETTES_CYCLE[depth % PALETTES_CYCLE.size]
+
+        bar = BarState.new(
+          name: name, title: title, parent: parent, children: [],
+          total: total, current: 0, started_at: nil, finished: false,
+          style: style, palette: palette, spinner: spinner,
+          rainbow_mode: rainbow_mode, glow: glow,
+          indeterminate: total.nil?, weight: weight
+        )
+
+        @bars[name] = bar
+        @bar_order << name
+
+        # Register as child of parent
+        if parent && @bars[parent]
+          @bars[parent].children << name
+        end
+      end
+    end
+
+    # Set or update the total for a bar (transitions from indeterminate to determinate)
+    def set_total(name, total)
+      @mutex.synchronize do
+        bar = @bars[name]
+        return unless bar
+        bar.total = total
+        bar.indeterminate = false
+      end
+      maybe_render
+    end
+
+    # Increment a bar's progress. Propagates to parent bars.
+    def increment(name, amount = 1, metrics: nil)
+      @mutex.synchronize do
+        bar = @bars[name]
+        return unless bar
+        bar.current += amount
+        bar.current = [bar.current, bar.total].min if bar.total
+        bar.started_at ||= Time.now
+
+        # Propagate to parent
+        propagate_to_parent(bar)
+      end
+      maybe_render
+    end
+
+    # Log a status message for a bar (shown as subtitle)
+    def log(name, message)
+      @mutex.synchronize do
+        bar = @bars[name]
+        return unless bar
+        bar.title = message
+      end
+      maybe_render
+    end
+
+    # Mark a bar as finished
+    def finish_bar(name)
+      @mutex.synchronize do
+        bar = @bars[name]
+        return unless bar
+        bar.current = bar.total if bar.total
+        bar.finished = true
+        propagate_to_parent(bar)
+      end
+      maybe_render
+    end
+
+    # Start the multi-bar display with a background render thread
+    def start
+      @start_time = Time.now
+      @started = true
+      @output.print ANSI::HIDE_CURSOR
+      render(force: true)
+
+      @render_thread = Thread.new do
+        loop do
+          break if @finished
+          sleep(1.0 / @fps)
+          render
+        end
+      end
+      self
+    end
+
+    # Stop rendering and clean up
+    def finish
+      @finished = true
+      @render_thread&.join
+      render(force: true)
+      @output.puts
+      @output.print ANSI::SHOW_CURSOR
+      self
+    end
+
+    private
+
+    def depth_of(name)
+      bar = @bars[name]
+      return 0 unless bar&.parent
+      1 + depth_of(bar.parent)
+    end
+
+    def propagate_to_parent(bar)
+      return unless bar.parent
+      parent = @bars[bar.parent]
+      return unless parent
+
+      # Recalculate parent progress from children
+      children = parent.children.map { |c| @bars[c] }.compact
+      return if children.empty?
+
+      # Total = sum of child totals (known ones)
+      known_children = children.select { |c| c.total && c.total > 0 }
+      if known_children.any?
+        parent.total = known_children.sum(&:total)
+        parent.current = known_children.sum(&:current)
+        parent.indeterminate = children.any?(&:indeterminate)
+      else
+        parent.indeterminate = true
+      end
+
+      propagate_to_parent(parent)
+    end
+
+    def maybe_render
+      render
+    end
+
+    def render(force: false)
+      @mutex.synchronize do
+        @frame += 1
+
+        clear_rendered_lines
+
+        lines = []
+        time = Time.now - (@start_time || Time.now)
+
+        @bar_order.each do |name|
+          bar = @bars[name]
+          depth = depth_of(name)
+          indent = "  " * depth
+
+          # Title line
+          title_color = ANSI.palette_color(bar.palette, 0.5)
+          spinner_char = spinning_char(bar, time)
+
+          if bar.finished
+            status = "#{ANSI::BOLD}#{ANSI::GREEN}✓#{ANSI::RESET}"
+          elsif bar.indeterminate
+            status = spinner_char
+          else
+            status = spinner_char
+          end
+
+          count_str = if bar.total && bar.total > 0
+            count_color = ANSI.palette_color(bar.palette, 0.7)
+            "#{count_color}#{bar.current}#{ANSI::RESET}#{ANSI::DIM}/#{bar.total}#{ANSI::RESET}"
+          elsif bar.current > 0
+            count_color = ANSI.palette_color(bar.palette, 0.7)
+            "#{count_color}#{bar.current}#{ANSI::RESET}#{ANSI::DIM}/?#{ANSI::RESET}"
+          else
+            ""
+          end
+
+          title_line = "#{indent}#{status} #{ANSI::BOLD}#{title_color}#{bar.title}#{ANSI::RESET}"
+          title_line += "  #{count_str}" unless count_str.empty?
+
+          # ETA/rate
+          if bar.started_at && bar.total && bar.total > 0 && bar.current > 0 && !bar.finished
+            elapsed = Time.now - bar.started_at
+            rate = bar.current / elapsed
+            eta = (bar.total - bar.current) / rate
+            title_line += "  #{ANSI::DIM}#{format_rate(rate)}  → #{format_time(eta)}#{ANSI::RESET}" if rate > 0
+          end
+
+          lines << "#{ANSI::CLEAR_LINE}#{title_line}"
+
+          # Bar line
+          bar_line = render_bar_line(bar, depth, time)
+          lines << "#{ANSI::CLEAR_LINE}#{bar_line}" if bar_line
+        end
+
+        # Output
+        lines.each_with_index do |line, i|
+          @output.print line
+          @output.print "\n" if i < lines.length - 1
+        end
+
+        @lines_rendered = lines.length
+      end
+    end
+
+    def render_bar_line(bar, depth, time)
+      indent = "  " * depth
+      width = @width - (depth * 2)
+      width = [width, 10].max
+
+      if bar.indeterminate
+        # Pulsing/bouncing bar for unknown total
+        render_indeterminate(bar, indent, width, time)
+      elsif bar.total && bar.total > 0
+        render_determinate(bar, indent, width, time)
+      else
+        nil
+      end
+    end
+
+    def render_indeterminate(bar, indent, width, time)
+      # Bouncing highlight
+      pos = ((Math.sin(time * 2.5) + 1) / 2 * (width - 4)).round
+      chars = ""
+      width.times do |i|
+        dist = (i - pos).abs
+        if dist < 3
+          intensity = 1.0 - dist / 3.0
+          color = ANSI.palette_color(bar.palette, intensity)
+          chars += "#{ANSI::BOLD}#{color}█#{ANSI::RESET}"
+        else
+          chars += "#{ANSI::DIM}░#{ANSI::RESET}"
+        end
+      end
+      "#{indent}  #{ANSI::DIM}⟨#{ANSI::RESET}#{chars}#{ANSI::DIM}⟩#{ANSI::RESET}"
+    end
+
+    def render_determinate(bar, indent, width, time)
+      progress = bar.current.to_f / bar.total
+      progress = [[progress, 0.0].max, 1.0].min
+
+      filled_count = (progress * width).floor
+      remaining = width - filled_count
+
+      # Build gradient bar
+      filled = ""
+      style_def = Renderer::STYLES[bar.style] || Renderer::STYLES[:crystal]
+
+      filled_count.times do |i|
+        char_progress = i.to_f / [width, 1].max
+        color = if bar.rainbow_mode
+                  ANSI.rainbow_cycle(char_progress, time, 0.5)
+                else
+                  ANSI.palette_color(bar.palette, char_progress)
+                end
+
+        # Shimmer wave
+        wave_pos = (time * 3.0 * width) % (width * 2)
+        dist = (i - wave_pos).abs
+        bold = dist < 5 ? ANSI::BOLD : ""
+
+        filled += "#{bold}#{color}#{style_def[:filled]}#{ANSI::RESET}"
+      end
+
+      # Partial block at edge
+      if remaining > 0 && progress > 0
+        partial_progress = (progress * width) - filled_count
+        partial_idx = (partial_progress * (style_def[:partial].length - 1)).round
+        partial_char = style_def[:partial][[partial_idx, 0].max] || style_def[:partial].last
+        edge_color = ANSI.palette_color(bar.palette, progress)
+        filled += "#{ANSI::BOLD}#{edge_color}#{partial_char}#{ANSI::RESET}"
+        remaining -= 1
+      end
+
+      # Empty portion
+      empty = ""
+      remaining.times { empty += "#{ANSI::DIM}#{style_def[:empty]}#{ANSI::RESET}" }
+
+      # Percentage
+      pct = (progress * 100).round(1)
+      pct_color = ANSI.palette_color(bar.palette, progress)
+      pct_str = "#{pct_color}#{format("%5.1f", pct)}%#{ANSI::RESET}"
+
+      left = "#{ANSI::DIM}#{style_def[:left]}#{ANSI::RESET}"
+      right = "#{ANSI::DIM}#{style_def[:right]}#{ANSI::RESET}"
+
+      "#{indent}  #{pct_str} #{left}#{filled}#{empty}#{right}"
+    end
+
+    def spinning_char(bar, time)
+      return "" if bar.finished
+      spinners = ANSI::SPINNERS[bar.spinner] || ANSI::SPINNERS[:braille]
+      idx = (@frame % spinners.length)
+      color = ANSI.palette_color(bar.palette, (time * 2) % 1.0)
+      "#{color}#{spinners[idx]}#{ANSI::RESET}"
+    end
+
+    def clear_rendered_lines
+      return if @lines_rendered.zero?
+      (@lines_rendered - 1).times do
+        @output.print ANSI.up(1)
+        @output.print ANSI::CLEAR_LINE
+      end
+      @output.print "\r#{ANSI::CLEAR_LINE}"
+    end
+
+    def format_rate(rate)
+      if rate >= 1000
+        "#{(rate / 1000.0).round(1)}K/s"
+      elsif rate >= 1
+        "#{rate.round(1)}/s"
+      else
+        "#{(rate * 60).round(1)}/min"
+      end
+    end
+
+    def format_time(seconds)
+      return "∞" if seconds == Float::INFINITY || seconds.nan?
+      return "0s" if seconds <= 0
+      if seconds < 60
+        "#{seconds.round(0)}s"
+      elsif seconds < 3600
+        "#{(seconds / 60).floor}m#{(seconds % 60).round}s"
+      else
+        "#{(seconds / 3600).floor}h#{((seconds % 3600) / 60).round}m"
+      end
+    end
+  end
+end

data/lib/progress/360/237/246/253bar/360/237/246/253none/progressbar_compat/360/237/246/253.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module ProgressBarNone
+  module ProgressbarCompat
+    class Bar
+      DEFAULT_TOTAL = 100
+
+      def self.create(**options)
+        new(**options)
+      end
+
+      def initialize(**options)
+        @output = options.fetch(:output, $stderr)
+        @title = options[:title]
+        @total = normalize_total(options[:total] || options[:length])
+        @progress = normalize_progress(options[:starting_at] || options[:progress] || 0)
+
+        @bar = ProgressBarNone::Bar.new(
+          total: @total,
+          title: @title,
+          output: @output,
+          width: options[:width] || options[:length] || 40,
+          style: options[:style] || :crystal,
+          palette: options[:palette] || :crystal,
+          spinner: options[:spinner] || :braille,
+          rainbow_mode: !!options[:rainbow_mode],
+          celebration: options[:celebration] || :confetti,
+          glow: !!options[:glow],
+          fps: options[:fps] || 15
+        )
+
+        @bar.start
+        @bar.set(@progress)
+      end
+
+      attr_reader :output
+
+      def total
+        @total
+      end
+
+      def total=(value)
+        @total = normalize_total(value)
+        @bar.instance_variable_set(:@total, @total)
+        @progress = [@progress, @total].min
+        @bar.set(@progress)
+      end
+
+      def progress
+        @progress
+      end
+
+      def progress=(value)
+        @progress = normalize_progress(value)
+        @bar.set(@progress)
+      end
+
+      def title
+        @title
+      end
+
+      def title=(value)
+        @title = value.to_s
+        @bar.instance_variable_set(:@title, @title)
+      end
+
+      def increment
+        increment_progress(1)
+      end
+
+      def decrement
+        increment_progress(-1)
+      end
+
+      def log(message)
+        output.puts(message)
+        output.flush
+      end
+
+      def pause; end
+
+      def resume; end
+
+      def stopped?
+        false
+      end
+
+      def finished?
+        @progress >= @total
+      end
+
+      def reset
+        self.progress = 0
+      end
+
+      def finish
+        @progress = @total
+        @bar.finish
+      end
+
+      private
+
+      def normalize_total(value)
+        n = value.to_i
+        n = DEFAULT_TOTAL if n <= 0
+        n
+      end
+
+      def normalize_progress(value)
+        n = value.to_i
+        n = 0 if n.negative?
+        [n, @total || DEFAULT_TOTAL].min
+      end
+
+      def increment_progress(by)
+        next_value = @progress + by.to_i
+        self.progress = next_value
+      end
+    end
+  end
+end
+
+# Top-level compatibility constants matching the common progressbar API.
+unless defined?(::ProgressBar)
+  module ProgressBar
+    class << self
+      def create(**options)
+        ProgressBarNone::ProgressbarCompat::Bar.create(**options)
+      end
+    end
+  end
+end