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

data/lib/pubid/ogc/renderer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    # Human-readable renderer for OGC identifiers.
+    #
+    # Produces the canonical printed form, e.g.:
+    #   "24-032r1"
+    #   "01-009a"
+    #   "OGC 24-032r1"   (only when with_publisher: true)
+    #
+    # Registered as the `:human` format in the OGC format registry and invoked
+    # via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "OGC"
+
+      def render(**_opts)
+        id = @id
+        result = +""
+        result << "#{PUBLISHER} " if with_publisher?(id)
+        result << "#{id.year}-#{id.number}"
+        result << id.revision.to_s if id.revision
+        result
+      end
+
+      private
+
+      def with_publisher?(id)
+        id.respond_to?(:with_publisher) && id.with_publisher == true
+      end
+    end
+  end
+end

data/lib/pubid/ogc/urn_generator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    # Emits `urn:ogc:<year>:<number>[:<revision>]`, e.g. `urn:ogc:24:032:r1`.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "ogc", identifier.year.to_s, identifier.number.to_s]
+        parts << identifier.revision.to_s if identifier.revision
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/ogc/urn_parser.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    # Parses OGC URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:ogc:<year>:<number>[:<revision>]`.
+    #
+    # Examples:
+    # - urn:ogc:25:023    → 25-023
+    # - urn:ogc:24:032:r1 → 24-032r1
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        year, number, revision = split_parts(body)
+        text = "#{year}-#{number}"
+        text += revision.to_s if revision
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/ogc.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  module Ogc
+    extend Pubid::PrefixesSupport
+
+    # OGC identifiers are digit-leading (`25-023`) and carry no publisher token
+    # in the printed form. Per the PREFIXES inclusion policy, bare numeric
+    # patterns are NOT listed (they would make cross-flavor routing ambiguous).
+    # Instead the sole entry is the publisher token "OGC", which relaton uses to
+    # route a reference to this flavor even though it is not literally present
+    # in the id string.
+    PREFIXES = ["OGC"].freeze
+
+    autoload :Builder, "#{__dir__}/ogc/builder"
+    autoload :Identifier, "#{__dir__}/ogc/identifier"
+    autoload :Identifiers, "#{__dir__}/ogc/identifiers"
+    autoload :Parser, "#{__dir__}/ogc/parser"
+    autoload :Renderer, "#{__dir__}/ogc/renderer"
+    autoload :UrnGenerator, "#{__dir__}/ogc/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ogc/urn_parser"
+
+    # Parse an OGC identifier string
+    def self.parse(identifier)
+      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: Ogc::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 OGC flavor with the registry
+Pubid::Registry.register(:ogc, Pubid::Ogc)

data/lib/pubid/oiml/builder.rb

@@ -21,8 +21,8 @@ module Pubid
           return build_short_amendment(parsed_hash)
         end
 
-        # Check for supplements first (have base_identifier)
-        if parsed_hash[:base_identifier]
+        # Check for supplements first (have base)
+        if parsed_hash[:base]
           return build_supplement(parsed_hash)
         end
 
@@ -53,11 +53,11 @@ module Pubid
         end
 
         # Build the base document
-        base_identifier = build_base_document(base_hash)
+        base = build_base_document(base_hash)
 
         # Create amendment
         amendment = Identifiers::Amendment.new
-        amendment.base_identifier = base_identifier
+        amendment.base = base
 
         # Extract year from edition_format if present, otherwise from year directly
         year_value = if parsed_hash[:edition_format].is_a?(Hash)
@@ -97,8 +97,8 @@ module Pubid
         supplement.joined = true if plus_marker
 
         # Recursively parse base identifier
-        if parsed_hash[:base_identifier]
-          supplement.base_identifier = build(parsed_hash[:base_identifier])
+        if parsed_hash[:base]
+          supplement.base = build(parsed_hash[:base])
         end
 
         # Extract year from edition_format if present, otherwise from year directly
@@ -116,7 +116,7 @@ module Pubid
         # Annex with no year of its own but a dated base ("R 60:2017 Annexes"):
         # the year belongs to the base and must render glued to it.
         if supplement.is_a?(Identifiers::Annex) && !year_value &&
-            supplement.base_identifier&.date
+            supplement.base&.date
           supplement.year_on_base = true
         end
 
@@ -152,7 +152,11 @@ module Pubid
             code_attrs[:suffix] = parsed_hash[:code_suffix].to_s
             code_attrs[:space_suffix] = true if parsed_hash.key?(:space_suffix)
           end
-          identifier.code = Components::Code.new(**code_attrs)
+          # The code fields are flat index columns on the leaf (see
+          # Identifiers::CodeNumber) — `number` is what relaton-index keys on —
+          # so they are assigned individually rather than as a Code object.
+          # Bulletin has no code columns and never reaches this branch.
+          code_attrs.each { |name, value| identifier.public_send(:"#{name}=", value) }
         end
 
         # Handle other attributes
@@ -214,6 +218,11 @@ module Pubid
       # Structured: :issue and :sequence captured directly as zero-padded
       # strings. Citation: :volume_roman, :issue_arabic, :article_id —
       # decode the 8-digit article_id to recover year+issue+sequence.
+      #
+      # For the citation form, the parsed roman volume is cross-checked
+      # against the year decoded from the article_id; a mismatch warns but
+      # does not raise (the article_id is the source of truth — the roman
+      # volume is redundant display).
       def apply_bulletin_locator(identifier, parsed_hash)
         if parsed_hash[:article_id]
           article_id = parsed_hash[:article_id].to_s
@@ -221,6 +230,7 @@ module Pubid
           identifier.date.year = article_id[0, 4]
           identifier.issue = article_id[4, 2]
           identifier.sequence = article_id[6, 2]
+          warn_on_volume_mismatch(identifier, parsed_hash[:volume_roman])
           return
         end
 
@@ -228,6 +238,24 @@ module Pubid
         identifier.sequence = parsed_hash[:sequence].to_s if parsed_hash[:sequence]
       end
 
+      # Citation form carries the volume in two places: spelled out as a
+      # roman numeral ("LXVII") and encoded in the 8-digit article_id
+      # (year+issue+sequence, where year - 1959 = volume). They should
+      # agree; if they don't, the input was malformed. Warn loudly so the
+      # user sees the discrepancy, but continue using the article_id
+      # (deterministic) rather than the roman (possibly mistyped).
+      def warn_on_volume_mismatch(identifier, parsed_volume_roman)
+        return unless parsed_volume_roman && identifier.date&.year
+
+        declared = parsed_volume_roman.to_s
+        computed = Identifiers::Bulletin.to_roman(identifier.date.year.to_i -
+                                                  Identifiers::Bulletin::BASE_YEAR_OFFSET)
+        return if declared == computed
+
+        warn "OIML Bulletin citation volume mismatch: parsed '#{declared}' " \
+             "but article_id year #{identifier.date.year} implies '#{computed}'"
+      end
+
       def extract_language(lang_data)
         # Handle both direct string and nested hash from parser
         case lang_data

data/lib/pubid/oiml/identifier.rb

@@ -37,7 +37,7 @@ module Pubid
       # lutaml's polymorphic_map only validates `_type` on deserialization; it
       # does not re-instantiate the concrete subclass. Route by `_type` so
       # `Pubid::Oiml::Identifier.from_hash(h)` returns the right class (and its
-      # nested base_identifier), mirroring Pubid::Iso::Identifier.from_hash.
+      # nested base), mirroring Pubid::Iso::Identifier.from_hash.
       def self.from_hash(data, options = {})
         type = data["_type"] || data[:_type]
         klass_name = OIML_TYPE_MAP[type]
@@ -48,6 +48,14 @@ module Pubid
         super
       end
 
+      # Uniform class-level parse entry, mirroring every other flavor's
+      # `Pubid::<Flavor>::Identifier.parse`. OIML's real logic lives in the
+      # module method, so delegate to it (same pattern as jcgm/nist/plateau).
+      # The `Pubid::MAX_INPUT_LENGTH` ReDoS guard lives in `Pubid::Oiml.parse`.
+      def self.parse(identifier)
+        Pubid::Oiml.parse(identifier)
+      end
+
       def to_urn
         UrnGenerator.new(self).generate
       end

data/lib/pubid/oiml/identifiers/basic_publication.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class BasicPublication < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "B"
         end

data/lib/pubid/oiml/identifiers/bulletin.rb

@@ -45,6 +45,42 @@ module Pubid
           map "sequence", to: :sequence
         end
 
+        # relaton-index keys on `id.root.number.to_s`. Bulletin is the one OIML
+        # leaf with no code (it does not include Identifiers::CodeNumber), so
+        # it derives the key from the year it already stores: every issue and
+        # article of a volume clusters into one bucket, with per-article
+        # distinctness coming from the MR slug instead. That is the BIPM
+        # Metrologia-volume precedent recorded in CLAUDE.md.
+        #
+        # A DERIVED READER, deliberately not an attribute: storing it would
+        # duplicate `year` in every row, and the key_value block above maps no
+        # "number", so nothing is added to the wire format. Safe as a plain
+        # method because Bulletin declares no `number` attribute of its own
+        # (the ITU itu/identifiers/base.rb precedent).
+        #
+        # nil for the bare periodical reference "OIML Bulletin", which names no
+        # year — a deliberate gap, pinned in spec/pubid/oiml/root_number_spec.rb.
+        def number
+          date&.year&.to_s
+        end
+
+        # The index key above is deliberately coarse — a whole volume in one
+        # bucket — which is only defensible because the MR slug stays
+        # per-article. The inherited hook reads through `code`, which Bulletin
+        # does not have, so it would return nil and collapse every article of a
+        # year onto `oiml.bulletin.<year>`; `to_slug` is an output FILENAME, so
+        # that is an overwrite. Emit the rest of the locator instead.
+        #
+        # The year is deliberately NOT included: Renderers::MrString already
+        # gives it its own segment (`mr_year`), so repeating it here would
+        # render `oiml.bulletin.1960-03-01.1960`.
+        def mr_number_with_part
+          segments = [issue, sequence].compact
+          return nil if segments.empty?
+
+          segments.join("-")
+        end
+
         def type_string
           "Bulletin"
         end

data/lib/pubid/oiml/identifiers/code_number.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # Installs the flat, index-friendly code columns and their serialization
+      # on the seven concrete OIML document leaves (Recommendation, Document,
+      # Vocabulary, Guide, BasicPublication, ExpertReport, SeminarReport).
+      #
+      # Why the leaves and not Pubid::Oiml::SingleIdentifier, which they all
+      # inherit from: `number` redefines the parent ::Pubid::Identifier's
+      # `attribute :number, Components::Code` as a plain :string (and `part` /
+      # `subpart` likewise). Declaring that on a class the concrete types
+      # INHERIT from resolves against the parent definition nondeterministically
+      # under multi-flavor load — it passes an OIML-only run and can flip
+      # `root.number` to "" under the full suite (the IEEE lesson; see
+      # lib/pubid/ieee/identifiers/code_number.rb and CLAUDE.md). Declaring on
+      # each leaf removes the ambiguity at the point of use.
+      #
+      # This matters because relaton-index sorts and bsearches every row on
+      # `id.root.number.to_s`. OIML kept the code in an Oiml::Components::Code
+      # under a `code` attribute and never set `number`, so all 12,226 lines of
+      # the published relaton-data-oiml index-v2 keyed "".
+      #
+      # The serialized hash ALREADY had these as bare top-level scalars — the
+      # old converters merely read them through `code` — so the wire format is
+      # byte-identical and that index needs no regeneration.
+      #
+      # Bulletin deliberately does NOT include this module. It carries no code
+      # at all (its locator is the year/issue/sequence tuple), so it would only
+      # gain a permanently-nil `number` and a `number` key that never appears.
+      # It derives its index key from the year instead; see bulletin.rb.
+      module CodeNumber
+        def self.included(base)
+          install_attributes(base)
+          install_mappings(base)
+        end
+
+        def self.install_attributes(base)
+          # Bare document number ("144"), the relaton index key. The part is a
+          # sibling column, never folded in, so every part of a document shares
+          # one bucket and a part-less reference finds them all.
+          base.attribute :number, :string
+          base.attribute :part, :string
+          base.attribute :subpart, :string
+          # Free-form trailing suffix glued to the code, e.g. "sup", "A",
+          # "erratum", "GUM 1", "ISO3930". Preserved verbatim for round-trip.
+          base.attribute :suffix, :string
+          # When true the suffix is space-separated ("D 1 Brochure") rather
+          # than the default dash ("R 60-sup"). Named for the RARE case with a
+          # false default, so the canonical to_hash drops it from every
+          # ordinary row.
+          base.attribute :space_suffix, :boolean, default: -> { false }
+        end
+
+        # Merged by lutaml with the block SingleIdentifier declares, which
+        # carries publisher/year/edition/stage/iteration.
+        def self.install_mappings(base)
+          base.key_value do
+            map "number", to: :number
+            map "part", to: :part
+            map "subpart", to: :subpart
+            map "suffix", to: :suffix
+            map "space_suffix", to: :space_suffix
+          end
+        end
+
+        # The composed document code, rebuilt on demand from the split columns
+        # so the renderer and the URN generator keep one place to ask for the
+        # printed form ("144-1", "60-sup"). Deliberately NOT an attribute and
+        # NOT memoised: the columns are writable (the base #exclude rebuilds
+        # through them), so a cached Code would go stale.
+        #
+        # nil when there is no number, preserving the old nil-`code` semantics
+        # the URN generator branches on.
+        def code
+          return nil if number.nil?
+
+          Components::Code.new(
+            number: number,
+            part: part,
+            subpart: subpart,
+            suffix: suffix,
+            space_suffix: space_suffix,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/document.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class Document < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "D"
         end

data/lib/pubid/oiml/identifiers/expert_report.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class ExpertReport < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "E"
         end

data/lib/pubid/oiml/identifiers/guide.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class Guide < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "G"
         end

data/lib/pubid/oiml/identifiers/recommendation.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class Recommendation < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "R"
         end

data/lib/pubid/oiml/identifiers/seminar_report.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class SeminarReport < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "S"
         end

data/lib/pubid/oiml/identifiers/vocabulary.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class Vocabulary < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "V"
         end

data/lib/pubid/oiml/identifiers.rb

@@ -7,6 +7,7 @@ module Pubid
       autoload :Annex, "#{__dir__}/identifiers/annex"
       autoload :BasicPublication, "#{__dir__}/identifiers/basic_publication"
       autoload :Bulletin, "#{__dir__}/identifiers/bulletin"
+      autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
       autoload :Document, "#{__dir__}/identifiers/document"
       autoload :Errata, "#{__dir__}/identifiers/errata"
       autoload :ExpertReport, "#{__dir__}/identifiers/expert_report"

data/lib/pubid/oiml/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Oiml
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
@@ -20,7 +20,7 @@ module Pubid
       rule(:identifier) do
         amendment_identifier | amendment_short | annex_letter_identifier |
           annex_identifier | plus_supplement_identifier |
-          trailing_supplement_identifier | bulletin_identifier | base_identifier
+          trailing_supplement_identifier | bulletin_identifier | base
       end
 
       # Publisher - always "OIML"
@@ -44,10 +44,9 @@ module Pubid
       rule(:two_digits) { match('\d').repeat(2, 2) }
 
       # Roman numeral token composed of I,V,X,L,C,D,M (uppercase, matching
-      # OIML's print convention). Consumed but not captured — the 8-digit
-      # article id in the same citation carries year/issue/sequence
-      # deterministically, so the roman volume is redundant for parsing.
-      rule(:roman_numeral) { match("[IVXLCDM]").repeat(1) }
+      # OIML's print convention). Captured so the builder can cross-check
+      # the declared volume against the year implied by the article_id.
+      rule(:roman_numeral) { match("[IVXLCDM]").repeat(1).as(:volume_roman) }
 
       # Bulletin locator — citation form. The format OIML prints on the
       # article page is: "LXVII(2) 20260211" where LXVII is the volume in
@@ -62,7 +61,7 @@ module Pubid
       # Bulletin identifier — no code; the locator (when present) is the
       # (year, issue, sequence) tuple drawn from either the structured
       # YYYY-II-SS form or the citation VOLUME(ISSUE) ARTID form. Both
-      # decode to the same record. Tried before base_identifier because
+      # decode to the same record. Tried before base because
       # "Bulletin" is a word that the single-letter doc_type rule cannot
       # match.
       rule(:bulletin_identifier) do
@@ -188,7 +187,7 @@ module Pubid
       rule(:amendment_identifier) do
         str("Amendment") >> space >> lparen >> year_digits.as(:year) >> rparen >>
           space >> str("to") >> space >>
-          base_without_language.as(:base_identifier) >>
+          base_without_language.as(:base) >>
           language_portion.maybe.as(:language)
       end
 
@@ -210,7 +209,7 @@ module Pubid
       # amendment_short is tried first; it only matches when a year follows the
       # word, so the no-year trailing form falls through to here.
       rule(:trailing_supplement_identifier) do
-        base_without_language.as(:base_identifier) >>
+        base_without_language.as(:base) >>
           space >> (str("Amendment") | str("Errata")).as(:trailing_marker) >>
           language_portion.maybe.as(:language)
       end
@@ -220,7 +219,7 @@ module Pubid
       # and errata to dated bases (e.g. "OIML B 10:2011+Amendment:2012").
       # Annexes already encode the year-on-base intent via their own model.
       rule(:plus_supplement_identifier) do
-        base_without_language.as(:base_identifier) >>
+        base_without_language.as(:base) >>
           str("+") >>
           (str("Amendment") | str("Errata")).as(:plus_marker) >>
           (colon >> year_digits.as(:year)).maybe >>
@@ -230,7 +229,7 @@ module Pubid
       # Annex identifier - "BASE Annexes Edition YYYY" / "BASE Annexes:YYYY" /
       # "BASE:YYYY Annexes" (year on the base, no annex year).
       rule(:annex_identifier) do
-        base_without_language.as(:base_identifier) >>
+        base_without_language.as(:base) >>
           space >> str("Annexes").as(:annex_marker) >>
           (
             (space >> edition_text >> space >> year_digits.as(:year)).as(:edition_format) |
@@ -246,7 +245,7 @@ module Pubid
 
       # Annex with letter - "BASE Annex A Edition YYYY" / "BASE:YYYY Annex B-C"
       rule(:annex_letter_identifier) do
-        base_without_language.as(:base_identifier) >>
+        base_without_language.as(:base) >>
           space >> str("Annex") >> space >> annex_letter_value >>
           ((space >> edition_text >> space >> year_digits.as(:year)) | (colon >> year_digits.as(:year))).maybe >>
           language_portion.maybe.as(:language)
@@ -262,7 +261,7 @@ module Pubid
       end
 
       # Base identifier for recursion and standalone parsing
-      rule(:base_identifier) do
+      rule(:base) do
         publisher >>
           doc_type >>
           full_number >>

data/lib/pubid/oiml/renderer.rb

@@ -138,7 +138,7 @@ module Pubid
         # Plus-joined: "BASE+Amendment:YEAR" / "BASE+Errata:YEAR" with both
         # the base and the supplement carrying their own year.
         if id.joined
-          base_str = strip_language(id.base_identifier.to_s)
+          base_str = strip_language(id.base.to_s)
           result = "#{base_str}+#{id.supplement_type}"
           result += ":#{id.year}" if id.year
           result += " (#{id.language})" if id.language
@@ -149,7 +149,7 @@ module Pubid
         # publication year kept on the base identifier. The word comes from the
         # concrete supplement class.
         if id.trailing
-          base_str = strip_language(id.base_identifier.to_s)
+          base_str = strip_language(id.base.to_s)
           result = "#{base_str} #{id.supplement_type}"
           result += " (#{id.language})" if id.language
           return result
@@ -157,16 +157,16 @@ module Pubid
 
         base_format = if format && format != :short
                         format
-                      elsif id.base_identifier.class.attributes.key?(:parsed_format) && id.base_identifier.parsed_format == "long"
+                      elsif id.base.class.attributes.key?(:parsed_format) && id.base.parsed_format == "long"
                         :long
                       else
                         :short
                       end
 
-        base_str = if id.base_identifier.is_a?(SingleIdentifier)
-                     id.base_identifier.to_s(format: base_format)
+        base_str = if id.base.is_a?(SingleIdentifier)
+                     id.base.to_s(format: base_format)
                    else
-                     id.base_identifier.to_s
+                     id.base.to_s
                    end
         base_str = strip_language(base_str)
 
@@ -182,14 +182,14 @@ module Pubid
         # "BASE:YYYY Annex(es)" — the year is glued to the base, the marker
         # carries none. Keep the base date instead of stripping it.
         if id.year_on_base
-          base_str = strip_language(id.base_identifier.to_s)
+          base_str = strip_language(id.base.to_s)
           marker = id.letter ? "Annex #{id.letter}" : "Annexes"
           result = "#{base_str} #{marker}"
           result += " (#{id.language})" if id.language
           return result
         end
 
-        base_format = if id.base_identifier.class.attributes.key?(:parsed_format) && id.base_identifier.parsed_format == "long"
+        base_format = if id.base.class.attributes.key?(:parsed_format) && id.base.parsed_format == "long"
                         :long
                       else
                         :short
@@ -203,10 +203,10 @@ module Pubid
                          :short
                        end
 
-        base_str = if id.base_identifier.is_a?(SingleIdentifier)
-                     id.base_identifier.to_s(format: base_format)
+        base_str = if id.base.is_a?(SingleIdentifier)
+                     id.base.to_s(format: base_format)
                    else
-                     id.base_identifier.to_s
+                     id.base.to_s
                    end
         result = base_str.sub(/:.*/, "").sub(/\s+Edition\s+\d{4}/, "").sub(
           /\(.*\)/, ""
@@ -219,8 +219,8 @@ module Pubid
           result += " Annexes"
           if id.year
             result += annex_format == :long ? " Edition #{id.year}" : ":#{id.year}"
-          elsif id.base_identifier.date
-            result += annex_format == :long ? " Edition #{id.base_identifier.date.render(context: @context)}" : ":#{id.base_identifier.date.render(context: @context)}"
+          elsif id.base.date
+            result += annex_format == :long ? " Edition #{id.base.date.render(context: @context)}" : ":#{id.base.date.render(context: @context)}"
           end
         end