relaton 2.2.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/relaton/jcgm/bibliography.rb

@@ -0,0 +1,97 @@
+require "net/http"
+
+module Relaton
+  module Jcgm
+    # Retrieval for JCGM (Joint Committee for Guides in Metrology) publications.
+    # Index-backed (no scraping): the reference is parsed with `Pubid::Jcgm`,
+    # matched against the pre-built index (whose rows are `Pubid::Jcgm::Identifier`
+    # hashes, deserialized via `pubid_class`), and the matching per-document YAML
+    # is fetched from the `relaton/relaton-data-jcgm` GitHub repo.
+    module Bibliography
+      ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-jcgm/main/".freeze
+
+      class << self
+        #
+        # Search for a JCGM publication by its identifier.
+        #
+        # @param text [String, Pubid::Jcgm::Identifier] e.g. "JCGM 200:2012" or
+        #   "JCGM 17th Meeting (2012)"
+        # @param year [String, nil] edition year (optional; may be embedded)
+        # @param _opts [Hash] options (unused)
+        #
+        # @return [Relaton::Jcgm::Item, nil]
+        #
+        def search(text, year = nil, _opts = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          pubid = parse_ref(text)
+          Util.info "Fetching from Relaton repository ...", key: pubid.to_s
+          row = index.search(pubid) { |r| pubid_match?(r[:id], pubid, year) }
+                     .max_by { |r| r[:id].year.to_i }
+          unless row
+            Util.info "Not found.", key: pubid.to_s
+            return
+          end
+
+          uri = URI("#{ENDPOINT}#{row[:file]}")
+          resp = Net::HTTP.get_response uri
+          unless resp.code == "200"
+            raise Relaton::RequestError, "Could not access #{uri}: HTTP #{resp.code}"
+          end
+
+          item = Relaton::Jcgm::Item.from_yaml resp.body
+          Util.info "Found: `#{item.docidentifier.first&.content}`", key: pubid.to_s
+          item.tap { |i| i.fetched = Date.today.to_s }
+        rescue SocketError, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+               Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+               Net::ProtocolError, Net::ReadTimeout, OpenSSL::SSL::SSLError,
+               Errno::ETIMEDOUT => e
+          raise Relaton::RequestError, "Could not access #{uri}: #{e.message}"
+        end
+
+        # @see #search
+        def get(ref, year = nil, opts = {})
+          search(ref, year, opts)
+        end
+
+        private
+
+        # Parse a reference into a Pubid::Jcgm identifier. An unrecognized
+        # reference raises; like ISO and 3GPP we let it propagate --
+        # relaton-cli rescues Pubid::Errors::Error and renders "... is not a
+        # recognized standards identifier". The `search` rescue lists transport
+        # errors only, so it does not swallow the parse error.
+        def parse_ref(text)
+          return text unless text.is_a?(String)
+
+          ::Pubid::Jcgm.parse(text)
+        end
+
+        def index
+          Relaton::Index.find_or_create(
+            :jcgm,
+            url: "#{ENDPOINT}#{INDEXFILE}.zip",
+            file: "#{INDEXFILE}.yaml",
+            pubid_class: ::Pubid::Jcgm::Identifier,
+          )
+        end
+
+        # `row_id` and `query` are both `Pubid::Jcgm::Identifier` instances.
+        # Matching is pubid's asymmetric subset match (`Pubid::SubsetMatch`):
+        # the reference on the left, the row on the right, and a component the
+        # reference omits matches any value. Guides distinguish editions by year
+        # (`JCGM 200:2008` vs `:2012`), so a reference without a year reaches
+        # both and the latest edition is picked by `max_by` in #search. Meetings
+        # distinguish by number (`17th` vs `18th`), which the reference states,
+        # so they never collapse together. The type is the identifier's class,
+        # and `===` requires the same class, so cross-type collisions cannot
+        # occur. The `year` argument lets a caller pin an edition the reference
+        # string omitted; a year the reference states is compared by `===`
+        # itself.
+        def pubid_match?(row_id, query, year)
+          wanted_year = (query.year || year)&.to_s
+          query === row_id &&
+            (wanted_year.nil? || row_id.year.to_s == wanted_year)
+        end
+      end
+    end
+  end
+end

data/lib/relaton/jcgm/data_fetcher.rb

@@ -0,0 +1,81 @@
+require_relative "../jcgm"
+require_relative "meetings_parser"
+
+module Relaton::Jcgm
+  # Harvests the JCGM **meeting proceedings** from the `jcgm/meetings-{en,fr}`
+  # dirs of a local checkout of metanorma/bipm-data-outcomes, writing one Relaton
+  # YAML per meeting and indexing each by its `Pubid::Jcgm` identifier.
+  #
+  # The curated guide/GUM/VIM records are **not** harvested here: they are
+  # hand-maintained YAMLs that live in the data repo's own `static/` dir, so the
+  # data repo's `crawler.rb` indexes them (like relaton-data-bipm's crawler does)
+  # by looping `static/**` and calling the public, guarded {#add_to_index} —
+  # keeping the "which static files" policy in the data repo while the guarded,
+  # sorted, `_type: pubid:jcgm:*` indexing mechanism stays here.
+  class DataFetcher < Relaton::Core::DataFetcher
+    attr_reader :output, :format, :ext, :files, :errors
+
+    def index
+      @index ||= Relaton::Index.find_or_create(
+        :jcgm, file: "#{INDEXFILE}.yaml", pubid_class: ::Pubid::Jcgm::Identifier
+      )
+    end
+
+    def log_error(msg) = Util.error msg
+
+    #
+    # @param [String] source dataset name ("bipm-data-outcomes")
+    #
+    def fetch(source)
+      MeetingsParser.parse(self) if source == "bipm-data-outcomes"
+      index.save
+      report_errors
+    end
+
+    #
+    # Save document to file
+    #
+    # @param [String] path Path to file
+    # @param [Relaton::Jcgm::ItemData] item document to save
+    # @param [Boolean, nil] warn_duplicate Warn if document already exists
+    #
+    def write_file(path, item, warn_duplicate: true)
+      content = serialize item
+      if @files.include?(path)
+        Util.warn "File #{path} already exists" if warn_duplicate
+      else
+        @files << path
+      end
+      File.write path, content, encoding: "UTF-8"
+    end
+
+    #
+    # Index a document by its pubid. Guarded defensively: a docnumber the
+    # `Pubid::Jcgm` grammar can't parse is skipped with a warning rather than
+    # allowed to corrupt the whole index (`Relaton::Index` rejects an index if a
+    # single row fails to deserialize). All current JCGM records parse on pubid
+    # main; the guard protects against a future malformed record.
+    #
+    # Public so the data repo's crawler can index its curated `static/` guides
+    # through the same guarded, sorted, pubid-backed path the meetings use.
+    #
+    # @param [String] docnumber the record's docnumber (e.g. "JCGM 17th Meeting (2012)")
+    # @param [String] path repo-relative path to the YAML file
+    #
+    def add_to_index(docnumber, path)
+      # Store the Pubid::Jcgm identifier object (not its hash): with pubid_class
+      # set, Relaton::Index then sorts the index by id number on save and
+      # serializes each id to its `_type: pubid:jcgm:*` hash, so the published
+      # index is already sorted (no "not sorted by id number" warning on fetch).
+      index.add_or_update ::Pubid::Jcgm.parse(docnumber), path
+    rescue StandardError => e
+      Util.warn "Skipping index entry for `#{docnumber}` (#{path}): #{e.message}"
+    end
+
+    def to_xml(item) = item.to_xml bibdata: true
+
+    def to_yaml(item) = item.to_yaml
+
+    def to_bibxml(item) = item.to_rfcxml
+  end
+end

data/lib/relaton/jcgm/docidentifier.rb

@@ -0,0 +1,102 @@
+module Relaton
+  module Jcgm
+    # A JCGM document identifier, backed by `Pubid::Jcgm` (mirrors OIML's
+    # pubid-backed Docidentifier). Parsing is best-effort: forms pubid doesn't
+    # recognise (e.g. the combined bilingual docidentifiers and the French
+    # `réunion` form) leave `pubid` nil via the `content=` rescue rather than
+    # raising during deserialization.
+    class Docidentifier < Bib::Docidentifier
+      attr_reader :pubid
+
+      # Capture the inherited content setter before overriding #content=, so
+      # #refresh_content! can write the re-rendered string back WITHOUT
+      # re-parsing (a re-parse would rebuild @pubid from the string, which may
+      # not even parse back — e.g. an all-parts wrapper's own "(all parts)"
+      # rendering — and would discard whatever mutation was just made).
+      alias_method :store_content, :content=
+
+      def initialize(attrs = {}, options = {})
+        pubid = attrs.is_a?(Hash) ? attrs.delete(:pubid) : nil
+        attrs[:content] ||= pubid.to_s if pubid
+        super
+        @pubid = pubid if pubid
+      end
+
+      def content=(value)
+        super
+        @pubid = ::Pubid::Jcgm.parse(value) if value
+      rescue StandardError
+        @pubid = nil
+      end
+
+      # The class carried `#pubid` but none of `Bib::Docidentifier`'s abstract
+      # `remove_part!` / `remove_date!` / `to_all_parts!`, so it looked migrated
+      # while still raising `NotImplementedError` on every JCGM item through
+      # `Bib::ItemData#to_all_parts` / `#to_most_recent_reference` — and
+      # `NotImplementedError` descends from `ScriptError`, so a caller's
+      # `rescue => e` did not catch it.
+      #
+      # `Pubid::Jcgm` keeps the publication date in `date` (a
+      # `Components::Date`, unlike EASC's and GOST's plain `year`), so
+      # `remove_date!` clears that: `JCGM 100:2008` -> `JCGM 100`. `part` and
+      # `subpart` come from the pubid base class and are unused by JCGM today,
+      # so `remove_part!` is a no-op for the rendered string — implemented so it
+      # never raises.
+      #
+      # The mutation is applied to the identifier **and to its `#root`**. A
+      # supplement/corrigendum wraps the document it amends in `base`, and it
+      # exposes its own `date=` while carrying nil there — the year lives on the
+      # base. Clearing only the wrapper is therefore a silent no-op:
+      # `JCGM 200:2008 Corrigendum` keeps its 2008. Clearing the root as well
+      # gives `JCGM 200 Corrigendum`. `#root` is the same accessor
+      # `Relaton::Index::Type#candidates_by_number` narrows on, so the two stay
+      # consistent.
+      #
+      # Every write is guarded by `respond_to?`, and all three no-op when
+      # `@pubid` is nil — the common case the `content=` rescue exists for (the
+      # combined bilingual docidentifiers and the French `réunion` form).
+
+      def remove_part!
+        clear_attr!(:part)
+      end
+
+      def remove_date!
+        clear_attr!(:date)
+      end
+
+      def to_all_parts!
+        return if !@pubid || @pubid.all_parts?
+
+        # `#exclude` (no args) rebuilds a full independent copy, including
+        # the `#root` of a supplement/corrigendum — `remove_part!`/
+        # `remove_date!` mutate BOTH `@pubid` and its root in place (see
+        # `clear_attr!`), so even a shallow `.dup` would still lose the
+        # original date to that mutation.
+        original = @pubid.exclude
+        remove_part!
+        remove_date!
+        @pubid = original.to_all_parts
+      end
+
+      private
+
+      def clear_attr!(attr)
+        return unless @pubid
+
+        targets = [@pubid]
+        targets << @pubid.root if @pubid.respond_to?(:root) && !@pubid.root.equal?(@pubid)
+        targets.each do |id|
+          next unless id.respond_to?("#{attr}=")
+
+          id.public_send("#{attr}=", nil)
+          id.subpart = nil if attr == :part && id.respond_to?(:subpart=)
+        end
+        refresh_content!
+      end
+
+      def refresh_content!
+        store_content(@pubid.to_s) if @pubid
+      end
+    end
+  end
+end

data/lib/relaton/jcgm/doctype.rb

@@ -0,0 +1,12 @@
+module Relaton
+  module Jcgm
+    # JCGM document types. Meetings are `meeting-report`; the guides/GUM/VIM
+    # records carry `international-standard` (the shape they were filed with
+    # under BIPM). The list is intentionally not enforced as an enum so any
+    # unforeseen dataset value still round-trips (mirrors OIML's Doctype).
+    class Doctype < Bib::Doctype
+      TYPES = %w[meeting-report guide international-standard vocabulary
+                 monographie rapport].freeze
+    end
+  end
+end

data/lib/relaton/jcgm/ext.rb

@@ -0,0 +1,23 @@
+require_relative "doctype"
+require_relative "structured_identifier"
+
+module Relaton
+  module Jcgm
+    # JCGM bibliographic item extension. JCGM records are BIPM-shaped, so this
+    # mirrors `Relaton::Bipm::Ext`: a JCGM `Doctype` and a single
+    # `structuredidentifier` (overriding the base collection). `flavor`,
+    # `schema_version`, `subdoctype`, `ics` come from the shared `Bib::Ext`.
+    class Ext < Bib::Ext
+      attribute :doctype, Doctype
+      attribute :structuredidentifier, StructuredIdentifier
+
+      xml do
+        map_element "structuredidentifier", to: :structuredidentifier
+      end
+
+      key_value do
+        map_element "structuredidentifier", to: :structuredidentifier
+      end
+    end
+  end
+end

data/lib/relaton/jcgm/item.rb

@@ -0,0 +1,20 @@
+require_relative "item_data"
+require_relative "ext"
+require_relative "docidentifier"
+
+module Relaton
+  module Jcgm
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :ext, Ext
+      attribute :docidentifier, Docidentifier, collection: true,
+                                               initialize_empty: true
+    end
+  end
+end
+
+require_relative "relation"
+
+Relaton::Jcgm::Item.attribute :relation, Relaton::Jcgm::Relation,
+                              collection: true, initialize_empty: true

data/lib/relaton/jcgm/item_base.rb

@@ -0,0 +1,18 @@
+module Relaton
+  module Jcgm
+    class ItemBase < Lutaml::Model::Serializable
+      include Bib::NamespaceHelper
+
+      attr_accessor :type
+
+      model ItemData
+
+      instance_exec(&Bib::ItemShared::ATTRIBUTES)
+
+      xml do
+        map_attribute "type", to: :type
+        instance_exec(&Bib::ItemShared::XML_BODY)
+      end
+    end
+  end
+end

data/lib/relaton/jcgm/item_data.rb

@@ -0,0 +1,6 @@
+module Relaton
+  module Jcgm
+    class ItemData < Bib::ItemData
+    end
+  end
+end

data/lib/relaton/jcgm/meetings_parser.rb

@@ -0,0 +1,175 @@
+require "fileutils"
+require "yaml"
+require "date"
+
+module Relaton::Jcgm
+  # Harvests JCGM meeting proceedings from the `jcgm/meetings-{en,fr}` dirs of a
+  # local checkout of metanorma/bipm-data-outcomes and writes one Relaton YAML
+  # per meeting into `<output>/jcgm/meeting/<num>.yaml`, indexing each by its
+  # `Pubid::Jcgm` meeting identifier.
+  #
+  # This is the JCGM-only slice of `Relaton::Bipm::DataOutcomesParser`: JCGM
+  # meetings carry no sub-resolutions and no parts, so the resolution/part
+  # machinery is dropped. The meeting docnumber's ordinal ("11st"/"12nd"/"13rd"
+  # — a naive last-digit rule with no teens exception) is delegated to
+  # `Pubid::Jcgm::Identifiers::Meeting.ordinal`, the single source of truth, so
+  # the printed form round-trips through pubid.
+  class MeetingsParser
+    SOURCE_ROOT = "bipm-data-outcomes".freeze
+    BODY = "JCGM".freeze
+    GH_SRC = "https://raw.githubusercontent.com/metanorma/bipm-data-outcomes/".freeze
+
+    def self.parse(data_fetcher)
+      new(data_fetcher).parse
+    end
+
+    def initialize(data_fetcher)
+      @data_fetcher = data_fetcher
+    end
+
+    def parse
+      Dir[File.join(SOURCE_ROOT, "jcgm", "meetings-en", "*.{yml,yaml}")].sort.each do |en_file|
+        fetch_meeting en_file
+      end
+    end
+
+    private
+
+    def fetch_meeting(en_file)
+      en, fr, fr_file = read_files en_file
+      md_en = en["metadata"]
+      md_fr = fr && fr["metadata"]
+      num = md_en["identifier"].to_s
+      date = md_en["date"].to_s
+      docnum = meeting_docnum num, date
+      id = "JCGMMeeting#{num}#{::Date.parse(date).year}"
+
+      outdir = File.join @data_fetcher.output, "jcgm", "meeting"
+      FileUtils.mkdir_p outdir
+      path = File.join outdir, "#{num}.#{@data_fetcher.ext}"
+
+      item = ItemData.new(**meeting_hash(md_en, md_fr, num, id, docnum,
+                                         meeting_links(en_file, fr_file), en["pdf"]))
+      @data_fetcher.write_file path, item
+      @data_fetcher.add_to_index docnum, path
+    end
+
+    # Read English + French metadata (the French file mirrors the path with
+    # `en` -> `fr`). `Date`/`Time` are permitted because the source may write
+    # an unquoted `date:` scalar; the date is coerced to a string downstream.
+    def read_files(en_file)
+      fr_file = en_file.sub "en", "fr"
+      en = load_yaml en_file
+      fr = File.exist?(fr_file) ? load_yaml(fr_file) : nil
+      [en, fr, (fr && fr_file)]
+    end
+
+    def load_yaml(file)
+      YAML.safe_load File.read(file, encoding: "UTF-8"), permitted_classes: [Date, Time]
+    end
+
+    # "JCGM 17th Meeting (2012)" — ordinal via pubid's Meeting.ordinal.
+    def meeting_docnum(num, date)
+      year = ::Date.parse(date).year
+      "#{BODY} #{::Pubid::Jcgm::Identifiers::Meeting.ordinal(num)} Meeting (#{year})"
+    end
+
+    def meeting_hash(md_en, md_fr, num, id, docnum, src, pdf) # rubocop:disable Metrics/MethodLength
+      {
+        id: id,
+        type: "proceedings",
+        title: titles(md_en, md_fr),
+        place: [Relaton::Bib::Place.new(city: "Paris")],
+        date: date(md_en["date"]),
+        docidentifier: docids(docnum),
+        docnumber: docnum,
+        source: links(md_en, md_fr, src, pdf),
+        language: %w[en fr],
+        script: ["Latn"],
+        contributor: [bipm_contrib],
+        ext: ext(num),
+      }
+    end
+
+    def titles(md_en, md_fr)
+      result = []
+      result << title(md_en["title"], "en") if md_en && md_en["title"]
+      result << title(md_fr["title"], "fr") if md_fr && md_fr["title"]
+      result
+    end
+
+    def title(content, language)
+      content = content.dup
+      content.sub!(/(\d+)(e)/, '\1<sup>\2</sup>') if language == "fr"
+      Relaton::Bib::Title.new(content: content, language: language, script: "Latn")
+    end
+
+    def date(at)
+      at = at.to_s
+      return [] if at.empty?
+
+      [Relaton::Bib::Date.new(type: "published", at: at)]
+    end
+
+    # en: "JCGM 17th Meeting (2012)"; fr: "JCGM 17<sup>e</sup> réunion (2012)";
+    # plus the combined "en / fr" form (mirrors BIPM's create_meeting_docids).
+    def docids(en_id)
+      fr_id = en_id.sub(/(\d+)(?:st|nd|rd|th)/, '\1e').sub("Meeting", "réunion")
+      fr_id_sup = fr_id.sub(/(\d+)(e)/, '\1<sup>\2</sup>')
+      [
+        docid(en_id, language: "en"),
+        docid(fr_id_sup, language: "fr"),
+        docid("#{en_id} / #{fr_id_sup}"),
+      ]
+    end
+
+    def docid(content, language: nil)
+      attrs = { content: content, type: "BIPM", primary: true }
+      attrs.merge!(language: language, script: "Latn") if language
+      Docidentifier.new(**attrs)
+    end
+
+    def links(md_en, md_fr, src, pdf)
+      links = []
+      links << uri("citation", md_en["url"], "en") if md_en && md_en["url"]
+      links << uri("citation", md_fr["url"], "fr") if md_fr && md_fr["url"]
+      Array(pdf).each { |p| links << Relaton::Bib::Uri.new(type: "pdf", content: p) }
+      links + Array(src)
+    end
+
+    def uri(type, content, language)
+      Relaton::Bib::Uri.new(type: type, content: content, language: language, script: "Latn")
+    end
+
+    # en/fr `src` links back to the source files in bipm-data-outcomes.
+    def meeting_links(en_file, fr_file)
+      { "en" => en_file, "fr" => fr_file }.filter_map do |lang, file|
+        next unless file
+
+        src = GH_SRC + file.split("/")[-3..].unshift("main").join("/")
+        Relaton::Bib::Uri.new(type: "src", content: src, language: lang, script: "Latn")
+      end
+    end
+
+    def ext(num)
+      Ext.new(doctype: Doctype.new(content: "meeting-report"),
+              structuredidentifier: StructuredIdentifier.new(docnumber: num))
+    end
+
+    def bipm_contrib
+      names = [
+        Relaton::Bib::TypedLocalizedString.new(content: "International Bureau of Weights and Measures", language: "en", script: "Latn"),
+        Relaton::Bib::TypedLocalizedString.new(content: "Bureau international des poids et mesures", language: "fr", script: "Latn"),
+      ]
+      org = Relaton::Bib::Organization.new(
+        name: names,
+        abbreviation: Relaton::Bib::LocalizedString.new(content: "BIPM", language: "fr", script: "Latn"),
+        uri: [Relaton::Bib::Uri.new(content: "www.bipm.org")],
+      )
+      Relaton::Bib::Contributor.new(
+        organization: org,
+        role: [Relaton::Bib::Contributor::Role.new(type: "publisher")],
+      )
+    end
+  end
+end

data/lib/relaton/jcgm/processor.rb

@@ -0,0 +1,71 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Jcgm
+    class Processor < Core::Processor
+      attr_reader :idtype
+
+      def initialize
+        @short = :relaton_jcgm
+        @prefix = "JCGM"
+        @defaultprefix = %r{^JCGM\s}
+        @idtype = "JCGM"
+        @datasets = %w[bipm-data-outcomes]
+        # Prefixes come from pubid (Pubid::Jcgm.prefixes => ["JCGM"]); see
+        # Core::Processor#prefixes.
+        @pubid_flavor = :Jcgm
+      end
+
+      # @param code [String]
+      # @param date [String, nil] year
+      # @param opts [Hash]
+      # @return [Relaton::Jcgm::ItemData, nil]
+      def get(code, date, opts)
+        require_relative "../jcgm"
+        Bibliography.get(code, date, opts)
+      end
+
+      #
+      # Harvest the JCGM meeting proceedings from metanorma/bipm-data-outcomes.
+      # Used to (re)generate the relaton-data-jcgm repo; the curated static guides
+      # are indexed by that repo's crawler via DataFetcher#add_to_index.
+      #
+      # @param [String] source source name ("bipm-data-outcomes")
+      # @param [Hash] opts
+      #
+      def fetch_data(source, opts)
+        require_relative "data_fetcher"
+        DataFetcher.fetch(source, **opts)
+      end
+
+      # @param xml [String]
+      # @return [Relaton::Jcgm::ItemData]
+      def from_xml(xml)
+        require_relative "../jcgm"
+        Item.from_xml xml
+      end
+
+      # @param yaml [String]
+      # @return [Relaton::Jcgm::ItemData]
+      def from_yaml(yaml)
+        require_relative "../jcgm"
+        Item.from_yaml yaml
+      end
+
+      # Returns hash of XML grammar
+      # @return [String]
+      def grammar_hash
+        require_relative "../jcgm"
+        @grammar_hash ||= ::Relaton::Jcgm.grammar_hash
+      end
+
+      #
+      # Remove index file
+      #
+      def remove_index_file
+        require_relative "../jcgm"
+        Relaton::Index.find_or_create(:jcgm, url: true, file: "#{INDEXFILE}.yaml").remove_file
+      end
+    end
+  end
+end

data/lib/relaton/jcgm/relation.rb

@@ -0,0 +1,9 @@
+require_relative "item_base"
+
+module Relaton
+  module Jcgm
+    class Relation < Bib::Relation
+      attribute :bibitem, ItemBase
+    end
+  end
+end

data/lib/relaton/jcgm/structured_identifier.rb

@@ -0,0 +1,40 @@
+module Relaton
+  module Jcgm
+    # A single structured identifier (e.g. `{ docnumber: "17" }`). JCGM records
+    # carry this as a single mapping, not a sequence, so it overrides the base
+    # `Bib::Ext#structuredidentifier` collection (mirrors BIPM's model).
+    class StructuredIdentifier < Lutaml::Model::Serializable
+      attribute :docnumber, :string
+      attribute :part, :string
+      attribute :appendix, :string
+
+      xml do
+        map_element "docnumber", to: :docnumber
+        map_element "part", to: :part
+        map_element "appendix", to: :appendix
+      end
+
+      # `Bib::ItemData#ext_to_all_parts!` / `#ext_remove_date` broadcast to
+      # `ext.structuredidentifier` just as they do to `docidentifier`, so these
+      # three are as required here as on the docidentifier. This class descends
+      # from `Lutaml::Model::Serializable` rather than `Bib::StructuredIdentifier`
+      # (JCGM stores a single mapping, not a sequence), so the methods were not
+      # merely unimplemented — they were absent, and the broadcast raised
+      # `NoMethodError` on every JCGM item.
+      #
+      # JCGM structured identifiers carry no date field, so `remove_date!` has
+      # nothing to strip and is a deliberate no-op; the year lives on the
+      # docidentifier's pubid, which `Docidentifier#remove_date!` handles.
+
+      def remove_part!
+        self.part = nil
+      end
+
+      def remove_date!; end
+
+      def to_all_parts!
+        remove_part!
+      end
+    end
+  end
+end

data/lib/relaton/jcgm/util.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Jcgm
+    module Util
+      extend Relaton::Bib::Util
+      PROGNAME = "relaton-jcgm".freeze
+    end
+  end
+end