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

data/lib/pubid/iec/single_identifier.rb

@@ -8,6 +8,31 @@ module Pubid
       attribute :typed_stage, ::Pubid::Components::TypedStage,
                 default: -> { self.class.published_typed_stage }
 
+      # number/part/subpart are mapped HERE, not on Iec::Identifier, and the
+      # placement is the whole design.
+      #
+      # The four wrapper identifiers — FragmentIdentifier,
+      # ConsolidatedIdentifier, VapIdentifier and SheetIdentifier — inherit
+      # from Iec::Identifier DIRECTLY and override `number`/`part`/`subpart` as
+      # readers that delegate to what they wrap. A map on the shared parent
+      # would therefore serialize
+      # the delegated value twice: once at the wrapper's top level and again
+      # inside "base"/"identifiers". SingleIdentifier is the seam that excludes
+      # exactly those four while covering both classes that own a number of
+      # their own (Identifiers::Base and SupplementIdentifier).
+      #
+      # That is a structural exclusion, not a denylist of no-op converters that
+      # a later key can be forgotten from — which is how `month`/`day` came to
+      # leak (see DelegatedFieldSuppression).
+      #
+      # The values are plain strings, so no converter is needed: lutaml writes
+      # the scalar, and ::Pubid::Identifier#to_hash drops a nil.
+      key_value do
+        map "number", to: :number
+        map "part", to: :part
+        map "subpart", to: :subpart
+      end
+
       # Generate URN for this identifier
       #
       # @return [String] URN representation
@@ -28,16 +53,14 @@ module Pubid
                        publisher.body
                      end
 
-        # Add type abbreviation if present
-        if typed_stage && !typed_stage.abbreviation.empty?
-          abbr = typed_stage.abbreviation
-          # For copublishers or empty abbr, use space; otherwise use slash
-          pub_string += if copublishers&.any? || abbr == ""
-                          (abbr == "" ? "" : " #{abbr}")
-                        else
-                          "/#{abbr}"
-                        end
-        end
+        # IEC house style separates the publisher from the typed-stage
+        # abbreviation with a SPACE, for every type and whether or not there
+        # are copublishers: "IEC CD 60038", "IEC PNW 1000-1:2023". The slash
+        # stays the copublisher separator only. The slash input spelling
+        # ("IEC/CD 60038") is still accepted by the parser; only rendering
+        # normalises. See issue #360 item 2.
+        abbr = typed_stage&.abbreviation.to_s
+        pub_string += " #{abbr}" unless abbr.empty?
 
         pub_string
       end
@@ -48,7 +71,7 @@ module Pubid
           (part ? "-#{part}" : ""),
           (subpart ? "-#{subpart}" : ""),
           (stage_iteration ? ".#{stage_iteration}" : ""),
-          (date ? ":#{date.year}" : ""),
+          (date ? ":#{date.render}" : ""),
         ].join
       end
 

data/lib/pubid/iec/supplement_identifier.rb

@@ -4,7 +4,7 @@ module Pubid
   module Iec
     # Identifier that represents a supplement to a base identifier.
     class SupplementIdentifier < SingleIdentifier
-      attribute :base_identifier, Identifier, polymorphic: true
+      attribute :base, Identifier, polymorphic: true
 
       # Serialize the supplemented document under "base". The supplement's own
       # number/date/stage come from the inherited common maps; route the nested
@@ -15,10 +15,10 @@ module Pubid
       end
 
       def base_to_kv(model, doc)
-        base = model.base_identifier
+        base = model.base
         return unless base
 
-        # `base_identifier` synthesises a base for a supplement that has none
+        # `base` synthesises a base for a supplement that has none
         # (e.g. a bare "+AMD1:2008" nested in a consolidation): a fake doc whose
         # number equals the supplement's own. It renders nothing and the getter
         # recreates it identically on load, so don't persist it. A standalone
@@ -34,7 +34,7 @@ module Pubid
         return unless value
 
         base = ::Pubid::Iec::Identifier.from_hash(value)
-        model.base_identifier = base
+        model.base = base
 
         # A base of the exact SingleIdentifier class is the synthetic self-base
         # of a standalone supplement ("IEC/FDAM 60038-1"); a real attached base
@@ -55,18 +55,18 @@ module Pubid
         @supplement_number = @number
       end
 
-      # Override base_identifier getter to ensure it's always created for standalone supplements
-      def base_identifier
-        @base_identifier || ensure_base_identifier
+      # Override base getter to ensure it's always created for standalone supplements
+      def base
+        @base || ensure_base
       end
 
       # Override number getter to trigger swap for standalone supplements
       def number
-        # Guard against recursion in ensure_base_identifier
+        # Guard against recursion in ensure_base
         return @number if @ensuring_base
 
         # For standalone supplements, trigger base creation first
-        ensure_base_identifier if @synthetic_base.nil? && publisher && part
+        ensure_base if @synthetic_base.nil? && publisher && part
 
         if @synthetic_base
           @supplement_number || @number
@@ -85,7 +85,7 @@ module Pubid
         end
       end
 
-      # Delegate publisher and copublishers to base_identifier whenever there is
+      # Delegate publisher and copublishers to base whenever there is
       # a base (a supplement carries the publisher of the document it
       # supplements). Checking base first — rather than `@publisher || base` — is
       # required now that the publisher attribute has an IEC default, which would
@@ -93,20 +93,20 @@ module Pubid
       def publisher
         return @publisher if @ensuring_base
 
-        base_identifier ? base_identifier.publisher : @publisher
+        base ? base.publisher : @publisher
       end
 
       def copublishers
         return @copublishers if @ensuring_base
 
-        base_identifier ? base_identifier.copublishers : @copublishers
+        base ? base.copublishers : @copublishers
       end
 
-      # Ensure we have a base_identifier for standalone supplements
+      # Ensure we have a base for standalone supplements
       # Creates a synthetic base identifier from supplement attributes if needed
-      # Returns the base_identifier
-      def ensure_base_identifier
-        return @base_identifier if @base_identifier
+      # Returns the base
+      def ensure_base
+        return @base if @base
 
         # Guard flag to prevent recursion in number getter
         @ensuring_base = true
@@ -140,14 +140,14 @@ module Pubid
           stage_code: :undated,
         )
 
-        @base_identifier = base
+        @base = base
 
         # Store the supplement number for getter override
-        # The original number is the base number (moved to base_identifier)
+        # The original number is the base number (moved to base)
         # The original part is the supplement number (what we want to return)
         @supplement_number = supplement_number
 
-        @base_identifier
+        @base
       ensure
         @ensuring_base = false
       end
@@ -160,6 +160,19 @@ module Pubid
       def to_s(**opts)
         render(format: :human, **opts)
       end
+
+      # MR supplement suffix: `/{type}.{number}.{year}` (e.g. "/amd.1.2016").
+      # The MrString renderer recurses into `base` and appends this so the
+      # full supplement chain round-trips losslessly (issue #142).
+      def mr_supplement_suffix
+        segments = []
+        segments << mr_type if mr_type
+        segments << number&.to_s if number
+        segments << date&.year&.to_s if date&.year
+        return nil if segments.empty?
+
+        segments.join(".")
+      end
     end
   end
 end

data/lib/pubid/iec/urn_generator.rb

@@ -2,77 +2,243 @@
 
 module Pubid
   module Iec
-    # Generates IEC URNs in the legacy positional format used as ground truth
-    # by relaton-data-iec:
+    # Generates IEC URNs in the positional format used as ground truth by
+    # relaton-data-iec:
     #
-    #   urn:iec:std:{publisher}:{number}[-{part}]:{date}:{type}:{deliverable}:{language}[:{adjuncts}]
+    #   urn:iec:std:{authority}:{number}[-{part}[-{subpart}]]
+    #       :{date}:{stage-or-type}:{deliverable}:{language}{adjuncts}
     #
-    # e.g. +urn:iec:std:iec:60050-102:2007:::+ (type after date; trailing empty
-    # type/deliverable/language slots). This is a port of relaton-iec's
-    # +Relaton::Iec.code_to_urn+ operating on +identifier.to_s+, which
-    # round-trips faithfully. The all-parts series URN is the one exception: it
-    # omits the language slot (8 fields), so it has a dedicated branch.
+    # e.g. +urn:iec:std:iec:60050-102:2007:::+. Absent trailing slots are
+    # emitted as empty fields. The all-parts series URN is the one exception:
+    # a bare series omits the language slot (8 fields).
+    #
+    # This used to be a port of relaton-iec's +code_to_urn+, which regex-scraped
+    # +identifier.to_s+. Three defects followed from reading the printed form:
+    # the stage was folded into the authority slot (+urn:iec:std:iec-np:...+),
+    # the edition was never emitted, and the regex was unanchored, so any type
+    # token outside its hard-coded list consumed the publisher instead
+    # (+IEC/DTS 62271-1+ became +urn:iec:std:dts:62271-1::::+, and every
+    # +IECEE TRF ...+ keyed +urn:iec:std:trf:...+). The generator now reads the
+    # identifier's own components. The slot ORDER is unchanged, because the
+    # published corpus uses it. See issue #360 item 4.
     class UrnGenerator < Pubid::UrnGenerator::Base
-      # Deliverable markers occupying the positional deliverable slot.
-      DELIVERABLES = /cmv|csv|exv|prv|rlv|ser/
+      URN_CONTEXT = Rendering::RenderingContext.urn.freeze
+      private_constant :URN_CONTEXT
+
+      # Type codes that occupy the type slot. `is` and `trf` render empty
+      # there, as they always have. `tec` and `wp` never appear in the corpus
+      # but the legacy grammar accepted them, so they stay recognised.
+      TYPE_SLOT_CODES = %w[tr ts pas srd guide tec wp].freeze
+
+      # Deliverable markers occupying the deliverable slot. "ser" reaches this
+      # list as a spelled-out VAP code ("IEC 60034:2026 SER"), which is not the
+      # same thing as the `all_parts` series form handled below.
+      DELIVERABLES = %w[cmv csv exv prv rlv ser].freeze
+
+      # Supplement classes that contribute an adjunct, and the token each one
+      # writes into it.
+      ADJUNCT_TOKENS = {
+        "Amendment" => "amd",
+        "Corrigendum" => "cor",
+        "InterpretationSheet" => "ish",
+      }.freeze
 
       def generate
-        return series_urn if identifier.class.attributes.key?(:all_parts) && identifier.all_parts
+        doc = document
+        return nil if doc.nil?
 
-        code_to_urn(identifier.to_s, urn_language)
+        num = number_segment(doc)
+        return nil if num.nil? || num.empty?
+
+        slots = ["urn", "iec", "std", authority(doc), num,
+                 date_slot(doc), stage_or_type_slot(doc), deliverable_slot]
+        adjuncts = adjunct_slots(identifier)
+        language = language_slot
+        slots << language unless bare_series?(slots, adjuncts, language)
+
+        (slots + adjuncts).join(":").downcase
       end
 
       private
 
-      # Hyphen-joined language codes (e.g. "en-fr"), or nil when unset.
-      def urn_language
-        return nil unless identifier.class.attributes.key?(:languages)
-
-        langs = identifier.languages
-        return nil unless langs&.any?
-
-        langs.map(&:code).join("-")
-      end
-
-      # The all-parts series URN drops the language slot and carries no part or
-      # date: urn:iec:std:iec:80000:::ser.
-      def series_urn
-        code = identifier.to_s.sub(/\s*\(all parts\)\s*\z/, "")
-        m = code.downcase.match(/(?<head>\S+)\s+(?<pnum>[\d-]+)/)
-        head = m[:head].split("/").join("-")
-        ["urn", "iec", "std", head, m[:pnum], "", "", "ser"].join(":")
-      end
-
-      # Port of Relaton::Iec.code_to_urn.
-      def code_to_urn(code, lang = nil)
-        rest = code.downcase.sub(%r{
-          (?<head>[^\s]+)\s
-          (?<type>is|ts|tr|pas|srd|guide|tec|wp)?(?(<type>)\s)
-          (?<pnum>[\d-]+)\s?
-          (?<_dd>:)?(?(<_dd>)(?<date>[\d-]+)\s?)
-        }x, "")
-        m = $~
-        return unless m && m[:head] && m[:pnum]
-
-        deliv = DELIVERABLES.match(code.downcase).to_s
-        urn = ["urn", "iec", "std", m[:head].split("/").join("-"), m[:pnum],
-               m[:date], m[:type], deliv, lang]
-        (urn + adjunct_to_urn(rest)).join(":")
-      end
-
-      # Port of Relaton::Iec.ajunct_to_urn — recursively emits amd/cor/ish
-      # adjuncts, prefixing "plus" for the "+" (consolidated) relation.
-      def adjunct_to_urn(rest)
-        r = rest.sub(%r{
-          (?<pl>\+|/)(?(<pl>)(?<adjunct>(?:amd|cor|ish))(?<adjnum>\d+)\s?)
-          (?<_d2>:)?(?(<_d2>)(?<adjdt>[\d-]+)\s?)
-        }x, "")
-        m = $~ || {}
-        return [] unless m[:adjunct]
-
-        plus = "plus" if m[:pl] == "+"
-        urn = [plus, m[:adjunct], m[:adjnum], m[:adjdt]]
-        urn + adjunct_to_urn(r)
+      # The document the URN names: the origin standard, with every amendment,
+      # corrigendum, consolidation, VAP and fragment layer peeled off. Those
+      # layers are what the adjunct and deliverable slots record.
+      #
+      # A CISPR test report form carries no number of its own — the document it
+      # reports on sits in `cispr_identifier`, and that is what the URN has
+      # always named.
+      def document
+        doc = identifier.respond_to?(:root) ? identifier.root : identifier
+        return doc if doc.nil? || number_segment(doc)
+
+        maybe_of(doc, :cispr_identifier) || doc
+      end
+
+      # A publisher body may carry a space ("IEC CA", "IECQ CS", "IECQ OD").
+      # The published corpus records only the last token for those
+      # (+urn:iec:std:ca:01:2017:::+), which is what the old whitespace-
+      # splitting regex produced. Keeping that spelling is what keeps those
+      # rows byte-identical; correcting it to "iec-ca" would need a data
+      # migration first.
+      def authority(doc)
+        publishers = [doc.publisher] + Array(doc.copublishers)
+        publishers.compact.map { |p| p.body.to_s.split(/\s+/).last.to_s }
+          .reject(&:empty?).join("-")
+      end
+
+      def number_segment(doc)
+        return nil unless doc.respond_to?(:number) && doc.number
+
+        segment = [doc.number, maybe_of(doc, :part), maybe_of(doc, :subpart)]
+          .compact.map(&:to_s).reject(&:empty?).join("-")
+        return nil if segment.empty?
+
+        # A few document numbers are multi-word ("DIR 1 IEC SUP"). A URN
+        # carries no spaces, so they become hyphens.
+        segment.gsub(/\s+/, "-")
+      end
+
+      # `Components::Date#render` under a URN context deliberately drops the
+      # month, which is the ISO convention. IEC keeps the precision it was
+      # given ("IEC CA 01:2025-10" keys ...:2025-10:...), so this reads the
+      # printed form.
+      def date_slot(doc)
+        maybe_of(doc, :date).to_s
+      end
+
+      # The stage slot and the type slot are the same slot, and a draft of a
+      # typed document has both. Both are kept, type first
+      # ("ts-stage-50.00"), because the harmonized codes are shared across
+      # types: dropping the type would make a draft TS, a draft TR and a draft
+      # International Standard collide, and `parse_urn` would resolve every one
+      # of them to an International Standard.
+      def stage_or_type_slot(doc)
+        type = type_token(doc)
+        stage = stage_token(doc)
+
+        return type if stage.nil?
+
+        [type, stage].reject { |t| t.nil? || t.empty? }.join("-")
+      end
+
+      def type_token(doc)
+        ts = maybe_of(doc, :typed_stage)
+        code = ts&.type_code.to_s.downcase
+        TYPE_SLOT_CODES.include?(code) ? code : ""
+      end
+
+      # nil when the document is published (or carries no stage at all), so the
+      # slot keeps holding the bare type token for every published row.
+      def stage_token(doc)
+        stage = maybe_of(doc, :typed_stage)&.to_stage || maybe_of(doc, :stage)
+        harmonized = stage&.harmonized_stages&.first.to_s
+        return nil if harmonized.empty?
+        return nil if published_stage?(stage)
+
+        "stage-#{harmonized}"
+      end
+
+      def published_stage?(stage)
+        stage.stage_code.to_s == "published"
+      end
+
+      # A deliverable code owns the slot; the edition takes it only when there
+      # is none.
+      def deliverable_slot
+        return "ser" if maybe_of(identifier, :all_parts)
+
+        vap = vap_codes
+        return vap unless vap.empty?
+
+        edition = maybe_of(identifier, :edition)
+        return "" unless edition&.number
+
+        edition.render(context: URN_CONTEXT).to_s
+      end
+
+      # A deliverable sits on the VAP layer, which is not always the outermost
+      # one: "IEC 60079-10-1:2020 CMV/COR1:2021" is a corrigendum wrapping the
+      # CMV, so the codes have to be looked for down the chain.
+      def vap_codes
+        codes = find_down(:vap)
+        return "" unless codes
+
+        Array(codes).map { |c| c.to_s.downcase }
+          .select { |c| DELIVERABLES.include?(c) }.join("-")
+      end
+
+      # First non-empty value of `attribute` from the outermost identifier
+      # inwards.
+      def find_down(attribute)
+        id = identifier
+        while id
+          value = maybe_of(id, attribute)
+          return value unless value.nil? ||
+            (value.respond_to?(:empty?) && value.empty?)
+
+          id = maybe_of(id, :base) ||
+            Array(maybe_of(id, :identifiers)).first
+        end
+        nil
+      end
+
+      def language_slot
+        langs = maybe_of(identifier, :languages)
+        return "" unless langs&.any?
+
+        langs.map { |l| l.code.to_s }.join("-")
+      end
+
+      # A bare, undated, stage- and language-less all-parts series drops the
+      # trailing empty language slot, matching the canonical relaton-data-iec
+      # form urn:iec:std:iec:80000:::ser. A dated series, or one carrying a
+      # stage, keeps the slot.
+      def bare_series?(slots, adjuncts, language)
+        slots.last == "ser" && slots[5, 2].all? { |s| s.to_s.empty? } &&
+          adjuncts.empty? && language.empty?
+      end
+
+      # Walks the identifier tree for the amendment / corrigendum /
+      # interpretation-sheet layers, innermost first. A member of a
+      # consolidated identifier carries the "plus" relation marker, which the
+      # printed form spells "+".
+      def adjunct_slots(id)
+        return [] if id.nil?
+
+        case id.class.name.split("::").last
+        when "ConsolidatedIdentifier"
+          members = Array(id.identifiers)
+          adjunct_slots(members.first) +
+            members.drop(1).flat_map { |m| adjunct_fields(m, plus: true) }
+        when *ADJUNCT_TOKENS.keys
+          adjunct_slots(id.base) + adjunct_fields(id, plus: false)
+        else
+          adjunct_slots(id.respond_to?(:base) ? id.base : nil)
+        end
+      end
+
+      def adjunct_fields(id, plus:)
+        token = ADJUNCT_TOKENS[id.class.name.split("::").last]
+        return adjunct_slots(id.respond_to?(:base) ? id.base : nil) unless token
+
+        [plus ? "plus" : "", token, id.number.to_s,
+         maybe_of(id, :date)&.render(context: URN_CONTEXT).to_s]
+      end
+
+      # Not every IEC class declares every attribute, and a wrapper may not
+      # declare one its base does. The `respond_to?` guard covers the missing
+      # attribute; the rescue covers an attribute that exists but nil-chases
+      # while resolving — `SupplementIdentifier#number` runs `ensure_base` and
+      # reads through a base that may not be built yet. It is deliberately
+      # narrow: a broader rescue would swallow a real bug into a silently
+      # empty URN slot instead of failing loudly.
+      def maybe_of(id, attribute)
+        return nil unless id.respond_to?(attribute)
+
+        id.public_send(attribute)
+      rescue NoMethodError
+        nil
       end
     end
   end

data/lib/pubid/iec/urn_parser.rb

@@ -31,16 +31,24 @@ module Pubid
       # @return [Identifier] parsed identifier
       def parse_urn(urn)
         unless urn.start_with?("urn:iec:std:")
-          raise Errors::ParseError, "Invalid IEC URN: #{urn}"
+          raise Pubid::UrnParser::Errors::ParseError, "Invalid IEC URN: #{urn}"
         end
 
         code, lang, all_parts = urn_to_code(urn)
-        raise Errors::ParseError, "Invalid IEC URN: #{urn}" unless code
+        unless code
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid IEC URN: #{urn}"
+        end
 
         id = Pubid::Iec::Identifier.parse(code)
         id.all_parts = true if all_parts && id.class.attributes.key?(:all_parts)
+        # The language slot joins codes with a hyphen ("en-fr"). Building one
+        # Language from the whole field gave a single bogus language that
+        # rendered as "(en-fr)".
         if lang && !lang.empty? && id.class.attributes.key?(:languages)
-          id.languages = [::Pubid::Components::Language.new(code: lang)]
+          id.languages = lang.split("-").map do |code|
+            ::Pubid::Components::Language.new(code: code)
+          end
         end
         id
       end
@@ -57,7 +65,8 @@ module Pubid
         all_parts = false
 
         code = head.gsub("-", "/")
-        code += " #{type}" unless type.nil? || type.empty?
+        type_code = type_slot_to_code(type)
+        code += " #{type_code}" unless type_code.empty?
         code += " #{num}"
         code += ":#{date}" unless date.nil? || date.empty?
         code += adjunct_to_code(fields[9..])
@@ -67,6 +76,8 @@ module Pubid
         # part or date, so to_s renders "IEC NNNN (all parts)").
         if deliv&.casecmp("SER")&.zero?
           all_parts = true
+        elsif (edition = edition_slot_to_code(deliv))
+          code += " #{edition}"
         elsif deliv && !deliv.empty?
           code += " #{deliv}"
         end
@@ -74,6 +85,33 @@ module Pubid
         [code, lang&.downcase, all_parts]
       end
 
+      # The type slot holds either the legacy type token ("TS"), a stage
+      # ("STAGE-10.20"), or both ("TS-STAGE-50.00"). A stage is written back as
+      # the abbreviation the grammar accepts, resolved from the registry by
+      # type code and harmonized code — so the round trip is exact in both
+      # directions. See issue #360 item 4.
+      def type_slot_to_code(type)
+        return "" if type.nil? || type.empty?
+
+        match = /\A(?:([A-Z]+)-)?STAGE-([\d.]+)\z/.match(type)
+        return type unless match
+
+        type_code = (match[1] || "IS").downcase
+        stage = Pubid::Iec.all_typed_stages.find do |s|
+          s.type_code.to_s == type_code &&
+            s.harmonized_stages&.first.to_s == match[2]
+        end
+        return "" unless stage
+
+        stage.abbr.first.to_s
+      end
+
+      # "ED-7" in the deliverable slot is an edition, not a deliverable code.
+      def edition_slot_to_code(deliv)
+        match = /\AED-(.+)\z/.match(deliv.to_s)
+        match && "ED#{match[1]}"
+      end
+
       # Port of Relaton::Iec.ajanct_to_code — recursively rebuilds amd/cor/ish
       # adjuncts from (relation, type, number, date) quartets. A "PLUS"
       # relation token (the consolidated "+" marker) yields "+"; otherwise "/".

data/lib/pubid/iec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Iec
     autoload :Components, "#{__dir__}/iec/components"
@@ -23,12 +24,7 @@ module Pubid
     autoload :Renderer, "#{__dir__}/iec/renderer"
 
     def self.parse(identifier_string)
-      if identifier_string.length > Pubid::MAX_INPUT_LENGTH
-        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
-      end
-
-      parsed = Parser.new.parse(identifier_string)
-      Builder.new.build(parsed)
+      Identifier.parse(identifier_string)
     end
 
     def self.parse_urn(urn)

data/lib/pubid/ieee/aiee/builder.rb

@@ -23,7 +23,7 @@ module Pubid
                               end
 
           # Extract code
-          code_str = extract_value(parsed[:number])
+          code_str = extract_number(parsed[:number])
           if code_str
             attributes[:code] = Components::Code.parse(code_str)
           end
@@ -36,9 +36,11 @@ module Pubid
           month_str = extract_value(parsed[:month])
           attributes[:month] = month_str if month_str
 
-          # Extract separator (for rendering distinction)
+          # Extract the long-form date separator ("," or ".") for rendering.
+          # Named `date_separator` on the identifier to avoid colliding with the
+          # CodeNumber code-part `separator`.
           separator_str = extract_value(parsed[:separator])
-          attributes[:separator] = separator_str if separator_str
+          attributes[:date_separator] = separator_str if separator_str
 
           # Set original format based on parsed data
           attributes[:original_format] = if separator_str || month_str
@@ -53,6 +55,18 @@ module Pubid
 
         private
 
+        # Extract the number, flattening a "431 (105)" main-number/parenthetical
+        # subtree into a plain string. Without this, a Hash node leaks its raw
+        # Parslet inspect form (e.g. `{main_number: "431"@8, ...}`) into `to_s`.
+        def extract_number(value)
+          return extract_value(value) unless value.is_a?(Hash)
+
+          main = extract_value(value[:main_number])
+          paren = value[:parenthetical]
+          alt = paren.is_a?(Hash) ? extract_value(paren[:alt_number]) : nil
+          alt ? "#{main} (#{alt})" : main
+        end
+
         def extract_value(value)
           return nil if value.nil?
           return nil if value.is_a?(Array) && value.empty?