fun_ci 2.0.0-arm64-darwin

data/lib/fun_ci/evidence/extractors/section.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../findings"
+require_relative "../source"
+require_relative "../line_scan"
+require_relative "../patterns"
+require_relative "../section_walk"
+
+module FunCi
+  module Evidence
+    module Extractors
+      # `section`: the lines of the output, or of a file, from a line that
+      # matches any of `start` up to one that matches any of `end` (or the
+      # last line), each section at most `lines` long. A preset names a tool's
+      # sections, such as rspec's failures.
+      class Section
+        OPTIONS = { "start" => :patterns, "end" => :patterns, "path" => :path, "lines" => :count,
+                    "title" => :word }.freeze
+        REQUIRED = %w[start].freeze
+        LINES = 200
+
+        def initialize(options)
+          @options = options
+        end
+
+        def extract(context) = found_in(Source.for(context, @options["path"]), context.deadline)
+
+        def found_in(source, deadline)
+          walk = new_walk
+          truncated = LineScan.cut_short?(source.lines, deadline) { |line, index| walk.step(line, index) }
+          Findings.new(excerpts: walk.finish(source.lines).map { |found| excerpt(source, found, truncated) })
+        end
+
+        private
+
+        def new_walk
+          SectionWalk.new(Patterns.compile(@options["start"]), Patterns.compile(@options["end"]),
+                          @options.fetch("lines", LINES))
+        end
+
+        def excerpt(source, found, truncated)
+          { title: @options.fetch("title") { "Lines from #{Array(@options["start"]).join(" or ")}" },
+            location: source.location(found.first, found.last), lines: source.lines[found.first..found.last],
+            truncated: truncated || found.cut }
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/findings.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # What an extractor found: facts ({ name:, value: }), failures ({ test:,
+    # file:, line:, message:, output: }) and excerpts ({ title:, location:,
+    # lines:, truncated: }).
+    Findings = Data.define(:facts, :failures, :excerpts)
+
+    class Findings
+      def initialize(facts: [], failures: [], excerpts: []) = super
+    end
+  end
+end

data/lib/fun_ci/evidence/line_ranges.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # The runs of lines around chosen lines: `context` lines either side of
+    # each, within 0...size, joined where they meet.
+    module LineRanges
+      def self.around(indexes, context, size)
+        indexes.map { |index| [index - context, 0].max..[index + context, size - 1].min }
+               .each_with_object([]) { |range, joined| join(joined, range) }
+      end
+
+      def self.join(joined, range)
+        return joined << range if joined.empty? || joined.last.last + 1 < range.first
+
+        joined[-1] = joined.last.first..[joined.last.last, range.last].max
+      end
+      private_class_method :join
+    end
+  end
+end

data/lib/fun_ci/evidence/line_scan.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # Walks lines for a built-in extractor, checking the deadline every
+    # CHECK_EVERY lines, since a built-in runs in fun-ci's own process and
+    # can't be killed.
+    module LineScan
+      CHECK_EVERY = 1000
+
+      # Yields each line and its index; answers whether the deadline stopped it first.
+      def self.cut_short?(lines, deadline)
+        lines.each_with_index do |line, index|
+          return true if (index % CHECK_EVERY).zero? && deadline.passed?
+
+          yield line, index
+        end
+        false
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/log_record.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "json"
+
+module FunCi
+  module Evidence
+    # One JSON log line, read through the field names a logging setup uses
+    # (`fields`: time, level, logger, message, stack), each a key or a dotted
+    # path, and `levels`, the names of numeric levels.
+    class LogRecord
+      RANKS = %w[trace debug info warn error fatal].freeze
+      ALIASES = { "warning" => "warn", "critical" => "fatal", "err" => "error", "panic" => "fatal",
+                  "verbose" => "debug" }.freeze
+
+      # The record on a line, or nil for one that isn't a JSON object.
+      def self.parse(line, fields, levels)
+        return nil unless line.lstrip.start_with?("{")
+
+        new(JSON.parse(line), fields, levels)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def self.rank(level) = RANKS.index(ALIASES.fetch(level.to_s.downcase, level.to_s.downcase))
+
+      def initialize(parsed, fields, levels)
+        @parsed = parsed
+        @fields = fields
+        @levels = levels
+      end
+
+      def level = LogRecord.rank(@levels.fetch(field("level").to_s, field("level")))
+      def at_least?(rank) = !level.nil? && level >= rank
+
+      def lines
+        logger = field("logger")
+        head = [field("time"), RANKS[level].upcase, logger && "#{logger}:", field("message")].compact.join(" ")
+        [head, *stack.map { |line| "  #{line}" }]
+      end
+
+      private
+
+      def stack
+        trace = field("stack")
+        trace.is_a?(Array) ? trace.map(&:to_s) : trace.to_s.lines(chomp: true)
+      end
+
+      def field(name)
+        key = @fields[name]
+        return nil unless key
+
+        @parsed.key?(key) ? @parsed[key] : @parsed.dig(*key.split("."))
+      rescue TypeError
+        nil
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/masking.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # Masks secrets in text before fun-ci keeps it (architecture.md, "Evidence
+    # of a failed stage"): the values of the stage's secret-named variables,
+    # well-known token shapes, and a project's own patterns. A best effort, not
+    # a guarantee. Given the environment as a hash; never reads ENV.
+    class Masking
+      SECRET_NAME = /TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|PRIVATE_KEY|CREDENTIAL/
+      SHORTEST = 8
+      SHAPES = [
+        /-----BEGIN [A-Z ]*PRIVATE KEY-----.*?-----END [A-Z ]*PRIVATE KEY-----/m,
+        /\bgh[pousr]_[A-Za-z0-9]{36,}/,
+        /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/,
+        /\bxox[abpors]-[A-Za-z0-9-]{10,}/,
+        /Authorization: \K.+/i
+      ].freeze
+
+      # Masks nothing, for a project that turned masking off.
+      def self.none = new({}, shapes: [])
+
+      def initialize(environment, patterns: [], shapes: SHAPES)
+        @secrets = secrets(environment)
+        @patterns = shapes + patterns
+      end
+
+      # Every string in the document masked.
+      def document(document) = document.with(**document.to_h.transform_values { |items| deep(items) })
+
+      # Bytes that aren't UTF-8 become U+FFFD first, as patterns can't read them.
+      def mask(text)
+        text = text.dup.force_encoding(Encoding::UTF_8).scrub
+        masked = @secrets.reduce(text) { |current, (name, value)| current.gsub(value, "[masked:#{name}]") }
+        @patterns.reduce(masked) { |current, pattern| current.gsub(pattern, "[masked]") }
+      end
+
+      private
+
+      def deep(value)
+        return mask(value) if value.is_a?(String)
+        return value.map { |item| deep(item) } if value.is_a?(Array)
+        return value.transform_values { |item| deep(item) } if value.is_a?(Hash)
+
+        value
+      end
+
+      # Longest first, so a value that contains another is masked whole.
+      def secrets(environment)
+        environment.select { |name, value| name.match?(SECRET_NAME) && value.to_s.length >= SHORTEST }
+                   .sort_by { |_name, value| -value.length }
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/option_check.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "patterns"
+require_relative "log_record"
+
+module FunCi
+  module Evidence
+    # Checks the options of an entry for a built-in against what the built-in
+    # declares it takes (OPTIONS, each with a kind, and REQUIRED), and
+    # answers the first mistake, or nil.
+    module OptionCheck
+      KINDS = {
+        patterns: lambda { |value|
+          next "must be a list of patterns" unless Array(value).all?(String)
+
+          Array(value).lazy.filter_map { |source| Patterns.mistake(source) }.first
+        },
+        count: ->(value) { "must be a whole number, not #{value.inspect}" unless value.is_a?(Integer) && value >= 0 },
+        path: ->(value) { "must be a path, not #{value.inspect}" unless value.is_a?(String) && !value.empty? },
+        globs: ->(value) { "must be a list of paths, not #{value.inspect}" unless Array(value).all?(String) },
+        word: ->(value) { "must be a word, not #{value.inspect}" unless value.is_a?(String) },
+        level: lambda { |value|
+          "must be one of trace, debug, info, warn, error or fatal, not #{value.inspect}" unless LogRecord.rank(value)
+        },
+        fields: lambda { |value|
+          "must map time, level, logger, message and stack to field names" unless mapping_of_strings?(value)
+        },
+        levels: ->(value) { "must map each level's number to its name" unless mapping_of_strings?(value) }
+      }.freeze
+
+      def self.mapping_of_strings?(value) = value.is_a?(Hash) && value.values.all?(String)
+
+      def self.mistake(name, built_in, options)
+        unknown = options.keys.find { |key| !built_in::OPTIONS.key?(key) }
+        return "#{name} doesn't take '#{unknown}'" if unknown
+
+        missing = built_in::REQUIRED.find { |key| !options.key?(key) }
+        return "#{name} needs '#{missing}'" if missing
+
+        kinds(name, built_in, options)
+      end
+
+      def self.kinds(name, built_in, options)
+        options.each do |key, value|
+          problem = KINDS.fetch(built_in::OPTIONS.fetch(key)).call(value)
+          return "#{name}: '#{key}' #{problem}" if problem
+        end
+        nil
+      end
+      private_class_method :kinds
+    end
+  end
+end

data/lib/fun_ci/evidence/outcome.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # How a failed stage ended, known once it has: its state in the words
+    # `status --json` uses, its exit status or signal, and the other stages
+    # that shared its slot while it ran, and for an overrun, what was found
+    # before the kill (an Extraction::Result).
+    Outcome = Data.define(:state, :exit_status, :signal, :alongside, :overrun)
+
+    class Outcome
+      def initialize(**given) = super(exit_status: nil, signal: nil, alongside: [], overrun: nil, **given)
+    end
+  end
+end

data/lib/fun_ci/evidence/patterns.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # Patterns a project or a preset supplies, each compiled with a timeout of
+    # its own rather than the process-wide Regexp.timeout, since stages run in
+    # threads side by side. The timeout bounds each match.
+    module Patterns
+      TIMEOUT = 1.0
+
+      def self.compile(sources, timeout: TIMEOUT) = Array(sources).map { |source| Regexp.new(source, timeout: timeout) }
+
+      # Why a pattern doesn't compile, or nil.
+      def self.mistake(source)
+        Regexp.new(source)
+        nil
+      rescue RegexpError => e
+        "has '#{source}', which doesn't compile: #{e.message}"
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/presets/README.md

@@ -0,0 +1,7 @@
+Presets: config entries fun-ci ships for popular tools, one file each, named
+for the preset, in the shape a project would write an entry (`use:` and the
+built-in's options), with when it applies: `markers`, files any of which the
+worktree must have (a path or a glob, or `{ path:, contains: }`), and `signature`, a
+pattern only the tool prints, matched within one line. Each is pinned by the
+recorded output of a real failing run in `test/fixtures/evidence/<name>/`, and
+none ships without one (`test/policy/test_evidence_fixtures.rb`).

data/lib/fun_ci/evidence/presets/bun-test.yml

@@ -0,0 +1,6 @@
+use: section
+title: Bun's failed tests
+start: ['^\s*\d+ \| ', '^error: ', '^\(fail\) ']
+end: ['^\((pass|skip|todo)\) ', '^ \d+ pass$', '^\S+:$']
+markers: [bun.lockb, bun.lock, bunfig.toml]
+signature: '^bun test v\d'

data/lib/fun_ci/evidence/presets/cargo-test.yml

@@ -0,0 +1,6 @@
+use: section
+title: cargo test's failed tests
+start: ['^---- \S+ stdout ----$']
+end: ['^test result: ', '^failures:$', '^---- \S+ stdout ----$']
+markers: [Cargo.toml]
+signature: '^test result: FAILED\. '

data/lib/fun_ci/evidence/presets/dart-test.yml

@@ -0,0 +1,6 @@
+use: section
+title: dart test's failures
+start: ['^\d+:\d+ \+\d+( ~\d+)?( -\d+)?: .* \[E\]$']
+end: ['^\d+:\d+ \+\d+( ~\d+)?( -\d+)?: ']
+markers: [pubspec.yaml]
+signature: '^\d+:\d+ \+\d+( ~\d+)?( -\d+)?: Some tests failed\.$'

data/lib/fun_ci/evidence/presets/deno-test.yml

@@ -0,0 +1,6 @@
+use: section
+title: Deno's failing tests
+start: ['^ ERRORS $']
+end: ['^ FAILURES $']
+markers: [deno.json, deno.jsonc]
+signature: 'running \d+ tests? from \./'

data/lib/fun_ci/evidence/presets/dotnet-test.yml

@@ -0,0 +1,6 @@
+use: section
+title: dotnet test's failed tests
+start: ['^\s+Failed \S.* \[[^\]]+\]$']
+end: ['^(Failed|Passed)!\s+- Failed:', '^Total tests: ']
+markers: ['*.sln', '*.csproj', '*.fsproj']
+signature: '^Failed!\s+- Failed:\s+\d+, Passed:\s+\d+'

data/lib/fun_ci/evidence/presets/ecs.yml

@@ -0,0 +1,3 @@
+use: json-log
+fields: { time: '@timestamp', level: log.level, logger: log.logger, message: message, stack: error.stack_trace }
+signature: '"log\.level": ?"'

data/lib/fun_ci/evidence/presets/eslint.yml

@@ -0,0 +1,6 @@
+use: section
+title: ESLint's problems, file by file
+start: ['^/\S+$']
+end: ['^\S+ \d+ problems? \(\d+ errors?, \d+ warnings?\)']
+markers: [eslint.config.js, eslint.config.mjs, .eslintrc.json, .eslintrc.js]
+signature: '\d+ problems? \(\d+ errors?, \d+ warnings?\)'

data/lib/fun_ci/evidence/presets/exunit.yml

@@ -0,0 +1,6 @@
+use: section
+title: ExUnit's failures
+start: ['^\s+\d+\) (test|doctest|property) .* \(\S+\)$', '^\s+\d+\) \S+: failure on setup_all callback']
+end: ['^Finished in [\d.]+ seconds \(']
+markers: [mix.exs]
+signature: '^Running ExUnit with seed: \d+'

data/lib/fun_ci/evidence/presets/gcc.yml

@@ -0,0 +1,6 @@
+use: section
+title: gcc's errors, file by file
+start: ['^(In file included from )?\S+\.(c|cc|cp|cpp|cxx|c\+\+|h|hh|hpp|hxx):']
+end: ['^g?make(\[\d+\])?: ', '^(cc|c\+\+|gcc|g\+\+|clang|clang\+\+) ']
+markers: [Makefile, makefile, GNUmakefile, CMakeLists.txt]
+signature: '^\S+\.(c|cc|cp|cpp|cxx|c\+\+|h|hh|hpp|hxx):\d+:\d+: (fatal )?error: '

data/lib/fun_ci/evidence/presets/go-build.yml

@@ -0,0 +1,5 @@
+use: grep
+title: go build's and go vet's errors
+patterns: ['^(vet: )?\S+\.go:\d+:\d+: ']
+markers: [go.mod]
+signature: '^(vet: )?\S+\.go:\d+:\d+: '

data/lib/fun_ci/evidence/presets/go-test.yml

@@ -0,0 +1,6 @@
+use: section
+title: go test's failed tests
+start: ['^\s*--- FAIL: ']
+end: ['^(FAIL|ok)\s']
+markers: [go.mod]
+signature: '^\s*--- FAIL: \S+ \(\d+\.\d+s\)$'

data/lib/fun_ci/evidence/presets/gradle.yml

@@ -0,0 +1,6 @@
+use: section
+title: Gradle's failed tests, and what went wrong
+start: [' FAILED$', '^\* What went wrong:']
+end: ['^\d+ tests? completed', '^\* Try:']
+markers: [build.gradle, build.gradle.kts, settings.gradle, settings.gradle.kts, gradlew]
+signature: '^BUILD FAILED in '

data/lib/fun_ci/evidence/presets/gtest.yml

@@ -0,0 +1,6 @@
+use: section
+title: GoogleTest's failures
+start: [': Failure$']
+end: ['^\[-{10}\] ', '^\[ RUN      \] ']
+markers: [{ path: CMakeLists.txt, contains: 'gtest' }]
+signature: '^\[  FAILED  \] '

data/lib/fun_ci/evidence/presets/jest.yml

@@ -0,0 +1,6 @@
+use: section
+title: Jest's failed tests
+start: ['^\s+● ']
+end: ['^Test Suites: ', '^(FAIL|PASS) ', '^\s+● ']
+markers: [{ path: package.json, contains: '"jest"' }, jest.config.js, jest.config.ts, jest.config.mjs, jest.config.cjs]
+signature: '^Test Suites: \d+ '

data/lib/fun_ci/evidence/presets/logstash.yml

@@ -0,0 +1,3 @@
+use: json-log
+fields: { time: '@timestamp', level: level, logger: logger_name, message: message, stack: stack_trace }
+signature: '"logger_name":'

data/lib/fun_ci/evidence/presets/maven.yml

@@ -0,0 +1,6 @@
+use: section
+title: Maven's failed tests
+start: ['<<< (FAILURE|ERROR)!', '^\[ERROR\] (Failures|Errors): $']
+end: ['^\[INFO\] ?$', '^\[INFO\] Results:']
+markers: [pom.xml, mvnw]
+signature: '^\[INFO\] BUILD FAILURE'

data/lib/fun_ci/evidence/presets/minitest.yml

@@ -0,0 +1,6 @@
+use: section
+title: Minitest's failures and errors
+start: ['^\s+\d+\) (Failure|Error):$']
+end: ['^\d+ runs, \d+ assertions']
+markers: [Gemfile, Rakefile]
+signature: '^\d+ runs, \d+ assertions, \d+ failures, \d+ errors'

data/lib/fun_ci/evidence/presets/mocha.yml

@@ -0,0 +1,6 @@
+use: section
+title: Mocha's failing tests
+start: ['^  \d+\) ']
+end: ['^  \d+\) ']
+markers: [{ path: package.json, contains: '"mocha"' }, .mocharc.yml, .mocharc.yaml, .mocharc.json, .mocharc.js, .mocharc.cjs]
+signature: '^  \d+ passing \(\d+\w+\)$'

data/lib/fun_ci/evidence/presets/mypy.yml

@@ -0,0 +1,6 @@
+use: section
+title: mypy's type errors
+start: ['^\S+\.pyi?:\d+(:\d+)?: (error|note): ']
+end: ['^Found \d+ errors? in \d+ files? \(checked ']
+markers: [{ path: pyproject.toml, contains: mypy }, mypy.ini, .mypy.ini, { path: setup.cfg, contains: mypy }]
+signature: '^Found \d+ errors? in \d+ files? \(checked \d+ source files?\)$'

data/lib/fun_ci/evidence/presets/node-test.yml

@@ -0,0 +1,6 @@
+use: section
+title: Node's failed tests
+start: ['^\s*not ok \d+ - ']
+end: ['^\s*\.\.\.$']
+markers: [{ path: package.json, contains: 'node --test' }]
+signature: '^\s+failureType: '''

data/lib/fun_ci/evidence/presets/phpunit.yml

@@ -0,0 +1,6 @@
+use: section
+title: PHPUnit's errors and failures
+start: ['^There (was|were) \d+ (errors?|failures?):$']
+end: ['^(ERRORS|FAILURES)!$', '^Tests: \d+, Assertions: \d+']
+markers: [phpunit.xml, phpunit.xml.dist, { path: composer.json, contains: phpunit }]
+signature: '^Tests: \d+, Assertions: \d+, '

data/lib/fun_ci/evidence/presets/pino.yml

@@ -0,0 +1,5 @@
+use: json-log
+fields: { time: time, level: level, logger: name, message: msg, stack: err.stack }
+levels: { '10': trace, '20': debug, '30': info, '40': warn, '50': error, '60': fatal }
+markers: [{ path: package.json, contains: '"pino"' }]
+signature: '"level":\d+,"time":\d+,"pid":\d+,"hostname":'

data/lib/fun_ci/evidence/presets/prove.yml

@@ -0,0 +1,6 @@
+use: section
+title: prove's failed tests
+start: ['^#\s+Failed test\b', '^Test Summary Report$']
+end: ['^\S+\.t \.+ ', '^Files=\d+, Tests=\d+, ']
+markers: [cpanfile, Makefile.PL, Build.PL, dist.ini]
+signature: '^Files=\d+, Tests=\d+, '

data/lib/fun_ci/evidence/presets/pytest.yml

@@ -0,0 +1,6 @@
+use: section
+title: pytest's failures and errors
+start: ['^=+ (FAILURES|ERRORS) =+$']
+end: ['^=+ (short test summary info|warnings summary) =+$', '^=+ .* in [\d.]+s( \([\d:]+\))? =+$']
+markers: [pyproject.toml, pytest.ini, setup.cfg, tox.ini, conftest.py]
+signature: '^=+ (FAILURES|ERRORS|short test summary info) =+$'

data/lib/fun_ci/evidence/presets/rspec.yml

@@ -0,0 +1,6 @@
+use: section
+title: rspec's failures
+start: ['^Failures:$']
+end: ['^Finished in ']
+markers: [Gemfile, .rspec]
+signature: '^rspec \./'

data/lib/fun_ci/evidence/presets/rubocop.yml

@@ -0,0 +1,6 @@
+use: section
+title: RuboCop's offenses
+start: ['^Offenses:$']
+end: ['^\d+ files? inspected, ']
+markers: [.rubocop.yml, { path: Gemfile, contains: rubocop }]
+signature: '^\d+ files? inspected, (\d+|no) offenses? detected'

data/lib/fun_ci/evidence/presets/ruff.yml

@@ -0,0 +1,6 @@
+use: section
+title: ruff's lint errors
+start: ['^[A-Z]+[0-9]+ ', '^\S+:\d+:\d+: [A-Z]+[0-9]+ ']
+end: ['^Found \d+ errors?']
+markers: [{ path: pyproject.toml, contains: ruff }, ruff.toml, .ruff.toml, { path: .pre-commit-config.yaml, contains: ruff }]
+signature: '^Found \d+ errors?( \(\d+ fixed, \d+ remaining\))?\.$'

data/lib/fun_ci/evidence/presets/rustc.yml

@@ -0,0 +1,6 @@
+use: section
+title: rustc's errors
+start: ['^error(\[E\d+\])?: (?!could not compile |aborting due to |test failed)']
+end: ['^$']
+markers: [Cargo.toml]
+signature: '^error\[E\d{4}\]: '

data/lib/fun_ci/evidence/presets/shellcheck.yml

@@ -0,0 +1,5 @@
+use: section
+title: ShellCheck's findings
+start: ['^In .+ line \d+:$', '^Did you mean:$']
+end: ['^$']
+signature: '\^-*\^? SC\d{4} \((error|warning|info|style)\): '

data/lib/fun_ci/evidence/presets/structlog.yml

@@ -0,0 +1,4 @@
+use: json-log
+fields: { time: timestamp, level: level, logger: logger, message: event, stack: exception }
+markers: [{ path: pyproject.toml, contains: structlog }, { path: requirements.txt, contains: structlog }, { path: setup.cfg, contains: structlog }, { path: setup.py, contains: structlog }]
+signature: '"event": ?".*"level": ?"(debug|info|warning|error|critical)"'

data/lib/fun_ci/evidence/presets/swift-test.yml

@@ -0,0 +1,5 @@
+use: grep
+title: XCTest's failures
+patterns: ['^.+:\d+: error: (-\[.+\]|\S+) : ']
+markers: [Package.swift]
+signature: '^Test Suite ''.+'' failed at '

data/lib/fun_ci/evidence/presets/tsc.yml

@@ -0,0 +1,6 @@
+use: section
+title: TypeScript's type errors
+start: ['\(\d+,\d+\): error TS\d+: ']
+end: ['^Found \d+ errors?']
+markers: [tsconfig.json]
+signature: '\(\d+,\d+\): error TS\d+: '

data/lib/fun_ci/evidence/presets/unittest.yml

@@ -0,0 +1,6 @@
+use: section
+title: unittest's failures and errors
+start: ['^={70}$']
+end: ['^Ran \d+ tests? in ']
+markers: [pyproject.toml, setup.py, setup.cfg, requirements.txt]
+signature: '^Ran \d+ tests? in \d+\.\d+s$'

data/lib/fun_ci/evidence/presets/vitest.yml

@@ -0,0 +1,6 @@
+use: section
+title: Vitest's failed tests
+start: ['^ FAIL  ']
+end: ['⎯\[\d+/\d+\]⎯', '^\s+Test Files  ']
+markers: [{ path: package.json, contains: '"vitest"' }, vitest.config.ts, vitest.config.js, vitest.config.mts, vitest.config.mjs]
+signature: '^\s+Test Files  \d+ '

data/lib/fun_ci/evidence/presets.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module FunCi
+  module Evidence
+    # The presets in presets/, one YAML file each (see its README): each a
+    # built-in (`use`) and its options.
+    module Presets
+      DIR = File.join(__dir__, "presets")
+
+      # markers: files any of which the worktree must have, each a path or
+      # { path, contains }; signature: a pattern only the tool prints. Either
+      # may be missing (architecture.md, "Evidence of a failed stage").
+      Preset = Data.define(:name, :use, :options, :markers, :signature)
+      OWN = %w[use markers signature].freeze
+
+      def self.all
+        @all ||= Dir.glob("*.yml", base: DIR).sort.map do |file|
+          raw = YAML.safe_load_file(File.join(DIR, file))
+          Preset.new(name: File.basename(file, ".yml"), use: raw.fetch("use"), options: raw.except(*OWN),
+                     markers: raw.fetch("markers", []), signature: raw["signature"])
+        end
+      end
+
+      def self.fetch(name) = all.find { |preset| preset.name == name } || raise(KeyError, "no preset '#{name}'")
+      def self.find(use, name) = all.find { |preset| preset.use == use && preset.name == name }
+    end
+  end
+end

data/lib/fun_ci/evidence/problem.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # What went wrong running an extractor, said as the problem the evidence
+    # records against its entry.
+    class Problem < StandardError; end
+  end
+end