Module: Rigor::BleedingEdge

Defined in:
lib/rigor/bleeding_edge.rb

Overview

ADR-50 § WD2 — the bleeding-edge overlay.

A Rigor-maintained set of the next major's queued changes — severity-map promotions and new-discipline rule enablements — that a user can adopt early, before they become default-on at a major (ADR-50 § WD7). It is orthogonal to severity_profile: (how loud today's rules are) and is versioned with the gem, NOT a user-supplied file: the inspectable counterpart to PHPStan's bleedingEdge include.

The overlay is empty today — no discipline has yet been queued for the next major. This module is the WD2 foundation (the v0.1.19 slice): the surface (bleeding_edge: config, the rigor show-bleedingedge command, the severity-composition hook in Configuration::SeverityProfile.resolve) exists and is wired end-to-end, so the first real feature lands as a single FEATURES entry with no engine plumbing.

Each feature carries a stable feature id — part of the ADR-50 WD1 contract vocabulary: the config, the show command, and the eventual CHANGELOG migration note all name the same id, and a feature graduates to default-on at a major by being removed from FEATURES.

Defined Under Namespace

Classes: Feature

Constant Summary collapse

FEATURES =

The overlay. Empty until the first next-major discipline is queued; add a Feature here (with a stable id) when one is.

[].freeze

Class Method Summary collapse

Class Method Details

.active_features(selector) ⇒ Array<Feature>

Resolves a normalized bleeding_edge: selector (see Configuration#bleeding_edge) to the active Feature list. Unknown ids in a list / except selector are simply absent from the overlay and contribute nothing — symmetric with how severity_overrides: keeps an unknown rule id inert until it lands (robust across gem versions).

Parameters:

  • selector (Hash) —

    { "mode" => "none" }, { "mode" => "all" }, { "mode" => "all", "except" => [ids] }, or { "mode" => "list", "ids" => [ids] }.

Returns:



75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/rigor/bleeding_edge.rb', line 75

def active_features(selector)
  case selector["mode"]
  when "all"
    except = selector["except"] || []
    FEATURES.reject { |f| except.include?(f.id) }
  when "list"
    ids = selector["ids"] || []
    FEATURES.select { |f| ids.include?(f.id) }
  else
    []
  end
end

.feature(id) ⇒ Feature?

Parameters:

  • id (String)

Returns:



61
62
63
 
# File 'lib/rigor/bleeding_edge.rb', line 61

def feature(id)
  FEATURES.find { |f| f.id == id }
end

.feature_ids ⇒ Array<String>

Returns every feature id in the overlay.

Returns:

  • (Array<String>) —

    every feature id in the overlay.



55
56
57
 
# File 'lib/rigor/bleeding_edge.rb', line 55

def feature_ids
  FEATURES.map(&:id)
end

.features ⇒ Array<Feature>

Returns the whole overlay.

Returns:

  • (Array<Feature>) —

    the whole overlay.



50
51
52
 
# File 'lib/rigor/bleeding_edge.rb', line 50

def features
  FEATURES
end

.severity_overrides_for(selector) ⇒ Hash{String => Symbol}

The merged severity-override map the active features impose for a selector. Frozen so the result is Ractor.shareable?.

Parameters:

  • selector (Hash) —

    see #active_features.

Returns:

  • (Hash{String => Symbol}) 


93
94
95
96
97
 
# File 'lib/rigor/bleeding_edge.rb', line 93

def severity_overrides_for(selector)
  active_features(selector).each_with_object({}) do |feature, acc|
    acc.merge!(feature.severity_overrides)
  end.freeze
end

.unknown_selected_ids(selector) ⇒ Array<String>

Feature ids named by a selector that are NOT in the overlay (typo / graduated / from a newer gem). Surfaced by rigor show-bleedingedge as a hint; never an error.

Parameters:

  • selector (Hash) —

    see #active_features.

Returns:

  • (Array<String>) 


104
105
106
107
108
109
110
111
112
113
 
# File 'lib/rigor/bleeding_edge.rb', line 104

def unknown_selected_ids(selector)
  named =
    case selector["mode"]
    when "list" then selector["ids"] || []
    when "all"  then selector["except"] || []
    else []
    end
  known = feature_ids
  named.reject { |id| known.include?(id) }
end