fun_ci 1.2.0 → 2.0.0

data/lib/fun_ci/tui/row_formatter.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ansi"
-require_relative "duration_formatter"
-require_relative "relative_time"
-
-module FunCi
-  module Tui
-    module RowFormatter
-      STAGE_NAMES = { "lint" => "Lint", "build" => "Build", "fast" => "Fast", "slow" => "Slow" }.freeze
-      STATUS_LABELS = {
-        "completed" => "PASSED", "failed" => "FAILED", "timed_out" => "TIMED OUT",
-        "running" => "RUNNING", "scheduled" => "Scheduled...", "cancelled" => "CANCELLED"
-      }.freeze
-      PROJECT_COLORS = %w[31 32 33 34 35 36 91 92 93 94].freeze
-
-      def self.format(run, now: Time.now, spinner_frame: nil, elapsed_seconds: nil)
-        commit = run[:commit_hash][0, 7]
-        branch = run[:branch]
-        status = run[:status]
-        project = format_project(run[:project_path])
-
-        case status
-        when "scheduled"
-          format_scheduled(commit, branch, project, run[:updated_at], now)
-        when "cancelled"
-          format_cancelled(commit, branch, project, run[:stages], run[:updated_at], now)
-        else
-          stages_text = format_stages(run[:stages], status, spinner_frame, elapsed_seconds)
-          status_text = format_status(status)
-          time_text = Ansi.dim(RelativeTime.format(run[:updated_at], now: now))
-          "  #{commit}  #{branch}#{project}  #{stages_text}  #{status_text}  #{time_text}"
-        end
-      end
-
-      def self.format_project(project_path)
-        return "" unless project_path
-        name = File.basename(project_path)
-        code = PROJECT_COLORS[name.hash.abs % PROJECT_COLORS.size]
-        "  \e[#{code}m#{name}#{Ansi::RESET}"
-      end
-      private_class_method :format_project
-
-      def self.format_scheduled(commit, branch, project, updated_at, now)
-        time_text = RelativeTime.format(updated_at, now: now)
-        Ansi.dim("  #{commit}  #{branch}#{project}  Scheduled...  #{time_text}")
-      end
-      private_class_method :format_scheduled
-
-      def self.format_cancelled(commit, branch, project, stages, updated_at, now)
-        stages_text = stages.map { |s| format_cancelled_stage(s) }.join("  ")
-        time_text = RelativeTime.format(updated_at, now: now)
-        Ansi.dim("  #{commit}  #{branch}#{project}  #{stages_text}  CANCELLED  #{time_text}")
-      end
-      private_class_method :format_cancelled
-
-      def self.format_cancelled_stage(stage)
-        name = STAGE_NAMES[stage[:stage]]
-        if stage[:duration]
-          "#{name} #{DurationFormatter.format(stage[:duration])}"
-        else
-          "#{name} --"
-        end
-      end
-      private_class_method :format_cancelled_stage
-
-      def self.format_stages(stages, run_status, spinner_frame, elapsed_seconds)
-        stages.map { |s| format_stage(s, spinner_frame, elapsed_seconds) }.join("  ")
-      end
-      private_class_method :format_stages
-
-      def self.format_stage(stage, spinner_frame, elapsed_seconds)
-        name = STAGE_NAMES[stage[:stage]]
-
-        case stage[:status]
-        when "completed"
-          time = DurationFormatter.format(stage[:duration])
-          Ansi.green("#{name} #{time}")
-        when "failed"
-          time = DurationFormatter.format(stage[:duration])
-          Ansi.bold_red("#{name} FAIL #{time}")
-        when "timed_out"
-          time = DurationFormatter.format(stage[:duration])
-          Ansi.bold_yellow("#{name} TIMEOUT #{time}")
-        when "running"
-          frame = spinner_frame || "\u2800"
-          time = elapsed_seconds ? "#{elapsed_seconds.to_i}s" : "--"
-          Ansi.cyan("#{name} #{frame} #{time}")
-        else
-          Ansi.dim("#{name} --")
-        end
-      end
-      private_class_method :format_stage
-
-      def self.format_status(status)
-        label = STATUS_LABELS[status]
-        case status
-        when "completed" then Ansi.bold_green(label)
-        when "failed"    then Ansi.bold_red(label)
-        when "timed_out" then Ansi.bold_yellow(label)
-        when "running"   then Ansi.bold_cyan(label)
-        else Ansi.dim(label)
-        end
-      end
-      private_class_method :format_status
-    end
-  end
-end

data/lib/fun_ci/tui/screen.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ansi"
-
-module FunCi
-  module Tui
-    class Screen
-      attr_reader :width, :height
-
-      def initialize(output: $stdout, width: 80)
-        @output = output
-        @width = width
-      end
-
-      def width=(new_width)
-        return if new_width == @width
-
-        clear
-        @width = new_width
-      end
-
-      def height=(new_height)
-        return if new_height == @height
-
-        clear
-        @height = new_height
-      end
-
-      def render_header(streak_text:)
-        title = " fun-ci"
-        if streak_text
-          streak_display = Ansi.green(streak_text)
-          plain_streak = streak_text
-          padding = @width - title.length - plain_streak.length
-          padding = 1 if padding < 1
-          line = "#{title}#{" " * padding}#{streak_display}"
-        else
-          line = title.ljust(@width)
-        end
-        println Ansi.bg_charcoal(Ansi.white(line))
-      end
-
-      def render_footer(empty: false, confirming: false)
-        if confirming
-          println Ansi.dim("  Cancel running pipeline? y/n")
-        elsif empty
-          println Ansi.dim("  q quit")
-        else
-          println Ansi.dim("  j/k move   c cancel   q quit")
-        end
-      end
-
-      def render_empty_state
-        println ""
-        println ""
-        println "          No runs yet."
-        println ""
-        println "          Trigger one:  fun-ci trigger HEAD"
-        println "          Or hook it:   fun-ci install-hook pre-push"
-        println ""
-      end
-
-      def render_board(rows, cursor_index:)
-        rows.each_with_index do |row, i|
-          if cursor_index == i
-            println "> #{row.lstrip}"
-          else
-            println row
-          end
-          println unless i == rows.length - 1
-        end
-      end
-
-      def println(text = "")
-        @output.print "#{text}\e[K\r\n"
-      end
-
-      def clear
-        @output.print "\e[2J\e[H"
-      end
-
-      def move_cursor_home
-        @output.print "\e[H"
-      end
-
-      def clear_below
-        @output.print "\e[J"
-      end
-
-      def write_at(row, col, text)
-        @output.print "\e[#{row};#{col}H#{text}"
-      end
-
-      def save_cursor
-        @output.print "\e[s"
-      end
-
-      def restore_cursor
-        @output.print "\e[u"
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/spinner.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  module Tui
-    class Spinner
-      BRAILLE_FRAMES = %W[\u2800 \u2801 \u2803 \u2807 \u280F \u281F \u283F \u287F].freeze
-
-      attr_reader :frames
-
-      def initialize
-        @frames = BRAILLE_FRAMES
-        @index = 0
-      end
-
-      def current_frame
-        @frames[@index]
-      end
-
-      def advance!
-        @index = (@index + 1) % @frames.length
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/stage_change_detector.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  module Tui
-    module StageChangeDetector
-      Change = Data.define(:run_id, :stage, :from, :to)
-
-      def self.detect(previous_runs, current_runs)
-        return [] if previous_runs.empty?
-
-        current_by_id = index_by_id(current_runs)
-        changes = []
-
-        previous_runs.each do |prev_run|
-          cur_run = current_by_id[prev_run[:id]]
-          next unless cur_run
-
-          changes.concat(compare_stages(prev_run, cur_run))
-        end
-
-        changes
-      end
-
-      def self.index_by_id(runs)
-        runs.each_with_object({}) { |r, h| h[r[:id]] = r }
-      end
-      private_class_method :index_by_id
-
-      def self.compare_stages(prev_run, cur_run)
-        prev_stages = index_stages(prev_run[:stages])
-        changes = []
-
-        cur_run[:stages].each do |cur_stage|
-          prev_stage = prev_stages[cur_stage[:stage]]
-          prev_status = prev_stage ? prev_stage[:status] : nil
-          next if prev_status == cur_stage[:status]
-
-          changes << Change.new(
-            run_id: cur_run[:id],
-            stage: cur_stage[:stage],
-            from: prev_status,
-            to: cur_stage[:status]
-          )
-        end
-
-        changes
-      end
-      private_class_method :compare_stages
-
-      def self.index_stages(stages)
-        return {} unless stages
-
-        stages.each_with_object({}) { |s, h| h[s[:stage]] = s }
-      end
-      private_class_method :index_stages
-    end
-  end
-end

data/lib/fun_ci/tui/streak_counter.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  module Tui
-    module StreakCounter
-      PASS_STATUS = "completed"
-      ACTIVE_STATUSES = %w[running scheduled].freeze
-
-      def self.count(runs)
-        terminal_runs = runs.reject { |r| ACTIVE_STATUSES.include?(r[:status]) }
-        return nil if terminal_runs.empty?
-
-        streak = 0
-        terminal_runs.each do |run|
-          break unless run[:status] == PASS_STATUS
-          streak += 1
-        end
-        streak
-      end
-
-      def self.format_text(streak)
-        return nil if streak.nil?
-        return "Streak broken" if streak == 0
-
-        "#{streak} in a row!"
-      end
-    end
-  end
-end

data/lib/fun_ci/tui/terminal_input.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  module Tui
-    class TerminalInput
-      def initialize(input:, width_provider: nil)
-        @input = input
-        @width_provider = width_provider
-        @signal_read = nil
-        @signal_write = nil
-      end
-
-      def setup_signal_trap
-        return unless @width_provider
-
-        @signal_read, @signal_write = IO.pipe
-        Signal.trap("WINCH") do
-          @signal_write&.write_nonblock(".") rescue nil # rubocop:disable Style/RescueModifier
-        end
-      end
-
-      def check_width
-        return nil unless @width_provider
-
-        @width_provider.call
-      end
-
-      def setup_raw_mode
-        @input.raw! if @input.respond_to?(:raw!)
-      rescue Errno::ENOTTY
-        # Not a terminal (testing)
-      end
-
-      def restore_terminal
-        @input.cooked! if @input.respond_to?(:cooked!)
-      rescue Errno::ENOTTY
-        # Not a terminal
-      end
-
-      def read_key_with_timeout(timeout)
-        return nil unless @input.respond_to?(:read_nonblock)
-
-        watched = [@input]
-        watched << @signal_read if @signal_read
-        ready = IO.select(watched, nil, nil, timeout)
-        return nil unless ready
-
-        if @signal_read && ready[0].include?(@signal_read)
-          @signal_read.read_nonblock(1) rescue nil # rubocop:disable Style/RescueModifier
-          return nil unless ready[0].include?(@input)
-        end
-
-        byte = @input.read_nonblock(1)
-        if byte == "\e"
-          seq = @input.read_nonblock(2) rescue "" # rubocop:disable Style/RescueModifier
-          case seq
-          when "[A" then :up
-          when "[B" then :down
-          else :escape
-          end
-        else
-          byte
-        end
-      rescue IO::WaitReadable, EOFError
-        nil
-      end
-    end
-  end
-end