rigortype 0.1.17 → 0.1.19

data/lib/rigor/cli/ci_detector.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Rigor
+  class CLI
+    # Runtime CI-environment detection (ADR-51 WD7), modelled on
+    # `OndraM/ci-detector` (the library PHPStan uses). Reads the well-known
+    # environment variables a CI provider sets and returns the matching
+    # {Platform}, classifying it into a **tier** that decides how
+    # `rigor check` surfaces diagnostics there:
+    #
+    #   :native_stdout   — Rigor has a native format that renders purely from
+    #                      stdout, so it is auto-emitted on top of the human
+    #                      output (GitHub Actions → `github`, TeamCity →
+    #                      `teamcity`). These are the first-class platforms.
+    #   :native_artifact — Rigor has a native format but it needs a CI-wired
+    #                      report artifact, not stdout (GitLab CI → `gitlab`).
+    #                      First-class, but Rigor only *hints* the format.
+    #   :reviewdog       — no native Rigor format; second-class, routed through
+    #                      reviewdog (`checkstyle`/`sarif`) or `junit`. Hint
+    #                      only.
+    #
+    # Detection is a pure function of the environment hash, so it is fully
+    # testable; the CLI passes `ENV`. `RIGOR_CI_DETECT=0` (or `false`/`no`)
+    # disables it globally — the seam the spec suite uses for determinism.
+    module CiDetector
+      Platform = Struct.new(:id, :name, :format, :tier, keyword_init: true) do
+        def native_stdout? = tier == :native_stdout
+        def native_artifact? = tier == :native_artifact
+        def reviewdog? = tier == :reviewdog
+      end
+
+      # The detection table, ordered most-specific first so the generic
+      # `CI=true` catch-all is last (a provider that also sets `CI` is still
+      # recognised by its own variable). `match` is `:truthy` (value in
+      # 1/true/yes/on), `:present` (variable set non-empty), or `:equals`.
+      PROVIDERS = [
+        { id: "github-actions", name: "GitHub Actions", format: "github", tier: :native_stdout,
+          var: "GITHUB_ACTIONS", match: :truthy },
+        { id: "gitlab", name: "GitLab CI", format: "gitlab", tier: :native_artifact,
+          var: "GITLAB_CI", match: :truthy },
+        { id: "teamcity", name: "TeamCity", format: "teamcity", tier: :native_stdout,
+          var: "TEAMCITY_VERSION", match: :present },
+        { id: "circleci", name: "CircleCI", format: nil, tier: :reviewdog,
+          var: "CIRCLECI", match: :truthy },
+        { id: "jenkins", name: "Jenkins", format: nil, tier: :reviewdog,
+          var: "JENKINS_URL", match: :present },
+        { id: "travis", name: "Travis CI", format: nil, tier: :reviewdog,
+          var: "TRAVIS", match: :truthy },
+        { id: "appveyor", name: "AppVeyor", format: nil, tier: :reviewdog,
+          var: "APPVEYOR", match: :truthy },
+        { id: "azure-pipelines", name: "Azure Pipelines", format: nil, tier: :reviewdog,
+          var: "TF_BUILD", match: :present },
+        { id: "bitbucket", name: "Bitbucket Pipelines", format: nil, tier: :reviewdog,
+          var: "BITBUCKET_BUILD_NUMBER", match: :present },
+        { id: "buildkite", name: "Buildkite", format: nil, tier: :reviewdog,
+          var: "BUILDKITE", match: :truthy },
+        { id: "drone", name: "Drone CI", format: nil, tier: :reviewdog,
+          var: "DRONE", match: :truthy },
+        { id: "semaphore", name: "Semaphore", format: nil, tier: :reviewdog,
+          var: "SEMAPHORE", match: :truthy },
+        { id: "codeship", name: "Codeship", format: nil, tier: :reviewdog,
+          var: "CI_NAME", match: :equals, value: "codeship" },
+        { id: "ci", name: "CI", format: nil, tier: :reviewdog,
+          var: "CI", match: :truthy }
+      ].freeze
+
+      module_function
+
+      # Returns the detected {Platform}, or nil when no CI is recognised or
+      # detection is disabled via `RIGOR_CI_DETECT`.
+      def detect(env = ENV)
+        return nil if disabled?(env)
+
+        row = PROVIDERS.find { |provider| matches?(env, provider) }
+        return nil if row.nil?
+
+        Platform.new(id: row[:id], name: row[:name], format: row[:format], tier: row[:tier])
+      end
+
+      def disabled?(env)
+        %w[0 false no off].include?(env["RIGOR_CI_DETECT"].to_s.strip.downcase)
+      end
+
+      def matches?(env, provider)
+        value = env[provider[:var]].to_s.strip
+        case provider[:match]
+        when :truthy then %w[1 true yes on].include?(value.downcase)
+        when :present then !value.empty?
+        when :equals then value.downcase == provider[:value]
+        end
+      end
+    end
+  end
+end

data/lib/rigor/cli/diagnostic_formats.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+require_relative "../version"
+
+module Rigor
+  class CLI
+    # CI-native diagnostic output formats (ADR-51). Each renders an
+    # `Analysis::Result` to a string a CI platform consumes to surface
+    # diagnostics inline in a pull / merge request, rather than only in the
+    # job log. They read the same `Diagnostic` fields as `--format json`
+    # (path / line / column / severity / qualified rule / message) and add
+    # no new information — only a platform-native rendering of it.
+    #
+    #   sarif      — SARIF 2.1.0 (cross-platform; GitHub code-scanning, any
+    #                other SARIF tool, and reviewdog `-f=sarif`)
+    #   github     — GitHub Actions workflow commands (`::error file=…,line=…::`)
+    #                that the runner turns into inline PR annotations
+    #   gitlab     — GitLab Code Quality report JSON (the CodeClimate subset)
+    #                that drives the merge-request Code Quality widget
+    #   checkstyle — Checkstyle XML, the broad lint-interchange format that
+    #                reviewdog (`-f=checkstyle`) and Jenkins/etc. consume
+    #   junit      — JUnit XML, the test-report format many CI systems render
+    #
+    # Severity maps once per format from Rigor's `:error` / `:warning` /
+    # `:info`; the qualified rule (`<source_family>.<rule>` or the bare rule
+    # for the builtin family) is the stable identifier, nil only for the
+    # ruleless producers (parse / internal errors), which each format
+    # degrades gracefully.
+    module DiagnosticFormats
+      FORMATS = %w[sarif github gitlab checkstyle junit teamcity].freeze
+
+      module_function
+
+      def supports?(format)
+        FORMATS.include?(format)
+      end
+
+      # Renders `result` in the named CI format. Callers gate on
+      # {.supports?} first; an unrecognised format returns nil.
+      def render(result, format)
+        case format
+        when "sarif" then Sarif.new(result).render
+        when "github" then GithubActions.new(result).render
+        when "gitlab" then GitlabCodeQuality.new(result).render
+        when "checkstyle" then Checkstyle.new(result).render
+        when "junit" then Junit.new(result).render
+        when "teamcity" then Teamcity.new(result).render
+        end
+      end
+
+      # XML attribute / text escaping shared by the Checkstyle and JUnit
+      # formatters. Covers the five predefined XML entities so a diagnostic
+      # message carrying `<`, `&`, or a quote can't break the document.
+      module XmlEscaping
+        ENTITIES = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;",
+                     '"' => "&quot;", "'" => "&apos;" }.freeze
+
+        def xml_escape(value)
+          value.to_s.gsub(/[&<>"']/, ENTITIES)
+        end
+      end
+
+      # SARIF 2.1.0 — the OASIS static-analysis interchange format. GitHub's
+      # `codeql-action/upload-sarif` ingests it to render findings on the PR
+      # diff and in the Security tab; it is the cross-platform anchor format.
+      class Sarif
+        SCHEMA = "https://json.schemastore.org/sarif-2.1.0.json"
+        INFORMATION_URI = "https://github.com/rigortype/rigor"
+
+        # SARIF defines exactly three result levels; Rigor's `:info` is a
+        # `note` (the SARIF spelling for advisory findings).
+        LEVELS = { error: "error", warning: "warning", info: "note" }.freeze
+
+        def initialize(result)
+          @result = result
+        end
+
+        def render
+          JSON.pretty_generate(document)
+        end
+
+        private
+
+        def document
+          { "version" => "2.1.0", "$schema" => SCHEMA, "runs" => [run] }
+        end
+
+        def run
+          {
+            "tool" => { "driver" => driver },
+            "results" => @result.diagnostics.map { |diagnostic| result_for(diagnostic) }
+          }
+        end
+
+        def driver
+          {
+            "name" => "Rigor",
+            "informationUri" => INFORMATION_URI,
+            "version" => Rigor::VERSION,
+            "rules" => rules
+          }
+        end
+
+        # The distinct rule ids seen in this run, declared so consumers can
+        # cross-reference each result's `ruleId`. Id-only is a valid minimal
+        # SARIF rule object; richer per-rule metadata is a later enrichment.
+        def rules
+          @result.diagnostics.filter_map(&:qualified_rule).uniq.map { |id| { "id" => id } }
+        end
+
+        def result_for(diagnostic)
+          entry = {
+            "level" => LEVELS.fetch(diagnostic.severity, "warning"),
+            "message" => { "text" => diagnostic.message },
+            "locations" => [location_for(diagnostic)]
+          }
+          rule_id = diagnostic.qualified_rule
+          entry["ruleId"] = rule_id if rule_id
+          entry
+        end
+
+        # Rigor lines / columns are already 1-based, matching SARIF's
+        # 1-based `startLine` / `startColumn`. Paths are project-relative;
+        # SARIF URIs use forward slashes on every platform.
+        def location_for(diagnostic)
+          {
+            "physicalLocation" => {
+              "artifactLocation" => { "uri" => diagnostic.path.to_s.tr("\\", "/") },
+              "region" => { "startLine" => diagnostic.line, "startColumn" => diagnostic.column }
+            }
+          }
+        end
+      end
+
+      # GitHub Actions workflow commands — `::<level> file=…,line=…,col=…,
+      # title=…::<message>` lines the runner parses out of stdout and turns
+      # into inline PR annotations, with no separate upload step.
+      class GithubActions
+        # GitHub's annotation levels; Rigor's `:info` is a `notice`.
+        LEVELS = { error: "error", warning: "warning", info: "notice" }.freeze
+
+        def initialize(result)
+          @result = result
+        end
+
+        def render
+          @result.diagnostics.map { |diagnostic| line_for(diagnostic) }.join("\n")
+        end
+
+        private
+
+        def line_for(diagnostic)
+          level = LEVELS.fetch(diagnostic.severity, "warning")
+          props = ["file=#{escape_property(diagnostic.path)}",
+                   "line=#{diagnostic.line}", "col=#{diagnostic.column}"]
+          rule_id = diagnostic.qualified_rule
+          props << "title=#{escape_property(rule_id)}" if rule_id
+          "::#{level} #{props.join(',')}::#{escape_data(diagnostic.message)}"
+        end
+
+        # GitHub's documented workflow-command escaping: `%` and the CR / LF
+        # that would otherwise terminate the command line, for message data.
+        def escape_data(value)
+          value.to_s.gsub("%", "%25").gsub("\r", "%0D").gsub("\n", "%0A")
+        end
+
+        # Property values additionally escape the `,` (property separator)
+        # and `:` (command terminator) so a path or rule id can carry them.
+        def escape_property(value)
+          escape_data(value).gsub(",", "%2C").gsub(":", "%3A")
+        end
+      end
+
+      # GitLab Code Quality report — the CodeClimate-subset JSON array GitLab
+      # reads from a `codequality` CI artifact to populate the merge-request
+      # Code Quality widget.
+      class GitlabCodeQuality
+        # GitLab's severity vocabulary (a CodeClimate subset). Rigor maps
+        # error → major, warning → minor, info → info; `critical` / `blocker`
+        # are left for a louder future tier.
+        SEVERITIES = { error: "major", warning: "minor", info: "info" }.freeze
+
+        def initialize(result)
+          @result = result
+        end
+
+        def render
+          JSON.pretty_generate(@result.diagnostics.map { |diagnostic| entry_for(diagnostic) })
+        end
+
+        private
+
+        def entry_for(diagnostic)
+          {
+            "description" => description(diagnostic),
+            "check_name" => diagnostic.qualified_rule || "rigor",
+            "fingerprint" => fingerprint(diagnostic),
+            "severity" => SEVERITIES.fetch(diagnostic.severity, "minor"),
+            "location" => {
+              "path" => diagnostic.path.to_s,
+              "lines" => { "begin" => diagnostic.line }
+            }
+          }
+        end
+
+        # The rule id is folded into the description (the widget shows it)
+        # because Code Quality has no dedicated rule field.
+        def description(diagnostic)
+          rule_id = diagnostic.qualified_rule
+          rule_id ? "#{diagnostic.message} [#{rule_id}]" : diagnostic.message
+        end
+
+        # GitLab dedups findings by fingerprint and tracks them across runs
+        # by it, so it must be stable for an unchanged finding and unique per
+        # finding. Hashing the locating tuple (path, rule, line, column,
+        # message) satisfies both — order-independent, no run-volatile input.
+        def fingerprint(diagnostic)
+          payload = [diagnostic.path, diagnostic.qualified_rule, diagnostic.line,
+                     diagnostic.column, diagnostic.message].join("")
+          Digest::SHA256.hexdigest(payload)
+        end
+      end
+
+      # Checkstyle XML — the lint-interchange format a wide range of tools
+      # read, most usefully reviewdog (`-f=checkstyle`), which then posts to
+      # any of its reporters (GitHub PR review, GitLab MR, Gerrit, …). Errors
+      # are grouped by file; the qualified rule rides in `source` (the rule
+      # code reviewdog surfaces). Checkstyle's native severities are
+      # `error` / `warning` / `info`, so Rigor's map through unchanged.
+      class Checkstyle
+        include XmlEscaping
+
+        def initialize(result)
+          @result = result
+        end
+
+        def render
+          lines = ['<?xml version="1.0" encoding="UTF-8"?>', "<checkstyle>"]
+          @result.diagnostics.group_by(&:path).each do |path, diagnostics|
+            lines << %(  <file name="#{xml_escape(path)}">)
+            diagnostics.each { |diagnostic| lines << error_element(diagnostic) }
+            lines << "  </file>"
+          end
+          lines << "</checkstyle>"
+          lines.join("\n")
+        end
+
+        private
+
+        def error_element(diagnostic)
+          attrs = %(line="#{diagnostic.line}" column="#{diagnostic.column}" ) +
+                  %(severity="#{diagnostic.severity}" message="#{xml_escape(diagnostic.message)}")
+          rule_id = diagnostic.qualified_rule
+          attrs += %( source="#{xml_escape(rule_id)}") if rule_id
+          "    <error #{attrs} />"
+        end
+      end
+
+      # JUnit XML — the test-report format GitHub's test reporting, GitLab,
+      # Jenkins, and CircleCI render. Following the established linter
+      # convention (rubocop / eslint / PHPStan): every diagnostic is a
+      # `testcase` carrying a `failure` typed by its severity, so all of them
+      # are visible in the report. The exit code (errors only) remains the
+      # gate; this view is for surfacing, not gating.
+      class Junit
+        include XmlEscaping
+
+        def initialize(result)
+          @result = result
+        end
+
+        def render
+          diagnostics = @result.diagnostics
+          # JUnit wants at least one test; a clean run reports one passing case.
+          tests = diagnostics.empty? ? 1 : diagnostics.size
+          lines = ['<?xml version="1.0" encoding="UTF-8"?>',
+                   %(<testsuite name="rigor" tests="#{tests}" failures="#{diagnostics.size}">)]
+          if diagnostics.empty?
+            lines << '  <testcase name="rigor" />'
+          else
+            diagnostics.each { |diagnostic| lines.concat(testcase(diagnostic)) }
+          end
+          lines << "</testsuite>"
+          lines.join("\n")
+        end
+
+        private
+
+        def testcase(diagnostic)
+          name = "#{diagnostic.path}:#{diagnostic.line}:#{diagnostic.column}"
+          classname = diagnostic.qualified_rule || "rigor"
+          [
+            %(  <testcase name="#{xml_escape(name)}" classname="#{xml_escape(classname)}">),
+            %(    <failure type="#{diagnostic.severity}" message="#{xml_escape(diagnostic.message)}" />),
+            "  </testcase>"
+          ]
+        end
+      end
+
+      # TeamCity inspection service messages — the `##teamcity[…]` lines a
+      # TeamCity build agent parses out of the build log into its Inspections
+      # view. The one stdout-native format (besides `github`) that
+      # CI-detection auto-emits. One `inspectionType` declares the category;
+      # each diagnostic is an `inspection` typed by severity.
+      class Teamcity
+        SEVERITIES = { error: "ERROR", warning: "WARNING", info: "INFO" }.freeze
+
+        def initialize(result)
+          @result = result
+        end
+
+        def render
+          return "" if @result.diagnostics.empty?
+
+          lines = [message("inspectionType", id: "rigor", name: "rigor",
+                                             category: "rigor", description: "Rigor inspection")]
+          @result.diagnostics.each { |diagnostic| lines << inspection(diagnostic) }
+          lines.join("\n")
+        end
+
+        private
+
+        def inspection(diagnostic)
+          rule_id = diagnostic.qualified_rule
+          text = rule_id ? "#{diagnostic.message} [#{rule_id}]" : diagnostic.message
+          message("inspection", typeId: "rigor", message: text, file: diagnostic.path,
+                                line: diagnostic.line, SEVERITY: SEVERITIES.fetch(diagnostic.severity, "WARNING"))
+        end
+
+        def message(name, attrs)
+          pairs = attrs.map { |key, value| "#{key}='#{escape(value)}'" }.join(" ")
+          "##teamcity[#{name} #{pairs}]"
+        end
+
+        # TeamCity's documented service-message escaping.
+        def escape(value)
+          value.to_s.gsub("|", "||").gsub("'", "|'").gsub("\n", "|n")
+               .gsub("\r", "|r").gsub("[", "|[").gsub("]", "|]")
+        end
+      end
+    end
+  end
+end

data/lib/rigor/cli/plugins_command.rb

@@ -30,7 +30,7 @@ module Rigor
     # - every manifest-declared extension surface
     #   (`open_receivers:` / `owns_receivers:` / `produces:` /
     #   `consumes:` / `block_as_methods:` / `heredoc_templates:` /
-    #   `trait_registries:` / `external_files:` /
+    #   `trait_registries:` /
     #   `type_node_resolvers:` / `hkt_registrations:` /
     #   `hkt_definitions:` / `protocol_contracts:` /
     #   `source_rbs_synthesizer:`);
@@ -233,7 +233,6 @@ module Rigor
           block_as_methods: manifest.block_as_methods.size,
           heredoc_templates: manifest.heredoc_templates.size,
           trait_registries: manifest.trait_registries.size,
-          external_files: manifest.external_files.size,
           type_node_resolvers: manifest.type_node_resolvers.size,
           hkt_registrations: manifest.hkt_registrations.size,
           hkt_definitions: manifest.hkt_definitions.size,
@@ -257,7 +256,6 @@ module Rigor
           block_as_methods: 0,
           heredoc_templates: 0,
           trait_registries: 0,
-          external_files: 0,
           type_node_resolvers: 0,
           hkt_registrations: 0,
           hkt_definitions: 0,
@@ -337,7 +335,7 @@ module Rigor
             signature_paths: [],
             open_receivers: [], owns_receivers: [], produces: [], consumes: [],
             block_as_methods: 0, heredoc_templates: 0, trait_registries: 0,
-            external_files: 0, type_node_resolvers: 0,
+            type_node_resolvers: 0,
             hkt_registrations: 0, hkt_definitions: 0,
             protocol_contracts: 0, source_rbs_synthesizer: false,
             node_rule_types: [], dynamic_return_receivers: [], type_specifier_methods: [],

data/lib/rigor/cli/plugins_renderer.rb

@@ -209,7 +209,6 @@ module Rigor
         parts << "block_as_methods=#{row[:block_as_methods]}" if row[:block_as_methods].positive?
         parts << "heredoc_templates=#{row[:heredoc_templates]}" if row[:heredoc_templates].positive?
         parts << "trait_registries=#{row[:trait_registries]}" if row[:trait_registries].positive?
-        parts << "external_files=#{row[:external_files]}" if row[:external_files].positive?
         return [] if parts.empty?
 
         ["        macro substrate: #{parts.join(', ')}"]
@@ -233,7 +232,6 @@ module Rigor
           "block_as_methods" => row[:block_as_methods],
           "heredoc_templates" => row[:heredoc_templates],
           "trait_registries" => row[:trait_registries],
-          "external_files" => row[:external_files],
           "type_node_resolvers" => row[:type_node_resolvers],
           "hkt_registrations" => row[:hkt_registrations],
           "hkt_definitions" => row[:hkt_definitions],

data/lib/rigor/cli/prism_colorizer.rb

@@ -41,12 +41,19 @@ module Rigor
       # @return [String] the source with ANSI colour escapes, or
       #   the input unchanged when lexing surfaces an error.
       def colorize(source)
+        # Sources read under a POSIX locale arrive tagged US-ASCII even
+        # when they carry UTF-8 bytes; retag so the token regexes below
+        # do not raise on multibyte comments.
+        source = source.dup.force_encoding(Encoding::UTF_8) unless source.encoding == Encoding::UTF_8
         result = Prism.lex(source)
         return source unless result.errors.empty?
 
         render(source, result.value)
       end
 
+      # Prism token offsets are BYTE offsets — slice with byteslice, or
+      # any multibyte character earlier in the source shifts every
+      # subsequent token boundary.
       def render(source, lexed)
         out = +""
         offset = 0
@@ -54,15 +61,15 @@ module Rigor
         lexed.each do |entry|
           token = entry.first
           location = token.location
-          out << source[offset...location.start_offset]
+          out << (source.byteslice(offset, [location.start_offset - offset, 0].max) || "")
           break if token.type == :EOF
 
-          text = source[location.start_offset...location.end_offset]
+          text = source.byteslice(location.start_offset, location.end_offset - location.start_offset) || ""
           out << paint(text, effective_category(token.type, previous_type))
           offset = location.end_offset
           previous_type = token.type
         end
-        out << (source[offset..] || "")
+        out << (source.byteslice(offset, source.bytesize - offset) || "")
         out
       end
 

data/lib/rigor/cli/show_bleedingedge_command.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "json"
+require "optionparser"
+
+require_relative "../bleeding_edge"
+require_relative "../configuration"
+require_relative "command"
+
+module Rigor
+  class CLI
+    # Executes `rigor show-bleedingedge` (ADR-50 § WD2).
+    #
+    # Prints the bleeding-edge overlay — the Rigor-maintained set of the
+    # next major's queued changes ({Rigor::BleedingEdge}) — as an
+    # explicit list, and reports which of them the project's
+    # `bleeding_edge:` configuration adopts. The overlay is empty in this
+    # release, so the command currently reports an empty set; it becomes
+    # the inspection surface ADR-50 describes once a feature is queued.
+    #
+    # Read-only: it loads `.rigor.yml` to resolve the active selection
+    # but runs no analysis.
+    class ShowBleedingedgeCommand < Command
+      USAGE = "Usage: rigor show-bleedingedge [options]"
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        configuration = load_configuration(options)
+        return CLI::EXIT_USAGE if configuration.nil?
+
+        case options.fetch(:format)
+        when "json" then render_json(configuration)
+        else render_text(configuration)
+        end
+        0
+      end
+
+      private
+
+      def parse_options
+        options = { format: "text", config: nil }
+        OptionParser.new do |opt|
+          opt.banner = USAGE
+          opt.on("--format=FORMAT", %w[text json], "Output format (text | json). Default: text.") do |fmt|
+            options[:format] = fmt
+          end
+          opt.on("--config=PATH", "Path to a .rigor.yml (default: auto-discovery).") do |path|
+            options[:config] = path
+          end
+        end.parse!(@argv)
+        options
+      end
+
+      def load_configuration(options)
+        Configuration.load(options.fetch(:config))
+      rescue StandardError => e
+        @err.puts("show-bleedingedge: could not load configuration: #{e.message}")
+        nil
+      end
+
+      def render_json(configuration)
+        selector = configuration.bleeding_edge
+        @out.puts(JSON.pretty_generate(
+                    "overlay" => BleedingEdge.features.map(&:to_h),
+                    "selector" => configuration.to_h.fetch("bleeding_edge"),
+                    "active" => BleedingEdge.active_features(selector).map(&:id),
+                    "unknown_selected" => BleedingEdge.unknown_selected_ids(selector)
+                  ))
+      end
+
+      def render_text(configuration)
+        @out.puts("Bleeding-edge overlay (ADR-50 § WD2)")
+        @out.puts("")
+        if BleedingEdge.features.empty?
+          render_empty_overlay
+        else
+          render_overlay
+        end
+        @out.puts("")
+        render_selection(configuration)
+      end
+
+      def render_empty_overlay
+        @out.puts("The overlay is empty in this release — no features are queued for")
+        @out.puts("the next major. The `bleeding_edge:` mechanism is wired and ready;")
+        @out.puts("there is simply nothing to adopt yet.")
+      end
+
+      def render_overlay
+        @out.puts("#{BleedingEdge.features.length} feature(s) queued for the next major:")
+        @out.puts("")
+        BleedingEdge.features.each do |feature|
+          @out.puts("  #{feature.id}")
+          @out.puts("    #{feature.summary}")
+          feature.severity_overrides.each do |rule, severity|
+            @out.puts("    severity: #{rule} → :#{severity}")
+          end
+        end
+      end
+
+      def render_selection(configuration)
+        selector = configuration.bleeding_edge
+        active = BleedingEdge.active_features(selector).map(&:id)
+        @out.puts("Your configuration adopts: #{active.empty? ? '(none)' : active.join(', ')}")
+
+        unknown = BleedingEdge.unknown_selected_ids(selector)
+        return if unknown.empty?
+
+        @out.puts("Selected but not in this overlay (ignored): #{unknown.join(', ')}")
+      end
+    end
+  end
+end