fun_ci 1.1.0 → 1.2.0

data/lib/fun_ci/pipeline_recorder.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "pipeline_run"
-require_relative "stage_job"
-
-module FunCi
-  class NullRecorder
-    def create_run(commit_hash:, branch:, project_path: nil) = nil
-    def start_stage(stage) = nil
-    def end_stage(job_id, status) = nil
-    def complete_run = nil
-    def fail_run = nil
-    def db = nil
-    def db_path = nil
-    def pipeline_run_id = nil
-    def close = nil
-  end
-
-  class DbRecorder
-    attr_reader :db, :db_path, :pipeline_run_id
-
-    def self.for_background(db_path, pipeline_run_id)
-      db = Database.connection(db_path)
-      new(db, pipeline_run_id: pipeline_run_id)
-    end
-
-    def initialize(db, pipeline_run_id: nil)
-      @db = db
-      @db_path = db.filename("main")
-      @pipeline_run_id = pipeline_run_id
-    end
-
-    def close
-      @db.close rescue nil
-    end
-
-    def create_run(commit_hash:, branch:, project_path: nil)
-      @pipeline_run_id = PipelineRun.create(@db, commit_hash: commit_hash, branch: branch, project_path: project_path)
-    end
-
-    def start_stage(stage)
-      return nil unless @pipeline_run_id
-      ensure_running
-      job_id = StageJob.create(@db, pipeline_run_id: @pipeline_run_id, stage: stage)
-      StageJob.update_status(@db, job_id, "running")
-      job_id
-    end
-
-    def end_stage(job_id, status)
-      return unless job_id
-      StageJob.update_status(@db, job_id, status)
-    end
-
-    def complete_run
-      return unless @pipeline_run_id
-      PipelineRun.update_status(@db, @pipeline_run_id, "completed")
-    end
-
-    def fail_run
-      return unless @pipeline_run_id
-      PipelineRun.update_status(@db, @pipeline_run_id, "failed")
-    end
-
-    private
-
-    def ensure_running
-      run = PipelineRun.find(@db, @pipeline_run_id)
-      return unless run && run[:status] == "scheduled"
-      PipelineRun.update_status(@db, @pipeline_run_id, "running")
-    end
-  end
-end

data/lib/fun_ci/pipeline_run.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-
-module FunCi
-  module PipelineRun
-    def self.create(db, commit_hash:, branch:, project_path: nil)
-      now = Time.now.utc.iso8601
-      db.execute(
-        "INSERT INTO pipeline_runs (commit_hash, branch, project_path, status, created_at, updated_at) VALUES (?, ?, ?, 'scheduled', ?, ?)",
-        [commit_hash, branch, project_path, now, now]
-      )
-      db.last_insert_row_id
-    end
-
-    def self.find(db, id)
-      row = db.execute("SELECT id, commit_hash, branch, status, pid, project_path, created_at, updated_at FROM pipeline_runs WHERE id = ?", [id]).first
-      return nil unless row
-      row_to_hash(row)
-    end
-
-    def self.find_by_branch(db, branch)
-      rows = db.execute("SELECT id, commit_hash, branch, status, pid, project_path, created_at, updated_at FROM pipeline_runs WHERE branch = ? ORDER BY id DESC", [branch])
-      rows.map { |row| row_to_hash(row) }
-    end
-
-    def self.find_by_commit(db, commit_hash)
-      rows = db.execute("SELECT id, commit_hash, branch, status, pid, project_path, created_at, updated_at FROM pipeline_runs WHERE commit_hash = ? ORDER BY id DESC", [commit_hash])
-      rows.map { |row| row_to_hash(row) }
-    end
-
-    def self.store_pid(db, id, pid)
-      db.execute("UPDATE pipeline_runs SET pid = ? WHERE id = ?", [pid, id])
-    end
-
-    def self.find_running_with_pid(db, branch)
-      row = db.execute("SELECT id, commit_hash, branch, status, pid, project_path, created_at, updated_at FROM pipeline_runs WHERE branch = ? AND status = 'running' AND pid IS NOT NULL ORDER BY id DESC LIMIT 1", [branch]).first
-      return nil unless row
-      row_to_hash(row)
-    end
-
-    def self.update_status(db, id, new_status)
-      now = Time.now.utc.iso8601
-      db.execute("UPDATE pipeline_runs SET status = ?, updated_at = ? WHERE id = ?", [new_status, now, id])
-    end
-
-    def self.recent(db, limit: 20)
-      rows = db.execute("SELECT id, commit_hash, branch, status, pid, project_path, created_at, updated_at FROM pipeline_runs ORDER BY id DESC LIMIT ?", [limit])
-      rows.map { |row| row_to_hash(row) }
-    end
-
-    def self.row_to_hash(row)
-      { id: row[0], commit_hash: row[1], branch: row[2], status: row[3], pid: row[4], project_path: row[5], created_at: row[6], updated_at: row[7] }
-    end
-    private_class_method :row_to_hash
-  end
-end

data/lib/fun_ci/progress_reporter.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  class ProgressReporter
-    def initialize(stdout:)
-      @stdout = stdout
-    end
-
-    def phase_one_result(results)
-      markers = results.map { |stage, passed| "#{stage} #{result_marker(passed)}" }
-      summary = results.values.all? ? "phase 1 passed" : "phase 1 failed"
-      @stdout.puts "fun-ci: #{markers.join("  ")}  (#{summary})"
-    end
-
-    def fast_result(passed)
-      @stdout.puts "fun-ci: fast #{result_marker(passed)}"
-    end
-
-    def slow_launched
-      @stdout.puts "fun-ci: slow (running in background)"
-    end
-
-    private
-
-    def result_marker(passed)
-      passed ? "ok" : "FAIL"
-    end
-  end
-end

data/lib/fun_ci/project_config.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  class ProjectConfig
-    REQUIRED_SCRIPTS = %w[lint.sh build.sh fast.sh slow.sh].freeze
-
-    def initialize(project_root)
-      @project_root = project_root
-      @fun_ci_dir = File.join(project_root, ".fun-ci")
-    end
-
-    def folder_exists?
-      Dir.exist?(@fun_ci_dir)
-    end
-
-    def validate
-      errors = []
-
-      unless folder_exists?
-        errors << "No .fun-ci/ folder found in #{@project_root}"
-        return errors
-      end
-
-      REQUIRED_SCRIPTS.each do |script|
-        path = File.join(@fun_ci_dir, script)
-        if !File.exist?(path)
-          errors << ".fun-ci/#{script} is not found"
-        elsif !File.executable?(path)
-          errors << ".fun-ci/#{script} is not executable"
-        end
-      end
-
-      errors
-    end
-
-    def script_path(stage)
-      File.join(@fun_ci_dir, "#{stage}.sh")
-    end
-  end
-end

data/lib/fun_ci/project_detector.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  class ProjectDetector
-    def initialize(filenames)
-      @filenames = filenames
-    end
-
-    def detect
-      return :ruby_bundler if @filenames.include?("Gemfile")
-      return :jvm_gradle_kotlin if @filenames.include?("build.gradle.kts")
-      return :jvm_gradle_groovy if @filenames.include?("build.gradle")
-      return :jvm_maven if @filenames.include?("pom.xml")
-
-      :unknown
-    end
-  end
-end

data/lib/fun_ci/relative_time.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-
-module FunCi
-  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

data/lib/fun_ci/row_formatter.rb

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

data/lib/fun_ci/screen.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ansi"
-
-module FunCi
-  class Screen
-    attr_reader :width
-
-    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 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
-          # Replace leading spaces with cursor marker
-          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

data/lib/fun_ci/setup_checker.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "project_config"
-
-module FunCi
-  class SetupChecker
-    def self.run(project_root:, stdout: $stdout, stderr: $stderr)
-      new(project_root: project_root, stdout: stdout).run
-    end
-
-    def initialize(project_root:, stdout:)
-      @config = ProjectConfig.new(project_root)
-      @stdout = stdout
-    end
-
-    def run
-      errors = @config.validate
-
-      if errors.empty?
-        @stdout.puts "All OK — project is configured."
-        0
-      else
-        errors.each { |e| @stdout.puts e }
-        1
-      end
-    end
-  end
-end

data/lib/fun_ci/spinner.rb

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

data/lib/fun_ci/stage_change_detector.rb

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

data/lib/fun_ci/stage_job.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-
-module FunCi
-  module StageJob
-    TERMINAL_STATUSES = %w[completed failed timed_out cancelled].freeze
-
-    def self.create(db, pipeline_run_id:, stage:)
-      db.execute(
-        "INSERT INTO stage_jobs (pipeline_run_id, stage, status) VALUES (?, ?, 'scheduled')",
-        [pipeline_run_id, stage]
-      )
-      db.last_insert_row_id
-    end
-
-    def self.find(db, id)
-      row = db.execute("SELECT id, pipeline_run_id, stage, status, started_at, completed_at FROM stage_jobs WHERE id = ?", [id]).first
-      return nil unless row
-      row_to_hash(row)
-    end
-
-    def self.update_status(db, id, new_status)
-      now = Time.now.utc.iso8601
-      if new_status == "running"
-        db.execute("UPDATE stage_jobs SET status = ?, started_at = ? WHERE id = ?", [new_status, now, id])
-      elsif TERMINAL_STATUSES.include?(new_status)
-        db.execute("UPDATE stage_jobs SET status = ?, completed_at = ? WHERE id = ?", [new_status, now, id])
-      else
-        db.execute("UPDATE stage_jobs SET status = ? WHERE id = ?", [new_status, id])
-      end
-    end
-
-    def self.elapsed_duration(job)
-      return nil unless job[:started_at] && job[:completed_at]
-      Time.parse(job[:completed_at]) - Time.parse(job[:started_at])
-    end
-
-    def self.row_to_hash(row)
-      { id: row[0], pipeline_run_id: row[1], stage: row[2], status: row[3], started_at: row[4], completed_at: row[5] }
-    end
-    private_class_method :row_to_hash
-  end
-end