fun_ci 1.0.0

data/lib/fun_ci/setup_checker.rb

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,22 @@
+# 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

@@ -0,0 +1,44 @@
+# 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

@@ -0,0 +1,108 @@
+# 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

@@ -0,0 +1,51 @@
+# 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/state_machine.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module FunCi
+  # Enforced state machine for pipeline runs and stage jobs.
+  #
+  # States: scheduled, running, completed, failed, timed_out, cancelled
+  #
+  # Valid transitions:
+  #   scheduled -> running
+  #   scheduled -> cancelled
+  #   running   -> completed
+  #   running   -> failed
+  #   running   -> timed_out
+  #   running   -> cancelled
+  class StateMachine
+    class InvalidTransition < StandardError; end
+
+    STATES = %i[scheduled running completed failed timed_out cancelled].freeze
+
+    TRANSITIONS = {
+      scheduled: %i[running cancelled],
+      running: %i[completed failed timed_out cancelled],
+      completed: [],
+      failed: [],
+      timed_out: [],
+      cancelled: []
+    }.freeze
+
+    TERMINAL_STATES = %i[completed failed timed_out cancelled].freeze
+
+    attr_reader :current_state
+
+    def initialize(initial_state)
+      validate_state!(initial_state)
+      @current_state = initial_state
+    end
+
+    def transition_to!(new_state)
+      validate_state!(new_state)
+      unless TRANSITIONS.fetch(@current_state).include?(new_state)
+        raise InvalidTransition,
+          "Cannot transition from #{@current_state} to #{new_state}"
+      end
+      @current_state = new_state
+    end
+
+    def terminal?
+      TERMINAL_STATES.include?(@current_state)
+    end
+
+    private
+
+    def validate_state!(state)
+      return if STATES.include?(state)
+
+      raise ArgumentError, "Unknown state: #{state}. Valid states: #{STATES.join(", ")}"
+    end
+  end
+end

data/lib/fun_ci/streak_counter.rb

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,51 @@
+# 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

data/lib/fun_ci/trigger.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+require_relative "project_config"
+require_relative "pipeline_recorder"
+require_relative "background_wrapper"
+require_relative "stage_runner"
+require_relative "stale_pipeline_canceller"
+require_relative "progress_reporter"
+require_relative "pipeline_forker"
+
+module FunCi
+  class Trigger
+    DEFAULT_BUDGETS = {
+      "lint" => 30,
+      "build" => 30,
+      "fast" => 10,
+      "slow" => 300
+    }.freeze
+
+    def self.run_from_args(args, stdout: $stdout, stderr: $stderr, recorder: NullRecorder.new, pipeline_forker: nil)
+      positional = args.reject { |a| a.start_with?("--") }
+      if positional.length < 2
+        stderr.puts "fun-ci: commit hash and branch name are required."
+        stderr.puts "Usage: fun-ci trigger <commit-hash> <branch>"
+        return 1
+      end
+      commit_hash, branch = positional
+      if args.include?("--no-validate")
+        db_path = recorder.db_path
+        recorder.close
+        (pipeline_forker || PipelineForker.method(:fork_pipeline)).call(
+          commit_hash: commit_hash, branch: branch, db_path: db_path
+        )
+        return 0
+      end
+      new(project_root: Dir.pwd, commit_hash: commit_hash, branch: branch,
+          stdout: stdout, stderr: stderr, recorder: recorder).run
+    end
+
+    attr_writer :command_runner
+
+    def initialize(project_root:, commit_hash:, branch:, stdout: $stdout, stderr: $stderr, command_runner: nil, time_budgets: {}, commit_validator: nil, recorder: NullRecorder.new, background_launcher: nil)
+      @project_root = project_root
+      @commit_hash = commit_hash
+      @branch = branch
+      @stdout = stdout
+      @stderr = stderr
+      @command_runner = command_runner
+      @time_budgets = DEFAULT_BUDGETS.merge(time_budgets)
+      @commit_validator = commit_validator || method(:default_commit_validator)
+      @recorder = recorder
+      @background_launcher = background_launcher || method(:default_background_launcher)
+    end
+
+    def run
+      config = ProjectConfig.new(@project_root)
+      return handle_config_errors(config) if config.validate.any?
+      unless @commit_validator.call(@commit_hash)
+        @stderr.puts "fun-ci: commit #{@commit_hash} not found in this repository."
+        return 1
+      end
+      cancel_stale_pipelines
+      @recorder.create_run(commit_hash: @commit_hash, branch: @branch, project_path: @project_root)
+      stage_runner = make_stage_runner
+      progress = ProgressReporter.new(stdout: @stdout)
+      results = run_phase_one(stage_runner, config)
+      progress.phase_one_result(results)
+      unless results.values.all?
+        @recorder.fail_run
+        return 1
+      end
+      spawn_slow_suite(config)
+      progress.slow_launched
+      fast_runner = make_stage_runner
+      fast_passed = fast_runner.run_stage(config, "fast")
+      progress.fast_result(fast_passed)
+      unless fast_passed
+        @recorder.fail_run
+        return 1
+      end
+      0
+    end
+
+    private
+
+    def handle_config_errors(config)
+      config.validate.each { |e| @stdout.puts "fun-ci: #{e}" }
+      unless config.folder_exists?
+        @stdout.puts "Create .fun-ci/lint.sh, build.sh, fast.sh, and slow.sh to set up this project."
+        @stdout.puts "Commit will proceed without CI."
+      end
+      0
+    end
+
+    def run_phase_one(stage_runner, config)
+      results = {}
+      threads = %w[lint build].map do |stage|
+        Thread.new { results[stage] = stage_runner.run_stage(config, stage) }
+      end
+      threads.each(&:join)
+      results
+    end
+
+    def spawn_slow_suite(config)
+      cmd = "#{config.script_path("slow")} #{@commit_hash}"
+      job_id = @recorder.start_stage("slow")
+      runner = @command_runner || ->(c) { Open3.capture2e(c) }
+      budget = @time_budgets["slow"]
+      executor = -> { Timeout.timeout(budget) { runner.call(cmd) } }
+      @background_launcher.call(
+        db_path: @recorder.db_path, pipeline_run_id: @recorder.pipeline_run_id,
+        job_id: job_id, executor: executor
+      )
+    end
+
+    def make_stage_runner
+      StageRunner.new(
+        commit_hash: @commit_hash, stdout: @stdout,
+        command_runner: @command_runner,
+        time_budgets: @time_budgets, recorder: @recorder
+      )
+    end
+
+    def cancel_stale_pipelines
+      return unless @recorder.db
+      StalePipelineCanceller.new(
+        db: @recorder.db, branch: @branch, stdout: @stdout
+      ).cancel(new_commit_hash: @commit_hash)
+    end
+
+    def default_background_launcher(db_path:, pipeline_run_id:, job_id:, executor:)
+      @recorder.close
+      pid = fork do
+        recorder = DbRecorder.for_background(db_path, pipeline_run_id)
+        BackgroundWrapper.new(recorder: recorder, job_id: job_id, executor: executor).run
+        recorder.close
+      end
+      @recorder = DbRecorder.for_background(db_path, pipeline_run_id)
+      Process.detach(pid)
+      PipelineRun.store_pid(@recorder.db, pipeline_run_id, pid)
+    end
+
+    def default_commit_validator(commit_hash)
+      _, status = Open3.capture2e("git", "cat-file", "-t", commit_hash)
+      status.success?
+    end
+  end
+end

data/lib/fun_ci.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "fun_ci/database"
+require_relative "fun_ci/state_machine"
+require_relative "fun_ci/pipeline_run"
+require_relative "fun_ci/stage_job"
+require_relative "fun_ci/project_config"
+
+module FunCi
+  VERSION = "1.0.0"
+
+  BUILD_TIMEOUT = 30
+  FAST_SUITE_TIMEOUT = 10
+  SLOW_SUITE_TIMEOUT = 300
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: fun_ci
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Erik Thyge Madsen
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Opinionated local CI that checks your code before it leaves your machine.
+  Runs a four-stage pipeline (lint, build, fast tests, slow tests) on every commit
+  with strict time budgets. Hooks into git pre-commit and pre-push, stores results
+  in SQLite, and includes a TUI dashboard for monitoring.
+executables:
+- fun-ci
+- fun-ci-trigger
+- fun-ci-tui
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/fun-ci
+- exe/fun-ci-trigger
+- exe/fun-ci-tui
+- lib/fun_ci.rb
+- lib/fun_ci/admin_tui.rb
+- lib/fun_ci/ansi.rb
+- lib/fun_ci/background_wrapper.rb
+- lib/fun_ci/board_data.rb
+- lib/fun_ci/cli.rb
+- lib/fun_ci/database.rb
+- lib/fun_ci/duration_formatter.rb
+- lib/fun_ci/hook_writer.rb
+- lib/fun_ci/installer.rb
+- lib/fun_ci/maven_linter_detector.rb
+- lib/fun_ci/pipeline_forker.rb
+- lib/fun_ci/pipeline_recorder.rb
+- lib/fun_ci/pipeline_run.rb
+- lib/fun_ci/progress_reporter.rb
+- lib/fun_ci/project_config.rb
+- lib/fun_ci/project_detector.rb
+- lib/fun_ci/relative_time.rb
+- lib/fun_ci/row_formatter.rb
+- lib/fun_ci/screen.rb
+- lib/fun_ci/setup_checker.rb
+- lib/fun_ci/spinner.rb
+- lib/fun_ci/stage_job.rb
+- lib/fun_ci/stage_runner.rb
+- lib/fun_ci/stale_pipeline_canceller.rb
+- lib/fun_ci/state_machine.rb
+- lib/fun_ci/streak_counter.rb
+- lib/fun_ci/template_writer.rb
+- lib/fun_ci/trigger.rb
+homepage: https://github.com/beatmadsen/fun-ci
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/beatmadsen/fun-ci
+  changelog_uri: https://github.com/beatmadsen/fun-ci/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Opinionated local CI that checks your code before it leaves your machine
+test_files: []