pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.9

data/lib/pubid/ieee/identifiers/iec_ieee_copublished.rb

@@ -3,15 +3,112 @@
 module Pubid
   module Ieee
     module Identifiers
-      # IEC/IEEE Copublished Identifier - represents standards copublished by IEC and IEEE
+      # IEC/IEEE Copublished Identifier - standards copublished by IEC and IEEE.
       # Example: "IEC/IEEE 60079-30-2/D5 IEC:2013 (10/07)"
-      class IecIeeeCopublished < Base
-        attribute :iec_identifier, Base, polymorphic: true
-        attribute :ieee_identifier, Base, polymorphic: true
-        attribute :copublished_number, :string  # The shared number like "60079-30-2"
+      #
+      # The printed IEC/IEEE number is stored as split index columns rather than
+      # a verbatim string: `number` (bare-digit narrowing key), `parts` (matched
+      # within the bucket), `separators` (per-part `.`/`-`, since a single code
+      # mixes them, e.g. `60076.57-1202`), and the trailing publication `year`
+      # (inherited from the base; attached with `year_sep`, always `-` in
+      # practice). The verbatim `copublished_number` is reconstructed from these
+      # for rendering — see #copublished_number — so it is NOT serialized.
+      class IecIeeeCopublished < Identifier
+        attribute :number, :string
+        attribute :parts, :string, collection: true, default: -> { [] }
+        attribute :separators, :string, collection: true, default: -> { [] }
+        attribute :year_sep, :string, default: -> { "-" }
+        # `year` is inherited from the base (:string).
+
+        attribute :iec_identifier, Identifier, polymorphic: true
+        attribute :ieee_identifier, Identifier, polymorphic: true
         attribute :draft_info, :string          # Draft information like "/D5"
         attribute :iec_year, :string            # IEC year like "2013"
         attribute :date_info, :string           # Date information like "(10/07)"
+
+        # The printed IEC/IEEE number, rebuilt losslessly from the split
+        # columns (the renderer/urn read this). Not stored — number/parts/
+        # separators/year fully describe it, so the verbatim string never
+        # bloats an index row.
+        # @param mark [String] IEEE trademark symbol, spliced in after the
+        #   number and its parts and before the publication year (IEEE prints
+        #   it there); "" for the ordinary, unmarked rendering.
+        def copublished_number(mark = "")
+          return nil if number.to_s.empty?
+
+          code = marked_code(mark)
+          code += "#{year_sep}#{year}" if year
+          code
+        end
+
+        # The dotted/dashed parts portion, each part with its own separator.
+        def parts_suffix
+          separators.zip(parts).map { |sep, part| "#{sep}#{part}" }.join
+        end
+
+        # A stage word printed ahead of the number (`FDIS 60079-30-2`,
+        # `CD2 P62704-5 ED1`, `TS P61869-105 ED1`). The lookahead — the next
+        # token must start like a document number — is what stops this eating a
+        # number that merely begins with a letter.
+        STAGE_PREFIX = /\A[A-Z]+\d*\s+(?=P?\d)/
+
+        # Inside the number token, the printed code stops early at:
+        #
+        # * a colon-attached publication year (`62582-2:2022`);
+        # * a dash/dot-attached 19xx/20xx year (`62395.1-2024 Redline`) — only
+        #   one a descriptive tail stranded inside the code gets here, since
+        #   #peel_copublished_year moves a genuinely trailing year into the
+        #   `year` attribute. The 19/20 prefix keeps a part that merely looks
+        #   like a year (`60076.57-1202`) from matching;
+        # * a glued parenthetical (`62704-1(E)`), which is a language marker
+        #   rather than part of the number.
+        CODE_END = /:\d{4}|[-.](?:19|20)\d{2}\z|\(/
+
+        # `number` + #parts_suffix with the mark spliced at the end of the code
+        # proper.
+        #
+        # Some copublished references carry an edition, a colon year, a stage
+        # word or a "- Redline" tail that the parser keeps inside
+        # `number`/`parts` rather than in dedicated attributes; appending the
+        # mark after all of it would print
+        # `IEC/IEEE 60076-16 Edition 2.0 2018-09™` instead of
+        # `IEC/IEEE 60076-16™ Edition 2.0 2018-09`. Scanning the whole printed
+        # code (not just the suffix) matters because the split point varies —
+        # `60802 Edition 1` lands in `number`, `-16 Edition 2` in `parts`.
+        #
+        # With the flag off `mark` is "" and this returns the code unchanged, so
+        # the plain rendering is byte-identical by construction.
+        def marked_code(mark)
+          code = "#{number}#{parts_suffix}"
+          return code if mark.to_s.empty?
+
+          at = code_end_index(code)
+          "#{code[0...at]}#{mark}#{code[at..]}"
+        end
+
+        # Index at which the printed code ends and descriptive text begins.
+        #
+        # The number is the first whitespace-delimited token after any stage
+        # word, so the code can never run past that token's end — which is what
+        # keeps the mark off a trailing edition/date phrase even when no
+        # CODE_END boundary matches inside the token.
+        def code_end_index(code)
+          start = code[STAGE_PREFIX]&.length || 0
+          token_end = code.index(" ", start) || code.length
+          boundary = code[start...token_end].index(CODE_END)
+          boundary ? start + boundary : token_end
+        end
+
+        # The base IEEE #exclude already nils year/month/day; also reset the
+        # year separator (a format sibling of the scalar year, per the CSA
+        # lesson) so a date-less reference matches a `:`-dated form too.
+        def exclude(*args)
+          result = super
+          if args.intersect?(%i[year date]) && result.respond_to?(:year_sep=)
+            result.year_sep = "-"
+          end
+          result
+        end
       end
     end
   end

data/lib/pubid/ieee/identifiers/interpretation_identifier.rb

@@ -7,7 +7,8 @@ module Pubid
       # Represents an interpretation sheet or clarification
       # Example: IEEE Std 1076/INT-1991, IEEE Std 1003.1-1988/INT
       class InterpretationIdentifier < SupplementIdentifier
-        attribute :int_year, :string
+        # Uniform `year` (the interpretation year), not `int_year` — inherited
+        # from the base, so no attribute is declared here.
 
         # TYPED_STAGES for interpretation
         # Interpretation uses "INT" abbreviation

data/lib/pubid/ieee/identifiers/joint_development.rb

@@ -29,18 +29,27 @@ module Pubid
       # - "P" prefix means IEEE project (any stage)
       # - ISO stages and IEEE drafts can coexist but are not equivalent
       # - Format conversion preserves semantic meaning within each system
-      class JointDevelopment < Base
+      class JointDevelopment < Identifier
+        # Split index columns (number/prefix/parts/separator) instead of a
+        # `code` string, like every IEEE leaf — see CodeNumber. Rendering reads
+        # `code` (base #code → code_obj), which CodeNumber rebuilds from the
+        # split fields, so to_ieee_format / to_iso_format are unaffected.
+        include CodeNumber
+
         attribute :publishers, :string, collection: true
         attribute :lead_party, :string              # "IEEE", "ISO", "IEC", etc.
-        attribute :code, :string
         attribute :typed_stage, Components::TypedStage
         attribute :year, :string
         attribute :iso_stage, :string               # For ISO stage if present
         attribute :ieee_draft, :string              # For IEEE P/D notation if present
 
-        def initialize(**args)
+        # Accepts keyword args or a single positional hash (the base
+        # #exclude/matching rebuild passes the latter) — see
+        # Identifier#initialize.
+        def initialize(args = {}, **kwargs)
+          args = args.merge(kwargs) unless kwargs.empty?
           # Call super FIRST to initialize Lutaml::Model attributes
-          super
+          super(args)
 
           # Then handle typed_stage
           if args[:typed_stage].is_a?(Components::TypedStage)
@@ -82,15 +91,25 @@ module Pubid
         # JointDevelopment has its own dual-format logic (IEEE vs ISO)
         # that doesn't go through the format registry renderer.
         # @param format [Symbol] :ieee or :iso (defaults to canonical_format)
+        # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
         # @return [String] formatted identifier
-        def to_s(format: canonical_format)
+        def to_s(format: canonical_format, trademark: false)
+          # The mark goes after the code number, before the draft and the year
+          # ("ISO/IEC/IEEE P26511™/D8-2018"), so it is threaded into the
+          # format builders rather than appended to the finished string.
+          mark = if trademark
+                   Pubid::Ieee.trademark_symbol_for(code&.number,
+                                                    code&.prefix,
+                                                    publishers: publishers)
+                 else
+                   ""
+                 end
+
           case format
           when :iso
-            to_iso_format
-          when :ieee
-            to_ieee_format
+            to_iso_format(mark)
           else
-            to_ieee_format
+            to_ieee_format(mark)
           end
         end
 
@@ -99,7 +118,7 @@ module Pubid
         # Convert to ISO format representation
         # ISO/IEC/IEEE FDIS 26511:2018
         # @return [String] ISO format string
-        def to_iso_format
+        def to_iso_format(mark = "")
           parts = []
 
           # Publishers (slash-separated)
@@ -117,6 +136,7 @@ module Pubid
 
           # Code (NO P prefix in ISO format, NO draft notation)
           code_str = code.to_s.gsub(/^P/, "")
+          code_str += mark unless code_str.empty?
           parts << code_str if code_str && !code_str.empty?
 
           # Join with space and add year with colon
@@ -129,7 +149,7 @@ module Pubid
         # Convert to IEEE format representation
         # ISO/IEC/IEEE P26511/D8-2018
         # @return [String] IEEE format string
-        def to_ieee_format
+        def to_ieee_format(mark = "")
           parts = []
 
           # Publishers (slash-separated)
@@ -143,6 +163,9 @@ module Pubid
             code_str = "P#{code_str}"
           end
 
+          # Mark after the number, before the draft and the year
+          code_str += mark unless code_str.empty?
+
           # Add IEEE draft notation if available (e.g., /D8)
           if ieee_draft
             code_str += "/#{ieee_draft}"
@@ -159,6 +182,12 @@ module Pubid
           result
         end
 
+        # Public again: these override base accessors and MUST be public — lutaml
+        # serialization calls `public_send(:publisher)`, so leaving them under the
+        # `private` above made JointDevelopment#to_hash raise (it could not be
+        # serialized or round-tripped / indexed at all).
+        public
+
         # Override to ensure proper publisher handling
         def publisher
           publishers&.first || super
@@ -168,6 +197,22 @@ module Pubid
         def copublisher
           publishers&.drop(1) || super
         end
+
+        # `publisher`/`copublisher` are *derived* from `publishers` (the source
+        # of truth, which IS serialized). Emitting them too breaks the canonical
+        # round-trip: the derived `publisher` is default-omitted on the parse
+        # path but re-emitted after from_hash (the override returns
+        # publishers.first, not the default). Drop both — publishers rebuilds
+        # them. (JointDevelopment is a top-level root, never nested, so a
+        # to_hash-level drop is sufficient.)
+        def to_hash(*args)
+          hash = super
+          if hash.is_a?(::Hash)
+            hash.delete("publisher")
+            hash.delete("copublisher")
+          end
+          hash
+        end
       end
     end
   end

data/lib/pubid/ieee/identifiers/multi_numbered_identifier.rb

@@ -8,7 +8,7 @@ module Pubid
       # Examples:
       # - "IEEE Std 1299/C62.22.1-1996" (same document, two numbers)
       # - "IEEE Std 960-1989, Std 1177-1989" (same document, two numbers)
-      class MultiNumberedIdentifier < Base
+      class MultiNumberedIdentifier < Identifier
         # Primary identifier (main IEEE standard number)
         # Stored as-is (Lutaml model type checking doesn't work with polymorphic identifiers)
         attr_accessor :primary_identifier

data/lib/pubid/ieee/identifiers/nesc/base.rb

@@ -13,21 +13,58 @@ module Pubid
         #
         # @example Standard format
         #   nesc = Pubid::Ieee.parse("C2-1997 National Electric Safety Code")
-        #   nesc.code.value  # => "C2"
-        #   nesc.year.year   # => 1997
+        #   nesc.code.number # => "2"   (prefix "C")
+        #   nesc.year        # => "1997"
         #
         # @example Handbook format
         #   nesc = Pubid::Ieee.parse("2017 NESC Handbook, Premier Edition")
-        #   nesc.year.year   # => 2017
+        #   nesc.year        # => "2017"
         #   nesc.variant     # => "Handbook"
         #   nesc.edition     # => "Premier Edition"
-        class Base < Lutaml::Model::Serializable
-          attribute :code, Pubid::Ieee::Components::Code # "C2" code designation
-          attribute :year, Pubid::Components::Date # Publication year
-          attribute :variant, :string              # Handbook, Redline, etc.
-          attribute :edition, :string              # Edition notation
-          attribute :draft, :boolean               # Draft flag
-          attribute :month, :string                # For draft identifiers
+        #
+        # Reparented onto Pubid::Ieee::Identifier (it used to descend from bare
+        # Lutaml::Model::Serializable) so NESC shares `#root`, a polymorphic
+        # `_type` and from_hash routing with every other IEEE type — see
+        # Pubid::Ieee::Aiee::Identifier for the same migration. Three
+        # attributes were reconciled against the base to avoid type collisions:
+        #
+        #   `code`  -> travels as the runtime `code_obj` (base #code returns
+        #              it); the concrete leaves serialize the flat split
+        #              columns via the CodeNumber mixin.
+        #   `year`  -> the base's plain `:string` year (was a
+        #              Pubid::Components::Date), matching IEEE's scalar-date
+        #              convention. `nesc.year` is now "2017", not a component.
+        #   `draft` -> dropped; the base declares a `:string` `draft` (the draft
+        #              *designator*), so a boolean here would corrupt it. Test
+        #              draft-ness with `#draft?` / the Nesc::Draft class.
+        #
+        # This class is abstract and enforces it in #initialize: the builder
+        # always instantiates a concrete leaf (Nesc::Edition for the plain
+        # year-first form), because only leaves may redefine `number` as a
+        # :string (see the CodeNumber mixin) and only leaves declare the
+        # NESC-specific `polymorphic_name` that from_hash routes on.
+        class Base < Pubid::Ieee::Identifier
+          attribute :variant, :string # Handbook, Redline, etc.
+          # Registered-trademark "(R)" after the full name or abbreviation
+          attribute :registered, :boolean
+          # Whether the "(NESC)"/"(NESC(R))" abbreviation suffix was present
+          attribute :abbr_suffix, :boolean
+          # Registered-trademark "(R)" inside the "(NESC(R))" suffix
+          attribute :abbr_suffix_registered, :boolean
+
+          # Guards the abstract contract — see the class docs. Ruby has no
+          # `abstract`, and an instantiated Base would carry the derived
+          # `_type` "pubid:ieee:base" (which from_hash cannot resolve back to
+          # NESC) and a nil `number` (the empty relaton index key).
+          def initialize(args = {}, **kwargs)
+            if instance_of?(Base)
+              raise NotImplementedError,
+                    "#{self.class} is abstract; instantiate a concrete NESC " \
+                    "type (Standard, Edition, Handbook, Redline, Draft)"
+            end
+
+            super
+          end
 
           # Publisher portion for NESC identifiers
           #
@@ -36,18 +73,52 @@ module Pubid
             "NESC"
           end
 
-          # Base rendering - override in subclasses
+          # Whether this is a draft of the code. NESC has no `draft` attribute
+          # of its own (the base's `draft` is the draft designator string), so
+          # draft-ness lives in the class.
+          #
+          # @return [Boolean]
+          def draft?
+            is_a?(Nesc::Draft)
+          end
+
+          # Rendering for year-first NESC identifiers (the C2-code standard form
+          # overrides this in Nesc::Standard). IEEE catalogues the year-first
+          # editions with the "IEEE Std" prefix, so it is prepended here.
           #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] String representation
-          def to_s
-            parts = []
-            if code && year
-              parts << "#{code}-#{year.year}"
-            elsif year
-              parts << year.year.to_s
+          def to_s(trademark: false)
+            result = ["IEEE Std", year, name_portion].compact.join(" ")
+            result += trademark_symbol if trademark
+            result
+          end
+
+          # Trademark symbol for this document's own code. A NESC string starts
+          # with the publication *year*, so the string-scanning
+          # Pubid::Ieee.trademark_symbol would pick the wrong field — an
+          # edition year of 2030 would silently render ®.
+          #
+          # @return [String] "®" or "™"
+          def trademark_symbol
+            Pubid::Ieee.trademark_symbol_for(code_obj&.number,
+                                             code_obj&.prefix,
+                                             publishers: [publisher])
+          end
+
+          # The document-name portion, including the registered marks and the
+          # optional "(NESC(R))" abbreviation suffix.
+          #
+          # @return [String] e.g. "National Electrical Safety Code(R) (NESC(R))"
+          def name_portion
+            name = "National Electrical Safety Code"
+            name += "(R)" if registered
+            if abbr_suffix
+              suffix = "NESC"
+              suffix += "(R)" if abbr_suffix_registered
+              name += " (#{suffix})"
             end
-            parts << "National Electrical Safety Code"
-            parts.join(" ")
+            name
           end
         end
       end

data/lib/pubid/ieee/identifiers/nesc/draft.rb

@@ -10,16 +10,31 @@ module Pubid
         # that are under development or review.
         #
         # @example
-        #   nesc = Pubid::Ieee.parse("Draft National Electrical Safety Code, January 2016")
-        #   nesc.to_s  # => "Draft National Electrical Safety Code, January 2016"
+        #   nesc = Pubid::Ieee.parse("Draft NESC, June 2011")
+        #   nesc.to_s
+        #   # => "Draft National Electrical Safety Code, June 2011"
+        #
+        # NOTE: the spelled-out "Draft National Electrical Safety Code, …" form
+        # is claimed by the generic IEEE grammar before it reaches the NESC
+        # sub-parser, so it does not currently build this class. Pre-existing
+        # dispatcher gap, pinned in spec/pubid/ieee/ire_nesc_roundtrip_spec.rb.
         class Draft < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-draft"
+          end
+
           # Render draft identifier
           #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] Draft format with optional month and year
-          def to_s
+          def to_s(trademark: false)
             parts = ["Draft National Electrical Safety Code"]
-            parts << ", #{month} #{year.year}" if month && year
-            parts.join
+            parts << ", #{month} #{year}" if month && year
+            result = parts.join
+            result += trademark_symbol if trademark
+            result
           end
         end
       end

data/lib/pubid/ieee/identifiers/nesc/edition.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        # A plain year-first NESC edition — the National Electrical Safety Code
+        # itself, referenced by publication year rather than by its C2 code.
+        #
+        # @example
+        #   nesc = Pubid::Ieee.parse(
+        #     "2017 National Electrical Safety Code(R) (NESC(R))",
+        #   )
+        #   nesc.to_s
+        #   # => "IEEE Std 2017 National Electrical Safety Code(R) (NESC(R))"
+        #
+        # Rendering is Nesc::Base's; this class exists so that the builder never
+        # instantiates the abstract Base. Only concrete leaves may carry the
+        # CodeNumber mixin's `:string` `number` (see the mixin's notes on the
+        # multi-flavor attribute-resolution landmine), and every identifier that
+        # can be a `#root` needs a non-empty `number` for the relaton index.
+        class Edition < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-edition"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/nesc/handbook.rb

@@ -11,19 +11,30 @@ module Pubid
         #
         # @example Basic handbook
         #   nesc = Pubid::Ieee.parse("2012 NESC Handbook")
-        #   nesc.to_s  # => "2012 NESC Handbook"
+        #   nesc.to_s  # => "IEEE Std 2012 NESC Handbook"
         #
         # @example With edition
         #   nesc = Pubid::Ieee.parse("2017 NESC Handbook, Premier Edition")
-        #   nesc.to_s  # => "2017 NESC Handbook, Premier Edition"
+        #   nesc.to_s  # => "IEEE Std 2017 NESC Handbook, Premier Edition"
         class Handbook < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-handbook"
+          end
+
           # Render handbook identifier
           #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] YYYY NESC Handbook format with optional edition
-          def to_s
-            parts = ["#{year.year} NESC Handbook"]
+          def to_s(trademark: false)
+            abbr = "NESC"
+            abbr += "(R)" if registered
+            parts = [["IEEE Std", year, "#{abbr} Handbook"].compact.join(" ")]
             parts << ", #{edition}" if edition
-            parts.join
+            result = parts.join
+            result += trademark_symbol if trademark
+            result
           end
         end
       end

data/lib/pubid/ieee/identifiers/nesc/redline.rb

@@ -13,11 +13,20 @@ module Pubid
         #   nesc = Pubid::Ieee.parse("2017 NESC Redline")
         #   nesc.to_s  # => "2017 NESC Redline"
         class Redline < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-redline"
+          end
+
           # Render redline identifier
           #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] YYYY NESC Redline format
-          def to_s
-            "#{year.year} NESC Redline"
+          def to_s(trademark: false)
+            result = [year, "NESC Redline"].compact.join(" ")
+            result += trademark_symbol if trademark
+            result
           end
         end
       end

data/lib/pubid/ieee/identifiers/nesc/standard.rb

@@ -13,11 +13,26 @@ module Pubid
         #   nesc = Pubid::Ieee.parse("C2-1997 National Electric Safety Code")
         #   nesc.to_s  # => "C2-1997 National Electrical Safety Code"
         class Standard < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          # Distinct from Identifiers::Standard, whose derived polymorphic name
+          # is also "pubid:ieee:standard".
+          def self.polymorphic_name
+            "pubid:ieee:nesc-standard"
+          end
+
           # Render standard NESC identifier
           #
-          # @return [String] C2-YYYY format
-          def to_s
-            "C2-#{year.year} National Electrical Safety Code"
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
+          # @return [String] C2-YYYY format (bare "C2" when the year is absent,
+          #   e.g. a partial reference produced by `#exclude(:year)`)
+          def to_s(trademark: false)
+            # Unlike the year-first NESC editions, this form renders a code, so
+            # the mark goes after it and before the year — as everywhere else.
+            code_part = "C2"
+            code_part += trademark_symbol if trademark
+            code_part += "-#{year}" if year
+            "#{code_part} National Electrical Safety Code"
           end
         end
       end

data/lib/pubid/ieee/identifiers/nesc.rb

@@ -6,6 +6,7 @@ module Pubid
       module Nesc
         autoload :Base, "#{__dir__}/nesc/base"
         autoload :Draft, "#{__dir__}/nesc/draft"
+        autoload :Edition, "#{__dir__}/nesc/edition"
         autoload :Handbook, "#{__dir__}/nesc/handbook"
         autoload :Redline, "#{__dir__}/nesc/redline"
         autoload :Standard, "#{__dir__}/nesc/standard"

data/lib/pubid/ieee/identifiers/parenthetical_identifier.rb

@@ -5,9 +5,9 @@ module Pubid
     module Identifiers
       # Parenthetical Identifier - wraps identifier with parenthetical annotation
       # Example: "IEEE Standard No 18-1968 (ANSI C55.1-1968)"
-      class ParentheticalIdentifier < Base
-        attribute :base_identifier, Base, polymorphic: true
-        attribute :parenthetical_identifier, Base, polymorphic: true
+      class ParentheticalIdentifier < Identifier
+        attribute :base, Identifier, polymorphic: true
+        attribute :parenthetical_identifier, Identifier, polymorphic: true
       end
     end
   end

data/lib/pubid/ieee/identifiers/project_draft_identifier.rb

@@ -8,7 +8,12 @@ module Pubid
       # where P1234 is the project number and D5 is the draft version
       # This is distinct from a StandardIdentifier - the "P" indicates project status,
       # not a code prefix like "C" in "C57.12"
-      class ProjectDraftIdentifier < Base
+      class ProjectDraftIdentifier < Identifier
+        # Reliable string `number` for relaton's index key (see CodeNumber).
+        # Its #initialize `super` chains through CodeNumber, which sets `number`
+        # from the (P-stripped) code after the parent builds code_obj.
+        include CodeNumber
+
         TYPED_STAGES = [
           Components::TypedStage.new(
             abbr: ["P"],
@@ -24,16 +29,19 @@ module Pubid
           { key: :P, title: "Project Draft", short: "P" }
         end
 
-        # Override initialize to strip "P" prefix from code before creating Code object
-        # The "P" is reflected in the typed_stage, not in the Code component itself
-        def initialize(**args)
+        # Override initialize to strip "P" prefix from code before creating Code
+        # object. The "P" is reflected in the typed_stage, not in the Code
+        # component itself. Accepts keyword args or a single positional hash (the
+        # base #exclude/matching rebuild passes the latter).
+        def initialize(args = {}, **kwargs)
+          args = kwargs.empty? ? args.dup : args.merge(kwargs)
           # If code is provided with "P" prefix (e.g., "P1234"), strip it
           if args[:code].is_a?(String) && args[:code].start_with?("P")
             args[:code] = args[:code][1..] # Strip leading "P"
           end
 
-          # Call parent initialize with modified code
-          super
+          # Call parent initialize with modified code (positional hash)
+          super(args)
         end
       end
     end

data/lib/pubid/ieee/identifiers/redlined_standard.rb

@@ -7,18 +7,18 @@ module Pubid
       # IEEE standard with optional revision note, marked as redline
       # Example: "IEEE Std 1018-2013 (Revison of IEEE Std 1018-2004) - Redline"
       # Contains: base standard + optional revision standard + redline flag
-      class RedlinedStandard < Base
+      class RedlinedStandard < Identifier
         # The current standard identifier
-        attribute :base_identifier, Base, polymorphic: true
+        attribute :base, Identifier, polymorphic: true
 
         # Optional: the standard this revises
-        attribute :revision_of, Base, polymorphic: true
+        attribute :revision_of, Identifier, polymorphic: true
 
         # Redline flag (always true for this class)
         attribute :redline, :boolean, default: -> { true }
 
         def publisher
-          base_identifier&.publisher || "IEEE"
+          base&.publisher || "IEEE"
         end
       end
     end