fun_ci 1.0.0 → 1.2.0

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

data/lib/fun_ci/tui/animation_compositor.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+require_relative "animation_frames"
+require_relative "row_formatter"
+require_relative "duration_formatter"
+
+module FunCi
+  module Tui
+    module AnimationCompositor
+      RESET = Ansi::RESET
+      STAGE_STAGGER = { "lint" => 0, "build" => 2, "fast" => 4, "slow" => 6 }.freeze
+
+      def self.header_overlay(animation, width)
+        frames = case animation.type
+                 when :failure then AnimationFrames.failure_header(width)
+                 when :success then AnimationFrames.success_header(width)
+                 when :timeout then AnimationFrames.timeout_header(width)
+                 else return nil
+                 end
+        frame_at(frames, animation.frame)
+      end
+
+      def self.footer_overlay(animation, width)
+        frames = case animation.type
+                 when :failure
+                   AnimationFrames.failure_footer(animation.stage || "stage", width)
+                 when :success then AnimationFrames.success_footer(width)
+                 else return nil
+                 end
+        frame_at(frames, animation.frame)
+      end
+
+      def self.stage_column_overlay(animation, stage_text, col)
+        case animation.type
+        when :stage_pass  then color_flash(animation, stage_text, AnimationFrames.stage_pass_colors)
+        when :timeout     then color_flash(animation, stage_text, AnimationFrames.timeout_colors)
+        when :failure     then failure_flanks(animation, stage_text)
+        when :success     then sparkle_sweep(animation, stage_text)
+        end
+      end
+
+      def self.stage_text_for(run, stage_name)
+        stage = run[:stages]&.find { |s| s[:stage] == stage_name }
+        return nil unless stage
+
+        name = RowFormatter::STAGE_NAMES[stage[:stage]] || stage[:stage]
+        dur = stage[:duration] ? DurationFormatter.format(stage[:duration]) : "--"
+        case stage[:status]
+        when "completed" then "#{name} #{dur}"
+        when "failed"    then "#{name} FAIL #{dur}"
+        when "timed_out" then "#{name} TIMEOUT #{dur}"
+        else "#{name} --"
+        end
+      end
+
+      def self.stage_col_for(run, stage_name)
+        project = run[:project_path] ? "  #{File.basename(run[:project_path])}" : ""
+        prefix_len = 2 + 7 + 2 + run[:branch].to_s.length + project.length + 2
+        (run[:stages] || []).each do |s|
+          return prefix_len + 1 if s[:stage] == stage_name
+          prefix_len += stage_text_for(run, s[:stage]).to_s.length + 2
+        end
+        nil
+      end
+
+      def self.color_flash(animation, stage_text, colors)
+        idx = [animation.frame, colors.length - 1].min
+        "#{colors[idx]}#{Ansi.strip(stage_text)}#{RESET}"
+      end
+      private_class_method :color_flash
+
+      def self.failure_flanks(animation, stage_text)
+        particles = AnimationFrames.failure_particles
+        return nil if animation.frame >= particles.length
+
+        p = particles[animation.frame]
+        plain = Ansi.strip(stage_text)
+        return plain if p[:chars].empty?
+
+        left = p[:chars].reverse
+        right = p[:chars]
+        "#{p[:color]}#{left}#{RESET} #{Ansi.bold_red(plain)} #{p[:color]}#{right}#{RESET}"
+      end
+      private_class_method :failure_flanks
+
+      def self.sparkle_sweep(animation, stage_text)
+        plain = Ansi.strip(stage_text)
+        stagger = STAGE_STAGGER[animation.stage] || 0
+        pos = animation.frame - stagger
+        return nil if pos < 0 || pos > plain.length
+
+        result = plain.chars.map { |c| "\e[32m#{c}" }
+        result[pos] = "\e[1;33m#{plain[pos]}" if pos < plain.length
+        "#{result.join}#{RESET}"
+      end
+      private_class_method :sparkle_sweep
+
+      def self.frame_at(frames, index)
+        return nil if index >= frames.length
+
+        frames[index]
+      end
+      private_class_method :frame_at
+    end
+  end
+end

data/lib/fun_ci/tui/animation_frames.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "ansi"
+
+module FunCi
+  module Tui
+    module AnimationFrames
+      RESET = Ansi::RESET
+      FOOTER_HOLD = 8
+
+      def self.failure_particles
+        [
+          { chars: "*",     color: "\e[1;31m" },
+          { chars: ".*",    color: "\e[1;31m" },
+          { chars: ".+*.",  color: "\e[38;5;208m" },
+          { chars: "*.+'",  color: "\e[38;5;208m" },
+          { chars: "' .",   color: "\e[38;5;52m" },
+          { chars: ".",     color: "\e[38;5;52m" },
+          { chars: "",      color: "" }
+        ]
+      end
+
+      def self.failure_header(width)
+        boom = "BOOM"
+        [
+          nil,
+          banner(boom, width, "\e[48;5;124m", particles: "* "),
+          banner(boom, width, "\e[48;5;166m", particles: "* * "),
+          banner(boom, width, "\e[48;5;52m",  particles: ". * * "),
+          banner(boom, width, "\e[48;5;236m", particles: "' . * "),
+          banner(boom, width, "\e[48;5;236m", particles: ". "),
+          nil
+        ]
+      end
+
+      def self.failure_footer(stage_name, width)
+        up = stage_name.upcase
+        down = stage_name.downcase
+        hold [
+          nil,
+          center("\e[1;31m>>> #{up} FAILED <<<#{RESET}", ">>> #{up} FAILED <<<", width),
+          center("\e[31m>> #{down} failed <<#{RESET}", ">> #{down} failed <<", width),
+          center("\e[2;31m> #{down} failed <#{RESET}", "> #{down} failed <", width),
+          nil
+        ]
+      end
+
+      def self.success_header(width)
+        text = "ALL PASSED"
+        [
+          nil,
+          banner(text, width, "\e[48;5;22m",  particles: ""),
+          banner(text, width, "\e[48;5;22m",  particles: "*  * "),
+          banner(text, width, "\e[48;5;22m",  particles: "* .  . "),
+          banner(text, width, "\e[48;5;58m",  particles: ". '  ' "),
+          banner(text, width, "\e[48;5;22m",  particles: "' "),
+          banner(text, width, "\e[48;5;22m",  particles: ""),
+          nil
+        ]
+      end
+
+      def self.success_footer(width)
+        hold [
+          nil,
+          center("\e[1;32m* * * NICE! * * *#{RESET}", "* * * NICE! * * *", width),
+          center("\e[32m. + . * NICE! * . + .#{RESET}", ". + . * NICE! * . + .", width),
+          center("\e[2;32m' . + .  nice  . + . '#{RESET}", "' . + .  nice  . + . '", width),
+          nil
+        ]
+      end
+
+      def self.timeout_header(width)
+        [
+          nil,
+          banner("TIMED OUT", width, "\e[48;5;58m", particles: ""),
+          banner("timed out", width, "\e[48;5;58m", particles: ""),
+          nil
+        ]
+      end
+
+      def self.stage_pass_colors
+        ["\e[1;33m", "\e[1;32m", "\e[32m"]
+      end
+
+      def self.timeout_colors
+        ["\e[1;33m", "\e[33m", "\e[1;33m", "\e[33m"]
+      end
+
+      def self.banner(text, width, bg_code, particles: "")
+        padded = if particles.empty?
+                   text.center(width)
+                 else
+                   inner = "#{particles} #{text} #{particles.reverse}"
+                   inner.center(width)
+                 end
+        "#{bg_code}\e[1;37m#{padded}#{RESET}"
+      end
+      private_class_method :banner
+
+      def self.hold(frames)
+        frames.flat_map { |f| Array.new(FOOTER_HOLD, f) }
+      end
+      private_class_method :hold
+
+      def self.center(colored_text, plain_text, width)
+        pad = [(width - plain_text.length) / 2, 0].max
+        "#{" " * pad}#{colored_text}"
+      end
+      private_class_method :center
+    end
+  end
+end