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

data/lib/pubid/builder/base.rb

@@ -125,9 +125,11 @@ module Pubid
 
       def parse_date(value)
         value = value.to_s
-        if value.match?(/^\d{4}(-\d{2})?$/)
-          year, month = value.split("-")
-          Pubid::Components::Date.new(year: year, month: month || nil)
+        if value.match?(/^\d{4}(-\d{2}){0,2}$/)
+          year, month, day = value.split("-")
+          Pubid::Components::Date.new(year: year,
+                                       month: month || nil,
+                                       day: day || nil)
         elsif value.is_a?(Integer) || (value.is_a?(String) && value.match?(/^\d{4}$/))
           Pubid::Components::Date.new(year: value)
         else
@@ -135,11 +137,14 @@ module Pubid
         end
       end
 
-      # Splits a compound document number ("1234", "1234-1", "1234-1-2")
-      # into number/part/subpart Code components. Flavor-specific dash/slash
-      # normalization lives in +normalize_number_with_part+; legacy year
-      # extraction (e.g. ISO "4037-1979") lives in +extract_legacy_year+.
-      def parse_number_with_part(value, code_class:)
+      # Splits a compound document number ("1234", "1234-1", "1234-1-2") into
+      # number/part/subpart. Each piece is wrapped in +code_class+ when the
+      # flavor declares those attributes as a Components::Code (ISO), and kept
+      # as a plain string when +code_class+ is nil (IEC and the other retyped
+      # flavors). Flavor-specific dash/slash normalization lives in
+      # +normalize_number_with_part+; legacy year extraction (e.g. ISO
+      # "4037-1979") lives in +extract_legacy_year+.
+      def parse_number_with_part(value, code_class: nil)
         normalized = normalize_number_with_part(value)
         parts = normalized.split("-").reject(&:empty?)
         number = parts.shift
@@ -151,12 +156,19 @@ module Pubid
 
         part = convert_roman_to_integer(part) if part
 
-        code_hash = { number: code_class.new(value: number) }
-        code_hash[:part] = code_class.new(value: part) if part
-        code_hash[:subpart] = code_class.new(value: subpart) if subpart
+        code_hash = { number: wrap_component(number, code_class) }
+        code_hash[:part] = wrap_component(part, code_class) if part
+        code_hash[:subpart] = wrap_component(subpart, code_class) if subpart
         code_hash
       end
 
+      # A nil +code_class+ means the flavor holds number/part/subpart as plain
+      # strings — the `number` retype tranches — so keep the raw scalar. ISO
+      # still passes its Components::Code and is unaffected.
+      def wrap_component(value, code_class)
+        code_class ? code_class.new(value: value) : value
+      end
+
       # Hook: normalize the raw number_with_part string before splitting.
       # Override in subclasses for flavor-specific dash/slash/space handling.
       def normalize_number_with_part(value)

data/lib/pubid/bundled_identifier.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   # Identifier that represents a combined bundle of documents using the + operator.
   # Examples:
@@ -45,22 +46,27 @@ module Pubid
       base_document&.typed_stage
     end
 
+    # `**opts` carries render flags this method does not name — `annotated:`
+    # above all. Without it the closed keyword list raised
+    # `ArgumentError: unknown keyword: :annotated` for every bundled
+    # identifier, which is worse than a missing span: a wrapper is exactly the
+    # shape a consumer renders.
     def to_s(lang: :en, lang_single: false, with_edition: false, format: nil,
-stage_format_long: nil, with_date: nil)
+stage_format_long: nil, with_date: nil, **opts)
       result = base_document.to_s(lang: lang, lang_single: lang_single,
-                                  with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)
+                                  with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)
 
       supplements.each do |supplement|
         # ISO DirectivesSupplement always uses " + " (space before)
-        # CEN-style supplements (AC, A) without base_identifier use "+" (no space before)
-        # Other ISO supplements with base_identifier use " + " (space before)
+        # CEN-style supplements (AC, A) without base use "+" (no space before)
+        # Other ISO supplements with base use " + " (space before)
         if supplement.class.name&.include?("DirectivesSupplement") ||
-            (supplement.class.attributes.key?(:base_identifier) && !supplement.base_identifier.nil?)
+            (supplement.class.attributes.key?(:base) && !supplement.base.nil?)
           result += " + #{supplement.to_s(lang: lang, lang_single: lang_single,
-                                          with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)}"
+                                          with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)}"
         else
           result += "+#{supplement.to_s(lang: lang, lang_single: lang_single,
-                                        with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)}"
+                                        with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)}"
         end
       end
 
@@ -102,9 +108,13 @@ stage_format_long: nil, with_date: nil)
             parts << supplement.date.year.to_s
           end
 
-          # Add supplement number if present
+          # Add supplement number if present. `supplement` is polymorphic and
+          # `number` is a Components::Code on ::Pubid::Identifier but a plain
+          # :string in a growing number of flavors, so read through either.
           if supplement.number
-            parts << "v#{supplement.number.value}"
+            number = supplement.number
+            value = number.respond_to?(:value) ? number.value : number
+            parts << "v#{value}"
           end
         end
       end

data/lib/pubid/calconnect/builder.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    # Builds a CalConnect identifier object from a Parslet parse tree. There is
+    # a single concrete type (Identifiers::Standard), so no type dispatch.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        Identifiers::Standard.new(
+          series: data[:series]&.to_s,
+          number: data[:number].to_s,
+          date: build_date(data),
+        )
+      end
+
+      private
+
+      # Publication date as a Pubid::Components::Date, or nil for a partial
+      # reference that omits the trailing ":YYYY" (relaton matches such refs by
+      # excluding the date). Digits are kept as strings verbatim (already
+      # zero-padded in the source, e.g. "07"/"23"); month/day are nil for the
+      # common year-only form.
+      def build_date(data)
+        return nil if data[:year].nil?
+
+        ::Pubid::Components::Date.new(
+          year: data[:year].to_s,
+          month: data[:month]&.to_s,
+          day: data[:day]&.to_s,
+        )
+      end
+    end
+  end
+end

data/lib/pubid/calconnect/identifier.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    # Base class for every CalConnect identifier AND the flavor's parse entry
+    # point — mirrors Pubid::Jis::Identifier. Concrete identifiers under
+    # Pubid::Calconnect::Identifiers descend from this class, so a parsed
+    # CalConnect id is an instance of Pubid::Calconnect::Identifier and
+    # relaton-index can pass this class as `pubid_class` for from_hash/to_hash.
+    class Identifier < ::Pubid::Identifier
+      # `number` is a CalConnect-specific plain string (preserves leading zeros
+      # like "0514" and the sub-part separator, "0812-1"/"0707.1"), so it
+      # overrides the inherited Components::Code type. The publication date uses
+      # the shared Pubid::Components::Date (inherited attribute): `year` is
+      # always present, `month`/`day` only for the rare full-date form
+      # ("CC/WD 51017:2024-07-23").
+      attribute :series, :string # Optional series letter/token (A, WD, DIR, …)
+      attribute :number, :string
+      attribute :date, ::Pubid::Components::Date
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization,
+      # mapping the concrete class's polymorphic_name to its class name so a
+      # stored hash rebuilds the correct identifier type via from_hash.
+      CALCONNECT_TYPE_MAP = {
+        "pubid:calconnect:standard" => "Pubid::Calconnect::Identifiers::Standard",
+      }.freeze
+
+      # The date serializes FLAT as year/month/day string keys (nils omitted),
+      # mirroring lib/pubid/iso/identifier.rb — not as a nested "date" object —
+      # so the index row stays a shallow hash and round-trips exactly.
+      key_value do
+        map "_type", to: :_type, polymorphic_map: CALCONNECT_TYPE_MAP
+        map "series", to: :series
+        map "number", to: :number
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "month", with: { to: :month_to_kv, from: :month_from_kv }
+        map "day", with: { to: :day_to_kv, from: :day_from_kv }
+      end
+
+      # Publisher is always "CC". A plain constant (not a `publisher` method) so
+      # it doesn't shadow the inherited lutaml `publisher` attribute, which
+      # would otherwise fail serialization type validation.
+      PUBLISHER = "CC"
+
+      attr_reader :with_publisher
+
+      # Render the publication date, e.g. "2018" or "2024-07-23". Shared by the
+      # renderer and the URN generator so they always agree.
+      # Pubid::Components::Date#to_s yields the year alone, or the zero-padded
+      # "YYYY-MM-DD" when month/day are present.
+      def date_string
+        date&.to_s
+      end
+
+      # Basic string representation. Delegates to the human renderer. The
+      # printed CalConnect id carries the "CC" publisher token by default; pass
+      # with_publisher: false to drop it (and the series slash).
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      # Capture the with_publisher flag on EVERY render call (default true), so
+      # it can never leak across calls. The base `render` only forwards
+      # `:with_edition` to the renderer, so the flag is threaded via this
+      # per-call instance write (the renderer reads `id.with_publisher`).
+      def render(format: :human, with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        super(format: format, **opts)
+      end
+
+      # --- date serialized flat as year/month/day (mirrors ISO) ---
+      def year_to_kv(model, doc)
+        emit_date_part(doc, "year", model.date&.year)
+      end
+
+      def month_to_kv(model, doc)
+        emit_date_part(doc, "month", model.date&.month)
+      end
+
+      def day_to_kv(model, doc)
+        emit_date_part(doc, "day", model.date&.day)
+      end
+
+      def year_from_kv(model, value) = date_for(model).year = value.to_s
+      def month_from_kv(model, value) = date_for(model).month = value.to_s
+      def day_from_kv(model, value) = date_for(model).day = value.to_s
+
+      def emit_date_part(doc, key, val)
+        return if val.nil? || val.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, val.to_s))
+      end
+
+      def date_for(model)
+        model.date ||= ::Pubid::Components::Date.new
+      end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
+      # CALCONNECT_TYPE_MAP remains as the key_value polymorphic_map.
+
+      # Parse a CalConnect identifier string into an identifier object.
+      # @param identifier [String] The CalConnect identifier string to parse
+      # @return [Identifier] The appropriate identifier object
+      # @raise [Pubid::Errors::InvalidInputError]
+      #   If the input exceeds the maximum length
+      # @raise [Pubid::Errors::ParseError] If parsing fails
+      def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        Builder.build(Parser.parse(identifier))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    module Identifiers
+      # The sole CalConnect document type. Its polymorphic_name resolves
+      # automatically to "pubid:calconnect:standard".
+      class Standard < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubcc,
+            stage_code: :published,
+            type_code: :cc,
+            abbr: ["CC"],
+            name: "CalConnect Standard",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cc,
+            web: :standard,
+            title: "CalConnect Standard",
+            short: "CC" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/calconnect/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    module Identifiers
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end

data/lib/pubid/calconnect/parser.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Calconnect
+    # Parslet grammar for CalConnect identifiers.
+    #
+    # Shape: CC[/<series>] <number>:<date>
+    #   CC 18011:2018
+    #   CC/DIR 10006:2019
+    #   CC/Adv 0707.1:2007        (dot sub-part)
+    #   CC/A 0812-1:2008          (dash sub-part)
+    #   CC/WD 51017:2024-07-23    (full ISO date)
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+
+      # Publisher token
+      rule(:publisher) { str("CC") }
+
+      # Series token — an open [A-Za-z]+ set (A, WD, R, S, CD, DIR, Adv, FDS, …)
+      rule(:series) { match["A-Za-z"].repeat(1).as(:series) }
+
+      # Number — digits, preserving leading zeros, with at most one dot- or
+      # dash-delimited sub-part ("0707.1", "0812-1"). Kept as a string.
+      rule(:number) do
+        (digits >> ((str(".") | str("-")) >> digits).maybe).as(:number)
+      end
+
+      # Date after the colon: a year, optionally a full "YYYY-MM-DD". The colon
+      # hard-delimits number from date, and month+day only appear together, so
+      # the split is unambiguous.
+      rule(:date) do
+        digits.as(:year) >>
+          (str("-") >> digits.as(:month) >> str("-") >> digits.as(:day)).maybe
+      end
+
+      rule(:identifier) do
+        publisher >>
+          (str("/") >> series).maybe >>
+          str(" ") >>
+          number >>
+          (str(":") >> date).maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/calconnect/renderer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    # Human-readable renderer for CalConnect identifiers.
+    #
+    # Produces the canonical printed form, e.g.:
+    #   "CC 18011:2018"
+    #   "CC/DIR 10006:2019"
+    #   "CC/WD 51017:2024-07-23"
+    #   "DIR 10006:2019"          (only when with_publisher: false)
+    #
+    # Registered as the `:human` format in the CalConnect format registry and
+    # invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "CC"
+
+      def render(**_opts)
+        id = @id
+        prefix = if with_publisher?(id)
+                   id.series ? "#{PUBLISHER}/#{id.series} " : "#{PUBLISHER} "
+                 else
+                   id.series ? "#{id.series} " : ""
+                 end
+        date = id.date_string
+        "#{prefix}#{id.number}#{":#{date}" if date}"
+      end
+
+      private
+
+      def with_publisher?(id)
+        id.respond_to?(:with_publisher) && id.with_publisher != false
+      end
+    end
+  end
+end

data/lib/pubid/calconnect/urn_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    # Emits CalConnect URNs of the form
+    #   urn:calconnect[:<series>]:<number>:<date>
+    # e.g. "urn:calconnect:DIR:10006:2019", "urn:calconnect:18011:2018",
+    # "urn:calconnect:WD:51017:2024-07-23".
+    #
+    # The series keeps its printed case (JIS keeps its code case likewise) so a
+    # URN reconstructs the human form losslessly — mirror in urn_parser.rb.
+    #
+    # NOTE: a *partial* (date-less) reference has NO round-trippable URN form.
+    # Both `series` and `date` are optional, and UrnParser reads the trailing
+    # segments positionally, so a date-less URN like "urn:calconnect:11001"
+    # (or "urn:calconnect:DIR:10006") is ambiguous with a series-less dated URN
+    # and does not parse back. Partial refs are matched by pubid `#exclude`,
+    # not by URN, so this generator simply omits the missing segment rather
+    # than emitting an empty ":" — callers must not rely on URN round-trip for
+    # a partial id.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        # series and date_string are nil for a series-less or partial
+        # (date-less) id; compact drops them so no empty ":" segment appears.
+        parts = [
+          "urn", "calconnect",
+          identifier.series, identifier.number.to_s, identifier.date_string
+        ]
+        parts.compact.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/calconnect/urn_parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Calconnect
+    # Parses CalConnect URNs back into identifiers.
+    #
+    # UrnGenerator emits: urn:calconnect[:<series>]:<number>:<date>
+    #   urn:calconnect:18011:2018            → CC 18011:2018
+    #   urn:calconnect:DIR:10006:2019        → CC/DIR 10006:2019
+    #   urn:calconnect:WD:51017:2024-07-23   → CC/WD 51017:2024-07-23
+    #
+    # The date segment (year or full "YYYY-MM-DD") never contains a colon, so
+    # it is a single trailing part; the number precedes it, and an optional
+    # series precedes the number.
+    #
+    # This positional pop assumes a *dated* URN (the form UrnGenerator emits for
+    # a full id). A partial (date-less) reference has no round-trippable URN —
+    # see UrnGenerator — so this parser is only guaranteed for URNs produced
+    # from a full id; a date-less URN misaligns the pops and will not parse.
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        parts = split_parts(strip_namespace(urn))
+        date = parts.pop
+        number = parts.pop
+        series = parts.pop
+
+        text = +"CC"
+        text << "/#{series}" if series
+        text << " #{number}:#{date}"
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/calconnect.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  # CalConnect (The Calendaring and Scheduling Consortium) flavor.
+  #
+  # Parses/renders the "CC …" numbering, e.g. "CC 18011:2018",
+  # "CC/DIR 10006:2019", "CC/Adv 0707.1:2007". Modeled on Pubid::Jis: a single
+  # flat identifier type (Identifiers::Standard) with no supplement layer.
+  module Calconnect
+    extend Pubid::PrefixesSupport
+
+    # Sole CalConnect publisher/leading token. Series letters (A, WD, R, S, CD,
+    # DIR, Adv, FDS) follow "CC/" and never lead a reference, so they are
+    # excluded per the PrefixesSupport inclusion policy.
+    PREFIXES = ["CC"].freeze
+
+    autoload :Builder, "#{__dir__}/calconnect/builder"
+    autoload :Identifier, "#{__dir__}/calconnect/identifier"
+    autoload :Identifiers, "#{__dir__}/calconnect/identifiers"
+    autoload :Parser, "#{__dir__}/calconnect/parser"
+    autoload :Renderer, "#{__dir__}/calconnect/renderer"
+    autoload :UrnGenerator, "#{__dir__}/calconnect/urn_generator"
+    autoload :UrnParser, "#{__dir__}/calconnect/urn_parser"
+
+    # Parse a CalConnect identifier string
+    def self.parse(identifier)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      Identifier.parse(identifier)
+    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: Calconnect::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
+end
+
+# Register CalConnect flavor with the registry
+Pubid::Registry.register(:calconnect, Pubid::Calconnect)

data/lib/pubid/ccsds/builder.rb

@@ -47,7 +47,7 @@ module Pubid
         # If multiple corrigenda exist, we build the last one wrapping the base
         corr_numbers.reduce(base) do |current_base, cor_num|
           Identifiers::Corrigendum.new(
-            base_identifier: current_base,
+            base: current_base,
             number: cor_num,
           )
         end

data/lib/pubid/ccsds/identifier.rb

@@ -10,7 +10,7 @@ module Pubid
     #
     # Keeping the root abstract (it is never itself a serialized type, so it is
     # absent from CCSDS_TYPE_MAP) is what breaks the polymorphic recursion a
-    # supplement's `base_identifier` would otherwise hit if it pointed at a
+    # supplement's `base` would otherwise hit if it pointed at a
     # concrete type that is also its own superclass.
     class Identifier < ::Pubid::Identifier
       # CCSDS stores every code component as a plain string (the Builder passes
@@ -54,12 +54,19 @@ module Pubid
 
       # Parse a CCSDS identifier string into the appropriate identifier object.
       def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.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(identifier, :ccsds)
         parsed = Pubid::Ccsds::Parser.parse(normalized)
         Pubid::Ccsds::Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse CCSDS identifier '#{identifier}': #{e.message}"
       end
 
       # from_hash is the shared polymorphic dispatch on Pubid::Identifier.

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

@@ -24,14 +24,16 @@ module Pubid
           { key: :base, web: :base, title: "Base Standard", short: nil }
         end
 
-        def to_s(**_opts)
+        # Composes its string by hand rather than going through `render`, so
+        # the annotation hook has to be applied on the way out.
+        def to_s(**opts)
           result = "#{publisher} #{number}"
           result += ".#{part}" if part
           result += "-#{type}" if type
           result += "-#{edition}" if edition
           result += "-#{suffix}" if suffix
           result += " - #{language} Translated" if language
-          result
+          annotate_plain_render(result, **opts)
         end
       end
     end

data/lib/pubid/ccsds/identifiers/corrigendum.rb

@@ -24,15 +24,15 @@ module Pubid
         # The corrigendum sequence number is stored in the inherited `number`
         # attribute (mirroring ISO), so it serializes via Base's key_value as
         # { _type, number: '1', base: {...} } with no corrigendum-specific map.
-        def to_s
-          base_str = base_identifier.to_s
-          "#{base_str} Cor. #{number}"
+        def to_s(**opts)
+          base_str = base.to_s
+          annotate_plain_render("#{base_str} Cor. #{number}", **opts)
         end
 
         def ==(other)
           return false unless other.is_a?(Corrigendum)
 
-          base_identifier == other.base_identifier && number == other.number
+          base == other.base && number == other.number
         end
       end
     end

data/lib/pubid/ccsds/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Ccsds
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }
       rule(:alnum) { match["A-Za-z0-9"] }

data/lib/pubid/ccsds/single_identifier.rb

@@ -19,7 +19,7 @@ module Pubid
       attribute :type, Components::Type
       attribute :typed_stage, Components::TypedStage
 
-      def to_s(lang: :en, lang_single: false)
+      def to_s(lang: :en, lang_single: false, **opts)
         result = ""
 
         # Publisher
@@ -47,7 +47,7 @@ module Pubid
         # Language (optional)
         result += " - #{language.code} Translated" if language
 
-        result
+        annotate_plain_render(result, **opts)
       end
 
       def <=>(other)