pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e650437c35c0d8e6ba019b07ae835ca224bd620415bd9c9d27c20a36a1b82589
-  data.tar.gz: 3d8d15f420d6cff7dbba69007218d670cde06511fc00df7b7dcfd957493600cb
+  metadata.gz: 296a51f39ef14271b7b66a8403042c4a35b214eb3e858c2a926ab9104e74acfa
+  data.tar.gz: 9dcdd6b5082ea2cc6b866078f7c749e687fd4f76ad767b94ed77347700f2a6c2
 SHA512:
-  metadata.gz: f231838d92fd52c9d8fb298899a6f62018c29872d0d67104ea064ea70ea5cd4e115490876e2e83ba9601da87aeb9060d9f28e34535d0495ca680bc93ad6801ec
-  data.tar.gz: de691a34d6783e9df75f4304315d6791eb30e68b7788177f8e04285aa8f88372e38ce9754527eb8479db0926ef9276ddef7c6fae1ede170380541459c150a823
+  metadata.gz: 974c5db378c9461c7636b47525054a7351fd136de2493710767abbb198e40fdadf7e21a9c9273d3bbe79707c301509e21aaea30eeae3d09931b11029e5cf69ae
+  data.tar.gz: 16d304dcd9a960da1386e46d692425e3c9a7153be96130187def4c02c9fc22e192bd4374956ee526678bbfe04add13ab50c71d625b860e0d6c65cd157ef12248

data/README.adoc

@@ -1729,9 +1729,13 @@ The V2 implementation strictly follows these design principles:
 
 Object-Oriented Design:: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
 MECE Organization:: Mutually Exclusive (no overlap), Collectively Exhaustive (full coverage), clear boundaries
-Separation of Concerns:: Parser handles syntax only, Builder handles transformation only, Identifier handles rendering only
+Separation of Concerns:: Parser handles syntax only, Builder handles transformation only, Renderer handles formatting only
+Self-Describing Types:: Each identifier class IS the type definition — no central registry required for type metadata
+Renderer Pattern:: Dedicated per-flavor Renderer classes handle human-readable output; identifier `to_s` delegates to `render(format: :human)` via `FormatRegistry`
+Single Source of Truth:: Series matching, type metadata, and rendering logic live in exactly one place per concern
 Extensibility:: Use inheritance and polymorphism, plugin/registry architecture, avoid hardcoding
 Test Quality:: Each class has dedicated spec file, no lowering pass thresholds, test actual behavior
+Autoload Everywhere:: Ruby autoload replaces `require_relative` for internal library code — lazy loading, no circular dependency risk
 
 === Pre-parser Normalization (update_codes.yaml)
 

data/data/nist/update_codes.yaml

@@ -1,3 +1,28 @@
+# NIST pre-parser normalization rules.
+#
+# This file is applied to every NIST identifier string BEFORE any Ruby
+# preprocessing (see lib/pubid/nist/preprocessor.rb). Each entry is one
+# of:
+#
+#   "plain string": "replacement"
+#       Full-line match (^...$), literal. Use for specific malformed IDs
+#       that have a single canonical form.
+#
+#   "/regex/": "replacement"          (no flags)
+#   "/regex/imx": "replacement"       (i = IGNORECASE, m = MULTILINE,
+#                                       x = EXTENDED)
+#       Applied via gsub. Use for general patterns that are pure
+#       string→string substitutions.
+#
+# Design split (MECE):
+#   - This file: data-driven lookups and pure subs that any maintainer
+#     (including non-Rubyists) can extend safely.
+#   - Preprocessor (Ruby): stateful or interdependent transformations
+#     where stage order, conditional logic, or external state (e.g.,
+#     Roman numeral conversion, year-range reverts) make YAML unsuitable.
+#
+# Reorder entries with care — later entries often match patterns produced
+# by earlier ones. Run `bundle exec rspec spec/pubid/nist/` after edits.
 NBS MN: NBS MONO
 NIST MN: NIST MONO
 NIST MP: NBS MP
@@ -26,7 +51,9 @@ NIST.CSWP.01162020pt: NIST.CSWP.01162020(por)
 FIPS PUB: FIPS
 NBS CRPL c4-4: NBS CRPL 4-4
 NIST AMS 300-8r1 (February 2021 update): NIST AMS 300-8r1/Upd1-202102
+NIST AMS 300-8r1/upd: NIST AMS 300-8r1/Upd1-202102
 NIST IR 8115r1-upd: NIST IR 8115r1/Upd1-202103
+NIST IR 8170-upd: NIST IR 8170/Upd1-202003
 NIST TN 2150-upd: NIST TN 2150/Upd1-202102
 NBS IR 73-197r: NBS IR 73-197r1
 NBS.HB.105-1r1990: NIST.HB.105-1r1990

data/lib/pubid/amca/builder.rb

@@ -3,7 +3,7 @@
 module Pubid
   module Amca
     # Builder class for constructing ACMA identifier scheme from parsed data
-    # Single Responsibility: Transform parsed data into Scheme objects
+    # Single Responsibility: Transform parsed data into identifier objects
     class Builder
       attr_reader :identifier_class
 
@@ -13,7 +13,7 @@ module Pubid
 
       # Build a scheme object from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [Scheme] the constructed scheme object
+      # @return [identifier] the constructed scheme object
       def build(parsed)
         # Parslet can return array of hashes - merge them
         parsed_hash = parsed.is_a?(Array) ? merge_parsed_array(parsed) : parsed

data/lib/pubid/amca/identifier.rb

@@ -2,6 +2,13 @@
 
 module Pubid
   module Amca
+    # NOTE: this flavor intentionally does NOT `extend Pubid::IdentifierFacade`
+    # (nor include it in Identifiers::Base). The facade's identity check makes
+    # `is_a?(<Flavor>::Identifier)` true, which routes the object through a
+    # consumer's `to_hash` (e.g. relaton-index#save) — but AMCA's `to_hash`
+    # currently raises (publisher is stored as a String, not a Publisher
+    # component). Enabling the facade here would turn a non-crashing path into a
+    # crash. Re-enable once AMCA serialization round-trips cleanly.
     module Identifier
       # Parse an ACMA identifier string into an identifier object
       # @param identifier [String] The ACMA identifier string to parse

data/lib/pubid/amca/identifiers/base.rb

@@ -25,37 +25,11 @@ module Pubid
           "AMCA"
         end
 
-        # Render the identifier as a string
-        def to_s
-          parts = []
-          parts << copublisher if copublisher
-          # type is a hash, get the title
-          t = self.class.attributes.key?(:type) ? type : nil
-          if t.is_a?(Hash) && t[:title]
-            parts << t[:title].to_s
-          end
-          parts << code.to_s
-          parts << "-#{year}" if year
-
-          result = parts.compact.join(" ")
-
-          # Handle additional copublisher after year (e.g., /ASHRAE 51-16)
-          if copublisher&.include?("/") && year
-            type_title = t.is_a?(Hash) ? t[:title].to_s : ""
-            result = "#{copublisher} #{type_title} #{code}-#{year}"
-          end
-
-          result += " (#{reaffirmed})" if reaffirmed
-
-          result
-        end
-
         def self.parse(string)
           Amca::Identifier.parse(string)
         end
 
         def to_urn
-          require_relative "../urn_generator"
           UrnGenerator.new(self).generate
         end
       end

data/lib/pubid/amca/identifiers/interpretation.rb

@@ -28,23 +28,6 @@ reaffirmed: nil, interpretation_code: nil)
         def type
           Interpretation.type
         end
-
-        # @return [String] the rendered interpretation identifier
-        def to_s
-          parts = []
-          parts << @copublisher if @copublisher
-          parts << @code.to_s
-
-          if @interpretation_code
-            parts << "– #{@interpretation_code}"
-          elsif @year
-            parts << "-#{@year}"
-          end
-
-          parts << " #{@suffix}" if @suffix
-
-          parts.join(" ").squeeze(" ")
-        end
       end
     end
   end

data/lib/pubid/amca/identifiers/publication.rb

@@ -28,19 +28,6 @@ reaffirmed: nil, revision: nil)
         def type
           Publication.type
         end
-
-        # @return [String] the rendered publication identifier
-        def to_s
-          parts = []
-          parts << @copublisher if @copublisher
-          parts << "Publication"
-          parts << @code.to_s
-          parts << "-#{@year}" if @year
-          parts << " (Rev. #{@revision})" if @revision
-          parts << " (#{@reaffirmed})" if @reaffirmed && !@revision
-
-          parts.join(" ").squeeze(" ")
-        end
       end
     end
   end

data/lib/pubid/amca/renderer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Human-readable renderer for AMCA identifiers.
+    #
+    # Produces strings like:
+    #   "AMCA Standard 210-16"
+    #   "AMCA Publication 211-22 (Rev. 01-23)"
+    #   "ANSI/AMCA 204 Interp"
+    #   "AMCA 99 JW Interp"
+    #
+    # The renderer is registered as the `:human` format in the AMCA format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::Publication
+          render_publication(id)
+        when Identifiers::Interpretation
+          render_interpretation(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      def render_base(id)
+        parts = []
+        parts << id.copublisher if id.copublisher
+        t = id.class.attributes.key?(:type) ? id.type : nil
+        if t.is_a?(Hash) && t[:title]
+          parts << t[:title].to_s
+        end
+        parts << id.code.to_s
+        parts << "-#{id.year}" if id.year
+
+        result = parts.compact.join(" ")
+
+        if id.copublisher&.include?("/") && id.year
+          type_title = t.is_a?(Hash) ? t[:title].to_s : ""
+          result = "#{id.copublisher} #{type_title} #{id.code}-#{id.year}"
+        end
+
+        result += " (#{id.reaffirmed})" if id.reaffirmed
+
+        result
+      end
+
+      def render_publication(id)
+        parts = []
+        parts << id.copublisher if id.copublisher
+        parts << "Publication"
+        parts << id.code.to_s
+        parts << "-#{id.year}" if id.year
+        parts << " (Rev. #{id.revision})" if id.revision
+        parts << " (#{id.reaffirmed})" if id.reaffirmed && !id.revision
+
+        parts.join(" ").squeeze(" ")
+      end
+
+      def render_interpretation(id)
+        parts = []
+        parts << id.copublisher if id.copublisher
+        parts << id.code.to_s
+
+        if id.interpretation_code
+          parts << "– #{id.interpretation_code}"
+        elsif id.year
+          parts << "-#{id.year}"
+        end
+
+        parts << " #{id.suffix}" if id.suffix
+
+        parts.join(" ").squeeze(" ")
+      end
+    end
+  end
+end

data/lib/pubid/amca/single_identifier.rb

@@ -5,29 +5,6 @@ module Pubid
     # Base class for single (non-supplement) ACMA identifiers
     # Includes: Standard, Publication
     class SingleIdentifier < Identifiers::Base
-      def to_s
-        parts = []
-        parts << copublisher if copublisher
-        # type is a hash, get the title
-        t = self.class.attributes.key?(:type) ? type : nil
-        if t.is_a?(Hash) && t[:title]
-          parts << t[:title].to_s
-        end
-        parts << code.to_s
-        parts << "-#{year}" if year
-
-        result = parts.compact.join(" ")
-
-        # Handle additional copublisher after year (e.g., /ASHRAE 51-16)
-        if copublisher&.include?("/") && year
-          type_title = t.is_a?(Hash) ? t[:title].to_s : ""
-          result = "#{copublisher} #{type_title} #{code}-#{year}"
-        end
-
-        result += " (#{reaffirmed})" if reaffirmed
-
-        result
-      end
     end
   end
 end

data/lib/pubid/amca/urn_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Parses AMCA URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:amca:{number}:{year}[:{copub.publisher}[:{other tokens}]]
+    #
+    # The current generator can leak the Type Hash literal into the URN
+    # (e.g., `copub.amca:{:key => :standard, ...}`). This parser filters
+    # any token containing `{` so round-trip works for the common case.
+    #
+    # Examples:
+    # - urn:amca:210:08              → AMCA 210-08
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body).reject { |p| p.include?("{") }
+
+        number, year = parts
+        text = "AMCA #{number}"
+        text += "-#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/amca.rb

@@ -6,9 +6,10 @@ module Pubid
     autoload :Identifiers, "#{__dir__}/amca/identifiers"
     autoload :Builder, "#{__dir__}/amca/builder"
     autoload :Parser, "#{__dir__}/amca/parser"
-    autoload :Scheme, "#{__dir__}/amca/scheme"
+    autoload :Renderer, "#{__dir__}/amca/renderer"
     autoload :SingleIdentifier, "#{__dir__}/amca/single_identifier"
     autoload :UrnGenerator, "#{__dir__}/amca/urn_generator"
+    autoload :UrnParser, "#{__dir__}/amca/urn_parser"
 
     # Parse an ACMA identifier string into an identifier object
     # @param identifier [String] The ACMA identifier string to parse
@@ -17,6 +18,46 @@ module Pubid
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifiers::Base.format_registry.register(:human, renderer: Amca::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
   end
 
   # Register this flavor with the Pubid registry

data/lib/pubid/ansi/builder.rb

@@ -3,9 +3,11 @@
 module Pubid
   module Ansi
     class Builder < Pubid::Builder::Base
-      def initialize(scheme)
-        @scheme = scheme
-        super(Identifiers::Standard)
+      def build(data)
+        data = flatten_array(data) if data.is_a?(Array)
+        identifier = default_identifier_class.new
+        assign_attributes(identifier, data)
+        identifier
       end
 
       private

data/lib/pubid/ansi/identifier.rb

@@ -6,7 +6,7 @@ module Pubid
     class Identifier < ::Pubid::Identifier
       def self.parse(string)
         parsed = Pubid::Ansi::Parser.new.parse(string)
-        Pubid::Ansi::Builder.new(Pubid::Ansi::Scheme).build(parsed)
+        Pubid::Ansi::Builder.new.build(parsed)
       end
     end
   end

data/lib/pubid/ansi/identifiers/american_national_standard.rb

@@ -4,7 +4,8 @@ module Pubid
       # American National Standard identifier
       class AmericanNationalStandard < SingleIdentifier
         def self.type
-          { key: :ans, title: "American National Standard", short: "ANS" }
+          { key: :ans, web: :american_national_standard,
+            title: "American National Standard", short: "ANS" }
         end
       end
     end

data/lib/pubid/ansi/identifiers/standard.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "american_national_standard"
-
 module Pubid
   module Ansi
     module Identifiers
       # American National Standard identifier
       class Standard < SingleIdentifier
         def self.type
-          { key: :ans, title: "American National Standard", short: "ANS" }
+          { key: :ans, web: :standard,
+            title: "American National Standard", short: "ANS" }
         end
       end
     end

data/lib/pubid/ansi/renderer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Human-readable renderer for ANSI identifiers.
+    #
+    # Produces strings like:
+    #   "ANSI X3.4"
+    #   "ANSI/ISO 9899"
+    #   "ANSI X9.8-1:2007"
+    #
+    # The renderer is registered as the `:human` format in the ANSI format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        parts = []
+        parts << publisher_portion(id, context)
+        parts << number_portion(id, context)
+        result = parts.compact.join(" ")
+
+        result << language_portion(id) if id.languages&.any?
+
+        result
+      end
+
+      private
+
+      def publisher_portion(id, context)
+        if id.copublishers&.any?
+          ([id.publisher] + id.copublishers).map { |p| p.render(context:) }.join("/")
+        else
+          id.publisher.render(context:)
+        end
+      end
+
+      def number_portion(id, context)
+        [
+          id.number.render(context:),
+          (id.part ? "-#{id.part.render(context:)}" : ""),
+          (id.date ? ":#{id.date.render(context:)}" : ""),
+        ].join
+      end
+
+      def language_portion(id)
+        return "" unless id.languages&.any?
+
+        "(#{id.languages.map(&:code).join(',')})"
+      end
+    end
+  end
+end

data/lib/pubid/ansi/single_identifier.rb

@@ -8,37 +8,8 @@ module Pubid
       #
       # @return [String] URN representation
 
-      def to_s(lang: :en)
-        [].tap do |parts|
-          parts << publisher_portion
-          parts << number_portion
-        end.compact.join(" ").tap do |s|
-          s << language_portion if languages&.any?
-        end
-      end
-
-      def publisher_portion
-        if copublishers&.any?
-          # ANSI/ISO 9899
-          ([publisher] + copublishers).map(&:body).join("/")
-        else
-          # ANSI X3.4
-          publisher.body
-        end
-      end
-
-      def number_portion
-        [
-          number.value,
-          (part ? "-#{part.value}" : ""),
-          (date ? ":#{date.year}" : ""),
-        ].join
-      end
-
-      def language_portion
-        return "" unless languages&.any?
-
-        "(#{languages.map(&:code).join(',')})"
+      def to_s(**opts)
+        render(format: :human, **opts)
       end
     end
   end

data/lib/pubid/ansi/urn_generator.rb

@@ -3,41 +3,6 @@
 module Pubid
   module Ansi
     class UrnGenerator < Pubid::UrnGenerator::Base
-      def urn_number
-        return nil unless identifier.number
-
-        identifier.number.value.to_s
-      end
-
-      def urn_part
-        return nil unless identifier.part
-
-        "-#{identifier.part.value}"
-      end
-
-      def urn_subpart
-        return nil unless identifier.subpart
-
-        "-#{identifier.subpart.value}"
-      end
-
-      def urn_year
-        if identifier.date&.year
-          return identifier.date.year.to_s
-        end
-
-        identifier.year&.to_s
-      end
-
-      def urn_edition
-        return nil unless identifier.edition
-
-        num = identifier.edition.number
-        return nil unless num
-
-        "ed.#{num}"
-      end
-
       def urn_typed_stage
         return nil unless identifier.typed_stage
 
@@ -57,12 +22,12 @@ module Pubid
         parts << urn_typed_stage if urn_typed_stage
 
         if identifier.publisher
-          parts[1] = identifier.publisher.body.to_s.downcase
+          parts[1] = identifier.publisher.render(context: URN_CONTEXT)
         end
 
         if identifier.copublishers&.any?
-          copubs = identifier.copublishers.map(&:body)
-          parts[1] = "#{parts[1]}-#{copubs.join('-').downcase}"
+          copubs = identifier.copublishers.map { |cp| cp.render(context: URN_CONTEXT) }
+          parts[1] = "#{parts[1]}-#{copubs.join('-')}"
         end
 
         if identifier.languages&.any?

data/lib/pubid/ansi/urn_parser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ansi
+    # Parses ANSI URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:ansi:{code}:{year}` where the code carries
+    # the alpha-numeric designation (e.g., "X3.4").
+    #
+    # Examples:
+    # - urn:ansi:X3.4:1963 → ANSI X3.4:1963
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        code, year = parts
+        text = "ANSI #{code}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/ansi.rb

@@ -4,22 +4,57 @@ module Pubid
   module Ansi
     autoload :Builder, "#{__dir__}/ansi/builder"
     autoload :Identifier, "#{__dir__}/ansi/identifier"
-    autoload :Identifiers, "#{__dir__}/ansi/identifiers/standard"
+    autoload :Identifiers, "#{__dir__}/ansi/identifiers"
     autoload :Parser, "#{__dir__}/ansi/parser"
-    autoload :Scheme, "#{__dir__}/ansi/scheme"
+    autoload :Renderer, "#{__dir__}/ansi/renderer"
     autoload :SingleIdentifier, "#{__dir__}/ansi/single_identifier"
     autoload :UrnGenerator, "#{__dir__}/ansi/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ansi/urn_parser"
 
     # Parse an ANSI identifier string
     # @param identifier [String] the identifier string to parse
     # @return [Identifier] the parsed identifier
     def self.parse(identifier)
       parser = Parser.new
-      builder = Builder.new(Scheme)
+      builder = Builder.new
 
       parsed = parser.parse(identifier)
       builder.build(parsed)
     end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Ansi::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # ANSI does not define typed stages; typed_stage lookup is not used by
+    # the builder. Provided here for API consistency with other flavors.
+    # @return [Array] always empty for ANSI
+    def self.all_typed_stages
+      []
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param _abbr [String, Symbol] unused; ANSI has no typed stages
+    # @return [nil] always nil for ANSI
+    def self.locate_stage(_abbr)
+      nil
+    end
   end
 end