fun_ci 1.0.0 → 1.2.0

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,81 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ansi"
-
-module FunCi
-  class Screen
-    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
-  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_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

data/lib/fun_ci/stage_runner.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-require "timeout"
-
-module FunCi
-  class StageRunner
-    def initialize(commit_hash:, stdout:, command_runner: nil, time_budgets: {}, recorder: NullRecorder.new)
-      @commit_hash = commit_hash
-      @stdout = stdout
-      @command_runner = command_runner
-      @time_budgets = time_budgets
-      @recorder = recorder
-    end
-
-    def run_stage(config, stage)
-      script = config.script_path(stage)
-      budget = @time_budgets[stage]
-
-      job_id = @recorder.start_stage(stage)
-      output, status, timed_out = run_with_timeout(script, budget)
-
-      if timed_out
-        @recorder.end_stage(job_id, "timed_out")
-        @stdout.puts "#{stage_label(stage)} killed -- exceeded #{budget}s time budget."
-        @stdout.puts budget_advice(stage)
-        return false
-      end
-
-      unless status.success?
-        @recorder.end_stage(job_id, "failed")
-        @stdout.puts output unless output.empty?
-        @stdout.puts "#{stage_label(stage)} failed."
-        return false
-      end
-
-      @recorder.end_stage(job_id, "completed")
-      true
-    end
-
-    private
-
-    def run_with_timeout(script, budget)
-      cmd = "#{script} #{@commit_hash}"
-
-      if @command_runner
-        begin
-          Timeout.timeout(budget) do
-            output, status = @command_runner.call(cmd)
-            [output, status, false]
-          end
-        rescue Timeout::Error
-          ["", nil, true]
-        end
-      else
-        run_process_with_timeout(cmd, budget)
-      end
-    end
-
-    def run_process_with_timeout(cmd, budget)
-      pid = nil
-      output = ""
-      r, w = IO.pipe
-      pid = Process.spawn(cmd, out: w, err: w)
-      w.close
-
-      begin
-        Timeout.timeout(budget) do
-          output = r.read
-          _, status = Process.waitpid2(pid)
-          pid = nil
-          [output, status, false]
-        end
-      rescue Timeout::Error
-        Process.kill("TERM", pid) rescue nil
-        Process.kill("KILL", pid) rescue nil
-        Process.waitpid(pid) rescue nil
-        r.close rescue nil
-        ["", nil, true]
-      ensure
-        r.close rescue nil
-      end
-    end
-
-    def stage_label(stage)
-      case stage
-      when "lint" then "Lint"
-      when "build" then "Build"
-      when "fast" then "Fast suite"
-      when "slow" then "Slow suite"
-      else stage
-      end
-    end
-
-    def budget_advice(stage)
-      case stage
-      when "lint"
-        "Trim your linter config or split into stages."
-      when "build"
-        "Keep your build efficient and not let it become a bottleneck."
-      when "fast"
-        "Your fast tests have gotten too slow. Split or speed them up."
-      when "slow"
-        "Pare down integration tests, parallelise, or raise the budget."
-      end
-    end
-  end
-end

data/lib/fun_ci/stale_pipeline_canceller.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "pipeline_run"
-
-module FunCi
-  class StalePipelineCanceller
-    def initialize(db:, branch:, stdout:, process_killer: nil)
-      @db = db
-      @branch = branch
-      @stdout = stdout
-      @process_killer = process_killer || method(:default_process_killer)
-    end
-
-    def cancel(new_commit_hash:)
-      run = PipelineRun.find_running_with_pid(@db, @branch)
-      return unless run
-
-      kill_process(run[:pid])
-      PipelineRun.update_status(@db, run[:id], "cancelled")
-      @stdout.puts "Cancelled stale pipeline for #{run[:commit_hash]}. Starting fresh for #{new_commit_hash}."
-    end
-
-    def store_pid(run_id, pid)
-      PipelineRun.store_pid(@db, run_id, pid)
-    end
-
-    private
-
-    def kill_process(pid)
-      @process_killer.call(0, pid)
-      safe_signal("TERM", pid)
-      safe_signal("KILL", pid)
-      begin
-        Process.waitpid(pid)
-      rescue Errno::ECHILD, Errno::ESRCH # rubocop:disable Lint/SuppressedException
-      end
-    rescue Errno::ESRCH
-      # Process already dead
-    end
-
-    def safe_signal(signal, pid)
-      @process_killer.call(signal, pid)
-    rescue Errno::ESRCH
-      # Already dead
-    end
-
-    def default_process_killer(signal, pid)
-      Process.kill(signal, pid)
-    end
-  end
-end

data/lib/fun_ci/streak_counter.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  module StreakCounter
-    PASS_STATUS = "completed"
-    ACTIVE_STATUSES = %w[running scheduled].freeze
-
-    # Counts consecutive passed runs from the most recent terminal run.
-    # Skips running/scheduled pipelines.
-    # Returns nil if no terminal runs exist, 0 if streak is broken.
-    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

data/lib/fun_ci/template_writer.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module FunCi
-  class TemplateWriter
-    TEMPLATES = {
-      ruby_bundler: {
-        "lint.sh" => "#!/bin/sh\nbundle exec rubocop\n",
-        "build.sh" => "#!/bin/sh\nbundle install --quiet\n",
-        "fast.sh" => "#!/bin/sh\nbundle exec rake test\n",
-        "slow.sh" => "#!/bin/sh\nbundle exec rake test:slow\n"
-      },
-      jvm_gradle_kotlin: {
-        "lint.sh" => "#!/bin/sh\n./gradlew check -x test\n",
-        "build.sh" => "#!/bin/sh\n./gradlew assemble\n",
-        "fast.sh" => "#!/bin/sh\n./gradlew test\n",
-        "slow.sh" => "#!/bin/sh\n./gradlew integrationTest\n"
-      },
-      jvm_gradle_groovy: {
-        "lint.sh" => "#!/bin/sh\n./gradlew check -x test\n",
-        "build.sh" => "#!/bin/sh\n./gradlew assemble\n",
-        "fast.sh" => "#!/bin/sh\n./gradlew test\n",
-        "slow.sh" => "#!/bin/sh\n./gradlew integrationTest\n"
-      },
-      jvm_maven: {
-        "lint.sh" => "#!/bin/sh\nmvn verify -DskipTests\n",
-        "build.sh" => "#!/bin/sh\nmvn compile\n",
-        "fast.sh" => "#!/bin/sh\nmvn test\n",
-        "slow.sh" => "#!/bin/sh\nmvn verify\n"
-      }
-    }.freeze
-
-    def initialize(template_id, target_dir, lint_override: nil)
-      @template_id = template_id
-      @target_dir = target_dir
-      @lint_override = lint_override
-    end
-
-    def write
-      scripts = TEMPLATES.fetch(@template_id)
-      fun_ci_dir = File.join(@target_dir, ".fun-ci")
-      Dir.mkdir(fun_ci_dir)
-
-      scripts.each do |name, content|
-        content = "#!/bin/sh\n#{@lint_override}\n" if name == "lint.sh" && @lint_override
-        path = File.join(fun_ci_dir, name)
-        File.write(path, content)
-        File.chmod(0o755, path)
-      end
-    end
-  end
-end