fun_ci 1.1.0 → 1.2.0

data/lib/fun_ci/pipeline/stale_pipeline_canceller.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../persistence/pipeline_run"
+
+module FunCi
+  module Pipeline
+    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 = Persistence::PipelineRun.find_running_with_pid(@db, @branch)
+        return unless run
+
+        kill_process(run[:pid])
+        Persistence::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)
+        Persistence::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
+end

data/lib/fun_ci/pipeline/trigger.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "../setup/project_config"
+require_relative "../persistence/pipeline_recorder"
+require_relative "background_wrapper"
+require_relative "stage_runner"
+require_relative "stale_pipeline_canceller"
+require_relative "progress_reporter"
+require_relative "pipeline_forker"
+require_relative "process_runner"
+
+module FunCi
+  module Pipeline
+    class Trigger
+      include ProcessRunner
+      NULL_SHA = ("0" * 40).freeze
+      DEFAULT_BUDGETS = { "lint" => 30, "build" => 30, "fast" => 10, "slow" => 300 }.freeze
+
+      def self.run_from_args(args, stdout: $stdout, stderr: $stderr, recorder: Persistence::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: Persistence::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 = Setup::ProjectConfig.new(@project_root)
+        return handle_config_errors(config) if config.validate.any?
+        unless @commit_hash == NULL_SHA || @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")
+        budget = @time_budgets["slow"]
+        executor = if @command_runner
+          runner = @command_runner
+          -> do
+            output, status = runner.call(cmd)
+            [output, status, false]
+          rescue Timeout::Error
+            ["", nil, true]
+          end
+        else
+          -> { run_process_with_timeout(cmd, budget) }
+        end
+        @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 = Persistence::DbRecorder.for_background(db_path, pipeline_run_id)
+          BackgroundWrapper.new(recorder: recorder, job_id: job_id, executor: executor).run
+          recorder.close
+        end
+        @recorder = Persistence::DbRecorder.for_background(db_path, pipeline_run_id)
+        Process.detach(pid)
+        Persistence::PipelineRun.store_pid(@recorder.db, pipeline_run_id, pid)
+      end
+
+      def default_commit_validator(hash)
+        Open3.capture2e("git", "cat-file", "-t", hash).last.success?
+      end
+    end
+  end
+end

data/lib/fun_ci/setup/hook_writer.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module FunCi
+  module Setup
+    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
+end

data/lib/fun_ci/setup/installer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "project_detector"
+require_relative "template_writer"
+require_relative "maven_linter_detector"
+
+module FunCi
+  module Setup
+    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
+end

data/lib/fun_ci/setup/maven_linter_detector.rb

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

data/lib/fun_ci/setup/project_config.rb

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

data/lib/fun_ci/setup/project_detector.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Setup
+    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_kotlin if @filenames.include?("settings.gradle.kts")
+        return :jvm_gradle_groovy if @filenames.include?("build.gradle")
+        return :jvm_gradle_groovy if @filenames.include?("settings.gradle")
+        return :jvm_maven if @filenames.include?("pom.xml")
+
+        :unknown
+      end
+    end
+  end
+end

data/lib/fun_ci/setup/setup_checker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "project_config"
+
+module FunCi
+  module Setup
+    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
+end

data/lib/fun_ci/setup/template_writer.rb

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

data/lib/fun_ci/tui/admin_tui.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "board_data"
+require_relative "board_renderer"
+require_relative "key_handler"
+require_relative "screen"
+require_relative "spinner"
+require_relative "terminal_input"
+require "io/console"
+
+module FunCi
+  module Tui
+    class AdminTui
+      FAST_REFRESH = 0.1
+      SLOW_REFRESH = 5.0
+
+      def initialize(db:, output: $stdout, input: $stdin, width: 80,
+                     width_provider: nil, height_provider: nil,
+                     page_size: nil, animation_renderer: nil)
+        @board_data = BoardData.new(db, page_size: page_size)
+        @terminal_input = TerminalInput.new(input: input, width_provider: width_provider)
+        @key_handler = KeyHandler.new(board_data: @board_data)
+        @renderer = BoardRenderer.new(
+          screen: Screen.new(output: output, width: width),
+          spinner: Spinner.new,
+          animation_renderer: animation_renderer,
+          height_provider: height_provider
+        )
+      end
+
+      def render_once
+        update_width_from_provider
+        @renderer.render(
+          runs: @board_data.runs,
+          streak: @board_data.streak,
+          cursor_index: @key_handler.cursor_index,
+          confirming: @key_handler.confirming?
+        )
+      end
+
+      def run
+        @renderer.clear
+
+        begin
+          @terminal_input.setup_raw_mode
+          @terminal_input.setup_signal_trap
+          loop do
+            @renderer.begin_frame
+            render_once
+            key = @terminal_input.read_key_with_timeout(refresh_interval)
+            break if key && @key_handler.handle_key(key) == :quit
+          end
+        ensure
+          @terminal_input.restore_terminal
+        end
+      end
+
+      def resize(new_width)
+        @renderer.resize(new_width)
+      end
+
+      def confirming?
+        @key_handler.confirming?
+      end
+
+      def confirmation_run
+        @key_handler.confirmation_run
+      end
+
+      def handle_key(key)
+        @key_handler.handle_key(key)
+      end
+
+      private
+
+      def refresh_interval
+        return FAST_REFRESH if @renderer.animation_renderer?
+
+        runs = @board_data.runs
+        any_running = runs.any? { |r| r[:status] == "running" }
+        any_running ? FAST_REFRESH : SLOW_REFRESH
+      end
+
+      def update_width_from_provider
+        new_width = @terminal_input.check_width
+        @renderer.resize(new_width) if new_width
+      end
+    end
+  end
+end

data/lib/fun_ci/tui/animation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Tui
+    class Animation
+      TYPES = {
+        failure: { total_frames: 40, priority: 3 },
+        timeout: { total_frames: 4, priority: 2 },
+        success: { total_frames: 40, priority: 1 },
+        stage_pass: { total_frames: 3, priority: 0 }
+      }.freeze
+
+      attr_reader :type, :run_id, :stage, :frame
+
+      def initialize(type:, run_id:, stage: nil)
+        raise ArgumentError, "Unknown animation type: #{type}" unless TYPES.key?(type)
+
+        @type = type
+        @run_id = run_id
+        @stage = stage
+        @frame = 0
+      end
+
+      def advance!
+        @frame += 1
+      end
+
+      def finished?
+        frame >= total_frames
+      end
+
+      def total_frames
+        TYPES[@type][:total_frames]
+      end
+
+      def priority
+        TYPES[@type][:priority]
+      end
+
+      def has_header?
+        %i[failure timeout success].include?(@type)
+      end
+
+      def has_footer?
+        %i[failure success].include?(@type)
+      end
+    end
+  end
+end