fun_ci 1.1.0 → 1.2.0

data/lib/fun_ci/animation_renderer.rb

@@ -1,142 +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
-  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

data/lib/fun_ci/ansi.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  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

data/lib/fun_ci/background_wrapper.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "timeout"
-
-module FunCi
-  class BackgroundWrapper
-    def initialize(recorder:, job_id:, executor:)
-      @recorder = recorder
-      @job_id = job_id
-      @executor = executor
-    end
-
-    def run
-      _output, status = @executor.call
-      if status.success?
-        @recorder.end_stage(@job_id, "completed")
-        @recorder.complete_run
-      else
-        @recorder.end_stage(@job_id, "failed")
-        @recorder.fail_run
-      end
-    rescue Timeout::Error
-      @recorder.end_stage(@job_id, "timed_out")
-      @recorder.fail_run
-    end
-  end
-end

data/lib/fun_ci/board_data.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-require_relative "pipeline_run"
-require_relative "stage_job"
-require_relative "streak_counter"
-
-module FunCi
-  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 = PipelineRun.recent(@db, limit: @limit)
-      pipeline_runs.map { |run| enrich_with_stages(run) }
-    end
-
-    def streak
-      pipeline_runs = PipelineRun.recent(@db, limit: @limit)
-      StreakCounter.count(pipeline_runs)
-    end
-
-    def cancel_run(run_id)
-      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 = 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

data/lib/fun_ci/database.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "sqlite3"
-
-module FunCi
-  module Database
-    def self.connection(db_path)
-      db = SQLite3::Database.new(db_path)
-      db.busy_timeout = 5000
-      db.execute("PRAGMA journal_mode=WAL")
-      db.execute("PRAGMA foreign_keys=ON")
-      db
-    end
-
-    def self.migrate!(db)
-      db.execute(<<~SQL)
-        CREATE TABLE IF NOT EXISTS pipeline_runs (
-          id INTEGER PRIMARY KEY,
-          commit_hash TEXT,
-          branch TEXT,
-          status TEXT DEFAULT 'scheduled',
-          pid INTEGER,
-          created_at TEXT,
-          updated_at TEXT
-        )
-      SQL
-
-      add_column_if_missing(db, "pipeline_runs", "pid", "INTEGER")
-      add_column_if_missing(db, "pipeline_runs", "project_path", "TEXT")
-
-      db.execute(<<~SQL)
-        CREATE TABLE IF NOT EXISTS stage_jobs (
-          id INTEGER PRIMARY KEY,
-          pipeline_run_id INTEGER REFERENCES pipeline_runs(id),
-          stage TEXT,
-          status TEXT DEFAULT 'scheduled',
-          started_at TEXT,
-          completed_at TEXT
-        )
-      SQL
-    end
-
-    def self.add_column_if_missing(db, table, column, type)
-      columns = db.execute("PRAGMA table_info(#{table})").map { |row| row[1] }
-      return if columns.include?(column)
-      db.execute("ALTER TABLE #{table} ADD COLUMN #{column} #{type}")
-    end
-    private_class_method :add_column_if_missing
-  end
-end

data/lib/fun_ci/duration_formatter.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  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)
-      # Show one decimal place, remove trailing zeros
-      sprintf("%.1f", value)
-    end
-    private_class_method :format_decimal
-  end
-end

data/lib/fun_ci/header_animation_manager.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "header_animation_player"
-require_relative "looping_animation_player"
-
-module FunCi
-  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

data/lib/fun_ci/header_animation_player.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ansi"
-
-module FunCi
-  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

data/lib/fun_ci/hook_writer.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module FunCi
-  class HookWriter
-    ALLOWED_HOOKS = %w[pre-commit pre-push].freeze
-    MARKER = "# fun-ci-managed-hook"
-
-    HOOK_COMMANDS = {
-      "pre-commit" => "fun-ci trigger --no-validate",
-      "pre-push" => "fun-ci trigger"
-    }.freeze
-
-    HOOK_TEMPLATE = <<~SH
-      #!/bin/sh
-      #{MARKER}
-      COMMIT=$(git rev-parse HEAD 2>/dev/null || echo "0000000000000000000000000000000000000000")
-      BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown")
-      %<command>s "$COMMIT" "$BRANCH"
-    SH
-
-    def self.run(project_root:, hook_type:, stdout: $stdout)
-      new(project_root: project_root, hook_type: hook_type, stdout: stdout).run
-    end
-
-    def initialize(project_root:, hook_type:, stdout:)
-      @project_root = project_root
-      @hook_type = hook_type
-      @stdout = stdout
-    end
-
-    def run
-      return reject("Not a git repository — no .git/ found.") unless git_repo?
-      return reject("Unknown hook type: #{@hook_type}") unless ALLOWED_HOOKS.include?(@hook_type)
-      return skip("Hook #{@hook_type} already exists from another tool — skipping.") if foreign_hook?
-
-      write_hook
-      @stdout.puts "Installed #{@hook_type} hook."
-      0
-    end
-
-    private
-
-    def git_repo?
-      Dir.exist?(File.join(@project_root, ".git"))
-    end
-
-    def hook_path
-      File.join(@project_root, ".git", "hooks", @hook_type)
-    end
-
-    def foreign_hook?
-      File.exist?(hook_path) && !File.read(hook_path).include?(MARKER)
-    end
-
-    def write_hook
-      FileUtils.mkdir_p(File.join(@project_root, ".git", "hooks"))
-      File.write(hook_path, format(HOOK_TEMPLATE, command: HOOK_COMMANDS[@hook_type]))
-      File.chmod(0o755, hook_path)
-    end
-
-    def reject(message)
-      @stdout.puts message
-      1
-    end
-
-    def skip(message)
-      @stdout.puts message
-      0
-    end
-  end
-end

data/lib/fun_ci/installer.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "project_detector"
-require_relative "template_writer"
-require_relative "maven_linter_detector"
-
-module FunCi
-  class Installer
-    def self.run(project_root:, stdout: $stdout, pom_reader: nil)
-      new(project_root: project_root, stdout: stdout, pom_reader: pom_reader).run
-    end
-
-    def initialize(project_root:, stdout:, pom_reader: nil)
-      @project_root = project_root
-      @stdout = stdout
-      @pom_reader = pom_reader || ->(path) { File.read(path) }
-    end
-
-    def run
-      if Dir.exist?(File.join(@project_root, ".fun-ci"))
-        @stdout.puts ".fun-ci/ already exists — skipping init."
-        return 0
-      end
-
-      filenames = Dir.children(@project_root)
-      detected = ProjectDetector.new(filenames).detect
-
-      if detected == :unknown
-        @stdout.puts "Could not detect project type. Create .fun-ci/ manually."
-        return 1
-      end
-
-      @stdout.puts "Detected: #{detected.to_s.tr("_", " ")}"
-
-      lint_override = detect_maven_linter(detected)
-      TemplateWriter.new(detected, @project_root, lint_override: lint_override).write
-
-      @stdout.puts "Created .fun-ci/ with template scripts."
-      0
-    end
-
-    private
-
-    def detect_maven_linter(detected)
-      return nil unless detected == :jvm_maven
-
-      pom_path = File.join(@project_root, "pom.xml")
-      pom_content = @pom_reader.call(pom_path)
-      command = MavenLinterDetector.new(pom_content).lint_command
-      command == MavenLinterDetector::DEFAULT_COMMAND ? nil : command
-    end
-  end
-end

data/lib/fun_ci/looping_animation_player.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ansi"
-
-module FunCi
-  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

data/lib/fun_ci/maven_linter_detector.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  class MavenLinterDetector
-    LINTERS = [
-      { artifact_id: "detekt-maven-plugin", command: "mvn detekt:check" },
-      { artifact_id: "ktlint-maven-plugin", command: "mvn ktlint:check" },
-      { artifact_id: "maven-checkstyle-plugin", command: "mvn checkstyle:check" },
-      { artifact_id: "spotbugs-maven-plugin", command: "mvn spotbugs:check" },
-      { artifact_id: "maven-pmd-plugin", command: "mvn pmd:check" }
-    ].freeze
-
-    DEFAULT_COMMAND = "mvn verify -DskipTests"
-
-    def initialize(pom_content)
-      @pom_content = pom_content
-    end
-
-    def lint_command
-      match = LINTERS.find { |linter| @pom_content.include?(linter[:artifact_id]) }
-      match ? match[:command] : DEFAULT_COMMAND
-    end
-  end
-end

data/lib/fun_ci/pipeline_forker.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "database"
-require_relative "pipeline_recorder"
-require_relative "background_wrapper"
-
-module FunCi
-  class PipelineForker
-    def self.fork_pipeline(commit_hash:, branch:, db_path:)
-      pid = fork do
-        run_in_child(commit_hash: commit_hash, branch: branch, db_path: db_path)
-      end
-      Process.detach(pid)
-    end
-
-    def self.run_in_child(commit_hash:, branch:, db_path:)
-      db = Database.connection(db_path)
-      recorder = DbRecorder.new(db)
-      Trigger.new(
-        project_root: Dir.pwd,
-        commit_hash: commit_hash,
-        branch: branch,
-        stdout: File.open(File::NULL, "w"),
-        recorder: recorder,
-        background_launcher: method(:sync_launcher)
-      ).run
-      recorder.close
-    end
-
-    def self.sync_launcher(db_path:, pipeline_run_id:, job_id:, executor:)
-      recorder = DbRecorder.for_background(db_path, pipeline_run_id)
-      BackgroundWrapper.new(recorder: recorder, job_id: job_id, executor: executor).run
-      recorder.close
-    end
-  end
-end