fun_ci 1.2.1 → 2.0.0

data/lib/fun_ci/setup/project_config.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "shellwords"
+require_relative "settings"
+require_relative "../evidence/settings"
+require_relative "../evidence/start"
+
 module FunCi
   module Setup
     class ProjectConfig
@@ -15,28 +20,49 @@ module FunCi
       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
+        return ["No .fun-ci/ folder found in #{@project_root}"] unless folder_exists?
+
+        REQUIRED_SCRIPTS.flat_map { |script| script_errors(script) } + settings.errors
       end
 
+      # Mistakes in the `evidence` key, which `fun-ci check` reports but which
+      # never stop a pipeline: the entry with the mistake is left out instead.
+      def evidence_errors = Evidence::Settings.load(File.join(@fun_ci_dir, "config")).errors(root: @project_root)
+
+      # The presets whose markers the project has, which run when a stage fails
+      # and its output shows their tool.
+      def presets = preset_candidates.select(&:because).map { |found| found.preset.name }
+
+      # The presets without markers, which read what any project's output
+      # may hold, such as JSON logs.
+      def any_project_presets = preset_candidates.reject(&:because).map { |found| found.preset.name }
+
+      def worktree_slots = settings.worktree_slots
+
       def script_path(stage)
         File.join(@fun_ci_dir, "#{stage}.sh")
       end
+
+      # The shell command that runs a stage's script on a commit, its path
+      # quoted, since a project's path may hold spaces.
+      def stage_command(stage, sha) = "#{Shellwords.escape(script_path(stage))} #{sha}"
+
+      private
+
+      def settings = Settings.new(File.join(@fun_ci_dir, "config"))
+
+      def preset_candidates
+        evidence = Evidence::Settings.load(File.join(@fun_ci_dir, "config"))
+        Evidence::Start.candidates(Evidence::Worktree.new(@project_root), evidence, "all")
+      end
+
+      def script_errors(script)
+        path = File.join(@fun_ci_dir, script)
+        return [".fun-ci/#{script} is not found"] unless File.exist?(path)
+        return [".fun-ci/#{script} is not executable"] unless File.executable?(path)
+
+        []
+      end
     end
   end
 end

data/lib/fun_ci/setup/project_detector.rb

@@ -2,21 +2,53 @@
 
 module FunCi
   module Setup
+    # Which kind of project a directory is, from the names at its top: the
+    # first stack, in this order, any of whose markers is there. A marker is a
+    # name, a glob, or a list of them that must all be there. A language
+    # comes before the tooling that sits beside it (Node beside Python, a
+    # Makefile around Go), and a lockfile picks the package manager.
     class ProjectDetector
+      STACKS = {
+        ruby_rspec: [%w[Gemfile spec], %w[Gemfile .rspec]],
+        ruby_bundler: ["Gemfile"],
+        jvm_gradle_kotlin: %w[build.gradle.kts settings.gradle.kts],
+        jvm_gradle_groovy: %w[build.gradle settings.gradle],
+        jvm_maven: ["pom.xml"],
+        rust_cargo: ["Cargo.toml"],
+        go: ["go.mod"],
+        elixir_mix: ["mix.exs"],
+        dart: ["pubspec.yaml"],
+        swift: ["Package.swift"],
+        php_composer: ["composer.json"],
+        dotnet: %w[*.sln *.csproj *.fsproj],
+        python_uv: ["uv.lock"],
+        python_poetry: ["poetry.lock"],
+        python: %w[pyproject.toml setup.py setup.cfg requirements.txt],
+        deno: %w[deno.json deno.jsonc],
+        bun: %w[bun.lock bun.lockb bunfig.toml],
+        node_pnpm: ["pnpm-lock.yaml"],
+        node_yarn: ["yarn.lock"],
+        node_npm: ["package.json"],
+        perl: %w[cpanfile Makefile.PL Build.PL dist.ini],
+        cmake: ["CMakeLists.txt"],
+        make: %w[Makefile makefile GNUmakefile]
+      }.freeze
+
       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")
+        STACKS.find { |_, markers| markers.any? { |marker| present?(marker) } }&.first || :unknown
+      end
 
-        :unknown
+      private
+
+      def present?(marker)
+        Array(marker).all? { |part| @filenames.any? { |name| names?(part, name) } }
       end
+
+      def names?(part, name) = File.fnmatch?(part, name)
     end
   end
 end

data/lib/fun_ci/setup/settings.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module FunCi
+  module Setup
+    # .fun-ci/config: settings for this machine's runs, as YAML. Each one left
+    # out takes its default; one that is wrong is reported and the default used,
+    # as are all of them when the file isn't YAML.
+    class Settings
+      DEFAULTS = { "worktree_slots" => 2 }.freeze
+
+      def initialize(path)
+        @path = path
+      end
+
+      def worktree_slots = errors.empty? ? values.fetch("worktree_slots") : DEFAULTS.fetch("worktree_slots")
+
+      def errors
+        return [".fun-ci/config must be a mapping such as `worktree_slots: 2`"] unless raw.is_a?(Hash)
+
+        slots = values["worktree_slots"]
+        return [] if slots.is_a?(Integer) && slots.positive?
+
+        [".fun-ci/config: worktree_slots must be a whole number above 0, not #{slots.inspect}"]
+      rescue Psych::SyntaxError => e
+        [".fun-ci/config is not YAML: #{e.problem} (line #{e.line})"]
+      end
+
+      private
+
+      def raw = File.exist?(@path) ? YAML.safe_load_file(@path) || {} : {}
+      def values = DEFAULTS.merge(raw)
+    end
+  end
+end

data/lib/fun_ci/setup/setup_checker.rb

@@ -1,29 +1,35 @@
 # frozen_string_literal: true
 
 require_relative "project_config"
+require_relative "legacy_hooks"
 
 module FunCi
   module Setup
     class SetupChecker
-      def self.run(project_root:, stdout: $stdout, stderr: $stderr)
-        new(project_root: project_root, stdout: stdout).run
+      def self.run(project_root:, stdout: $stdout)
+        new(config: ProjectConfig.new(project_root), hooks: LegacyHooks.new(project_root), stdout: stdout).run
       end
 
-      def initialize(project_root:, stdout:)
-        @config = ProjectConfig.new(project_root)
+      def initialize(config:, hooks:, stdout:)
+        @config = config
+        @hooks = hooks
         @stdout = stdout
       end
 
+      # Warnings are printed but don't fail the check.
       def run
-        errors = @config.validate
+        errors = @config.validate + @config.evidence_errors
+        @stdout.puts(errors.empty? ? "All OK. The project is configured." : errors)
+        list_presets
+        @hooks.warnings.each { |warning| @stdout.puts "Warning: #{warning}" }
+        errors.empty? ? 0 : 1
+      end
+
+      private
 
-        if errors.empty?
-          @stdout.puts "All OK. The project is configured."
-          0
-        else
-          errors.each { |e| @stdout.puts e }
-          1
-        end
+      def list_presets
+        lists = { "this project" => @config.presets, "any project's output" => @config.any_project_presets }
+        lists.each { |what, names| @stdout.puts "Evidence presets for #{what}: #{names.join(", ")}" if names.any? }
       end
     end
   end

data/lib/fun_ci/setup/stage_templates/javascript.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "shell"
+
+module FunCi
+  module Setup
+    # JavaScript and TypeScript: Deno, Bun, and Node with its package managers.
+    module StageTemplates
+      JAVASCRIPT = {
+        deno: stages("deno lint", "deno check", "deno test", "deno task test:slow"),
+        bun: stages("bunx eslint .", "bun install", "bun test", "bun run test:slow"),
+        node_pnpm: stages("pnpm exec eslint .", "pnpm install", "pnpm test", "pnpm run test:slow"),
+        node_yarn: stages("yarn eslint .", "yarn install", "yarn test", "yarn run test:slow"),
+        node_npm: stages("npx eslint .", "npm install", "npm test", "npm run test:slow")
+      }.freeze
+    end
+  end
+end

data/lib/fun_ci/setup/stage_templates/managed.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "shell"
+
+module FunCi
+  module Setup
+    # Stacks that run on a virtual machine: the JVM, .NET, the BEAM and Dart's.
+    module StageTemplates
+      GRADLE = stages("./gradlew check -x test", "./gradlew assemble", "./gradlew test", "./gradlew integrationTest")
+               .freeze
+
+      MANAGED = {
+        jvm_gradle_kotlin: GRADLE,
+        jvm_gradle_groovy: GRADLE,
+        jvm_maven: stages("mvn verify -DskipTests", "mvn compile", "mvn test", "mvn verify"),
+        dotnet: stages("dotnet format --verify-no-changes", "dotnet build",
+                       'dotnet test --filter "Category!=Slow"', 'dotnet test --filter "Category=Slow"'),
+        elixir_mix: stages("mix format --check-formatted", "mix deps.get && mix compile",
+                           "mix test --exclude slow", "mix test --only slow"),
+        dart: stages("dart analyze", "dart pub get", "dart test --exclude-tags slow", "dart test --tags slow")
+      }.freeze
+    end
+  end
+end

data/lib/fun_ci/setup/stage_templates/native.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "shell"
+
+module FunCi
+  module Setup
+    # Stacks that compile to the machine: Rust, Go, Swift, and C or C++ built
+    # with CMake or make.
+    module StageTemplates
+      CTEST = "ctest --test-dir build --output-on-failure --no-tests=error"
+      CLANG_FORMAT = "git ls-files -z '*.c' '*.cc' '*.cpp' '*.h' '*.hpp' | xargs -0 clang-format --dry-run --Werror"
+
+      NATIVE = {
+        rust_cargo: stages("cargo clippy --all-targets -- -D warnings", "cargo build --all-targets",
+                           "cargo test", "cargo test -- --ignored"),
+        go: stages("go vet ./...", "go build ./...", "go test -short ./...", "go test ./..."),
+        swift: stages("swift format lint --recursive --strict .", "swift build --build-tests",
+                      "swift test --skip Slow", "swift test --filter Slow"),
+        cmake: stages(CLANG_FORMAT, "cmake -S . -B build && cmake --build build",
+                      "#{CTEST} -LE slow", "#{CTEST} -L slow"),
+        make: stages("make lint", "make", "make test", "make test-slow")
+      }.freeze
+    end
+  end
+end

data/lib/fun_ci/setup/stage_templates/scripting.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "shell"
+
+module FunCi
+  module Setup
+    # Interpreted stacks: Ruby, Python, PHP and Perl.
+    module StageTemplates
+      def self.python(runner, build)
+        stages("#{runner}ruff check .", build, "#{runner}pytest -m \"not slow\"", "#{runner}pytest -m slow")
+      end
+
+      SCRIPTING = {
+        ruby_rspec: stages("bundle exec rubocop", "bundle install --quiet",
+                           "bundle exec rspec --tag ~slow", "bundle exec rspec --tag slow"),
+        ruby_bundler: stages("bundle exec rubocop", "bundle install --quiet",
+                             "bundle exec rake test", "bundle exec rake test:slow"),
+        php_composer: stages("vendor/bin/phpcs", "composer install --no-interaction --no-progress",
+                             "vendor/bin/phpunit --exclude-group slow", "vendor/bin/phpunit --group slow"),
+        python_uv: python("uv run ", "uv sync"),
+        python_poetry: python("poetry run ", "poetry install"),
+        python: python("python3 -m ", "python3 -m compileall -q ."),
+        perl: stages("perlcritic lib", "cpanm --installdeps --notest .", "prove -lr t", "prove -lr xt")
+      }.freeze
+    end
+  end
+end

data/lib/fun_ci/setup/stage_templates/shell.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Setup
+    # What every stack's stage scripts are made of.
+    module StageTemplates
+      def self.script(body) = "#!/bin/sh\n#{body}\n"
+
+      def self.stages(lint, build, fast, slow)
+        { "lint.sh" => lint, "build.sh" => build, "fast.sh" => fast, "slow.sh" => slow }.transform_values do |body|
+          script(body)
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/setup/stage_templates.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "stage_templates/managed"
+require_relative "stage_templates/native"
+require_relative "stage_templates/scripting"
+require_relative "stage_templates/javascript"
+
+module FunCi
+  module Setup
+    # The stage scripts `fun-ci init` writes, per kind of project (AT-10.21).
+    # Test stages run the fast suite without the tests the tool's convention
+    # marks slow, and the slow suite with only those; where the tool has no
+    # such convention, the slow suite is a `test:slow` script (`test-slow`,
+    # for make).
+    module StageTemplates
+      TEMPLATES = [MANAGED, NATIVE, SCRIPTING, JAVASCRIPT].reduce(:merge).freeze
+
+      # { "lint.sh" => script, ... }; +lint_override+ replaces the lint command.
+      def self.scripts(template_id, lint_override: nil)
+        scripts = TEMPLATES.fetch(template_id)
+        lint_override ? scripts.merge("lint.sh" => script(lint_override)) : scripts
+      end
+    end
+  end
+end

data/lib/fun_ci/setup/template_writer.rb

@@ -1,52 +1,27 @@
 # frozen_string_literal: true
 
+require_relative "stage_templates"
+
 module FunCi
   module Setup
+    # Writes a project's .fun-ci/ stage scripts, executable.
     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
+        @scripts = StageTemplates.scripts(template_id, lint_override: lint_override)
         @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 { |name, content| write_script(File.join(fun_ci_dir, name), content) }
+      end
+
+      private
 
-        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
+      def write_script(path, content)
+        File.write(path, content)
+        File.chmod(0o755, path)
       end
     end
   end

data/lib/fun_ci/version.rb

@@ -2,5 +2,5 @@
 
 # Loaded on its own by the gemspec, so it must not require anything.
 module FunCi
-  VERSION = "1.2.1"
+  VERSION = "2.0.0"
 end

data/lib/fun_ci.rb

@@ -2,7 +2,6 @@
 
 require_relative "fun_ci/version"
 require_relative "fun_ci/persistence/database"
-require_relative "fun_ci/persistence/state_machine"
 require_relative "fun_ci/persistence/pipeline_run"
 require_relative "fun_ci/persistence/stage_job"
 require_relative "fun_ci/setup/project_config"