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

data/lib/pubid/ieee/pre_parser.rb

@@ -4,7 +4,7 @@ module Pubid
   module Ieee
     # Pre-parser for IEEE identifiers.
     #
-    # Owns all regex/scan/dispatch logic that used to live on Identifiers::Base.parse.
+    # Owns all regex/scan/dispatch logic that used to live on Identifier.parse.
     # Base.parse becomes a thin orchestrator that asks PreParser for a decision
     # and then routes to the right builder.
     module PreParser

data/lib/pubid/ieee/renderer.rb

@@ -17,8 +17,52 @@ module Pubid
     # identifier's own publisher/code/relationship helpers.
     class Renderer < ::Pubid::Renderers::Base
       def render(context: nil, **opts)
-        id = @id
+        # IEEE attaches the trademark mark to the document number, before the
+        # year and every suffix ("IEEE Std 802.3®-2018"), so the mark is
+        # emitted by whichever method renders the number rather than appended
+        # to the finished string. A renderer instance is built per render call
+        # (Pubid::Identifier#render), so the flag is safe as instance state.
+        @trademark = opts[:trademark]
+
+        render_id(@id)
+      end
+
+      private
+
+      # Trademark mark for a document number, or "" when the flag is off.
+      # @param number [String, nil] bare document number
+      # @param prefix [String, nil] letter series of the code
+      # @param publishers [Array<String>] printed publisher tokens — the ®
+      #   series belongs to IEEE, not to another body numbering a document 802
+      def mark(number, prefix = nil, publishers: nil)
+        return "" unless @trademark
 
+        Pubid::Ieee.trademark_symbol_for(number, prefix, publishers: publishers)
+      end
+
+      # The publisher tokens an identifier prints, for the ® decision.
+      def publishers_of(id)
+        return id.publishers if id.respond_to?(:publishers) && id.publishers
+
+        copublishers = id.copublisher if id.respond_to?(:copublisher)
+        [id.publisher, *copublishers].compact
+      end
+
+      # Compose a child identifier, propagating the trademark flag only when it
+      # is safe. A foreign (non-IEEE) leaf may not accept the `trademark:`
+      # keyword at all — Pubid::Nist's `to_s(format = :short)` would silently
+      # swallow it as a positional Hash, and Pubid::Iso's would raise — and an
+      # adopted or parenthetical child is not the IEEE document being marked.
+      def child_to_s(child, **opts)
+        return child.to_s(**opts) unless @trademark &&
+          child.is_a?(Pubid::Ieee::Identifier)
+
+        child.to_s(**opts, trademark: true)
+      end
+
+      # Dispatch to the type-specific renderer, returning the composed string
+      # (each branch inserts the trademark mark at its own number boundary).
+      def render_id(id)
         case id
         when Identifiers::DualPublished
           render_dual_published(id)
@@ -28,6 +72,8 @@ module Pubid
           render_adopted_standard(id)
         when Identifiers::RedlinedStandard
           render_redlined_standard(id)
+        when Identifiers::Amendment
+          render_amendment(id)
         when Identifiers::Corrigendum
           render_corrigendum(id)
         when Identifiers::InterpretationIdentifier
@@ -45,14 +91,12 @@ module Pubid
         when Identifiers::SiStandard
           render_si_standard(id)
         when Identifiers::JointDevelopment
-          id.to_s
+          child_to_s(id)
         else
           render_base(id)
         end
       end
 
-      private
-
       # ------------------------------------------------------------------
       # Base IEEE identifier rendering
       # ------------------------------------------------------------------
@@ -70,12 +114,18 @@ module Pubid
         # Draft status
         parts << id.draft_status if id.draft_status
 
-        # Type - only render for IEEE/AIEE publishers, and only for non-projects
+        # Type - only render for IEEE/AIEE publishers, and only for non-projects.
+        # An unapproved draft is not yet a standard, so per IEEE guidance the
+        # "Std" token is dropped from the type when draft_status is "Unapproved"
+        # (e.g. "Draft Std" -> "Draft", "Std" -> "").
         should_render_type = id.publisher&.match?(/^(IEEE|AIEE)/)
 
         if should_render_type && !id.typed_stage&.project_status && id.type && !id.type.to_s.strip.empty? && id.type != "P"
           type_str = id.type.dup
           type_str = type_str.sub(/^P/, "") if type_str.start_with?("P")
+          if id.draft_status.to_s.match?(/unapproved/i)
+            type_str = type_str.gsub(/\bStd\b/i, "").squeeze(" ").strip
+          end
           parts << type_str unless type_str.strip.empty?
         end
 
@@ -88,9 +138,19 @@ module Pubid
             result = "P#{result}"
           end
 
+          # Trademark mark — right after the number and its parts, before the
+          # year, the revision, the draft and every other suffix.
+          result += mark(id.code_obj.number, id.code_obj.prefix,
+                         publishers: publishers_of(id))
+
           # Only attach year to code if there's no edition, no month, and no draft
           result += "-#{id.year}" if id.year && !id.draft_obj && !id.edition && !id.month
 
+          # Append the numbered/lettered revision inline, in IEEE's native
+          # position — right after the code number and before the draft
+          # ("P802.16Rev2/D3"). Keeps a revision distinct from its base standard.
+          result += "Rev#{id.revision}" if id.revision
+
           # Append draft to code - with or without space based on original format
           if id.draft_obj
             result += id.space_before_draft ? " #{id.draft_obj}" : id.draft_obj.to_s
@@ -99,11 +159,9 @@ module Pubid
           # Append interpretation notation (/INT)
           result += "/INT" if id.interpretation
 
-          # Append conformance notation (/ConformanceNN-YYYY)
-          if id.conf_number
-            result += "/Conformance#{id.conf_number}"
-            result += "-#{id.conf_year}" if id.conf_year
-          end
+          # Conformance is always built as a ConformanceIdentifier wrapper
+          # (render_conformance), never inline on a base standard — the base no
+          # longer carries a conf_number attribute.
 
           # Append ASHRAE joint publication (/ASHRAE Guideline NN-YYYY)
           if id.ashrae_number
@@ -138,31 +196,30 @@ module Pubid
           result += ", #{id.month}"
           result += " #{id.day}" if id.day
           if id.year && !id.edition
-            result += ", #{id.year}"
+            result += " #{id.year}"
           end
         end
 
-        # Add parenthetical content if present
+        # Bounded parenthetical markers only. The unbounded relationship/
+        # amendment narrative (relationships, revision_of, amendment_to,
+        # adoption, note) is deliberately NOT rendered here: an
+        # "as amended by …" list can run 300+ chars, and an identifier's to_s
+        # is used by consumers (relaton) as a document number and filename. The
+        # narrative is preserved on the runtime accessors (id.relationships
+        # etc.), just not embedded in the identifier string.
         parentheticals = []
 
+        # Reaffirmation year — a bounded status marker.
         reaff = id.reaffirmed
-        if reaff && !reaff.to_s.strip.empty?
-          parentheticals << "(R#{reaff})"
-        end
+        parentheticals << "(R#{reaff})" if reaff && !reaff.to_s.strip.empty?
 
+        # The catch-all parenthetical is a bounded, printed identity token, not
+        # relationship prose (e.g. the "S-135 (IPCEA P46-426)" co-designation).
+        # Long amendment narratives match the structural relationship grammar
+        # and land in `relationships`, never in this catch-all, so it stays
+        # bounded.
         if id.parenthetical_content
           parentheticals << "(#{id.parenthetical_content})"
-        elsif id.relationships && !id.relationships.empty?
-          relationship_str = id.relationships.join(" / ")
-          parentheticals << "(#{relationship_str})"
-        elsif id.revision_of
-          parentheticals << "(Revision of IEEE Std #{id.revision_of})"
-        elsif id.amendment_to
-          parentheticals << "(Amendment to IEEE Std #{id.amendment_to})"
-        elsif id.adoption
-          parentheticals << "(Adoption of #{id.adoption})"
-        elsif id.note && !id.note.to_s.strip.empty?
-          parentheticals << "(#{id.note})"
         end
 
         result += " #{parentheticals.join(' ')}" unless parentheticals.empty?
@@ -181,15 +238,19 @@ module Pubid
       # ------------------------------------------------------------------
 
       def render_dual_published(id)
-        "#{id.first_identifier} and #{id.second_identifier}"
+        "#{child_to_s(id.first_identifier)} and " \
+          "#{child_to_s(id.second_identifier)}"
       end
 
       def render_dual_identifier(id)
-        "#{id.first_identifier} and #{id.second_identifier}"
+        "#{child_to_s(id.first_identifier)} and " \
+          "#{child_to_s(id.second_identifier)}"
       end
 
       def render_adopted_standard(id)
-        result = id.ieee_identifier.to_s
+        # Only the IEEE designation is marked; the adopted identifiers are
+        # other bodies' documents (and may be foreign pubid objects).
+        result = child_to_s(id.ieee_identifier)
         if id.adopted_identifiers && !id.adopted_identifiers.empty?
           adopted_strs = id.adopted_identifiers.map(&:to_s)
           result += " (#{adopted_strs.join(' and ')})"
@@ -198,68 +259,101 @@ module Pubid
       end
 
       def render_redlined_standard(id)
-        result = id.base_identifier.to_s
+        result = child_to_s(id.base)
+        # NOTE: currently unreachable — a redline is built as a flat
+        # `redline: true` on a plain Standard (see the redline invariant in
+        # CLAUDE.md), so determine_identifier_class never routes here. Kept for
+        # completeness; if this path is ever revived, note `revision_of` is a
+        # bounded single-id reference, unlike the unbounded relationship
+        # narrative that render_base deliberately drops.
         result += " (Revision of #{id.revision_of})" if id.revision_of
         result += " - Redline" if id.redline
         result
       end
 
       def render_corrigendum(id)
-        return render_base(id) unless id.base_identifier
+        return render_base(id) unless id.base
 
-        result = id.base_identifier.to_s
+        result = child_to_s(id.base)
         result += "/Cor"
-        result += ". " if id.cor_number # Add period and space for formal format
-        result += id.cor_number if id.cor_number
-        result += "-#{id.cor_year}" if id.cor_year
+        result += ". " if id.number # Add period and space for formal format
+        result += id.number if id.number
+        result += "-#{id.year}" if id.year
+        result
+      end
+
+      def render_amendment(id)
+        return render_base(id) unless id.base
+
+        result = child_to_s(id.base)
+        result += "/Amd"
+        result += " #{id.number}" if id.number # canonical "/Amd 4-2020"
+        result += "-#{id.year}" if id.year
         result
       end
 
       def render_interpretation(id)
-        return render_base(id) unless id.base_identifier
+        return render_base(id) unless id.base
 
-        result = id.base_identifier.to_s
+        result = child_to_s(id.base)
         result += "/INT"
-        result += "-#{id.int_year}" if id.int_year
+        result += "-#{id.year}" if id.year
         result
       end
 
       def render_conformance(id)
-        return render_base(id) unless id.base_identifier
+        return render_base(id) unless id.base
 
-        result = id.base_identifier.to_s
-        result += "/Conformance#{id.conf_number}" if id.conf_number
-        result += "-#{id.conf_year}" if id.conf_year
+        result = child_to_s(id.base)
+        result += "/Conformance#{id.number}" if id.number
+        result += "-#{id.year}" if id.year
         result
       end
 
       def render_multi_numbered(id)
-        return id.primary_identifier.to_s unless id.secondary_identifier
+        return child_to_s(id.primary_identifier) unless id.secondary_identifier
+
+        # Co-equal designations: each carries its own mark, before its own
+        # suffixes, as IEEE prints them.
+        primary = child_to_s(id.primary_identifier)
+        secondary = child_to_s(id.secondary_identifier)
 
         secondary_code = id.secondary_identifier.code.to_s
         if secondary_code.start_with?("C") && secondary_code.match?(/^C\d+\./)
-          "#{id.primary_identifier}/#{id.secondary_identifier}"
+          # A cross-reference prints the bare second designation after the
+          # slash — "IEEE Std 1299/C62.22.1-1996" — not a second full
+          # reference, so this branch must not reuse `secondary`, which
+          # carries its own "IEEE Std " prefix.
+          "#{primary}/#{secondary_code}"
         else
-          "#{id.primary_identifier} and #{id.secondary_identifier}"
+          "#{primary} and #{secondary}"
         end
       end
 
       def render_parenthetical(id)
-        result = id.base_identifier.to_s
+        # The mark belongs on the base; the parenthetical is a separate token.
+        result = child_to_s(id.base)
         result += " (#{id.parenthetical_identifier})" if id.parenthetical_identifier
         result
       end
 
       def render_csa_dual_published(id)
+        # csa_identifier is a Pubid::Csa object — never marked.
         csa_str = id.csa_identifier.to_s
         csa_str = "CSA #{csa_str}" unless csa_str.start_with?("CSA", "CAN/")
 
-        "#{id.ieee_identifier}/#{csa_str}"
+        "#{child_to_s(id.ieee_identifier)}/#{csa_str}"
       end
 
       def render_iec_ieee_copublished(id)
         result = "IEC/IEEE"
-        result += " #{id.copublished_number}" if id.copublished_number
+        # copublished_number glues the parts and the publication year onto the
+        # number, so the mark is spliced in by that single implementation
+        # rather than rebuilt here; with the flag off it is passed "".
+        if id.copublished_number
+          result += " #{id.copublished_number(mark(id.number,
+                                                   publishers: %w[IEC IEEE]))}"
+        end
         result += id.draft_info if id.draft_info
         result += " IEC:#{id.iec_year}" if id.iec_year
         result += " #{id.date_info}" if id.date_info
@@ -279,8 +373,11 @@ module Pubid
                    "SI"
                  end
 
-        # Code (number) with draft version for PSI
+        # Code (number) with draft version for PSI — the mark goes after the
+        # code, before the draft and the date.
         code_part = id.code.to_s
+        code_part += mark(id.code_obj&.number, id.code_obj&.prefix,
+                          publishers: publishers_of(id))
         if id.draft_obj
           code_part += "/D#{id.draft_obj.version}"
         end
@@ -293,14 +390,18 @@ module Pubid
           parts << "-#{id.year}"
         end
 
-        # Relationships (if present)
-        result = parts.join(" ")
-        if id.relationships && !id.relationships.empty?
-          rel_strs = id.relationships.map(&:to_s)
-          result += " (#{rel_strs.join(' / ')})"
-        end
-
-        result
+        # Join parts with spaces, but don't insert a space before parts
+        # that start with "-" or "," (e.g., "-2010", ", July 2014") so the
+        # SI form renders as "SI 10-2010" not "SI 10 -2010". The descriptive
+        # relationships narrative is deliberately kept out of to_s (see
+        # render_base); it stays reachable on id.relationships.
+        parts.each_with_object([]) do |part, acc|
+          if acc.empty? || part.to_s.start_with?("-", ",")
+            acc << part.to_s
+          else
+            acc << " " << part.to_s
+          end
+        end.join
       end
     end
   end

data/lib/pubid/ieee/typed_stages.rb

@@ -101,7 +101,7 @@ module Pubid
         ),
 
         Components::TypedStage.new(
-          abbr: ["CD", "CD2", "CD3"],
+          abbr: ["CD", "CD1", "CD2", "CD3", "CD4"],
           stage_code: "committee_draft",
           type_code: "draft",
           ieee_draft_equivalent: "D2-D3",
@@ -110,6 +110,17 @@ module Pubid
           project_status: true,
         ),
 
+        # Committee Draft for Vote (IEC/ISO-led historical stage)
+        Components::TypedStage.new(
+          abbr: ["CDV"],
+          stage_code: "committee_draft_for_vote",
+          type_code: "draft",
+          ieee_draft_equivalent: "D2-D3",
+          iso_stage_equivalent: "CDV",
+          approval_status: "unapproved",
+          project_status: true,
+        ),
+
         Components::TypedStage.new(
           abbr: ["DIS"],
           stage_code: "draft_international_standard",

data/lib/pubid/ieee/urn_generator.rb

@@ -17,7 +17,8 @@ module Pubid
         cc = code_component
         parts << cc if cc
 
-        parts << identifier.year if identifier.year
+        yc = year_component
+        parts << yc if yc
 
         dc = draft_component
         parts << dc if dc
@@ -39,11 +40,9 @@ module Pubid
           parts << "int"
         end
 
-        if special_type != "conformance" && identifier.conf_number
-          conf = "conf.#{identifier.conf_number}"
-          conf += "-#{identifier.conf_year}" if identifier.conf_year
-          parts << conf
-        end
+        # Conformance is always a ConformanceIdentifier wrapper (special_type
+        # "conformance"), never inline on a base standard — the base no longer
+        # carries a conf_number attribute, so there is no inline conf part.
 
         if identifier.ashrae_number
           ashrae = "ashrae.#{identifier.ashrae_number}"
@@ -128,8 +127,7 @@ module Pubid
       end
 
       def publisher_component
-        pub = identifier.publisher || "IEEE"
-        pub = pub.to_s.downcase
+        pub = normalized_publisher
 
         if identifier.copublisher&.any?
           copubs = identifier.copublisher.map(&:to_s).map(&:downcase)
@@ -139,6 +137,18 @@ module Pubid
         pub
       end
 
+      # A dual-published document has TWO publishers, and
+      # DualPublished#publisher returns them as an Array — which `to_s`
+      # rendered into the URN as a literal Ruby array literal, brackets and
+      # quotes included: `urn:ieee:["ieee", "asme"]`. Join them the same way a
+      # copublisher list is joined above.
+      def normalized_publisher
+        names = Array(identifier.publisher)
+          .map { |p| p.to_s.downcase }.reject(&:empty?)
+
+        names.empty? ? "ieee" : names.join("-")
+      end
+
       def type_component
         return nil unless identifier.type
 
@@ -154,6 +164,23 @@ module Pubid
         identifier.code_obj.to_s
       end
 
+      # A multi-designation wrapper (AdoptedStandard, DualPublished,
+      # MultiNumberedIdentifier) carries no year of its own — the year sits on
+      # the designation it wraps — so the URN dropped it and two editions of
+      # one document produced the SAME urn: "AIEE No 15-1944" and
+      # "AIEE No 15-1959" both gave urn:ieee:aiee:15.
+      #
+      # Fixed here, in the one place that reads the year, rather than by
+      # defining a `#year` method on each wrapper: `year` is a lutaml attribute
+      # on the base and a method of that name would shadow its generated
+      # accessor. `#root` already walks to the wrapped designation.
+      def year_component
+        return identifier.year if identifier.year
+
+        root = identifier.root
+        root.equal?(identifier) ? nil : root.year
+      end
+
       def draft_component
         return nil unless identifier.draft_obj
 

data/lib/pubid/ieee.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Ieee
     extend Pubid::PrefixesSupport
@@ -12,12 +13,13 @@ module Pubid
 
     autoload :Aiee, "#{__dir__}/ieee/aiee"
     autoload :Builder, "#{__dir__}/ieee/builder"
-    autoload :Identifier, "#{__dir__}/ieee/identifier"
+    autoload :Identifier, "#{__dir__}/ieee/identifiers/base"
     autoload :Identifiers, "#{__dir__}/ieee/identifiers"
     autoload :Ire, "#{__dir__}/ieee/ire"
     autoload :Nesc, "#{__dir__}/ieee/nesc"
     autoload :Parser, "#{__dir__}/ieee/parser"
     autoload :PreParser, "#{__dir__}/ieee/pre_parser"
+    autoload :Compaction, "#{__dir__}/ieee/compaction"
     autoload :Renderer, "#{__dir__}/ieee/renderer"
     autoload :TypedStages, "#{__dir__}/ieee/typed_stages"
     autoload :UrnGenerator, "#{__dir__}/ieee/urn_generator"
@@ -31,15 +33,72 @@ module Pubid
       autoload :TypedStage, "#{__dir__}/ieee/components/typed_stage"
     end
 
+    # Document-number series carrying an IEEE registered trademark ("®").
+    # 8802 is the ISO/IEC co-published form of the 802 series.
+    REGISTERED_SERIES = %w[802 8802 2030].freeze
+
+    # The ISO/IEC adoption of IEEE 802: the number alone identifies the series,
+    # whatever publishers are printed.
+    ISO_ADOPTED_SERIES = "8802"
+
     class << self
       def 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 ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         Identifier.parse(input)
       end
 
+      # True when the document number belongs to a registered-trademark series.
+      # A project number keeps its series identity, so a leading "P" is
+      # stripped. `prefix` is the code's letter series, which must be absent
+      # (or the bare project "P") — "C802.1" is a different series that merely
+      # starts with the same digits. `publishers` guards against claiming an
+      # IEEE registered mark for another body that happens to have numbered a
+      # document 802 or 2030 — "AIEE Std No. 802" predates the IEEE 802 series
+      # by two decades. It is optional: with no publishers given the number
+      # decides, which keeps the plain number lookup usable on its own.
+      # @param number [String, nil] bare document number ("802", "P802")
+      # @param prefix [String, nil] letter series of the code ("C" for C37.09)
+      # @param publishers [Array<String>, String, nil] printed publisher tokens
+      def registered_series?(number, prefix = nil, publishers: nil)
+        return false unless prefix.nil? || prefix.to_s.empty? ||
+          prefix.to_s == "P"
+
+        bare = number.to_s.delete_prefix("P")
+        return false unless REGISTERED_SERIES.include?(bare)
+        return true if bare == ISO_ADOPTED_SERIES || publishers.nil?
+
+        Array(publishers).any? { |p| p.to_s.split("/").include?("IEEE") }
+      end
+
+      # IEEE trademark symbol for a document number: ® for the registered
+      # series, ™ for everything else. This is the entry point render sites
+      # use, because they hold the identifier and so know its number — the
+      # symbol must not depend on where in the rendered string the mark lands.
+      def trademark_symbol_for(number, prefix = nil, publishers: nil)
+        if registered_series?(number, prefix, publishers: publishers)
+          "®"
+        else
+          "™"
+        end
+      end
+
+      # IEEE trademark symbol for a rendered identifier string. Kept for
+      # external callers only — every render site inside pubid passes the
+      # document number to #trademark_symbol_for instead, because the first
+      # numeric token of a rendered string is not reliably the document number
+      # (a NESC or IRE string starts with the publication year).
+      def trademark_symbol(rendered)
+        trademark_symbol_for(rendered.to_s[/(?<![0-9A-Za-z])P?(\d+)/, 1])
+      end
+
       # Auto-discover all identifier types from the Identifiers namespace
       # @return [Array<Class>] identifier classes that define a self.type Hash
       def identifier_types
@@ -101,5 +160,5 @@ end
 Pubid::Registry.register(:ieee, Pubid::Ieee)
 
 # Per-flavor format registry: inherits global formats, overrides :human
-Pubid::Ieee::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::Ieee::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Ieee::Renderer)
+Pubid::Ieee::Identifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Ieee::Identifier.format_registry.register(:human, renderer: Pubid::Ieee::Renderer)

data/lib/pubid/ieee_debug.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Ieee
     autoload :Aiee, "#{__dir__}/aiee"

data/lib/pubid/ietf/builder.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    # Turns the Parser's parse tree into a concrete identifier object, choosing
+    # the class from which fields are present.
+    class Builder
+      SUBSERIES_CLASSES = {
+        "BCP" => "Bcp",
+        "STD" => "Std",
+        "FYI" => "Fyi",
+      }.freeze
+
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        if data.key?(:draft_rest)
+          build_draft(data)
+        elsif data[:series]
+          build_subseries(data)
+        else
+          build_rfc(data)
+        end
+      end
+
+      private
+
+      def build_rfc(data)
+        Identifiers::Rfc.new(number: unpad(data[:number]))
+      end
+
+      # The series token only selects the class: it is derived back from the
+      # class (Identifiers::Std::SERIES) rather than stored, since `_type`
+      # already carries it.
+      def build_subseries(data)
+        klass = Identifiers.const_get(
+          SUBSERIES_CLASSES.fetch(data[:series].to_s),
+        )
+        klass.new(number: unpad(data[:number]))
+      end
+
+      # Strip the zero-padding the RFC editor's rfc-index.xml writes ("STD0066",
+      # "RFC0001") so the canonical printed form is the unpadded one. The
+      # look-ahead keeps the last digit, so an all-zero number stays "0" rather
+      # than becoming empty.
+      def unpad(number)
+        number.to_s.sub(/\A0+(?=\d)/, "")
+      end
+
+      def build_draft(data)
+        full = "draft-#{data[:draft_rest]}"
+        slug, version = split_draft_version(full)
+        Identifiers::InternetDraft.new(number: slug, version: version)
+      end
+
+      # An Internet-Draft version is a trailing "-NN" of *exactly* two digits at
+      # the very end of the slug. A three-digit topic tail (e.g. "...-256") is
+      # NOT a version: there the char before the last two digits is itself a
+      # digit, not "-", so the guard below leaves it in the slug. This also
+      # means a (non-existent in practice) revision >= 100 would be read as part
+      # of the slug — IETF drafts are always two-digit-versioned, so that case
+      # never arises. Either way the printed string round-trips exactly.
+      #
+      # Dotted slugs need no special handling here: only the final three
+      # characters are inspected, so "draft-ietf-pilc-2.5g3g-12" splits into
+      # ("draft-ietf-pilc-2.5g3g", "12").
+      def split_draft_version(full)
+        if full.length > 3 && full[-3] == "-" && full[-2..].match?(/\A\d\d\z/)
+          [full[0...-3], full[-2..]]
+        else
+          [full, nil]
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifier.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Pubid::Ietf::Identifier is the IETF base class and the flavor's parse entry
+# point; its body lives in
+# identifiers/base.rb (mirrors the AMCA layout).