pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/parsers/mr_string.rb

@@ -2,6 +2,28 @@
 
 module Pubid
   module Parsers
+    # Parses a machine-readable (MR) identifier string back into an Identifier.
+    #
+    # The MR format produced by `Renderers::MrString` mirrors the human form,
+    # lowercased and filename-safe:
+    #
+    #   iso.9001.2015                              → ISO 9001:2015
+    #   iso-iec.17031-1.2020                       → ISO/IEC 17031-1:2020
+    #   iso.1234-1-2-3.2020                        → ISO 1234-1-2-3:2020
+    #   iso.tr.14627.2017                          → ISO/TR 14627:2017
+    #   iso.16634.--                               → ISO 16634:--
+    #   iso.9001.2015_amd.1.2020                   → ISO 9001:2015/Amd 1:2020
+    #   iso-iec.13818-1.2015_amd.3.2016_cor.1.2017 → ISO/IEC 13818-1:2015/Amd 3:2016/Cor 1:2017
+    #
+    # Copublishers join with `-` (`iso-iec`), supplements append with `_`
+    # (`iso.9001.2015_amd.1.2020`). Both round-trip back to `/` here. The
+    # flavor's own parser is case-insensitive on the type/publisher tokens
+    # we emit, so the lowercased slug re-parses cleanly.
+    #
+    # Note: NIST, CSA, IEEE, JIS, and SAE emit their own MR shapes that this
+    # parser does not attempt to reverse (their `to_s` already round-trips
+    # through the flavor's own parser, so callers should use that path for
+    # those flavors).
     class MrString < Base
       FLAVOR_MAP = {
         "ISO" => :iso,
@@ -59,6 +81,14 @@ module Pubid
         ccsds: :Ccsds,
       }.freeze
 
+      # Lower-case type codes the renderer emits as a separate MR segment
+      # (e.g. `iso.tr.14627`). When the parser sees one of these in the
+      # second position, it splits it back out as `/TYPE`.
+      TYPE_CODES = %w[
+        tr ts pas is amd cor suppl add ext guide spec
+        standard corrigendum amendment
+      ].freeze
+
       def self.parse(mr_string)
         flavor = detect_flavor(mr_string)
 
@@ -71,23 +101,106 @@ module Pubid
         raise ArgumentError, "Unknown flavor: #{flavor}" unless flavor_module
 
         identifier_string = convert_to_human_readable(mr_string)
+
+        # Refuse to hand the flavor a string this parser did not change.
+        #
+        # `detect_flavor` falls back to `:iso` for any publisher it does not
+        # know, and `Pubid::Iso.parse` sends an MR-shaped string straight back
+        # here — so a string that survives conversion unchanged recurses
+        # forever. `ECMA-426 ed1` is the standing example: "ECMA" is absent
+        # from FLAVOR_MAP, the string matches the MR shape heuristic
+        # (`/\A[A-Z]{2,}[.-]/`), and conversion is a fixed point.
+        # `Pubid::Iso.parse("ECMA-426 ed1")` raised SystemStackError.
+        #
+        # A fixed point means "this was never an MR string", which is a parse
+        # failure — the class the cross-flavor contract requires, and the one
+        # `Pubid.parse` treats as "try the next flavor".
+        if identifier_string == mr_string && flavor_module == Pubid::Iso
+          raise Parslet::ParseFailed,
+                "#{mr_string.inspect} is not an MR string"
+        end
+
         flavor_module.parse(identifier_string)
       end
 
       def self.detect_flavor(mr_string)
-        publisher = mr_string.split(".").first.upcase
+        publisher = mr_string.split(/[._-]/).first.to_s.upcase
         FLAVOR_MAP[publisher] || :iso
       end
 
+      # Convert the MR slug back to a human-readable identifier string the
+      # flavor's own parser will accept. Splits on `_` first so each segment
+      # (head + each supplement) is converted independently, then re-joined
+      # with `/`. Within the head, the copublisher separator `-` (first
+      # segment only) is restored to `/`.
       def self.convert_to_human_readable(mr_string)
-        parts = mr_string.split(".")
-        if parts.size > 2
-          year_part = parts.pop
-          parts.join(" ") + ":#{year_part}"
-        else
-          parts.join(" ")
+        head, *supplements = mr_string.split("_")
+        human = convert_head(head)
+        return human if supplements.empty?
+
+        supplements.inject(human) do |acc, supp|
+          "#{acc}/#{convert_supplement(supp)}"
         end
       end
+
+      # Converts a head segment like `iso-iec.13818-1.2015` to
+      # `ISO/IEC 13818-1:2015`.
+      def self.convert_head(head)
+        parts = head.split(".")
+        return parts.join(" ").upcase if parts.length <= 1
+
+        publisher, *rest = parts
+
+        # Optional type code segment (iso.tr.14627.2017 → ISO/TR 14627:2017).
+        type_segment = nil
+        if rest.first && TYPE_CODES.include?(rest.first.downcase)
+          type_segment = rest.shift.upcase
+        end
+
+        # Trailing language segment — bare language code(s) with no parens.
+        # Detect by length <= 5 and all-alpha (en, fr, en-fr, ru).
+        language_segment = nil
+        if rest.last&.match?(/\A[a-z]{2}(-[a-z]{2})*\z/)
+          language_segment = rest.pop
+        end
+
+        # Trailing year segment (may be `--` for undated, or YYYY[-MM[-DD]]).
+        year_segment = nil
+        if rest.any? && rest.last.match?(/\A(?:\d{4}(?:-\d{2}){0,2}|--)\z/)
+          year_segment = rest.pop
+        end
+
+        # Copublishers in the first segment: `iso-iec` → `ISO/IEC`. Multi-word
+        # publisher bodies (e.g. `cen-cenelec`) round-trip the same way.
+        publisher_part = publisher.split("-").map(&:upcase).join("/")
+        publisher_part = "#{publisher_part}/#{type_segment}" if type_segment
+
+        number_part = rest.join(" ")
+        result = publisher_part
+        result += " #{number_part}" unless number_part.empty?
+        result += ":#{year_segment}" if year_segment
+        if language_segment
+          langs = language_segment.split("-").join(",")
+          result += "(#{langs})"
+        end
+        result
+      end
+
+      # Converts a supplement segment like `amd.1.2020` to `Amd 1:2020`.
+      # The first token is the lowercase type code; remaining tokens are
+      # number and optional year.
+      def self.convert_supplement(supp)
+        tokens = supp.split(".")
+        type = tokens.shift&.upcase
+        year = tokens.last&.match?(/\A\d{4}\z/) ? tokens.pop : nil
+        number = tokens.join(" ")
+
+        result = type.to_s
+        result += " #{number}" unless number.empty?
+        result += ":#{year}" if year
+        result
+      end
     end
   end
 end
+

data/lib/pubid/plateau/builder.rb

@@ -9,7 +9,7 @@ module Pubid
 
       def build(parsed)
         # Check for annex supplement first
-        if parsed[:base_identifier] && parsed[:annex_letter]
+        if parsed[:base] && parsed[:annex_letter]
           return build_annex(parsed)
         end
 
@@ -29,7 +29,11 @@ module Pubid
         }
 
         params[:annex] = parsed[:annex].to_s.to_i if parsed[:annex]
-        params[:edition] = parsed[:edition].to_s if parsed[:edition]
+        # Only Handbook carries an edition; a legacy Latin TR captures the
+        # edition slice via the shared handbook rule, so drop it here.
+        if parsed[:edition] && klass == Identifiers::Handbook
+          params[:edition] = parsed[:edition].to_s
+        end
 
         klass.new(**params)
       end
@@ -38,10 +42,10 @@ module Pubid
 
       def build_annex(parsed)
         # Recursively parse base identifier
-        base = build(parsed[:base_identifier])
+        base = build(parsed[:base])
 
         Identifiers::Annex.new(
-          base_identifier: base,
+          base: base,
           letter: parsed[:annex_letter].to_s,
         )
       end

data/lib/pubid/plateau/identifier.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
 # Pubid::Plateau::Identifier is the PLATEAU base class (a real Pubid::Identifier
-# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
-# live in identifiers/base.rb. This file just ensures it is loaded.
-require_relative "identifiers/base"
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.

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

@@ -3,7 +3,7 @@
 module Pubid
   module Plateau
     # Base class for all PLATEAU identifiers. Canonical name
-    # Pubid::Plateau::Identifier (Identifiers::Base is a back-compat alias).
+    # Pubid::Plateau::Identifier.
     class Identifier < ::Pubid::Identifier
       # Delegate to the flavor module so callers can use
       # `Pubid::Plateau::Identifier.parse` consistently with other flavors.
@@ -51,10 +51,5 @@ module Pubid
       end
     end
 
-    module Identifiers
-      # Backward-compatible alias: PLATEAU's base class used to be
-      # Pubid::Plateau::Identifiers::Base. It is now Pubid::Plateau::Identifier.
-      Base = Pubid::Plateau::Identifier
-    end
   end
 end

data/lib/pubid/plateau/identifiers/handbook.rb

@@ -6,7 +6,7 @@ module Pubid
       # PLATEAU Handbook
       # Format: PLATEAU Handbook #NN[-annex] [第X.Y版]
       # Example: PLATEAU Handbook #00 第1.0版
-      class Handbook < Base
+      class Handbook < Identifier
         attribute :edition, :string, default: -> {}
 
         def type_string

data/lib/pubid/plateau/identifiers/technical_report.rb

@@ -6,7 +6,7 @@ module Pubid
       # PLATEAU Technical Report
       # Format: PLATEAU Technical Report #NN[-annex]
       # Example: PLATEAU Technical Report #01
-      class TechnicalReport < Base
+      class TechnicalReport < Identifier
         def type_string
           "Technical Report"
         end

data/lib/pubid/plateau/identifiers.rb

@@ -4,7 +4,6 @@ module Pubid
   module Plateau
     module Identifiers
       autoload :Annex, "#{__dir__}/identifiers/annex"
-      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :Handbook, "#{__dir__}/identifiers/handbook"
       autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
     end

data/lib/pubid/plateau/parser.rb

@@ -2,7 +2,7 @@
 
 module Pubid
   module Plateau
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:space) { str(" ") }
       rule(:dash) { str("-") }
       rule(:hash) { str("#") }
@@ -21,17 +21,23 @@ module Pubid
       # Number: #00, #01, #46, etc.
       rule(:number) { hash >> digits.as(:number) }
 
-      # Annex: -1, -2, etc.
-      rule(:annex) { dash >> digits.as(:annex) }
+      # Annex: -1, -2, etc. Legacy Latin references use "_" as the sub-number
+      # separator (e.g. "#46_1"); both render as the canonical dash.
+      rule(:annex) { (dash | str("_")) >> digits.as(:annex) }
 
-      # Edition: 第1.0版, 第2.3版, etc. (only for Handbook)
+      # Edition (Handbook only). Canonical form is 第X.Y版; legacy Latin
+      # references write the bare X.Y (e.g. "PLATEAU Handbook #00 1.0"). Both
+      # capture the same numeric :edition slice, so they build the same object
+      # and render to the canonical 第X.Y版.
       rule(:edition_part) do
         str("第") >>
           (digits >> str(".") >> digits).as(:edition) >>
           str("版")
       end
 
-      rule(:edition) { space >> edition_part }
+      rule(:edition_latin) { (digits >> str(".") >> digits).as(:edition) }
+
+      rule(:edition) { space >> (edition_part | edition_latin) }
 
       # Annex supplement: "Annex A", "Annex B", etc.
       rule(:annex_letter) { match["A-Z"].as(:annex_letter) }
@@ -45,6 +51,10 @@ module Pubid
           number >> annex.maybe >> edition.maybe
       end
 
+      # Technical Report has no edition. A legacy Latin TR reference carrying a
+      # trailing edition (e.g. "#00 1.0") is matched by the `handbook` rule
+      # (doc_type matches either keyword, tried first); the builder dispatches
+      # on :type and drops the captured edition for Technical Report.
       rule(:technical_report) do
         publisher >> space >> doc_type >> space >>
           number >> annex.maybe
@@ -52,7 +62,7 @@ module Pubid
 
       # Annex identifier (supplement)
       rule(:annex_identifier) do
-        (handbook | technical_report).as(:base_identifier) >> annex_supplement
+        (handbook | technical_report).as(:base) >> annex_supplement
       end
 
       rule(:identifier) { annex_identifier | handbook | technical_report }

data/lib/pubid/plateau/renderer.rb

@@ -44,7 +44,7 @@ module Pubid
       end
 
       def render_supplement(id)
-        "#{id.base_identifier} #{id.supplement_string}"
+        "#{id.base} #{id.supplement_string}"
       end
     end
   end

data/lib/pubid/plateau/supplement_identifier.rb

@@ -7,7 +7,7 @@ module Pubid
     # Base class for PLATEAU supplements (Annex)
     # Supplements reference a base identifier
     class SupplementIdentifier < Pubid::Identifier
-      attribute :base_identifier, Identifiers::Base
+      attribute :base, Identifier
       attribute :letter, :string, default: -> {}
 
       def publisher
@@ -19,20 +19,20 @@ module Pubid
         raise NotImplementedError, "Subclasses must implement supplement_string"
       end
 
-      # Override base_hash to extract edition, type, and annex from base_identifier
+      # Override base_hash to extract edition, type, and annex from base
       def base_hash
         hash = super
         # For Plateau supplements, edition comes from the base identifier
-        if base_identifier.class.attributes.key?(:edition) && base_identifier.edition
-          hash[:edition] = base_identifier.edition
+        if base.class.attributes.key?(:edition) && base.edition
+          hash[:edition] = base.edition
         end
-        # Include type from base_identifier
-        if base_identifier.class.attributes.key?(:type_string) && base_identifier.type_string
-          hash[:type] = base_identifier.type_string
+        # Include type from base
+        if base.class.attributes.key?(:type_string) && base.type_string
+          hash[:type] = base.type_string
         end
-        # Include annex from base_identifier
-        if base_identifier.class.attributes.key?(:annex) && base_identifier.annex
-          hash[:annex] = base_identifier.annex
+        # Include annex from base
+        if base.class.attributes.key?(:annex) && base.annex
+          hash[:annex] = base.annex
         end
         hash
       end
@@ -60,7 +60,7 @@ module Pubid
       def ==(other)
         return false unless other.class == self.class
 
-        base_identifier == other.base_identifier &&
+        base == other.base &&
           letter == other.letter
       end
     end

data/lib/pubid/plateau.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 require "parslet"
 
 module Pubid
@@ -10,7 +11,7 @@ module Pubid
     PREFIXES = ["PLATEAU"].freeze
 
     autoload :Builder, "#{__dir__}/plateau/builder"
-    autoload :Identifier, "#{__dir__}/plateau/identifier"
+    autoload :Identifier, "#{__dir__}/plateau/identifiers/base"
     autoload :Identifiers, "#{__dir__}/plateau/identifiers"
     autoload :Parser, "#{__dir__}/plateau/parser"
     autoload :Renderer, "#{__dir__}/plateau/renderer"
@@ -19,6 +20,15 @@ module Pubid
     autoload :UrnParser, "#{__dir__}/plateau/urn_parser"
 
     def self.parse(input)
+      unless input.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if input.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       # Apply legacy update_codes normalization first
       normalized = Core::UpdateCodes.apply(input, :plateau)
       parser = Parser.new
@@ -27,9 +37,9 @@ module Pubid
     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: Plateau::Renderer)
-    SupplementIdentifier.format_registry = Identifiers::Base.format_registry
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Plateau::Renderer)
+    SupplementIdentifier.format_registry = Identifier.format_registry
 
     # Auto-discover all identifier types from the Identifiers namespace
     # @return [Array<Class>] identifier classes that define a self.type Hash

data/lib/pubid/prefixes_support.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   # Mixin providing the uniform, static +prefixes+ class method that every
   # registered flavor exposes. relaton uses this to build a global prefix

data/lib/pubid/renderers/annotator.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    # Adds semantic <span class="..."> markers to an already-rendered
+    # identifier string.
+    #
+    # In pubid 1.x annotation was applied in ONE place — `prerender_params`
+    # wrapped every value in the param hash — so all 40-odd flavors got it for
+    # free. pubid 2 replaced that hash with typed components and per-flavor
+    # renderers, and the annotation went with it: `Renderers::Base#annotate`
+    # exists, but only the HumanReadable family calls it. All 39 flavor
+    # renderers receive `context.annotated` and ignore it, so
+    # `to_s(annotated: true)` returned plain text for every flavor but ISO.
+    #
+    # Re-annotating inside 39 renderers would mean 39 chances to drift. This
+    # class recovers the markup from the OUTSIDE instead: it asks the
+    # identifier for its own component values and wraps each one where it
+    # appears in the rendered string. That is one implementation, and a flavor
+    # added tomorrow is covered without touching its renderer.
+    #
+    # It is a fallback, not a replacement. `Identifier#render` uses it only
+    # when the renderer produced no span of its own, so ISO's exact,
+    # render-time placement still wins.
+    #
+    # Deliberate limits:
+    #
+    # * A token that does not appear verbatim in the output is skipped. A
+    #   renderer may transform a value (abbreviate it, change its case), and a
+    #   missing span is a far better outcome than a wrong one or a crash.
+    # * Matching walks left to right behind a cursor, so a later token can
+    #   never match text an earlier one already claimed — that is what stops
+    #   the part "1" of `ISO 1234-1` from matching inside "1234".
+    class Annotator
+      # Semantic class for each token, in the order tokens appear in a printed
+      # identifier. Order matters: it is the sequence the cursor walks.
+      TOKENS = [
+        [:publisher, "publisher"],
+        [:copublishers, "publisher"],
+        %i[typed_stage typed_stage_css],
+        [:type, "doctype"],
+        [:stage, "stage"],
+        [:number, "docnumber"],
+        [:part, "part"],
+        [:subpart, "part"],
+        [:stage_iteration, "iteration"],
+        [:year, "year"],
+        [:edition, "edition"],
+        [:languages, "language"],
+      ].freeze
+
+      # Characters that may not sit directly against a match, so a token never
+      # binds to the middle of a longer run of the same character class.
+      WORD_CHAR = /[A-Za-z0-9]/
+
+      # How deep to follow nested identifiers. A wrapper around a wrapper is
+      # real (BSI adopts a CEN prestandard that adopts an ISO standard); four
+      # levels is past anything the corpus holds, and the cap is here so a
+      # cyclic `base` cannot hang a rendering call.
+      MAX_NESTING = 4
+
+      def initialize(identifier, context = nil)
+        @id = identifier
+        @context = context
+      end
+
+      # @param rendered [String] the plain rendering of {@id}
+      # @return [String] the same string with semantic spans inserted
+      def annotate(rendered)
+        return rendered unless rendered.is_a?(String) && !rendered.empty?
+
+        cursor = 0
+        result = +""
+
+        ordered_tokens(rendered).each do |text, css_class|
+          index = find_token(rendered, text, cursor)
+          next if index.nil?
+
+          result << rendered[cursor...index]
+          result << %(<span class="#{css_class}">#{text}</span>)
+          cursor = index + text.length
+        end
+
+        result << rendered[cursor..]
+        result
+      end
+
+      private
+
+      # Tokens sorted by where they actually appear, not by the order
+      # {TOKENS} lists them.
+      #
+      # Flavors disagree about layout: ISO prints the number before the type
+      # ("ISO/IEC TR 2131"), CCSDS prints it after ("CCSDS 121.0-B-2"). Walking
+      # in declaration order pushed the cursor past the number for CCSDS, so
+      # "121" was never annotated. Sorting by first occurrence makes the walk
+      # follow the printed identifier instead of a fixed idea of one.
+      def ordered_tokens(rendered)
+        tokens = []
+        each_token { |text, css_class| tokens << [text, css_class] }
+
+        decorated = tokens.each_with_index.map do |token, i|
+          position = find_token(rendered, token.first, 0) || rendered.length
+          [position, i, token]
+        end
+
+        decorated.sort_by { |position, i, _| [position, i] }.map(&:last)
+      end
+
+      # Yields [text, css_class] for every annotatable token this identifier
+      # actually carries, then every one its nested identifiers carry.
+      def each_token(&)
+        emit_tokens(@id, 0, &)
+      end
+
+      # A wrapper — an adoption, a supplement, a bundle — carries no number of
+      # its own and prints the document it wraps, so the annotatable tokens in
+      # its string belong to `base`. Reading only the wrapper's own attributes
+      # is why every CSA container and CIE's supplement rendered plain while
+      # accepting the flag.
+      #
+      # Order does not matter here: `ordered_tokens` sorts by first occurrence,
+      # so a nested token lands where it actually appears in the string.
+      def emit_tokens(id, depth, &)
+        return if depth > MAX_NESTING
+
+        tokens_for(id).each do |attr_name, css_class|
+          Array(token_values(id, attr_name)).each do |value|
+            text = token_text(value)
+            next if text.nil? || text.empty?
+
+            yield text, resolve_class(css_class, value)
+          end
+        end
+
+        nested_identifiers(id).each { |nested| emit_tokens(nested, depth + 1, &) }
+      end
+
+      # {TOKENS} unless the identifier names more of its own — see
+      # `Pubid::Identifier#annotation_tokens`.
+      def tokens_for(id)
+        id.respond_to?(:annotation_tokens) ? id.annotation_tokens : TOKENS
+      end
+
+      # The identifiers this one wraps, under any of the four names the gem
+      # uses: `base` (the uniform parent accessor), the `ids` / `identifiers`
+      # collections that bundles and consolidated identifiers hold instead, and
+      # CSA `Bundled`'s `bundled_with` — which holds the amendments a
+      # consolidation prints, and whose values it composes into the string from
+      # their components rather than from their own `to_s`.
+      def nested_identifiers(id)
+        %i[base ids identifiers bundled_with].flat_map do |name|
+          next [] unless id.respond_to?(name)
+
+          begin
+            Array(id.public_send(name))
+          rescue StandardError
+            []
+          end
+        end.grep(::Pubid::Identifier)
+      end
+
+      def token_values(id, attr_name)
+        return nil unless id.respond_to?(attr_name)
+
+        id.public_send(attr_name)
+      rescue StandardError
+        # A derived reader may assume state a partial identifier lacks. A
+        # missing span is not worth an exception on a rendering path.
+        nil
+      end
+
+      # The printed form of one component. Components render themselves through
+      # the context; a bare scalar is already its own text.
+      def token_text(value)
+        return nil if value.nil?
+
+        text = if value.respond_to?(:render)
+                 value.render(context: @context)
+               else
+                 value
+               end
+        text.to_s.strip
+      rescue StandardError
+        nil
+      end
+
+      def resolve_class(css_class, value)
+        return css_class unless css_class == :typed_stage_css
+
+        TypedStageClass.for(value)
+      end
+
+      # First occurrence of +text+ at or after +cursor+ that is not embedded in
+      # a longer word — so "1" matches the part in "ISO 1234-1", never the "1"
+      # inside "1234".
+      def find_token(rendered, text, cursor)
+        at = cursor
+        while (index = rendered.index(text, at))
+          return index if standalone?(rendered, index, text.length)
+
+          at = index + 1
+        end
+        nil
+      end
+
+      def standalone?(rendered, index, length)
+        before = index.zero? ? nil : rendered[index - 1]
+        after = rendered[index + length]
+
+        !WORD_CHAR.match?(before.to_s) && !WORD_CHAR.match?(after.to_s)
+      end
+
+      # The typed-stage class depends on the stage's type code, the same
+      # mapping `Renderers::Base#typed_stage_css` applies. Kept here rather
+      # than reached for through a private method on another object.
+      module TypedStageClass
+        MAP = {
+          "amd" => "amendment",
+          "cor" => "corrigendum",
+          "add" => "addendum",
+        }.freeze
+
+        def self.for(typed_stage)
+          code = typed_stage.respond_to?(:type_code) ? typed_stage.type_code.to_s : ""
+          return "stage" if code.empty? || code == "is"
+
+          MAP[code] || "doctype"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/renderers/base.rb

@@ -41,6 +41,19 @@ module Pubid
         %(#{lead}<span class="#{css_class}">#{core}</span>#{trail})
       end
 
+      # Render a value that may be a component or a bare scalar.
+      #
+      # `number`, `part` and `subpart` are `Components::Code` on
+      # ::Pubid::Identifier but a plain `:string` in a growing number of
+      # flavors, so a shared renderer cannot assume the format-aware
+      # `#render(context:)` seam is there. This keeps both shapes working while
+      # the flavors convert one tranche at a time.
+      def render_component(value, context)
+        return nil if value.nil?
+
+        value.respond_to?(:render) ? value.render(context: context) : value.to_s
+      end
+
       # Choose between "stage" and a type/supplement class for a typed stage.
       def typed_stage_css(typed_stage)
         code = typed_stage&.type_code.to_s