pubid 2.0.0.pre.alpha.7 → 2.0.0.pre.alpha.9

data/lib/pubid/bipm/identifiers/si_brochure.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    module Identifiers
+      # The SI Brochure — a single bespoke record. The English form drops the
+      # "sur le SI" phrase the French form carries.
+      #
+      # Printed forms (both round-trip):
+      #   "BIPM SI Brochure 9e v3.01 (2019/2024, E)"
+      #   "BIPM SI Brochure sur le SI 9e v3.01 (2019/2024, F)"
+      class SiBrochure < Identifier
+        def self.type
+          { key: :si_brochure, web: :si_brochure,
+            title: "SI Brochure", short: "si-brochure" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bipm/identifiers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Namespace for concrete BIPM identifier types.
+    module Identifiers
+      autoload :CommitteeDocument, "#{__dir__}/identifiers/committee_document"
+      autoload :Guide, "#{__dir__}/identifiers/guide"
+      autoload :Meeting, "#{__dir__}/identifiers/meeting"
+      autoload :Mep, "#{__dir__}/identifiers/mep"
+      autoload :MetrologiaArticle, "#{__dir__}/identifiers/metrologia_article"
+      autoload :SiBrochure, "#{__dir__}/identifiers/si_brochure"
+    end
+  end
+end

data/lib/pubid/bipm/parser.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Bipm
+    # Parslet grammar for the four BIPM identifier families. The root branches
+    # by leading token / shape; each alternative is wrapped in a distinct key
+    # (:committee_short, :meeting_en, …) so the Builder can dispatch on the
+    # matched branch without re-inspecting the string.
+    #
+    # Group and type-word alternations are built from the shared vocabularies on
+    # {Identifier} (sorted longest-first so e.g. "CCTF" is tried before "CCT").
+    class Parser < Parslet::Parser
+      # --- primitives ---
+      rule(:space) { str(" ") }
+      rule(:digits) { match["0-9"].repeat(1) }
+      rule(:alnum) { match["0-9A-Za-z"].repeat(1) }
+      # Number, preserved as a string: digits with optional hyphenated parts.
+      rule(:number) do
+        (digits >> (str("-") >> digits).repeat).as(:number)
+      end
+      rule(:year) { match["0-9"].repeat(4, 4).as(:year) }
+      rule(:lang) { match["EF"].as(:language) }
+      # "(YYYY)" or "(YYYY, E)"
+      rule(:year_paren) do
+        str("(") >> year >> (str(", ") >> lang).maybe >> str(")")
+      end
+      rule(:year_paren_nolang) { str("(") >> year >> str(")") }
+
+      # Longest-first alternation over a list of literal tokens, so a token that
+      # is a prefix of another (e.g. "CCT" of "CCTF") never shadows it.
+      def alternation(tokens)
+        tokens.sort_by { |t| -t.length }.map { |t| str(t) }.reduce(:|)
+      end
+
+      rule(:group) { alternation(Identifier::GROUPS).as(:group) }
+
+      rule(:type_abbrev) do
+        alternation(Identifier::TYPE_CODES).as(:type_word)
+      end
+      rule(:type_name_en) do
+        names = Identifier::TYPE_NAME_EN.values.uniq + ["Declaration"]
+        alternation(names).as(:type_word)
+      end
+      rule(:type_name_fr) do
+        names = Identifier::TYPE_NAME_FR.values.uniq + ["Déclaration"]
+        alternation(names).as(:type_word)
+      end
+      rule(:connective) { str("de la") | str("du") }
+      rule(:ordinal) { str("st") | str("nd") | str("rd") | str("th") }
+
+      # --- committee documents ---
+      # The trailing "(YYYY)" date is optional (`.maybe`) so a partial reference
+      # that omits it — e.g. "CCTF REC 2" — still parses, leaving :year absent.
+      rule(:committee_short) do
+        (group >> space >> type_abbrev >>
+          (space >> number).maybe >> (space >> year_paren).maybe)
+          .as(:committee_short)
+      end
+      rule(:committee_long_en) do
+        (group >> space >> type_name_en >>
+          (space >> number).maybe >> (space >> year_paren_nolang).maybe)
+          .as(:committee_long_en)
+      end
+      rule(:committee_long_fr) do
+        (type_name_fr >> (space >> number).maybe >> space >>
+          connective >> space >> group >> (space >> year_paren_nolang).maybe)
+          .as(:committee_long_fr)
+      end
+      # Bare MRA-interpretation form: a group directly followed by a document
+      # number with no type word (e.g. "CIPM 2005-06"). Tried last, so typed
+      # committee documents and meetings always win; only fires when a digit
+      # follows the group and the string is fully consumed.
+      rule(:committee_bare) do
+        (group >> space >> number >> (space >> year_paren).maybe)
+          .as(:committee_bare)
+      end
+
+      # --- meetings ---
+      rule(:meeting_en) do
+        (group >> space >> number >> ordinal >> space >>
+          str("Meeting") >> (space >> year_paren).maybe).as(:meeting_en)
+      end
+      rule(:meeting_fr) do
+        (group >> space >> number >> str("<sup>e</sup>") >> space >>
+          str("réunion") >> (space >> year_paren).maybe).as(:meeting_fr)
+      end
+
+      # --- Metrologia journal ---
+      rule(:metrologia) do
+        (str("Metrologia") >>
+          (space >> digits.as(:volume) >>
+            (space >> alnum.as(:issue) >>
+              (space >> alnum.as(:article)).maybe).maybe).maybe).as(:metrologia)
+      end
+
+      # --- SI Brochure ---
+      rule(:edition) { (digits >> str("e")).as(:edition) }
+      rule(:version) { (str("v") >> match["0-9."].repeat(1)).as(:version) }
+      rule(:years) { (digits >> (str("/") >> digits).maybe).as(:years) }
+      rule(:si_brochure) do
+        (str("BIPM SI Brochure") >> space >>
+          (str("sur le SI") >> space).maybe >>
+          edition >> space >> version >> space >>
+          str("(") >> years >> str(", ") >> lang >> str(")")).as(:si_brochure)
+      end
+
+      # --- SI Brochure appendices / derived products ---
+      # The full primary-docidentifier content the relaton crawler indexes by,
+      # e.g. "BIPM SI Brochure Appendix 3" / "…Concise" / "…FAQ". The bare
+      # "SI Brochure Appendix 3" docnumber form is accepted too (rendered back
+      # with the "BIPM " prefix, matching the base SI Brochure record).
+      rule(:brochure_variant) do
+        ((str("Appendix") >> space >> digits) | str("Concise") | str("FAQ"))
+          .as(:variant)
+      end
+      rule(:si_brochure_variant) do
+        ((str("BIPM SI Brochure") | str("SI Brochure")) >> space >>
+          brochure_variant).as(:si_brochure_variant)
+      end
+
+      # Shared "Appendix N [Annex N] Part N[.M]" tail carried by the full
+      # docidentifier content of MEPs and CC guides (the "Appendix 2 Part 1.1"
+      # or "Appendix 2 Annex 2 Part 1" suffix on "BIPM SI MEP …" etc.).
+      rule(:appendix_part) do
+        str("Appendix") >> space >> digits.as(:appendix) >>
+          (space >> str("Annex") >> space >> digits.as(:annex)).maybe >>
+          space >> str("Part") >> space >>
+          (digits >> (str(".") >> digits).maybe).as(:part)
+      end
+
+      # --- Mises en pratique (MEP) ---
+      # Two index-relevant spellings: the short docnumber ("SI MEP S1",
+      # "Rapport BIPM-2019/05") and the full "BIPM …" primary-docidentifier
+      # content the crawler actually keys on ("BIPM SI MEP S1 Appendix 2 Part
+      # 1.1"). The renderer reproduces whichever the identifier carries.
+      rule(:mep_code) { match["0-9A-Za-z"].repeat(1).as(:mep_code) }
+      rule(:report_code) do
+        (str("BIPM-") >> digits >> str("/") >> digits).as(:report_code)
+      end
+      rule(:mep_body) do
+        (str("SI MEP") >> space >> mep_code) |
+          (str("Rapport") >> space >> report_code)
+      end
+      rule(:mep) do
+        ((str("BIPM") >> space >> mep_body >> space >> appendix_part) |
+          mep_body).as(:mep)
+      end
+
+      # --- Consultative-Committee guides ---
+      # "<committee>-GD-<kind>-<number>" (e.g. "CCL-GD-MeP-1"), and its full
+      # "BIPM … Appendix 2 Part 2.2" content form. <kind> is "MeP" (mise en
+      # pratique) or "RSI" (réalisation du SI). Reuses the shared `group`
+      # (committee) and `number` (trailing sequence).
+      rule(:guide_kind) { (str("MeP") | str("RSI")).as(:guide_kind) }
+      rule(:guide_body) do
+        group >> str("-GD-") >> guide_kind >> str("-") >> digits.as(:number)
+      end
+      rule(:guide) do
+        ((str("BIPM") >> space >> guide_body >> space >> appendix_part) |
+          guide_body).as(:guide)
+      end
+
+      # After a leading group token, the shape after the first space decides:
+      # a digit → meeting; a type word → committee.
+      rule(:group_leading) do
+        meeting_en | meeting_fr | committee_short | committee_long_en |
+          committee_bare
+      end
+
+      rule(:identifier) do
+        metrologia | si_brochure | si_brochure_variant | mep | guide |
+          committee_long_fr | group_leading
+      end
+
+      root(:identifier)
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/bipm/renderer.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Human-readable renderer for the four BIPM identifier families. Registered
+    # as the `:human` format and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        case @id
+        when Identifiers::CommitteeDocument then render_committee(@id)
+        when Identifiers::Meeting then render_meeting(@id)
+        when Identifiers::MetrologiaArticle then render_metrologia(@id)
+        when Identifiers::SiBrochure then render_si_brochure(@id)
+        when Identifiers::Mep then render_mep(@id)
+        when Identifiers::Guide then render_guide(@id)
+        else
+          raise "Cannot render BIPM identifier: #{@id.class}"
+        end
+      end
+
+      private
+
+      # Optional " <number>" segment (with a leading space), or "" when absent.
+      def number_segment(id)
+        id.number ? " #{id.number}" : ""
+      end
+
+      # Optional " (<year>[, <lang>])" segment (with a leading space), or ""
+      # when the year is absent (a partial reference). `lang` is the trailing
+      # ", E"/", F" suffix carried only by the short committee form.
+      def year_segment(id, lang: "")
+        id.year ? " (#{id.year}#{lang})" : ""
+      end
+
+      def render_committee(id)
+        return render_committee_long(id) if id.long?
+
+        # short abbreviated key form. The type word is optional — the bare MRA
+        # form (e.g. "CIPM 2005-06") has no type_code, so omit it (and its
+        # leading space) rather than emit a double space.
+        lang = id.language ? ", #{id.language}" : ""
+        type = id.type_code ? " #{id.type_code}" : ""
+        "#{id.group}#{type}#{number_segment(id)}" \
+          "#{year_segment(id, lang: lang)}"
+      end
+
+      def render_committee_long(id)
+        if id.language == "F"
+          name = Identifier::TYPE_NAME_FR[id.type_code]
+          conn = Identifier.french_connective(id.group)
+          "#{name}#{number_segment(id)} #{conn} #{id.group}#{year_segment(id)}"
+        else
+          name = Identifier::TYPE_NAME_EN[id.type_code]
+          "#{id.group} #{name}#{number_segment(id)}#{year_segment(id)}"
+        end
+      end
+
+      def render_meeting(id)
+        if id.language == "F"
+          "#{id.group} #{id.number}<sup>e</sup> réunion#{year_segment(id)}"
+        else
+          "#{id.group} #{id.ordinal_en} Meeting#{year_segment(id)}"
+        end
+      end
+
+      def render_metrologia(id)
+        result = +"Metrologia"
+        result << " #{id.volume}" if id.volume
+        result << " #{id.issue}" if id.issue
+        result << " #{id.article}" if id.article
+        result
+      end
+
+      def render_si_brochure(id)
+        # Appendix / derived-product form indexed by relaton, keyed on the full
+        # "BIPM SI Brochure …" primary docidentifier content.
+        return "BIPM SI Brochure #{id.variant}" if id.variant
+
+        phrase = id.language == "F" ? "sur le SI " : ""
+        lang = id.language ? ", #{id.language}" : ""
+        "BIPM SI Brochure #{phrase}#{id.edition} #{id.version} " \
+          "(#{id.years}#{lang})"
+      end
+
+      # MEP: short docnumber ("SI MEP <code>" / "Rapport BIPM-YYYY/NN"), or the
+      # full "BIPM … Appendix N [Annex N] Part N.M" content the crawler keys on.
+      def render_mep(id)
+        body = id.report_code ? "Rapport #{id.report_code}" : "SI MEP #{id.mep_code}"
+        render_full_content(id, body)
+      end
+
+      # CC guide: short "<committee>-GD-<kind>-<number>", or its full
+      # "BIPM … Appendix N Part N.M" content form.
+      def render_guide(id)
+        body = "#{id.group}-GD-#{id.guide_kind}-#{id.number}"
+        render_full_content(id, body)
+      end
+
+      # Wrap a short body in the "BIPM … Appendix N [Annex N] Part N.M" content
+      # form when the identifier carries the appendix/part tail; otherwise emit
+      # the bare short body. `part` presence is what distinguishes the two.
+      def render_full_content(id, body)
+        return body unless id.part
+
+        annex = id.annex ? " Annex #{id.annex}" : ""
+        "BIPM #{body} Appendix #{id.appendix}#{annex} Part #{id.part}"
+      end
+    end
+  end
+end

data/lib/pubid/bipm/urn_generator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Emits a URN carrying the canonical (language/form-neutral) document
+    # identity for each family:
+    #   committee:  urn:bipm:<group>:<type>:<number>:<year>   (empty number seg
+    #                                                          when number-less)
+    #   meeting:    urn:bipm:<group>:meeting:<number>:<year>
+    #   metrologia: urn:bipm:metrologia:<vol>[:<issue>[:<article>]]
+    #   brochure:   urn:bipm:si-brochure:<lang>:<edition>:<version>:<years>
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        case identifier
+        when Identifiers::CommitteeDocument then committee
+        when Identifiers::Meeting then meeting
+        when Identifiers::MetrologiaArticle then metrologia
+        when Identifiers::SiBrochure then si_brochure
+        else
+          raise "Cannot build URN for BIPM identifier: #{identifier.class}"
+        end
+      end
+
+      private
+
+      def committee
+        id = identifier
+        # type_code is nil for the bare MRA form → empty type segment, mirroring
+        # the empty-number-segment convention for number-less documents.
+        parts = ["urn", "bipm", id.group.downcase,
+                 id.type_code.to_s.downcase, id.number.to_s]
+        # A partial (date-less) reference drops the trailing year segment; a
+        # number-less-but-dated doc keeps its empty number segment.
+        parts << id.year if id.year
+        parts.join(":")
+      end
+
+      def meeting
+        id = identifier
+        parts = ["urn", "bipm", id.group.downcase, "meeting", id.number.to_s]
+        parts << id.year if id.year
+        parts.join(":")
+      end
+
+      def metrologia
+        parts = ["urn", "bipm", "metrologia", identifier.volume]
+        parts << identifier.issue if identifier.issue
+        parts << identifier.article if identifier.article
+        parts.join(":")
+      end
+
+      def si_brochure
+        ["urn", "bipm", "si-brochure", identifier.language.to_s.downcase,
+         identifier.edition, identifier.version, identifier.years].join(":")
+      end
+    end
+  end
+end

data/lib/pubid/bipm/urn_parser.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Inverts {UrnGenerator}, rebuilding the identifier directly from the URN
+    # fields (rather than reconstructing a printed string) because the printed
+    # forms carry surface detail — meeting ordinals, French wording — that the
+    # canonical URN intentionally omits.
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = body.split(":", -1)
+
+        case parts.first
+        when "metrologia" then build_metrologia(parts)
+        when "si-brochure" then build_si_brochure(parts)
+        else build_group_leading(parts)
+        end
+      end
+
+      private
+
+      def build_group_leading(parts)
+        group = parts[0].upcase
+        if parts[1] == "meeting"
+          Identifiers::Meeting.new(
+            group: group, number: parts[2].to_s, year: parts[3]&.to_i,
+          )
+        else
+          Identifiers::CommitteeDocument.new(
+            group: group,
+            type_code: (parts[1].empty? ? nil : parts[1].upcase),
+            number: (parts[2].empty? ? nil : parts[2]), year: parts[3]&.to_i
+          )
+        end
+      end
+
+      def build_metrologia(parts)
+        Identifiers::MetrologiaArticle.new(
+          volume: parts[1]&.to_i, issue: parts[2], article: parts[3],
+        )
+      end
+
+      def build_si_brochure(parts)
+        Identifiers::SiBrochure.new(
+          language: parts[1].to_s.upcase, edition: parts[2],
+          version: parts[3], years: parts[4]
+        )
+      end
+    end
+  end
+end

data/lib/pubid/bipm.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    extend Pubid::PrefixesSupport
+
+    # Leading tokens a printed BIPM identifier can start with: the 13 committee
+    # acronyms, "Metrologia" (journal), and "BIPM" (the SI Brochure). JCGM is
+    # deliberately excluded — it is owned by the separate Pubid::Jcgm flavor,
+    # so BIPM never emits pubid:jcgm:* rows. French full-name forms that lead
+    # with a type word ("Recommandation 1 du CCL …") are omitted per the
+    # "exclude ambiguous tokens" policy.
+    PREFIXES = %w[
+      BIPM Metrologia
+      CIPM CGPM JCRB CCTF CCQM CCT CCL CCAUV CCU CCM CCEM CCPR CCRI
+    ].freeze
+
+    autoload :Builder, "#{__dir__}/bipm/builder"
+    autoload :Identifier, "#{__dir__}/bipm/identifier"
+    autoload :Identifiers, "#{__dir__}/bipm/identifiers"
+    autoload :Parser, "#{__dir__}/bipm/parser"
+    autoload :Renderer, "#{__dir__}/bipm/renderer"
+    autoload :UrnGenerator, "#{__dir__}/bipm/urn_generator"
+    autoload :UrnParser, "#{__dir__}/bipm/urn_parser"
+
+    # Parse a BIPM identifier string into an identifier object.
+    # @param identifier [String] the printed identifier
+    # @return [Identifier] the parsed identifier
+    def self.parse(identifier)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Bipm::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 do |const|
+        klass = Identifiers.const_get(const)
+        klass if klass.is_a?(Class) &&
+          klass.singleton_methods(false).include?(:type) &&
+          klass.type.is_a?(Hash)
+      rescue NameError
+        nil
+      end
+    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 do |s|
+        s.abbr.any? { |a| a.to_s.upcase == abbr_str }
+      end
+    end
+  end
+end
+
+# Register BIPM flavor with the registry
+Pubid::Registry.register(:bipm, Pubid::Bipm)

data/lib/pubid/bsi/builder.rb

@@ -674,7 +674,7 @@ module Pubid
         topic = @original_data[:expert_commentary_topic]&.to_s
 
         Identifiers::ExpertCommentary.new(
-          base_identifier: base_id,
+          base: base_id,
           format: format,
           topic: topic,
         )
@@ -724,7 +724,7 @@ module Pubid
                           end
 
         Identifiers::SupplementDocument.new(
-          base_identifier: base_id,
+          base: base_id,
           supplement_number: data[:supplement_number].to_s,
           supplement_year: data[:supplement_year].to_i,
           supplement_type: supplement_type,
@@ -771,7 +771,7 @@ module Pubid
         end
 
         Identifiers::AddendumDocument.new(
-          base_identifier: base_id,
+          base: base_id,
           addendum_number: data[:addendum_number].to_s,
           addendum_year: data[:addendum_year].to_i,
           addendum_type: addendum_type,
@@ -837,7 +837,7 @@ module Pubid
         base_id = build(base_data)
 
         Identifiers::ValueAddedPublication.new(
-          base_identifier: base_id,
+          base: base_id,
           format: format,
         )
       end
@@ -882,14 +882,14 @@ module Pubid
 
           if supp[:type] == :amendment
             Identifiers::Amendment.new(
-              base_identifier: nil, # NA supplements don't wrap base
+              base: nil, # NA supplements don't wrap base
               amendment_number: supp[:number],
               amendment_year: year_val&.to_i,
               separator: supp[:separator] || "+",
             )
           else
             Identifiers::Corrigendum.new(
-              base_identifier: nil,
+              base: nil,
               corrigendum_number: supp[:number],
               corrigendum_year: year_val&.to_i,
               separator: supp[:separator] || "+",
@@ -1411,17 +1411,17 @@ module Pubid
         end
       end
 
-      def wrap_with_consolidated(base_identifier, supplements_data,
+      def wrap_with_consolidated(base, supplements_data,
 expert_commentary: nil, expert_commentary_topic: nil)
-        # If expert_commentary data is provided, set it on the base_identifier
+        # If expert_commentary data is provided, set it on the base
         # This allows ConsolidatedIdentifier to render the ExComm suffix correctly
         if expert_commentary
-          base_attrs = base_identifier.class.attributes
+          base_attrs = base.class.attributes
           if base_attrs.key?(:expert_commentary)
-            base_identifier.expert_commentary = expert_commentary
+            base.expert_commentary = expert_commentary
           end
           if expert_commentary_topic && base_attrs.key?(:expert_commentary_topic)
-            base_identifier.expert_commentary_topic = expert_commentary_topic
+            base.expert_commentary_topic = expert_commentary_topic
           end
         end
 
@@ -1436,7 +1436,7 @@ expert_commentary: nil, expert_commentary_topic: nil)
 
           if supp[:type] == :amendment
             Identifiers::Amendment.new(
-              base_identifier: base_identifier,
+              base: base,
               amendment_number: supp[:number],
               amendment_year: year_val&.to_i,
               separator: supp[:separator] || "+",
@@ -1444,7 +1444,7 @@ expert_commentary: nil, expert_commentary_topic: nil)
             )
           else
             Identifiers::Corrigendum.new(
-              base_identifier: base_identifier,
+              base: base,
               corrigendum_number: supp[:number],
               corrigendum_year: year_val&.to_i,
               separator: supp[:separator] || "+",
@@ -1453,7 +1453,7 @@ expert_commentary: nil, expert_commentary_topic: nil)
         end
 
         Identifiers::ConsolidatedIdentifier.new(
-          identifiers: [base_identifier] + supplement_ids,
+          identifiers: [base] + supplement_ids,
         )
       end
 

data/lib/pubid/bsi/identifier.rb

@@ -4,4 +4,3 @@
 # subclass); its body, `.parse` (including the IEC-delegation logic), and the
 # SingleIdentifier back-compat alias live in single_identifier.rb. This file
 # just ensures it is loaded when a consumer references Pubid::Bsi::Identifier.
-require_relative "single_identifier"

data/lib/pubid/bsi/identifiers/addendum_document.rb

@@ -11,7 +11,7 @@ module Pubid
       # "BS 2000-0:Addendum 1:1983"
       # "BS 6034:1981:Addendum No. 1:1986"
       class AddendumDocument < SingleIdentifier
-        attribute :base_identifier, ::Pubid::Identifier, polymorphic: true
+        attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :addendum_number, :string
         attribute :addendum_year, :integer
         attribute :addendum_type, :string, default: -> {
@@ -22,7 +22,7 @@ module Pubid
         } # Separator before Addendum (":" or " ")
 
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
       end
     end