pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/bipm/builder.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Turns the parse tree into the matching concrete identifier. Each root
+    # branch tags its subtree with a distinct key, so dispatch is a lookup on
+    # which key the parser produced.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        if data[:committee_short]
+          build_committee(data[:committee_short], form: "short")
+        elsif data[:committee_long_en]
+          build_committee(data[:committee_long_en], form: "long", language: "E")
+        elsif data[:committee_bare]
+          # Bare MRA form: no type word, so build_committee yields nil type.
+          build_committee(data[:committee_bare], form: "short")
+        elsif data[:committee_long_fr]
+          build_committee(data[:committee_long_fr], form: "long", language: "F")
+        elsif data[:meeting_en]
+          build_meeting(data[:meeting_en])
+        elsif data[:meeting_fr]
+          build_meeting(data[:meeting_fr], language: "F")
+        elsif data.key?(:metrologia)
+          build_metrologia(data[:metrologia])
+        elsif data[:si_brochure]
+          build_si_brochure(data[:si_brochure])
+        elsif data[:si_brochure_variant]
+          build_si_brochure_variant(data[:si_brochure_variant])
+        elsif data.key?(:si_brochure_section)
+          build_si_brochure_section(data[:si_brochure_section])
+        elsif data[:mep]
+          build_mep(data[:mep])
+        elsif data[:guide]
+          build_guide(data[:guide])
+        else
+          raise "Unrecognized BIPM parse tree: #{data.inspect}"
+        end
+      end
+
+      private
+
+      # `group` and `language` are normalized here, so a historic committee
+      # name (CCDS) and a two-letter language code (EN/FR) never reach an
+      # attribute — the index stores only the current name and the one-letter
+      # code BIPM prints.
+      def build_committee(node, form:, language: nil)
+        Identifiers::CommitteeDocument.new(
+          group: Identifier.normalize_group(node[:group]),
+          type_code: Identifier::TYPE_WORD_TO_CODE[node[:type_word].to_s],
+          number: node[:number]&.to_s,
+          year: node[:year]&.to_s&.to_i,
+          language: Identifier.normalize_language(language || node[:language]),
+          form: form,
+        )
+      end
+
+      def build_meeting(node, language: nil)
+        Identifiers::Meeting.new(
+          group: Identifier.normalize_group(node[:group]),
+          number: node[:number].to_s,
+          year: node[:year]&.to_s&.to_i,
+          language: Identifier.normalize_language(language || node[:language]),
+        )
+      end
+
+      # `number` is the volume, so every article of a volume clusters into one
+      # relaton-index bucket (the IETF draft-slug / IANA registry-slug
+      # convention). It is nil only for the journal-level record, which carries
+      # no volume at all.
+      #
+      # It is deliberately redundant with `volume`, which stays because the
+      # renderer and the URN generator read it. Two limits of that redundancy,
+      # both accepted rather than engineered around (see the note above
+      # NUMBER_SOURCE_ATTRIBUTES in identifier.rb for the half that IS
+      # handled):
+      #
+      #   * THE BUILDER IS THE CONSTRUCTOR OF RECORD. A caller that bypasses it
+      #     — `MetrologiaArticle.new(volume: 51, …)` — gets a nil `number` and
+      #     so an empty index key. Deriving it in `initialize` instead would
+      #     cover that, but `#exclude` rebuilds through `self.class.new`, so it
+      #     would also silently re-fill a `number` the caller just excluded.
+      #   * NO SELF-HEALING ACROSS from_hash. lutaml assigns attributes AFTER
+      #     `initialize`, so a legacy pre-`number` index row (one carrying only
+      #     `volume`) deserializes with `number` nil and no error at all —
+      #     lutaml ignores unknown keys and relaton's `id_supported?` skips its
+      #     round-trip check for concrete subclasses, which every BIPM id is.
+      #     relaton-data-bipm must regenerate index-v2 to gain the key. This is
+      #     weaker than the IEEE `CodeNumber` mixin, which rebuilds `code_obj`
+      #     from its split columns after `from_hash`.
+      def build_metrologia(node)
+        node = {} unless node.is_a?(Hash)
+        Identifiers::MetrologiaArticle.new(
+          number: node[:volume]&.to_s,
+          issue: node[:issue]&.to_s,
+          article: node[:article]&.to_s,
+        )
+      end
+
+      # The SI Brochure has no document number of its own, so the edition is
+      # the index key — it clusters the English and French records of one
+      # edition. The grammar makes `edition` mandatory here, so it is never nil.
+      def build_si_brochure(node)
+        Identifiers::SiBrochure.new(
+          number: node[:edition].to_s,
+          edition: node[:edition].to_s,
+          version: node[:version].to_s,
+          years: node[:years].to_s,
+          language: Identifier.normalize_language(node[:language]),
+        )
+      end
+
+      # The derived products (Appendix N, Concise, FAQ) carry no edition, so
+      # the variant name is their key. The grammar makes it mandatory here.
+      def build_si_brochure_variant(node)
+        variant = node[:variant].to_s
+        Identifiers::SiBrochure.new(number: variant, variant: variant)
+      end
+
+      # A bare or sectioned reference names no edition, so it gets no key: it is
+      # a partial reference that wildcards every edition. The bare form captures
+      # nothing, so the parser hands back a slice rather than a hash.
+      def build_si_brochure_section(node)
+        node = {} unless node.is_a?(Hash)
+        Identifiers::SiBrochure.new(part: node[:part]&.to_s)
+      end
+
+      # The Appendix/Annex/Part tail is the full-content spelling of the SAME
+      # document, so it stays out of the key.
+      def build_mep(node)
+        Identifiers::Mep.new(
+          **mep_codes(node),
+          appendix: node[:appendix]&.to_s,
+          annex: node[:annex]&.to_s,
+          part: node[:part]&.to_s,
+        )
+      end
+
+      # A MEP is identified by its unit code, or by the report code for the
+      # `Rapport BIPM-YYYY/NN` variant; exactly one of the two is set, and
+      # whichever it is becomes the relaton index key.
+      def mep_codes(node)
+        mep_code = node[:mep_code]&.to_s
+        report_code = node[:report_code]&.to_s
+        { number: mep_code || report_code, mep_code: mep_code,
+          report_code: report_code }
+      end
+
+      def build_guide(node)
+        Identifiers::Guide.new(
+          group: Identifier.normalize_group(node[:group]),
+          guide_kind: node[:guide_kind].to_s,
+          number: node[:number].to_s,
+          appendix: node[:appendix]&.to_s,
+          part: node[:part]&.to_s,
+        )
+      end
+    end
+  end
+end

data/lib/pubid/bipm/identifier.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Base class for every BIPM identifier AND the flavor's parse/create entry
+    # point — mirrors Pubid::Jis::Identifier. Concrete identifiers under
+    # Pubid::Bipm::Identifiers descend from this class.
+    #
+    # BIPM has several unrelated document families (committee documents,
+    # meetings, the Metrologia journal, the SI Brochure and its appendices,
+    # mises en pratique, and Consultative-Committee guides) with no shared
+    # numbering, so every family-specific attribute lives here as a flat,
+    # nil-defaulted attribute and is used only by the classes that need it. The
+    # canonical `to_hash` drops any attribute at its default/empty value, so an
+    # unused attribute never appears in a family's serialized hash.
+    class Identifier < ::Pubid::Identifier
+      # Committee acronyms BIPM owns (JCGM excluded — see Pubid::Jcgm).
+      GROUPS = %w[
+        CIPM CGPM JCRB CCTF CCQM CCT CCL CCAUV CCU CCM CCEM CCPR CCRI
+      ].freeze
+
+      # Historic committee names consumer references still use. BIPM renamed the
+      # CCDS (Comité Consultatif pour la Définition de la Seconde) to CCTF in
+      # 1997 and the index keys the current name, so an alias is resolved at
+      # parse time and never stored. Extend the map, not the parser, to add one.
+      GROUP_ALIASES = { "CCDS" => "CCTF" }.freeze
+
+      # Every group token the grammar accepts, current names and aliases alike.
+      PARSEABLE_GROUPS = (GROUPS + GROUP_ALIASES.keys).freeze
+
+      # Two-letter codes consumer references use for the one-letter language
+      # codes BIPM prints. Resolved at parse time, so only "E"/"F" is stored.
+      LANGUAGE_ALIASES = { "EN" => "E", "FR" => "F" }.freeze
+
+      # Committee document type codes and their printed long-form names. Note
+      # DECL prints as "Statement" in BOTH languages in the source data.
+      TYPE_CODES = %w[REC RES DECN ACT DECL].freeze
+      TYPE_NAME_EN = {
+        "REC" => "Recommendation", "RES" => "Resolution",
+        "DECN" => "Decision", "ACT" => "Action", "DECL" => "Statement"
+      }.freeze
+      TYPE_NAME_FR = {
+        "REC" => "Recommandation", "RES" => "Résolution",
+        "DECN" => "Décision", "ACT" => "Action", "DECL" => "Statement"
+      }.freeze
+      # Printed type words that are not the canonical name of their code. BIPM
+      # prints DECL as "Statement" in both languages, but a reference spells the
+      # word out; without these the parser matched "Declaration" and then mapped
+      # it to NO code, so the renderer emitted a corrupt "CGPM  1 (1971)".
+      TYPE_WORD_ALIASES = {
+        "Declaration" => "DECL", "Déclaration" => "DECL"
+      }.freeze
+
+      # Every printed type word (abbrev + English + French + alias) → code.
+      TYPE_WORD_TO_CODE = TYPE_CODES.each_with_object({}) do |code, map|
+        map[code] = code
+        map[TYPE_NAME_EN[code]] = code
+        map[TYPE_NAME_FR[code]] = code
+      end.merge(TYPE_WORD_ALIASES).freeze
+
+      # Shared attributes (flat). Booleans/strings carry no default so they stay
+      # nil and drop from the serialized hash unless set.
+      attribute :group, :string
+      attribute :type_code, :string # REC/RES/DECN/ACT/DECL (avoids base `type`)
+      attribute :number, :string    # may be hyphenated ("10-1") or nil
+      attribute :year, :integer
+      attribute :language, :string  # "E"/"F"; nil = language-neutral
+      # Surface style of committee documents: "short" (abbreviated key form) vs
+      # "long" (full type-word name). Defaults to "short" so it drops from the
+      # canonical hash for the indexed primary form.
+      attribute :form, :string, default: "short"
+      # Metrologia journal fields. `volume` is NOT stored — it is exactly the
+      # index key, so MetrologiaArticle derives it from `number` (the IANA
+      # `registry` / IETF `series` pattern) rather than serializing both.
+      attribute :issue, :string # may be alphanumeric ("1A")
+      attribute :article, :string
+      # SI Brochure fields.
+      attribute :edition, :string   # "9e"
+      attribute :version, :string   # "v3.01"
+      attribute :years, :string     # "2019/2024"
+      # SI Brochure appendix/derived variant: "Appendix 3", "Concise", "FAQ".
+      attribute :variant, :string
+      # Mise en pratique (MEP) fields.
+      attribute :mep_code, :string    # "S1", "KUPRTM"
+      attribute :report_code, :string # MEP report variant: "BIPM-2019/05"
+      # Consultative-Committee guide kind ("MeP"/"RSI"); group + number reused.
+      attribute :guide_kind, :string
+      # Full-content "Appendix N [Annex N] Part N.M" tail shared by MEP + guide
+      # primary-docidentifier forms (nil for the bare short docnumber spelling).
+      attribute :appendix, :string
+      attribute :annex, :string
+      attribute :part, :string
+
+      # Attributes `Builder` derives `number` from for the families that have no
+      # document number of their own. Excluding one of these has to clear
+      # `number` too, or a wildcarded identifier would keep a stale index key —
+      # the "reset the WHOLE cluster, not just the scalar" lesson CLAUDE.md
+      # records for CSA's year and IEEE's year/month/day. `:volume` is listed
+      # even though it is no longer an attribute: the base loop skips it, but
+      # `exclude(:volume)` must still clear the key it derives from.
+      NUMBER_SOURCE_ATTRIBUTES = %i[
+        volume edition variant mep_code report_code
+      ].freeze
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization:
+      # maps each subclass's polymorphic_name to its class name so a stored hash
+      # rebuilds the correct identifier type via from_hash.
+      BIPM_TYPE_MAP = {
+        "pubid:bipm:committee-document" =>
+          "Pubid::Bipm::Identifiers::CommitteeDocument",
+        "pubid:bipm:meeting" => "Pubid::Bipm::Identifiers::Meeting",
+        "pubid:bipm:metrologia-article" =>
+          "Pubid::Bipm::Identifiers::MetrologiaArticle",
+        "pubid:bipm:si-brochure" => "Pubid::Bipm::Identifiers::SiBrochure",
+        "pubid:bipm:mep" => "Pubid::Bipm::Identifiers::Mep",
+        "pubid:bipm:guide" => "Pubid::Bipm::Identifiers::Guide",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: BIPM_TYPE_MAP
+        map "group", to: :group
+        map "type_code", to: :type_code
+        map "number", to: :number
+        map "year", to: :year
+        map "language", to: :language
+        map "form", to: :form
+        map "issue", to: :issue
+        map "article", to: :article
+        map "edition", to: :edition
+        map "version", to: :version
+        map "years", to: :years
+        map "variant", to: :variant
+        map "mep_code", to: :mep_code
+        map "report_code", to: :report_code
+        map "guide_kind", to: :guide_kind
+        map "appendix", to: :appendix
+        map "annex", to: :annex
+        map "part", to: :part
+      end
+
+      # Publisher is always "BIPM". A plain constant (not a `publisher` method)
+      # so it doesn't shadow the inherited lutaml `publisher` attribute, which
+      # would otherwise fail serialization type validation.
+      PUBLISHER = "BIPM"
+
+      # French connective before a committee acronym: "de la" for the (feminine)
+      # CGPM, "du" for every other (masculine) committee.
+      def self.french_connective(group)
+        group == "CGPM" ? "de la" : "du"
+      end
+
+      # Resolve a historic committee name to the name the index keys.
+      def self.normalize_group(token)
+        name = token.to_s
+        GROUP_ALIASES.fetch(name, name)
+      end
+
+      # Resolve a two-letter language code to the one-letter code BIPM prints.
+      def self.normalize_language(token)
+        return nil if token.nil?
+
+        code = token.to_s
+        LANGUAGE_ALIASES.fetch(code, code)
+      end
+
+      def long?
+        form == "long"
+      end
+
+      # BIPM keeps the publication year in its own `year` integer attribute
+      # rather than the base `date` component, so the base #exclude's
+      # :year->:date remap would nil the (unused) inherited `date` and leave
+      # `year` intact. Clear `year` directly when either alias is excluded so
+      # `matches?(row, ignore: [:year])` treats a partial (date-less) reference
+      # as a year wildcard.
+      def exclude(*args)
+        result = super
+        result.year = nil if args.include?(:year) || args.include?(:date)
+        result.number = nil if args.intersect?(NUMBER_SOURCE_ATTRIBUTES)
+        result
+      end
+
+      # Basic string representation. Delegates to renderer.
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      # --- MR string / slug -------------------------------------------------
+      #
+      # `to_slug` is what consumers use as an output FILENAME, so every BIPM
+      # identifier needs a non-empty, filename-safe, non-colliding MR. None of
+      # the base ::Pubid::Identifier hooks work here unchanged, because BIPM
+      # models each of them with its own flat attribute rather than the shared
+      # component the base expects. Each override below says which.
+      #
+      # The number segment and the family discriminator are supplied per leaf
+      # (`mr_number_with_part` / `mr_type`), because BIPM's six families share
+      # no numbering.
+      #
+      # Three deliberate collapses — MR is a canonical DOCUMENT slug, so
+      # alternate print spellings of one document share it (the URN already
+      # collapses the first two): `form` (short vs long committee spelling) and
+      # the MEP/Guide `appendix`/`annex`/`part` full-content tail are omitted,
+      # while `language` is kept because the E and F records are distinct
+      # documents upstream.
+
+      # BIPM keeps its publisher in the PUBLISHER constant rather than the
+      # inherited `publisher` attribute (which would fail type validation), so
+      # the base hook — `publisher&.to_s` — is nil. The JIS/IANA shape.
+      def mr_publisher
+        PUBLISHER.downcase
+      end
+
+      # BIPM stores the publication year in its own :integer attribute rather
+      # than a Components::Date, so the base hook reads an unset `date`.
+      def mr_year
+        year&.to_s
+      end
+
+      # BIPM's `edition` is a plain :string ("9e"), not a Components::Edition,
+      # so the base hook's `edition.number` raises NoMethodError. SiBrochure
+      # folds the edition into its own number segment instead.
+      def mr_edition
+        nil
+      end
+
+      # BIPM has a single `language` string, not the base's `languages`
+      # collection.
+      def mr_languages
+        language&.to_s&.downcase
+      end
+
+      # BIPM uses its own `type_code` attribute rather than a typed_stage, so
+      # the base hook is always nil; the leaves supply the discriminator.
+      def mr_type
+        nil
+      end
+
+      # Join the parts of a number segment into one filename-safe token.
+      #
+      # The sanitisation is by CHARSET, not an enumerated escape list, so a
+      # field added later cannot leak an unsafe character: everything outside
+      # [a-z0-9] collapses to `-`. BIPM needs at least three of those today —
+      # a `/` (the MEP report code "BIPM-2019/05"), a space (the SI Brochure
+      # variant "Appendix 3") and a `.` (the brochure version "v3.01"). The
+      # dot matters beyond filename safety: Renderers::MrString joins SEGMENTS
+      # with ".", so a dot inside one would break the documented segment
+      # structure.
+      #
+      # Caveat: `-` is both the intra-segment join and a substitute, so two
+      # different field splits could in principle produce one slug. That
+      # cannot happen with today's grammar — none of `group`, `guide_kind`,
+      # `mep_code`, `issue` or `article` admits a `-`, and `number`'s own
+      # internal `-` ("10-1") is unambiguous because the `group` before it
+      # cannot contain one. A future hyphen-bearing free-text field would
+      # need a different join.
+      def mr_slug(*parts)
+        slug = parts.compact.map(&:to_s).reject(&:empty?).join("-").downcase
+        slug = slug.gsub(/[^a-z0-9]+/, "-").gsub(/\A-+|-+\z/, "")
+        slug unless slug.empty?
+      end
+
+      # Parse a BIPM identifier string into an identifier object.
+      # @param identifier [String] the BIPM identifier string
+      # @return [Identifier] the appropriate identifier object
+      # @raise [Pubid::Errors::ParseError] if parsing fails
+      def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        # Normalize legacy/docnumber-style spellings before parsing
+        # (data/bipm/update_codes.yaml), mirroring Pubid::Ccsds / Pubid::Plateau.
+        normalized = Core::UpdateCodes.apply(identifier, :bipm)
+        parsed = Parser.parse(normalized)
+        Builder.build(parsed)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    module Identifiers
+      # A committee document: a Recommendation (REC), Resolution (RES),
+      # Decision (DECN), Action (ACT) or Declaration (DECL) issued by one of the
+      # BIPM committees.
+      #
+      # Printed forms (all round-trip):
+      #   "CCTF REC 2 (2012)"              short, language-neutral
+      #   "CCTF REC 2 (2012, E)"           short, with language
+      #   "CGPM DECL (1889)"               number-less
+      #   "CCL Recommendation 1 (2001)"    full English name  (form: "long")
+      #   "Recommandation 1 du CCL (2001)" full French name   (form: "long")
+      class CommitteeDocument < Identifier
+        def self.type
+          { key: :committee_document, web: :committee_document,
+            title: "Committee Document", short: "committee-document" }
+        end
+
+        # MR: `bipm.<type>.<group>-<number>.<year>[.<lang>]`. The type code
+        # discriminates REC/RES/DECN/ACT/DECL; the bare CIPM MRA form has none.
+        def mr_type
+          type_code&.downcase
+        end
+
+        # The group has to be in the number segment or `CCTF REC 2` and
+        # `CCEM REC 2` would share a slug.
+        def mr_number_with_part
+          mr_slug(group, number)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    module Identifiers
+      # A Consultative-Committee guideline document (realization / calibration
+      # guide). Printed from its short docnumber form, the relaton index key.
+      #
+      # Printed forms (all round-trip):
+      #   "CCL-GD-MeP-1"    metre realization guide
+      #   "CCEM-GD-RSI-1"   ampere realization guide
+      #   "CCM-GD-RSI-2"    kilogram dissemination guide
+      #
+      # Shape: <committee>-GD-<kind>-<number>, where <kind> is "MeP" (mise en
+      # pratique guide) or "RSI" (réalisation du SI guide). The committee reuses
+      # the shared `group` attribute; the trailing sequence reuses `number`.
+      class Guide < Identifier
+        def self.type
+          { key: :guide, web: :guide, title: "Guide", short: "guide" }
+        end
+
+        # MR: `bipm.guide.<group>-<kind>-<number>`. Both the committee and the
+        # kind are needed — the trailing sequence restarts per committee, so
+        # `CCL-GD-MeP-1` and `CCEM-GD-RSI-1` both carry number "1".
+        def mr_type
+          "guide"
+        end
+
+        def mr_number_with_part
+          mr_slug(group, guide_kind, number)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    module Identifiers
+      # A committee meeting (proceedings). Printed with a naive ordinal derived
+      # from the first number component's last digit (as the source data
+      # generates it: "11st", "12nd", "13rd"), and ranges keep that first
+      # component's ordinal ("100-1th").
+      #
+      # Printed forms (all round-trip):
+      #   "CGPM 17th Meeting (1983)"             English      (language nil)
+      #   "CCAUV 11st Meeting (2017)"            naive ordinal
+      #   "CIPM 100-1th Meeting (2011)"          range
+      #   "CCAUV 10<sup>e</sup> réunion (2015)"  French       (language "F")
+      class Meeting < Identifier
+        def self.type
+          { key: :meeting, web: :meeting, title: "Meeting", short: "meeting" }
+        end
+
+        # English ordinal suffix from the first number component's last digit.
+        # Naive (matches the source data): 1→st, 2→nd, 3→rd, else→th — no
+        # 11/12/13 exception, so "11" → "11st", and a range "22-23" → "22-23nd".
+        def self.ordinal_suffix(number)
+          first = number.to_s.split("-").first.to_s
+          case first[-1]
+          when "1" then "st"
+          when "2" then "nd"
+          when "3" then "rd"
+          else "th"
+          end
+        end
+
+        # "15" → "15th", "100-1" → "100-1th".
+        def ordinal_en
+          "#{number}#{self.class.ordinal_suffix(number)}"
+        end
+
+        # MR: `bipm.meeting.<group>-<number>.<year>`. The English and French
+        # spellings of one meeting collapse onto the same slug on purpose.
+        def mr_type
+          "meeting"
+        end
+
+        # The group has to be in the number segment or the 17th CGPM and the
+        # 17th CIPM meeting would share a slug.
+        def mr_number_with_part
+          mr_slug(group, number)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    module Identifiers
+      # A mise en pratique (MEP) of an SI base-unit definition, and the related
+      # BIPM report variant. Printed from the short docnumber form that relaton
+      # uses as the index key — NOT the long "Appendix 2 Part x" content string.
+      #
+      # Printed forms (all round-trip):
+      #   "SI MEP S1"              standard MEP code (unit letter + number)
+      #   "SI MEP KUPRTM"          alphabetic MEP code
+      #   "Rapport BIPM-2019/05"   report variant (mep_code absent, report_code set)
+      class Mep < Identifier
+        def self.type
+          { key: :mep, web: :mep, title: "Mise en pratique", short: "mep" }
+        end
+
+        # MR: `bipm.mep.<code>`. Exactly one of `mep_code` / `report_code` is
+        # set; the report code carries a `/` that `mr_slug` sanitises away. The
+        # full-content "Appendix 2 Part x" tail is the same document, so it
+        # stays out of the slug.
+        def mr_type
+          "mep"
+        end
+
+        def mr_number_with_part
+          mr_slug(mep_code || report_code)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    module Identifiers
+      # A Metrologia journal reference, at volume, volume+issue, or
+      # volume+issue+article granularity. Issue may be alphanumeric ("1A") and
+      # the article keeps its printed form ("06007", "S138").
+      #
+      # Printed forms (all round-trip):
+      #   "Metrologia 51"          volume only
+      #   "Metrologia 1 1"         volume + issue
+      #   "Metrologia 51 1 128"    volume + issue + article
+      class MetrologiaArticle < Identifier
+        GROUP = "Metrologia"
+
+        def self.type
+          { key: :metrologia_article, web: :metrologia_article,
+            title: "Metrologia Article", short: "metrologia-article" }
+        end
+
+        # MR: `bipm.metrologia[.<volume>[-<issue>[-<article>]]]`.
+        # The volume IS the index key, so it is derived from `number` instead
+        # of being stored beside it — storing both would duplicate the same
+        # value in every one of the 6,204 published article rows. Kept as an
+        # Integer because that is the public type consumers already read
+        # (`Relaton::Bipm::Bibliography#id_hash` calls `pubid.volume`).
+        #
+        # Safe as a plain method only because `volume` is no longer a lutaml
+        # attribute anywhere in the hierarchy — a method that shadows a
+        # generated accessor corrupts attribute resolution (CLAUDE.md).
+        def volume
+          number&.to_i
+        end
+
+        def mr_type
+          "metrologia"
+        end
+
+        # `number` is only the volume (it is the CLUSTERING relaton-index key),
+        # so per-article distinctness has to come from here: the full triple.
+        def mr_number_with_part
+          mr_slug(volume, issue, article)
+        end
+      end
+    end
+  end
+end