fun_ci 1.2.1 → 2.0.0

data/lib/fun_ci/tui/animation_renderer.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "animation"
-require_relative "animation_compositor"
-require_relative "animation_library"
-require_relative "header_animation_manager"
-require_relative "stage_change_detector"
-
-module FunCi
-  module Tui
-    class AnimationRenderer
-      HEADER_HEIGHT = HeaderAnimationManager::HEADER_HEIGHT
-
-      def initialize(animation_library: AnimationLibrary)
-        @previous_runs = []
-        @animations = []
-        @header_manager = HeaderAnimationManager.new(animation_library: animation_library)
-      end
-
-      def render(screen, runs)
-        detect_and_queue(runs)
-
-        screen.save_cursor
-        render_header_overlay(screen)
-        render_stage_overlays(screen, runs)
-        render_footer_overlay(screen, runs)
-        screen.restore_cursor
-
-        advance_all
-        expire_finished
-      end
-
-      def any_active?
-        @animations.any? { |a| !a.finished? } || @header_manager.any_active_event?
-      end
-
-      def active_count
-        @animations.count { |a| !a.finished? }
-      end
-
-      private
-
-      def detect_and_queue(runs)
-        changes = StageChangeDetector.detect(@previous_runs, runs)
-        @previous_runs = snapshot(runs)
-        changes.each { |change| queue_animation(change, runs) }
-        update_running_state(runs)
-      end
-
-      def update_running_state(runs)
-        any_running = runs.any? { |r| r[:status] == "running" }
-        any_running ? @header_manager.start_running : @header_manager.stop_running
-      end
-
-      def queue_animation(change, runs)
-        run_status = runs.find { |r| r[:id] == change.run_id }&.dig(:status)
-
-        case change.to
-        when "failed"
-          add_animation(:failure, change.run_id, change.stage)
-          @header_manager.trigger_failure
-        when "timed_out"
-          add_animation(:timeout, change.run_id, change.stage)
-        when "completed"
-          if run_status == "completed"
-            add_animation(:success, change.run_id, change.stage)
-            @header_manager.trigger_success
-          else
-            add_animation(:stage_pass, change.run_id, change.stage)
-          end
-        end
-      end
-
-      def add_animation(type, run_id, stage)
-        @animations.reject! do |a|
-          a.type == type && a.run_id == run_id && a.stage == stage
-        end
-        @animations << Animation.new(type: type, run_id: run_id, stage: stage)
-      end
-
-      def render_header_overlay(screen)
-        @header_manager.current_lines(screen.width).each_with_index do |line, i|
-          screen.write_at(1 + i, 1, line)
-        end
-      end
-
-      def render_footer_overlay(screen, runs)
-        anim = highest_priority(:has_footer?)
-        return unless anim
-
-        footer_row = HEADER_HEIGHT + (runs.length * 2) + 1
-        overlay = AnimationCompositor.footer_overlay(anim, screen.width)
-        screen.write_at(footer_row, 1, "#{overlay}\e[K") if overlay
-      end
-
-      def render_stage_overlays(screen, runs)
-        @animations.each do |anim|
-          next if anim.finished?
-
-          run_index = runs.index { |r| r[:id] == anim.run_id }
-          next unless run_index
-
-          row = HEADER_HEIGHT + 1 + (run_index * 2)
-          run = runs[run_index]
-          text = AnimationCompositor.stage_text_for(run, anim.stage)
-          next unless text
-
-          overlay = AnimationCompositor.stage_column_overlay(anim, text, 0)
-          next unless overlay
-
-          col = AnimationCompositor.stage_col_for(run, anim.stage)
-          screen.write_at(row, col, overlay) if col
-        end
-      end
-
-      def highest_priority(predicate)
-        @animations
-          .select { |a| a.send(predicate) && !a.finished? }
-          .max_by(&:priority)
-      end
-
-      def advance_all
-        @animations.each { |a| a.advance! unless a.finished? }
-        @header_manager.advance!
-      end
-
-      def expire_finished
-        @animations.reject!(&:finished?)
-        @header_manager.expire_if_finished!
-      end
-
-      def snapshot(runs)
-        runs.map do |r|
-          {
-            id: r[:id],
-            stages: (r[:stages] || []).map do |s|
-              { stage: s[:stage], status: s[:status] }
-            end
-          }
-        end
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/ansi.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  module Tui
-    module Ansi
-      RESET = "\e[0m"
-
-      def self.green(text)      = "\e[32m#{text}#{RESET}"
-      def self.bold_green(text)  = "\e[1;32m#{text}#{RESET}"
-      def self.bold_red(text)    = "\e[1;31m#{text}#{RESET}"
-      def self.bold_yellow(text) = "\e[1;33m#{text}#{RESET}"
-      def self.cyan(text)        = "\e[36m#{text}#{RESET}"
-      def self.bold_cyan(text)   = "\e[1;36m#{text}#{RESET}"
-      def self.dim(text)         = "\e[2m#{text}#{RESET}"
-      def self.bold_white(text)  = "\e[1;37m#{text}#{RESET}"
-      def self.white(text)       = "\e[37m#{text}#{RESET}"
-      def self.yellow(text)      = "\e[33m#{text}#{RESET}"
-      def self.dim_green(text)   = "\e[2;32m#{text}#{RESET}"
-      def self.dim_red(text)     = "\e[2;31m#{text}#{RESET}"
-      def self.orange(text)      = "\e[38;5;208m#{text}#{RESET}"
-      def self.dark_red(text)    = "\e[38;5;52m#{text}#{RESET}"
-      def self.bg_charcoal(text) = "\e[48;5;236m#{text}#{RESET}"
-      def self.bg_dark_red(text)    = "\e[48;5;124m#{text}#{RESET}"
-      def self.bg_orange(text)      = "\e[48;5;166m#{text}#{RESET}"
-      def self.bg_very_dark_red(text) = "\e[48;5;52m#{text}#{RESET}"
-      def self.bg_dark_green(text)  = "\e[48;5;22m#{text}#{RESET}"
-      def self.bg_dark_yellow(text) = "\e[48;5;58m#{text}#{RESET}"
-
-      def self.strip(text)
-        text.gsub(/\e\[[0-9;]*[A-Za-z]/, "")
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/board_data.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-require_relative "../persistence/pipeline_run"
-require_relative "../persistence/stage_job"
-require_relative "streak_counter"
-
-module FunCi
-  module Tui
-    class BoardData
-      def initialize(db, limit: 15, page_size: nil)
-        @db = db
-        @page_size = page_size || limit
-        @limit = @page_size
-      end
-
-      def load_more
-        @limit += @page_size
-      end
-
-      def runs
-        pipeline_runs = Persistence::PipelineRun.recent(@db, limit: @limit)
-        pipeline_runs.map { |run| enrich_with_stages(run) }
-      end
-
-      def streak
-        pipeline_runs = Persistence::PipelineRun.recent(@db, limit: @limit)
-        StreakCounter.count(pipeline_runs)
-      end
-
-      def cancel_run(run_id)
-        Persistence::PipelineRun.update_status(@db, run_id, "cancelled")
-      end
-
-      private
-
-      def enrich_with_stages(run)
-        rows = @db.execute(
-          "SELECT id, pipeline_run_id, stage, status, started_at, completed_at FROM stage_jobs WHERE pipeline_run_id = ? ORDER BY id",
-          [run[:id]]
-        )
-
-        stages = rows.map do |row|
-          job = { id: row[0], pipeline_run_id: row[1], stage: row[2], status: row[3], started_at: row[4], completed_at: row[5] }
-          duration = Persistence::StageJob.elapsed_duration(job)
-          { stage: job[:stage], status: job[:status], duration: duration, started_at: job[:started_at] }
-        end
-
-        run.merge(stages: stages)
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/board_renderer.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "header_animation_manager"
-require_relative "row_formatter"
-require_relative "streak_counter"
-
-module FunCi
-  module Tui
-    class BoardRenderer
-      HEADER_HEIGHT = HeaderAnimationManager::HEADER_HEIGHT
-
-      def initialize(screen:, spinner:, animation_renderer:, height_provider:)
-        @screen = screen
-        @spinner = spinner
-        @animation_renderer = animation_renderer
-        @height_provider = height_provider
-      end
-
-      def render(runs:, streak:, cursor_index:, confirming:)
-        update_height
-        render_header_area(runs, streak)
-
-        if runs.empty?
-          @screen.render_empty_state
-          @screen.render_footer(empty: true)
-        else
-          rows = runs.map { |run| format_run(run) }
-          rows = truncate_rows_to_height(rows)
-          @screen.render_board(rows, cursor_index: cursor_index)
-          @screen.println unless rows.empty?
-          @screen.render_footer(empty: false, confirming: confirming)
-        end
-
-        @screen.clear_below
-        render_animations(runs)
-      end
-
-      def begin_frame
-        @screen.move_cursor_home
-        @spinner.advance!
-      end
-
-      def clear
-        @screen.clear
-      end
-
-      def resize(new_width)
-        @screen.width = new_width
-      end
-
-      def animation_renderer?
-        !!@animation_renderer
-      end
-
-      private
-
-      def render_header_area(runs, streak)
-        if @animation_renderer
-          @screen.write_at(HEADER_HEIGHT + 1, 1, "")
-        else
-          streak_text = StreakCounter.format_text(streak)
-          @screen.render_header(streak_text: streak_text)
-          (HEADER_HEIGHT - 1).times { @screen.println }
-        end
-      end
-
-      def format_run(run)
-        opts = {}
-        if run[:status] == "running"
-          active_stage = run[:stages].find { |s| s[:status] == "running" }
-          if active_stage && active_stage[:started_at]
-            opts[:elapsed_seconds] = Time.now - Time.parse(active_stage[:started_at])
-          end
-          opts[:spinner_frame] = @spinner.current_frame
-        end
-        RowFormatter.format(run, **opts)
-      end
-
-      def render_animations(runs)
-        return unless @animation_renderer
-
-        @animation_renderer.render(@screen, runs)
-      end
-
-      def update_height
-        return unless @height_provider
-
-        height = @height_provider.call
-        @screen.height = height if height
-      end
-
-      def truncate_rows_to_height(rows)
-        height = @screen.height
-        return rows unless height
-
-        # Line budget: N rows consume 2N-1 lines (row + separator between rows).
-        # Remaining height after header, post-board separator, and footer:
-        #   available = height - HEADER_HEIGHT - 2
-        # Solving 2N - 1 <= available gives N <= (available) / 2.
-        max_rows = [(height - HEADER_HEIGHT - 2) / 2, 0].max
-        rows.first(max_rows)
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/duration_formatter.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  module Tui
-    module DurationFormatter
-      def self.format(seconds)
-        if seconds >= 60
-          mins = (seconds / 60).to_i
-          secs = (seconds % 60).to_i
-          "#{mins}m#{secs.to_s.rjust(2, "0")}"
-        elsif seconds == seconds.to_i
-          "#{seconds.to_i}s"
-        else
-          "#{format_decimal(seconds)}s"
-        end
-      end
-
-      def self.format_decimal(value)
-        sprintf("%.1f", value)
-      end
-      private_class_method :format_decimal
-    end
-  end
-end

data/lib/fun_ci/tui/header_animation_manager.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "header_animation_player"
-require_relative "looping_animation_player"
-
-module FunCi
-  module Tui
-    class HeaderAnimationManager
-      HEADER_HEIGHT = 14
-
-      def initialize(animation_library:)
-        @idle_player = LoopingAnimationPlayer.new(animation_library.idle)
-        @running_player = nil
-        @header_player = nil
-        @animation_library = animation_library
-      end
-
-      def trigger_failure
-        @header_player = HeaderAnimationPlayer.new(@animation_library.random_failure)
-      end
-
-      def trigger_success
-        @header_player = HeaderAnimationPlayer.new(@animation_library.random_success)
-      end
-
-      def start_running
-        @running_player ||= LoopingAnimationPlayer.new(@animation_library.running)
-      end
-
-      def stop_running
-        @running_player = nil
-      end
-
-      def current_lines(width)
-        lines = active_player.current_lines(width)
-        pad_to_height(lines, HEADER_HEIGHT)
-      end
-
-      def advance!
-        @idle_player.advance!
-        @running_player&.advance!
-        @header_player&.advance!
-      end
-
-      def expire_if_finished!
-        @header_player = nil if @header_player&.finished?
-      end
-
-      def any_active_event?
-        @header_player && !@header_player.finished?
-      end
-
-      private
-
-      def active_player
-        return @header_player if any_active_event?
-        return @running_player if @running_player
-
-        @idle_player
-      end
-
-      def pad_to_height(lines, height)
-        return lines if lines.length >= height
-
-        top_pad = (height - lines.length) / 2
-        blank = "\e[K"
-        Array.new(top_pad, blank) + lines + Array.new(height - lines.length - top_pad, blank)
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/header_animation_player.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ansi"
-
-module FunCi
-  module Tui
-    class HeaderAnimationPlayer
-      attr_reader :frame
-
-      def initialize(data)
-        @data = data
-        @frame = 0
-      end
-
-      def advance!
-        @frame += 1
-      end
-
-      def finished?
-        @frame >= total_frames
-      end
-
-      def total_frames
-        @data[:frames].length
-      end
-
-      def current_lines(width)
-        return [] if finished?
-
-        frame_lines = @data[:frames][@frame]
-        return [] unless frame_lines
-
-        frame_lines.map { |line| center_line(line, width) }
-      end
-
-      private
-
-      def center_line(line, width)
-        visible_len = Ansi.strip(line).length
-        pad = [(width - visible_len) / 2, 0].max
-        "#{" " * pad}#{line}\e[K"
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/key_handler.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  module Tui
-    class KeyHandler
-      attr_reader :cursor_index
-
-      def initialize(board_data:)
-        @board_data = board_data
-        @cursor_index = nil
-        @confirm_cancel = nil
-      end
-
-      def handle_key(key)
-        if @confirm_cancel
-          handle_confirm_key(key)
-          return
-        end
-
-        case key
-        when "q"
-          :quit
-        when "j", :down
-          move_cursor_down
-        when "k", :up
-          move_cursor_up
-        when "c"
-          initiate_cancel
-        end
-      end
-
-      def confirming?
-        !@confirm_cancel.nil?
-      end
-
-      def confirmation_run
-        @confirm_cancel
-      end
-
-      private
-
-      def move_cursor_down
-        runs = @board_data.runs
-        return if runs.empty?
-
-        if @cursor_index.nil?
-          @cursor_index = 0
-        elsif @cursor_index < runs.length - 1
-          @cursor_index += 1
-          @board_data.load_more if @cursor_index == runs.length - 1
-        end
-      end
-
-      def move_cursor_up
-        return if @cursor_index.nil?
-
-        @cursor_index -= 1 if @cursor_index > 0
-      end
-
-      def initiate_cancel
-        return if @cursor_index.nil?
-
-        runs = @board_data.runs
-        return if @cursor_index >= runs.length
-
-        run = runs[@cursor_index]
-        case run[:status]
-        when "scheduled"
-          @board_data.cancel_run(run[:id])
-        when "running"
-          @confirm_cancel = run
-        end
-      end
-
-      def handle_confirm_key(key)
-        case key
-        when "y"
-          @board_data.cancel_run(@confirm_cancel[:id])
-          @confirm_cancel = nil
-        when "n", :escape
-          @confirm_cancel = nil
-        end
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/looping_animation_player.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ansi"
-
-module FunCi
-  module Tui
-    class LoopingAnimationPlayer
-      def initialize(data)
-        @data = data
-        @frame = 0
-      end
-
-      def advance!
-        @frame += 1
-      end
-
-      def frame
-        @frame % total_frames
-      end
-
-      def finished?
-        false
-      end
-
-      def total_frames
-        @data[:frames].length
-      end
-
-      def current_lines(width)
-        frame_lines = @data[:frames][frame]
-        return [] unless frame_lines
-
-        frame_lines.map { |line| center_line(line, width) }
-      end
-
-      private
-
-      def center_line(line, width)
-        visible_len = Ansi.strip(line).length
-        pad = [(width - visible_len) / 2, 0].max
-        "#{" " * pad}#{line}\e[K"
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/relative_time.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-
-module FunCi
-  module Tui
-    module RelativeTime
-      def self.format(iso_timestamp, now: Time.now)
-        elapsed = now - Time.parse(iso_timestamp)
-        seconds = elapsed.to_i
-
-        if seconds < 60
-          "just now"
-        elsif seconds < 3600
-          "#{seconds / 60}m ago"
-        else
-          "#{seconds / 3600}h ago"
-        end
-      end
-    end
-  end
-end