progress_bar_none_overload_3000 1.0.0

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

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module ProgressBarNone
+  module DownloadThreadState
+    ThreadState = Struct.new(
+      :site,
+      :thread,
+      :total,
+      :done,
+      :status,
+      :reason,
+      :resume_at,
+      :slug,
+      :percent,
+      :size_str,
+      :speed_str,
+      :attempt,
+      :message,
+      keyword_init: true
+    )
+
+    class Tracker
+      attr_reader :cycle_id
+
+      def initialize(sites:, threads_per_site:)
+        @mutex = Mutex.new
+        @cycle_id = "%d-%04d" % [Process.pid, rand(1000..9999)]
+        @states = {}
+
+        sites.each do |site|
+          @states[site.to_sym] = {}
+          (1..threads_per_site.to_i).each do |thread_number|
+            @states[site.to_sym][thread_number] = ThreadState.new(
+              site: site.to_sym,
+              thread: thread_number,
+              total: 0,
+              done: 0,
+              status: :idle,
+              reason: :waiting,
+              resume_at: nil,
+              slug: nil,
+              percent: nil,
+              size_str: nil,
+              speed_str: nil,
+              attempt: nil,
+              message: "waiting"
+            )
+          end
+        end
+      end
+
+      def set_plan(site:, thread:, total:)
+        mutate(site, thread) do |state|
+          state.total = [total.to_i, 0].max
+          state.done = 0
+          state.status = :idle
+          state.reason = state.total.zero? ? :no_work : :waiting
+          state.resume_at = nil
+          state.slug = nil
+          state.percent = nil
+          state.size_str = nil
+          state.speed_str = nil
+          state.attempt = nil
+          state.message = state.total.zero? ? "blocked: no work" : "queued"
+        end
+      end
+
+      def mark_active(site:, thread:, slug:)
+        mutate(site, thread) do |state|
+          state.status = :active
+          state.reason = nil
+          state.resume_at = nil
+          state.slug = slug
+          state.message = "active"
+        end
+      end
+
+      def mark_progress(site:, thread:, slug:, percent:, size_str:, speed_str:)
+        mutate(site, thread) do |state|
+          state.status = :active
+          state.reason = nil
+          state.resume_at = nil
+          state.slug = slug
+          state.percent = percent.to_f
+          state.size_str = size_str.to_s
+          state.speed_str = speed_str.to_s
+          state.message = "downloading"
+        end
+      end
+
+      def mark_blocked(site:, thread:, reason:, resume_at: nil, attempt: nil, message: nil)
+        mutate(site, thread) do |state|
+          state.status = :blocked
+          state.reason = reason.to_sym
+          state.resume_at = resume_at
+          state.attempt = attempt.to_i if attempt
+          state.message = message.to_s if message
+        end
+      end
+
+      def mark_resumed(site:, thread:)
+        mutate(site, thread) do |state|
+          state.status = :active
+          state.reason = nil
+          state.resume_at = nil
+          state.message = "resumed"
+        end
+      end
+
+      def increment_done(site:, thread:, ok:, cause: nil)
+        mutate(site, thread) do |state|
+          state.done += 1
+          state.status = :idle
+          state.reason = ok ? :waiting : (cause || :failed)
+          state.resume_at = nil
+          state.percent = nil
+          state.size_str = nil
+          state.speed_str = nil
+          state.message = ok ? "ok" : "failed: #{cause || :unknown}"
+        end
+      end
+
+      def finish_thread(site:, thread:)
+        mutate(site, thread) do |state|
+          if state.total.zero?
+            state.status = :blocked
+            state.reason = :no_work
+            state.message = "blocked: no work"
+          else
+            state.status = :done
+            state.reason = nil
+            state.message = "done"
+          end
+          state.resume_at = nil
+          state.percent = nil
+          state.size_str = nil
+          state.speed_str = nil
+        end
+      end
+
+      def snapshot
+        @mutex.synchronize do
+          now = Time.now
+          {
+            cycle_id: @cycle_id,
+            sites: @states.each_with_object({}) do |(site, threads), out|
+              out[site] = threads.each_with_object({}) do |(thread, state), th_out|
+                resume_in = if state.resume_at
+                  [state.resume_at - now, 0.0].max
+                end
+
+                th_out[thread] = {
+                  total: state.total,
+                  done: state.done,
+                  status: state.status,
+                  reason: state.reason,
+                  slug: state.slug,
+                  percent: state.percent,
+                  size_str: state.size_str,
+                  speed_str: state.speed_str,
+                  attempt: state.attempt,
+                  resume_at: state.resume_at,
+                  resume_in: resume_in,
+                  message: state.message
+                }
+              end
+            end
+          }
+        end
+      end
+
+      private
+
+      def mutate(site, thread)
+        @mutex.synchronize do
+          state = @states.dig(site.to_sym, thread.to_i)
+          return unless state
+
+          yield(state)
+        end
+      end
+    end
+
+    MUTEX = Mutex.new
+
+    class << self
+      def start_cycle!(sites:, threads_per_site: 2)
+        tracker = Tracker.new(sites: sites, threads_per_site: threads_per_site)
+        MUTEX.synchronize { @tracker = tracker }
+        tracker
+      end
+
+      def tracker
+        MUTEX.synchronize { @tracker }
+      end
+
+      def clear_cycle!
+        MUTEX.synchronize { @tracker = nil }
+      end
+
+      def snapshot
+        tracker&.snapshot || { cycle_id: nil, sites: {} }
+      end
+
+      def format_line(site:, thread:, state:)
+        prefix = "%s t%d" % [site.to_s, thread.to_i]
+        total = state[:total].to_i
+        done = state[:done].to_i
+
+        case state[:status]
+        when :blocked
+          reason = state[:reason] || :blocked
+          if state[:resume_in]
+            "%s | %d/%d | blocked(%s), resumes in %ds" % [prefix, done, total, reason, state[:resume_in].ceil]
+          else
+            "%s | %d/%d | blocked(%s)" % [prefix, done, total, reason]
+          end
+        when :active
+          if state[:percent]
+            "%s | %d/%d | %.0f%% of %s @ %s | %s" % [
+              prefix,
+              done,
+              total,
+              state[:percent].to_f,
+              state[:size_str],
+              state[:speed_str],
+              state[:slug].to_s
+            ]
+          else
+            "%s | %d/%d | active | %s" % [prefix, done, total, state[:slug].to_s]
+          end
+        when :done
+          "%s | %d/%d | done" % [prefix, done, total]
+        else
+          "%s | %d/%d | %s" % [prefix, done, total, state[:message] || "idle"]
+        end
+      end
+
+      def backoff_wait(seconds, tick: 1)
+        remain = [seconds.to_i, 0].max
+        while remain.positive?
+          yield(remain) if block_given?
+          sleep([tick.to_i, remain].min)
+          remain -= tick.to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ProgressBarNone
+  # A wrapper that provides progress tracking for any enumerable
+  class ProgressEnumerator
+    include Enumerable
+
+    def initialize(enumerable, bar_options = {})
+      @enumerable = enumerable
+      @bar_options = bar_options
+      @items = nil
+    end
+
+    def each(&block)
+      return to_enum(:each) unless block_given?
+
+      # Materialize the enumerable to get count
+      @items ||= @enumerable.to_a
+      total = @items.length
+
+      return if total.zero?
+
+      bar = Bar.new(total: total, **@bar_options)
+      bar.start
+
+      begin
+        @items.each do |item|
+          # Yield to the block
+          result = yield(item)
+
+          # Check if result includes metrics
+          if result.is_a?(Hash)
+            # If it has a :metrics key, use that
+            if result.key?(:metrics)
+              bar.increment(metrics: result[:metrics])
+            else
+              # Treat the whole hash as metrics
+              bar.increment(metrics: result)
+            end
+          else
+            bar.increment
+          end
+        end
+      ensure
+        bar.finish
+      end
+    end
+
+    # Forward common Enumerable methods
+    def size
+      @items ||= @enumerable.to_a
+      @items.size
+    end
+
+    def length
+      size
+    end
+  end
+end
+
+# Extend Enumerable with progress bar support
+module Enumerable
+  # Iterate with a spectacular progress bar
+  #
+  # @param title [String, nil] Optional title for the progress bar
+  # @param style [Symbol] Visual style (:crystal, :blocks, :dots, :arrows, :ascii, :fire, :nyan, :matrix, etc.)
+  # @param palette [Symbol] Color palette (:crystal, :fire, :ocean, :neon, :synthwave, :vaporwave, :acid, etc.)
+  # @param width [Integer] Width of the progress bar (default: 40)
+  # @param output [IO] Output stream (default: $stderr)
+  # @param spinner [Symbol] Spinner style (:braille, :moon, :clock, :earth, :fire, :nyan, etc.)
+  # @param rainbow_mode [Boolean] Enable rainbow color cycling animation
+  # @param celebration [Symbol] Celebration effect on completion (:confetti, :firework, :party, :success)
+  # @param glow [Boolean] Enable neon glow effect
+  # @param fps [Integer] Frames per second for animation (default: 15)
+  # @return [ProgressEnumerator] A progress-tracking enumerator
+  #
+  # @example Basic usage
+  #   (1..100).with_progress.each { |i| sleep(0.01) }
+  #
+  # @example MAXIMUM PIZZAZZ mode
+  #   items.with_progress(
+  #     title: "🔥 TURBO MODE 🔥",
+  #     style: :fire,
+  #     palette: :neon,
+  #     rainbow_mode: true,
+  #     spinner: :rocket,
+  #     celebration: :firework,
+  #     glow: true
+  #   ).each { |item| process(item) }
+  #
+  # @example Reporting metrics
+  #   files.with_progress(title: "Analyzing").each do |file|
+  #     size = File.size(file)
+  #     lines = File.readlines(file).count
+  #     { bytes: size, lines: lines }  # Return metrics hash
+  #   end
+  #
+  def with_progress(title: nil, style: :crystal, palette: :crystal, width: 40, output: $stderr,
+                    spinner: :braille, rainbow_mode: false, celebration: :confetti, glow: false, fps: 15)
+    ProgressBarNone::ProgressEnumerator.new(
+      self,
+      title: title,
+      style: style,
+      palette: palette,
+      width: width,
+      output: output,
+      spinner: spinner,
+      rainbow_mode: rainbow_mode,
+      celebration: celebration,
+      glow: glow,
+      fps: fps
+    )
+  end
+end
+

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module ProgressBarNone
+  # Decorative frames and borders for the progress cockpit
+  module Frames
+    class << self
+      # Draw a decorative frame around content
+      # @param content [Array<String>] Lines of content
+      # @param style [Symbol] Frame style (:single, :double, :rounded, :bold, :ascii, :cyber, :neon)
+      # @param palette [Symbol] Color palette for the frame
+      # @param title [String, nil] Optional title for the frame
+      # @param animated [Boolean] Enable animated frame
+      # @param frame_num [Integer] Animation frame number
+      # @return [Array<String>] Framed content lines
+      def wrap(content, style: :rounded, palette: :crystal, title: nil, animated: false, frame_num: 0)
+        lines = content.is_a?(Array) ? content : content.split("\n")
+        return lines if lines.empty?
+
+        # Calculate max width
+        max_width = lines.map { |l| ANSI.visible_length(l) }.max
+
+        # Get frame characters
+        frame = frame_chars(style)
+
+        # Build framed output
+        result = []
+
+        # Top border
+        top_border = build_top_border(frame, max_width, title, palette, animated, frame_num)
+        result << top_border
+
+        # Content lines
+        lines.each_with_index do |line, i|
+          padding = max_width - ANSI.visible_length(line)
+          left = frame_color(frame[:v], palette, i, animated, frame_num)
+          right = frame_color(frame[:v], palette, i, animated, frame_num)
+          result << "#{left} #{line}#{" " * padding} #{right}"
+        end
+
+        # Bottom border
+        bottom_border = build_bottom_border(frame, max_width, palette, animated, frame_num)
+        result << bottom_border
+
+        result
+      end
+
+      # Create a simple horizontal separator
+      def separator(width: 40, style: :single, palette: :crystal, animated: false, frame_num: 0)
+        frame = frame_chars(style)
+        char = frame[:h]
+
+        if animated
+          # Animated separator with traveling highlight
+          result = ""
+          width.times do |i|
+            highlight_pos = (frame_num * 2) % width
+            if (i - highlight_pos).abs < 3
+              intensity = 1.0 - (i - highlight_pos).abs / 3.0
+              result += "#{ANSI::BOLD}#{ANSI.palette_color(palette, intensity)}#{char}#{ANSI::RESET}"
+            else
+              result += "#{ANSI::DIM}#{char}#{ANSI::RESET}"
+            end
+          end
+          result
+        else
+          color = ANSI.palette_color(palette, 0.5)
+          "#{color}#{char * width}#{ANSI::RESET}"
+        end
+      end
+
+      # Create a decorative header banner
+      def banner(text, style: :double, palette: :neon, animated: false, frame_num: 0)
+        width = text.length + 4
+        frame = frame_chars(style)
+
+        lines = []
+
+        # Top
+        top_color = animated ? ANSI.rainbow_cycle(0, frame_num * 0.1, 1.0) : ANSI.palette_color(palette, 0.0)
+        lines << "#{top_color}#{frame[:tl]}#{frame[:h] * width}#{frame[:tr]}#{ANSI::RESET}"
+
+        # Middle with text
+        mid_color = animated ? ANSI.rainbow_cycle(0.5, frame_num * 0.1, 1.0) : ANSI.palette_color(palette, 0.5)
+        text_color = animated ? rainbow_text(text, frame_num) : "#{ANSI::BOLD}#{mid_color}#{text}#{ANSI::RESET}"
+        lines << "#{mid_color}#{frame[:v]}#{ANSI::RESET}  #{text_color}  #{mid_color}#{frame[:v]}#{ANSI::RESET}"
+
+        # Bottom
+        bot_color = animated ? ANSI.rainbow_cycle(1.0, frame_num * 0.1, 1.0) : ANSI.palette_color(palette, 1.0)
+        lines << "#{bot_color}#{frame[:bl]}#{frame[:h] * width}#{frame[:br]}#{ANSI::RESET}"
+
+        lines
+      end
+
+      # ASCII art title banners
+      def ascii_title(text, style: :block, palette: :neon)
+        case style
+        when :block
+          block_title(text, palette)
+        when :shadow
+          shadow_title(text, palette)
+        when :outline
+          outline_title(text, palette)
+        else
+          simple_title(text, palette)
+        end
+      end
+
+      private
+
+      def frame_chars(style)
+        case style
+        when :single
+          { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│" }
+        when :double
+          { tl: "╔", tr: "╗", bl: "╚", br: "╝", h: "═", v: "║" }
+        when :rounded
+          { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" }
+        when :bold
+          { tl: "┏", tr: "┓", bl: "┗", br: "┛", h: "━", v: "┃" }
+        when :ascii
+          { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" }
+        when :cyber
+          { tl: "⟦", tr: "⟧", bl: "⟦", br: "⟧", h: "═", v: "▐" }
+        when :neon
+          { tl: "◤", tr: "◥", bl: "◣", br: "◢", h: "━", v: "┃" }
+        when :stars
+          { tl: "✦", tr: "✦", bl: "✦", br: "✦", h: "✧", v: "✧" }
+        else
+          { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" }
+        end
+      end
+
+      def build_top_border(frame, width, title, palette, animated, frame_num)
+        h_char = frame[:h]
+        total_width = width + 2  # +2 for padding
+
+        if title && !title.empty?
+          title_display = " #{title} "
+          title_len = ANSI.visible_length(title_display)
+          left_width = 2
+          right_width = total_width - left_width - title_len
+
+          left = frame_color(frame[:tl], palette, 0, animated, frame_num)
+          right = frame_color(frame[:tr], palette, 0, animated, frame_num)
+          left_h = frame_color(h_char * left_width, palette, 0, animated, frame_num)
+          right_h = frame_color(h_char * [right_width, 0].max, palette, 0, animated, frame_num)
+
+          title_color = animated ? rainbow_text(title_display, frame_num) :
+                                  "#{ANSI::BOLD}#{ANSI.palette_color(palette, 0.5)}#{title_display}#{ANSI::RESET}"
+
+          "#{left}#{left_h}#{title_color}#{right_h}#{right}"
+        else
+          left = frame_color(frame[:tl], palette, 0, animated, frame_num)
+          right = frame_color(frame[:tr], palette, 0, animated, frame_num)
+          middle = frame_color(h_char * total_width, palette, 0, animated, frame_num)
+
+          "#{left}#{middle}#{right}"
+        end
+      end
+
+      def build_bottom_border(frame, width, palette, animated, frame_num)
+        h_char = frame[:h]
+        total_width = width + 2
+
+        left = frame_color(frame[:bl], palette, 1, animated, frame_num)
+        right = frame_color(frame[:br], palette, 1, animated, frame_num)
+        middle = frame_color(h_char * total_width, palette, 1, animated, frame_num)
+
+        "#{left}#{middle}#{right}"
+      end
+
+      def frame_color(char, palette, position, animated, frame_num)
+        if animated
+          color = ANSI.rainbow_cycle(position * 0.5, frame_num * 0.1, 1.0)
+          "#{color}#{char}#{ANSI::RESET}"
+        else
+          color = ANSI.palette_color(palette, position)
+          "#{color}#{char}#{ANSI::RESET}"
+        end
+      end
+
+      def rainbow_text(text, frame_num)
+        result = ""
+        text.each_char.with_index do |char, i|
+          color = ANSI.rainbow_cycle(i * 0.1, frame_num * 0.1, 1.0)
+          result += "#{color}#{char}"
+        end
+        result + ANSI::RESET
+      end
+
+      def block_title(text, palette)
+        # Simple block-style title
+        color = ANSI.palette_color(palette, 0.5)
+        [
+          "#{color}#{ANSI::BOLD}█▀▀ #{text.upcase} ▀▀█#{ANSI::RESET}",
+        ]
+      end
+
+      def shadow_title(text, palette)
+        color = ANSI.palette_color(palette, 0.5)
+        shadow = ANSI::DIM
+        [
+          "#{color}#{ANSI::BOLD}#{text}#{ANSI::RESET}",
+          "#{shadow}#{text.gsub(/[^ ]/, "░")}#{ANSI::RESET}",
+        ]
+      end
+
+      def outline_title(text, palette)
+        color = ANSI.palette_color(palette, 0.5)
+        border = "═" * (text.length + 2)
+        [
+          "#{color}╔#{border}╗#{ANSI::RESET}",
+          "#{color}║ #{ANSI::BOLD}#{text}#{ANSI::RESET}#{color} ║#{ANSI::RESET}",
+          "#{color}╚#{border}╝#{ANSI::RESET}",
+        ]
+      end
+
+      def simple_title(text, palette)
+        color = ANSI.palette_color(palette, 0.5)
+        ["#{color}#{ANSI::BOLD}▸ #{text}#{ANSI::RESET}"]
+      end
+    end
+  end
+end