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

data/lib/relaton/bib/sanitizer.rb

@@ -0,0 +1,264 @@
+require "nokogiri"
+
+module Relaton
+  module Bib
+    # Strips inline markup not in the basicdoc PureTextElement set
+    # (plus <p>, <eref>, <xref>, <fn>, <link>) from raw marked-up content
+    # strings. Disallowed elements are unwrapped: tags removed, inner text kept.
+    #
+    # <link> (basicdoc's inline hyperlink) is admitted because it is a valid
+    # TextElement child of a biblionote and carries a target URL that must
+    # survive the from_xml/to_xml round-trip — dropping it silently loses
+    # every URL in amended note.display references (relaton-bib#122).
+    #
+    # <fn> is admitted beyond strict PureTextElement because bibliographic
+    # titles in real Metanorma input routinely carry footnotes (e.g. ISO
+    # standards titles with a disclaimer footnote), and downstream
+    # consumers — notably relaton-render's own inline-tag allow-list —
+    # already accept <fn> as a legitimate child of <title>. Stripping it
+    # here would break the round-trip.
+    #
+    # OPAQUE elements (currently <stem>) are also allowed, but the
+    # sanitiser does not descend into them: their contents are out-of-band
+    # inline notation (MathML, AsciiMath, LaTeX) rather than basicdoc
+    # markup, and must be preserved verbatim. Without the opaque-skip,
+    # the recursive walk would unwrap MathML / AsciiMath elements down to
+    # bare text nodes — see #116 for the round-trip-loss symptom.
+    module Sanitizer
+      ALLOWED = %w[
+        em strong sub sup tt underline strike smallcap br stem
+        p eref xref fn link
+      ].freeze
+
+      # Elements whose children are non-basicdoc inline notation
+      # (MathML, AsciiMath, LaTeX, …) and must be preserved verbatim
+      # rather than sanitised against ALLOWED.
+      OPAQUE = %w[stem].freeze
+
+      RENAME = {
+        "italic" => "em",
+      }.freeze
+
+      TAG_RX = %r{<[a-zA-Z/!?]}
+
+      # Captures a namespace prefix, on a tag or on an attribute: the
+      # "jats" of <jats:p> and </jats:italic>, and the "xlink" of
+      # xlink:href.
+      NS_PREFIX_RX = %r{(?:</?|\s)([A-Za-z_][\w.-]*):(?=[A-Za-z_])}
+
+      # Namespace that declares a prefix which the content leaves
+      # undeclared. The sanitiser removes it again before it serialises.
+      NS_PLACEHOLDER = "urn:x-relaton-undeclared:%s".freeze
+
+      # Element that carries the placeholder declarations. Its children
+      # are the sanitised content, so the element itself never reaches
+      # the output.
+      NS_WRAPPER = "relaton-sanitizer-root".freeze
+
+      # Extension that lengthens the wrapper name past a collision, and
+      # the pattern that measures how far the content already extends it.
+      NS_WRAPPER_SUFFIX = "-x".freeze
+      NS_WRAPPER_RX = /#{NS_WRAPPER}(?:#{NS_WRAPPER_SUFFIX})*/
+
+      # Reserved prefixes. XML declares both, so the content must not.
+      NS_RESERVED = %w[xml xmlns].freeze
+
+      # Serialise without the FORMAT option, so the sanitiser keeps the
+      # shape of element-only content instead of adding newlines and
+      # indent.
+      SAVE_OPTS = Nokogiri::XML::Node::SaveOptions::AS_XML
+
+      def self.sanitize(content)
+        return content unless sanitizable?(content)
+
+        node = parse(content)
+        return content if node.nil?
+
+        sanitize_children(node)
+        node.children.map do |c|
+          c.to_xml(encoding: "UTF-8", save_with: SAVE_OPTS)
+        end.join
+      end
+
+      #
+      # Parse the content into a node whose children are the content.
+      #
+      # @param [String] content The raw marked-up content.
+      #
+      # @return [Nokogiri::XML::Node, nil] The node, or nil when the
+      #   content does not parse.
+      #
+      def self.parse(content)
+        fragment = Nokogiri::XML::DocumentFragment.parse(content)
+        return fragment if fragment.errors.empty?
+
+        parse_with_prefixes(content)
+      end
+      private_class_method :parse
+
+      #
+      # Parse content that uses undeclared namespace prefixes.
+      #
+      # An undeclared prefix is always a parse error, so without this the
+      # sanitiser gives up on exactly the third-party markup that needs
+      # sanitising most. Declare every prefix that the content uses on a
+      # wrapper element, parse, then remove the placeholder namespaces
+      # from the elements and from the attributes. See metanorma-pdfa#99.
+      #
+      # An undeclared prefix inside an OPAQUE <stem> goes as well. The
+      # sanitiser cannot keep it: an undeclared prefix in the output is
+      # the exact failure that this method removes. Only a namespace that
+      # the content declares itself survives verbatim.
+      #
+      # @param [String] content The raw marked-up content.
+      #
+      # @return [Nokogiri::XML::Element, nil] The wrapper element, or nil
+      #   when the content uses no prefix or does not parse.
+      #
+      def self.parse_with_prefixes(content)
+        decl = placeholder_declarations(content) or return
+        name = wrapper_name(content)
+        doc = Nokogiri::XML "<#{name} #{decl}>#{content}</#{name}>"
+        return unless doc.errors.empty?
+
+        drop_placeholder_namespaces doc.root
+      end
+      private_class_method :parse_with_prefixes
+
+      #
+      # Declare every namespace prefix that the content uses.
+      #
+      # @param [String] content The raw marked-up content.
+      #
+      # @return [String, nil] The declarations, or nil when the content
+      #   uses no prefix.
+      #
+      def self.placeholder_declarations(content)
+        prefixes = content.scan(NS_PREFIX_RX).flatten.uniq - NS_RESERVED
+        return if prefixes.empty?
+
+        prefixes.map do |pfx|
+          %(xmlns:#{pfx}="#{format NS_PLACEHOLDER, pfx}")
+        end.join(" ")
+      end
+      private_class_method :placeholder_declarations
+
+      #
+      # Name a wrapper element that the content does not close itself.
+      #
+      # Content that holds the literal end tag of the wrapper would close
+      # it early. The document then has more than one root, the parse
+      # fails, and the sanitiser gives up on content that it can handle.
+      #
+      # Extend past the longest run of the suffix that the content already
+      # holds, in ONE scan. Growing the name and re-testing with include?
+      # is quadratic: each extension re-scans the whole string, and
+      # content shaped like "…-root-x-x-x" forces one pass per two
+      # characters (measured at 229 ms for 20k characters). The sanitiser
+      # runs on every marked-up assignment, on third-party content.
+      #
+      # @param [String] content The raw marked-up content.
+      #
+      # @return [String] A name that the content does not contain.
+      #
+      def self.wrapper_name(content)
+        longest = content.scan(NS_WRAPPER_RX).map(&:size).max
+        return NS_WRAPPER unless longest
+
+        extra = ((longest - NS_WRAPPER.size) / NS_WRAPPER_SUFFIX.size) + 1
+        NS_WRAPPER + (NS_WRAPPER_SUFFIX * extra)
+      end
+      private_class_method :wrapper_name
+
+      #
+      # Remove the placeholder namespaces, and only those.
+      #
+      # Nokogiri's remove_namespaces! would also strip a namespace that
+      # the content declares itself, such as the MathML xmlns inside an
+      # OPAQUE <stem>, which must survive verbatim. Match the wrapper's
+      # own declarations, so a namespace of the content never matches,
+      # whatever its URI.
+      #
+      # The declarations stay on the wrapper element. Only its children
+      # reach the output, so the declarations never leak. Do not
+      # serialise the root itself.
+      #
+      # @param [Nokogiri::XML::Element] root The wrapper element.
+      #
+      # @return [Nokogiri::XML::Element] The same element.
+      #
+      def self.drop_placeholder_namespaces(root)
+        placeholders = root.namespace_definitions
+        root.traverse do |node|
+          node.namespace = nil if placeholders.include?(node.namespace)
+          next unless node.element?
+
+          drop_attribute_namespaces node, placeholders
+        end
+        root
+      end
+      private_class_method :drop_placeholder_namespaces
+
+      #
+      # Un-prefix the placeholder attributes of one element.
+      #
+      # Un-prefixing renames the attribute, so it can collide: an element
+      # carrying both target and xlink:target would keep two attributes
+      # called target, and Nokogiri rejects the result with "Attribute
+      # target redefined" -- the unparseable output this whole path
+      # exists to prevent. Drop the prefixed one instead.
+      #
+      # @param [Nokogiri::XML::Element] node The element.
+      # @param [Array<Nokogiri::XML::Namespace>] placeholders The
+      #   wrapper's own declarations.
+      #
+      # @return [void]
+      #
+      def self.drop_attribute_namespaces(node, placeholders)
+        node.attribute_nodes.each do |attr|
+          next unless placeholders.include?(attr.namespace)
+
+          if plain_attribute?(node, attr.name) then attr.unlink
+          else attr.namespace = nil
+          end
+        end
+      end
+      private_class_method :drop_attribute_namespaces
+
+      #
+      # Does the element already carry this attribute without a prefix?
+      #
+      # Nokogiri's Node#attribute matches on the name alone, so it finds
+      # the prefixed attribute itself and every un-prefixing would look
+      # like a collision. Match on the namespace as well.
+      #
+      # @param [Nokogiri::XML::Element] node The element.
+      # @param [String] name The un-prefixed attribute name.
+      #
+      # @return [Boolean] Whether the element carries it.
+      #
+      def self.plain_attribute?(node, name)
+        node.attribute_nodes.any? { |a| a.namespace.nil? && a.name == name }
+      end
+      private_class_method :plain_attribute?
+
+      def self.sanitizable?(content)
+        content.is_a?(::String) && !content.empty? && content.match?(TAG_RX)
+      end
+      private_class_method :sanitizable?
+
+      def self.sanitize_children(node)
+        node.children.to_a.each do |child|
+          next unless child.element?
+
+          child.name = RENAME[child.name] if RENAME.key?(child.name)
+          next if OPAQUE.include?(child.name)
+
+          sanitize_children(child)
+          child.replace(child.children) unless ALLOWED.include?(child.name)
+        end
+      end
+      private_class_method :sanitize_children
+    end
+  end
+end

data/lib/relaton/bib/util.rb

@@ -0,0 +1,18 @@
+module Relaton
+  module Bib
+    module Util
+      extend self
+
+      PROGNAME = "relaton-bib".freeze
+
+      def method_missing(method_name, msg = nil, prog = nil, **opts, &block)
+        prog ||= self::PROGNAME
+        Relaton.logger_pool.send method_name, msg, prog, **opts, &block
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        Relaton.logger_pool.respond_to?(method_name) || super
+      end
+    end
+  end
+end

data/lib/relaton/bib/versions.json

@@ -0,0 +1,35 @@
+{
+"relaton-models": "v1.5.6",
+"basicdoc-models": "v1.2.5",
+"metanorma-requirements-models": "v1.0.2",
+"relaton-model-ieee": "v1.1.3",
+"relaton-model-iso": "v1.1.2",
+"relaton-model-iec": "v1.1.2",
+"relaton-model-bsi": "v1.1.3",
+"relaton-model-gb": "v1.1.2",
+"relaton-model-mpfa": "v1.0.0",
+"relaton-model-bipm": "v1.1.2",
+"relaton-model-w3c": "v1.0.0",
+"relaton-model-3gpp": "v1.0.4",
+"relaton-model-cc": "v1.1.2",
+"relaton-model-ietf": "v1.1.2",
+"relaton-model-iho": "v1.1.2",
+"relaton-model-itu": "v1.1.3",
+"relaton-model-m3aawg": "v1.0.1",
+"relaton-model-nist": "v1.1.2",
+"relaton-model-ribose": "v1.1.2",
+"relaton-model-ogc": "v1.1.2",
+"relaton-model-cen": "v1.0.1",
+"relaton-model-ecma": "v1.0.0",
+"relaton-model-cie": "v1.0.0",
+"relaton-model-iana": "v1.0.0",
+"relaton-model-omg": "v1.0.0",
+"relaton-model-oasis": "v1.0.4",
+"relaton-model-jis": "v1.0.2",
+"relaton-model-etsi": "v0.1.2",
+"relaton-model-plateau": "v0.1.0",
+"relaton-model-ccsds": "",
+"relaton-model-un": "v1.0.2",
+"metanorma-model": "v2.1.6",
+"date": "2026-04-30T03:49:24Z"
+}

data/lib/relaton/bib.rb

@@ -0,0 +1,46 @@
+require "relaton/logger"
+require "forwardable"
+# require "htmlentities"
+require "bibtex"
+require "iso639"
+require "rfcxml"
+require "relaton/core"
+require_relative "version"
+require_relative "bib/util"
+require_relative "bib/sanitizer"
+require_relative "bib/namespace_helper"
+require_relative "bib/item_data"
+require_relative "bib/model/item"
+require_relative "bib/model/item_base"
+require_relative "bib/model/bibitem_shared"
+require_relative "bib/model/bibdata_shared"
+require_relative "bib/model/bibitem"
+require_relative "bib/model/bibdata"
+require_relative "bib/converter/bibxml"
+require_relative "bib/converter/bibtex"
+require_relative "bib/converter/asciibib"
+require_relative "bib/model/relation"
+
+module Relaton
+  # class Error < StandardError; end
+
+  class << self
+    #
+    # Read schema versions from file
+    #
+    # @return [Hash{String=>String}] schema versions
+    #
+    def schema_versions
+      @@schema_versions ||= JSON.parse File.read(File.join(__dir__, "bib/versions.json"))
+    end
+  end
+
+  module Bib
+    def self.grammar_hash
+      # gem_path = File.expand_path "..", __dir__
+      # grammars_path = File.join gem_path, "grammars", "*"
+      # grammars = Dir[grammars_path].sort.map { |gp| File.read gp }.join
+      Digest::MD5.hexdigest Relaton::VERSION # grammars
+    end
+  end
+end

data/lib/relaton/bipm/bibliography.rb

@@ -0,0 +1,231 @@
+require "mechanize"
+
+module Relaton::Bipm
+  class Bibliography
+    GH_ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-bipm/refs/heads/v2/".freeze
+
+    class << self
+      # @param text [String]
+      # @return [RelatonBipm::BipmBibliographicItem]
+      def search(text, _year = nil, _opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        Util.info "Fetching from Relaton repository ...", key: text
+        ref = text.sub(/^BIPM\s/, "")
+        item = get_bipm ref
+        unless item
+          Util.info "Not found.", key: text
+          return
+        end
+
+        Util.info "Found: `#{item.docidentifier[0].content}`", key: text
+        item
+      rescue Mechanize::ResponseCodeError => e
+        raise Relaton::RequestError, e.message unless e.response_code == "404"
+      end
+
+      # @return [Mechanize]
+      # def magent # rubocop:disable Metrics/MethodLength
+      #   a = Mechanize.new
+      #   a.request_headers = {
+      #     "Accept" => "text/html,application/xhtml+xml,application/xml;q=0.9," \
+      #                 "image/avif,image/webp,image/apng," \
+      #                 "*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
+      #     "Accept-Encoding" => "gzip, deflate, br",
+      #     "Accept-Language" => "en-US,en;q=0.9,ru-RU;q=0.8,ru;q=0.7",
+      #     "Cache-Control" => "max-age=0",
+      #     "Upgrade-Insecure-Requests" => "1",
+      #   }
+      #   a.user_agent_alias = Mechanize::AGENT_ALIASES.map(&:first).shuffle.first
+      #   # a.user_agent_alias = "Mac Safari"
+      #   a
+      # end
+
+      #
+      # @param reference [String]
+      #
+      # @return [RelatonBipm::BipmBibliographicItem]
+      #
+      def get_bipm(reference) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        pubid = parse_ref reference
+        rows = search_index pubid, reference
+        return if rows.empty?
+
+        # Latest edition wins. Metrologia and SI Brochure rows carry no year,
+        # so they all score 0; the file path breaks that tie so a repeated
+        # lookup returns the same document (the index sort is not stable).
+        row = rows.max_by { |r| [r[:id].year.to_i, r[:file]] }
+        url = "#{GH_ENDPOINT}#{row[:file]}"
+        resp = Mechanize.new.get url
+        return unless resp.code == "200"
+
+        item = Item.from_yaml resp.body
+        item.fetched = Date.today.to_s
+        item
+      end
+
+      # Look the reference up in the pubid `index-v2`, narrowing the candidate
+      # rows before the match runs. `Relaton::Index::Type#search` binary-searches
+      # only when given an identifier — the same call shape ISO, OIML and JCGM
+      # use. Both sides are now `Pubid::Bipm` objects, so the bespoke `Id`
+      # grammar takes no part in a query.
+      #
+      # Two escapes sit under the narrowing, each covering a case where the
+      # query's bsearch key cannot equal its row's:
+      #
+      # 1. A bare `SI Brochure` names no edition, so it keys to `""` while its
+      #    row keys to `"9e"`. The rescan finds it.
+      # 2. `CCTF Recommendation 2009-02` parses as the literal number
+      #    `2009-02`, while the row keys on `2`. No row carries that number, so
+      #    a rescan cannot help — only re-reading the tail as number-plus-year.
+      #
+      # @param pubid [Pubid::Bipm::Identifier] the parsed reference
+      # @param reference [String, nil] the raw reference, for the retry
+      # @return [Array<Hash>] the matching index rows
+      def search_index(pubid, reference)
+        # Reduce the query once, not once per row. `#exclude` copies the
+        # identifier, so rebuilding it per candidate dominated the lookup.
+        query_stem = stem pubid, pubid
+        rows = index.search(pubid) { |r| pubid_match? r[:id], pubid, query_stem }
+        rows = index.search { |r| pubid_match? r[:id], pubid, query_stem } if rows.empty?
+        return rows unless rows.empty?
+
+        retry_pubid = year_number_retry reference
+        retry_pubid ? search_index(retry_pubid, nil) : rows
+      end
+
+      # Re-read a trailing `YYYY-NN` as number `NN` of year `YYYY`
+      # (`CCTF Recommendation 2009-02` → `CCTF Recommendation 2 (2009)`). Tried
+      # only after a miss, because `NNNN-NN` is also a real BIPM number
+      # (`CIPM 2005-06`), so the literal reading has to be preferred.
+      #
+      # The re-read string is a machine-derived probe, not the caller's
+      # reference, so a probe that does not parse is a miss (nil), never a
+      # malformed-reference error -- the same rule as ISO's type/stage probe.
+      #
+      # @param reference [String, nil]
+      # @return [Pubid::Bipm::Identifier, nil]
+      def year_number_retry(reference)
+        match = reference&.match(/\A(?<stem>.+)\s(?<year>\d{4})-(?<number>\d+)\z/)
+        return unless match
+
+        parse_ref "#{match[:stem]} #{match[:number].sub(/\A0+(?=\d)/, '')} (#{match[:year]})"
+      rescue ::Pubid::Errors::ParseError
+        nil
+      end
+
+      # Compare a row's identifier with the query. Index rows are stored
+      # language- and form-neutral — verified across all committee-document and
+      # meeting rows — while a reference may name a language (`(2009, E)`) and
+      # always names a form (short `CCTF REC 2` vs long `CCTF Recommendation 2`).
+      # The year joins them when the query omits it, mirroring what `Id#==` did
+      # with `other_hash.delete(:year) unless hash[:year]`.
+      #
+      # @param row_id [Pubid::Bipm::Identifier]
+      # @param query [Pubid::Bipm::Identifier]
+      # @param query_stem [Pubid::Bipm::Identifier, nil] the reduced query, when
+      #   the caller already built it once for the whole search
+      # @return [Boolean]
+      def pubid_match?(row_id, query, query_stem = nil)
+        # A bare brochure names no edition, so it is a partial reference and
+        # cannot equal the `9e v3.01` row. Match any brochure row, which is what
+        # the old `{group: "SI", type: "Brochure"}` projection already meant.
+        if query.is_a?(::Pubid::Bipm::Identifiers::SiBrochure) && query.edition.nil?
+          return row_id.is_a?(::Pubid::Bipm::Identifiers::SiBrochure)
+        end
+
+        return false unless row_id.instance_of?(query.class)
+
+        # `Id#==` treated a document numbered "1" and a number-less one as the
+        # same document when both carried a year, so `CIPM Resolution 1 (1879)`
+        # reached `CIPM RES (1879)`. pubid has no such rule and the six
+        # ordinal-less declarations are only addressable this way, so keep it.
+        if number_collapses?(row_id, query)
+          keys = stem_keys(query) + [:number]
+          return row_id.exclude(*keys) == query.exclude(*keys)
+        end
+
+        return false unless cheap_reject_passes?(row_id, query)
+
+        stem(row_id, query) == (query_stem || stem(query, query))
+      end
+
+      # @param row_id [Pubid::Bipm::Identifier]
+      # @param query [Pubid::Bipm::Identifier]
+      # @return [Boolean] true when one side is number-less, the other is
+      #   numbered "1", and both carry a year
+      def number_collapses?(row_id, query)
+        return false unless row_id.year && query.year
+
+        numbers = [row_id.number.to_s, query.number.to_s]
+        numbers.include?("") && numbers.include?("1")
+      end
+
+      # Attributes the stem never removes, so stem equality implies equality on
+      # every one of them. Comparing them first cannot change the answer, it
+      # only avoids the reduction — and `#exclude` copies the identifier, which
+      # is what made an unguarded compare cost roughly 165x a plain attribute
+      # read and turned a rescan into seconds.
+      CHEAP_KEYS = %i[number group year issue article].freeze
+
+      # @param row_id [Pubid::Bipm::Identifier]
+      # @param query [Pubid::Bipm::Identifier]
+      # @return [Boolean] false as soon as one cheap attribute differs
+      def cheap_reject_passes?(row_id, query)
+        CHEAP_KEYS.all? do |key|
+          # `:year` is dropped from the stem when the query has none, so it is
+          # only significant when the query supplies one.
+          next true if key == :year && query.year.nil?
+          next true unless query.respond_to?(key) && row_id.respond_to?(key)
+
+          row_id.public_send(key).to_s == query.public_send(key).to_s
+        end
+      end
+
+      # @param pubid [Pubid::Bipm::Identifier] the identifier to reduce
+      # @param query [Pubid::Bipm::Identifier] the query that sets which
+      #   attributes are significant
+      # @return [Pubid::Bipm::Identifier] a copy; the cached row id is untouched
+      def stem(pubid, query)
+        pubid.exclude(*stem_keys(query))
+      end
+
+      # @param query [Pubid::Bipm::Identifier]
+      # @return [Array<Symbol>] the attributes a match must ignore
+      def stem_keys(query)
+        keys = %i[language form]
+        keys << :year if query.year.nil?
+        keys
+      end
+
+      # Parse a user reference with `Pubid::Bipm`, which since pubid `a96e9f45`
+      # accepts the loose consumer forms this flavor once needed `Id` for
+      # (`CCDS Recommendation 2 (2009)`, `CIPM 111e Réunion (2022)`,
+      # `CCTF Meeting 14 (1999)`, `SI Brochure Part 1`, …) and normalizes them
+      # to BIPM's canonical spelling. 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".
+      #
+      # @param reference [String]
+      # @return [Pubid::Bipm::Identifier]
+      # @raise [Pubid::Errors::ParseError]
+      def parse_ref(reference)
+        ::Pubid::Bipm.parse reference
+      end
+
+      def index
+        Relaton::Index.find_or_create(
+          :bipm, url: "#{GH_ENDPOINT}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml",
+          pubid_class: ::Pubid::Bipm::Identifier
+        )
+      end
+
+      # @param ref [String] the BIPM standard Code to look up (e..g "BIPM B-11")
+      # @param year [String] not used
+      # @param opts [Hash] not used
+      # @return [RelatonBipm::BipmBibliographicItem]
+      def get(ref, year = nil, opts = {})
+        search(ref, year, opts)
+      end
+    end
+  end
+end

data/lib/relaton/bipm/converter/asciibib.rb

@@ -0,0 +1,64 @@
+module Relaton
+  module Bipm
+    module Converter
+      module Asciibib
+        def self.from_item(item)
+          ToAsciibib.new(item).transform
+        end
+
+        class ToAsciibib < Bib::Converter::Asciibib::ToAsciibib
+          def transform
+            out = super
+            return out unless @item.ext
+
+            out << render_comment_period
+            out << render_si_aspect
+            out << render_meeting_note
+            out
+          end
+
+          private
+
+          def render_doctype
+            return "" unless @item.ext&.doctype
+
+            "doctype.type:: #{@item.ext.doctype.content}\n"
+          end
+
+          def render_structuredidentifiers
+            return "" unless @item.ext&.structuredidentifier
+
+            si = @item.ext.structuredidentifier
+            pref = "structuredidentifier"
+            out = "#{pref}.docnumber:: #{si.docnumber}\n"
+            out << "#{pref}.part:: #{si.part}\n" if si.part
+            out << "#{pref}.appendix:: #{si.appendix}\n" if si.appendix
+            out
+          end
+
+          def render_comment_period
+            return "" unless @item.ext.comment_period
+
+            cp = @item.ext.comment_period
+            out = ""
+            out << "commentperiod.from:: #{cp.from}\n" if cp.from
+            out << "commentperiod.to:: #{cp.to}\n" if cp.to
+            out
+          end
+
+          def render_si_aspect
+            return "" unless @item.ext.si_aspect
+
+            "si_aspect:: #{@item.ext.si_aspect}\n"
+          end
+
+          def render_meeting_note
+            return "" unless @item.ext.meeting_note
+
+            "meeting_note:: #{@item.ext.meeting_note}\n"
+          end
+        end
+      end
+    end
+  end
+end